Table of Contents Previous Chapter

uLPC - Ett lättanvänt kraftpaket

uLPC-kod är väldigt lik C-kod men fungerar väldigt annorlunda. För det första så behöver man inte kompilera uLPC. uLPC interpreteras av programmet /usr/local/bin/ulpc och för att man ska kunna skriva skriva scripts i uLPC så kan man skriva #!/usr/local/bin/ulpc på första raden i sitt uLPC-program.

Det som händer när uLPC startas med ett uLPC-program som argument är att funktionen main() i det programmet anropas. På så sätt kan man skriva programmet 'hello_world' som följer:

#!/usr/local/bin/ulpc

int main()

{

  write("Hello world.\n");

}

Funktionen write() är en fördefinierad funktion som skriver ut den sträng man ger som argument till stdout.

Kort men användbart exempel

Programmet på nästa sida rsif (Replace String In File) kommer med uLPC.

Här kan vi se exempel på if-satser och for-loopar. Som synes fungerar de precis som sina motsvarighter i C. Detta gäller även för while, do-while och return.

Inbyggda typer

uLPC har många trevliga och kraftfulla typer. Dessa typer är inbyggda och är inte 'objekt' i objektorienterad mening. Någon typsäker objektorientering finns inte, inte heller 'operator overloading'.

• int Detta är i princip samma typ som typen 'int' i C, alla operatorer som kan användas med ints i C kan även användas i uLPC.
  

• float Detta är i princip samma typ som typen 'float' i C, alla operatorer som kan användas med ints i C kan även användas i uLPC. Även de vanliga trigonometriska funktionerna finns.
  

• string Denna typ innehåller en sträng, till skillnad från C så är strängar inte en array av tecken. Man kan inte heller ändra ett tecken mitt i en sträng. Däremot kan man addera strängar med +. Strängar allokeras (liksom allting annat) dynamiskt och frias när man inte använder dem längre. Strängar kan dessutom vara godtyckligt långa och innehålla nulltecken.
  #!/usr/local/bin/ulpc // Som du ser anropas main på samma sätt som i C // Notera att argv är en array av strängar, och inte en 'char **' int main(int argc,string *argv) { int i; string file; if(argc<4) { write("Usage: rsif <from> <to> <files>\n"); return 0; } for(i=3; i<sizeof(argv);i++) if (file = read_bytes(argv[i])) // read_bytes läser in hela filen i en sträng if (-1 != strstr(file, argv[1])) { // strstr söker efter en sträng i en sträng write("Processing "+argv[i]+".\n"); // replace byter ut alla förekomster av en sträng mot // en annan sträng och returnerar resultatet. file=replace(file,argv[1],argv[2]); // Flytta originalfilen till en fil med ~ på slutet if( mv(argv[i],argv[i]+"~") ) // Skriv den nya filen. write_file(argv[i],file); else write("Failed to create backup file.\n"); } }

• array Detta typ är en behållare som kan innehålla ett antal värden av en speciell eller godtycklig typ. Arrayer indexeras med indexoperatorn och kan ändras destruktivt. Konstanta arrayers skrives: ({värde1, värde2, }). Man kan också allokera tomma arrayer med funktionen allocate(). Notera att om man skickar en array till en funktion så skickas bara en referens till array och om funktionen ändrar på arrayen så ändras den därför även i den anropande funktionen.
  

• mapping Den här typen fungerar ungefär som arrayer, men kan indexeras på vad som helst, inte bara integers. Om man sätter ett index i en mapping som inte redan finns där så kommer den att lägga till det indexet och mappingens storlek ändras därmed. Detta skiljer sig från arrayer, arrayer kan inte ändra storlek destruktivt. En konstant mapping skrives som följer: ([index1 : värde1, index2 : värde2, ])
  

• program Program påminer om klasser i C++, man kan inte göra så mycket med dem utom att skapa dem, jämföra dem med varann och instansiera dem. Instansiering sker med funktionen clone(), som tar ett program som argument och returnerar ett object.
  

• object Objekt är instanser av klasser (program). Man kan komma åt identifierare i ett objekt genom att indexera objektet med namnet på identifieraren i en sträng. Det kan man skriva på 2 sätt:
  /* Sätt 1*/ obj["identifier"]
/* Sätt 2*/ obj->identifier
Om identifieraren är en variabel (och inte statisk) så returneras variabelns innehåll. Om identifieraren å andra sidan är en funktion så returneras en funktionspekare.
  

• function Denna typ utgör en funktionspekare. Den är alltså en pekare till en funktion i ett speciellt objekt. Funktionspekare anropas enkelt genom att bara sätta paranteser efter. Alla funktionsanrop går via funktionspekare. För att få en funktionspekare till en funktion i samma program skriver man bara funktionens namn. Dock måste funktionen vara deklarerad före användandet.
  

Notera att det inte finns några explicita pekare. Arrayer, mappings, program, object och funktioner skickas dock runt ungefär som om man skickade runt pekare till dem. Detta märks inte i hur man skriver, vilket är smidigt men kan verka förvillande för somliga.

Masterobjektet

Innan ditt program laddas laddas masterobjektet. Masterobjektet finns nomalt i filen /usr/local/lib/ulpc/master.lpc. Mycket av uLPCs beteende kan ändras genom att modifiera masterobjektet. Om man vill kan man ange vilket masterobjekt som skall användas med -m masterobjekt. Masterobjektet är ansvarigt för att skriva ut felmeddlanden, ladda ditt script, sätta upp efuns skrivna i uLPC (som write) mm. mm.

Simulerade Funktioner

Masterobjektet laddar normalt också in /usr/local/lib/ulpc/simulate.lpc som innehåller en hög funktioner som adderas som efuns av simulate.lpc. Efun betyder 'external function' och är helt enkelt funktioner som är globalt definierade för alla program. De kan vara inbyggda i drivern eller skrivna i uLPC. Exempel på simulerade funktioner är read_bytes och write_file. De är bekvämlighets- och kompatiblitets-funktioner skrivna i uLPC som använder i sin tur använder read() och write().

Filhantering

Filhanteringen i uLPC är objektorienterad, man instansierar filprogrammet, anropar open() i det och kan sedan använda read()/write() mm. Man kan också öppna sockets eller dubbelriktade pipes. Dock finns inga buffrar i uLPCs filhantering, det får man skriva själv. Jag kommer snart att implementera buffrad filhantering för uLPC i uLPC. Den buffrade filhanteringen kommer då att ingå i standarddistributionen.

Kraftfulla funktioner

Som vi sett exempel på i rsif så innehåller uLPC en hel del kraftfulla funktioner. Några exempel:

• explode/implode - dela en sträng vid varje förekomst av en annan sträng och returnera delarna i en array resp slå ihop en array till en sträng.
  

• replace - byt ut alla förekomster av en sträng i en sträng mot en tredje sträng
  

• sprintf - formatterar strängar, klarar även tabeller, radbrytning och rekursiv formattering
  

• addition, subtraktion, and, or, xor på arrayer, mappings och listor.
  

Vill du veta mer? Jag jobbar för närvarande på en referensmanual till uLPC och även om den inte är färdig än så finns det jag skrivit hittils att beskåda på:
http://www.signum.se/~hubbe/ulpc.html.

Kreativt samarbete genom MUD