plätt Linköpings universitet

plätt Linköpings universitet Innovativ programmering TDP019 Projekt: Datorspråk Sebastian Törngren sebto088@student.liu.se Examinator: Anders Haraldsson, IDA Utskriftsdatum: 28 maj 2012

Innehåll Inledning... 3 Användarhandledning...3 Variabler och utskrift...3 Matematiska uträkningar...4 Tilldelningsoperatorer...5 Relationsuttryck och logiska uttryck...6 Villkorssats...6 Repetitionssats...7 Listor... 7 Funktioner...7 Kommentarer... 9 Systemdokumentation...10 Lexikalisk analys...10 Parsning... 11 Evaluering... 11 Installation... 11 Reflektion... 11 Grammatik... 13

Inledning plätt är ett enkelt programmeringsspråk främst anpassat för svensktalande personer som ska lära sig att programmera för första gången. Språket och dess nyckelord är helt och hållet på svenska vilket gör att man som svensktalande inte behöver tänka på att översätta orden. Detta språk är gjort under andra terminen på IP-programmet vid Linköpings universitet. Språket hör till kursen TDP019 Projekt: Datorspråk. Denna rapport består av fyra avsnitt: en Användarhandledning, en Systemdokumentation, Fullständig programkod, samt ett reflektionsavsnitt som beskriver erfarenheter jag fått från genomförande av projektet. Användarhandledning plätt står för att programmera lätt och är förhoppningsvis ett lättare språk för ickeprogrammerare att lära sig än många andra programmeringsspråk som finns ute på marknaden idag. plätt är ett imperativt språk med syntax som liknar C++ och Python. För er som inte har programmerat tidigare säger detta troligtvis ingenting, men plätt liknar i grunden två av de mest populära språken som finns. Detta är en fördel ifall ni vill prova på andra programmeringsspråk i framtiden. Här nedan kommer korta beskrivningar på de olika delarna som finns i plätt. Efter det kommer några exempel på vad man kan använda plätt till. Variabler och utskrift Variabler är en av de viktigaste delarna i ett programmeringsspråk. En variabel betecknar ett namngivet objekt som används för att representera ett okänt värde, till exempel ett reellt tal eller en sträng med tecken. Här kommer en del exempel på hur man tilldelar variabler i plätt: Heltal apelsiner = 5 Sträng förnamn = "Sebastian" Bool tre_mindre_än_fyra = 3<4 Flyttal zero Lista abc = ["a", "b", "c"] Det är alltid viktigt att ange vilken sorts variabel man vill ha. Som exemplet ovan visar är variabeln apelsiner ett heltal och innehåller värdet 5. Om du vill skapa en variabel skriver du alltså på detta vis: <Vilken typ av variabel man vill ha> <Namn på variabeln> = <Uttryck> Men du kan lika gärna strunta i att ge variabeln ett värde. Då tilldelas den automatiskt ett värde beroende på vilken typ variabeln är. Heltal får värdet 0, flyttal värdet 0.0, strängar värdet "" och bool värdet "sant". Vilka typer finns det i plätt att använda sig av? 3

Det finns fyra olika typer som kan vara bra att lägga på minnet. Dessa är: Heltal - Ett tal helt enkelt. Ex. 8056, 15, 1337, 10010100110. Flyttal - Decimaltal. Ex. 3.14, 80.56, 3.3333333. Sträng - En textsträng som alltid börjar och slutar med " eller '. Ex. "Hej på dig!", 'bläää', "Jag är arg! %&#!" Bool - Returnerar alltid sant eller falskt. Kan skrivas direkt med sant eller falskt eller med ett relationsuttryck. Lista En lista med uttryck av vilken typ som helst. Skrivs inom hakparenteser. Ex. [1, 2, hej ], [1.9, 65, 1<4]. Kan namnet på variabeln se ut på vilket sätt som helst? Nej. Eftersom plätt fungerar ungefär som en sträng magister som kräver vilken typ av variabel man vill ha osv. så är även namnen begränsade. En variabel måste alltid börja på ett tecken mellan A-Ö (spelar ingen roll om det är versaler eller gemener) följt av oändligt antal tecken mellan A-Ö, 0-9 samt _. Variabler kan alltså ha namn som dessa: kanske_världens_längsta_och_minst_lämpliga_variabelnamn FjOrTiS_VaRiAbEL för_och_efternamn Men inte som dessa: _apelsiner %#&@ för- och efternamn Hur gör man för att skriva ut sin variabel då? Det är faktiskt inte svårare än vad det låter. Man skriver bara helt enkelt Skriv ut före sin variabel eller det uttryck man vill skriva ut. Nedan följer några exempel på hur man kan göra: Skriv ut apelsiner Skriver ut: 5 Skriv ut "Tjolahopp!" Skriver ut: Tjolahopp! Skriv ut "hej" * 2 Skriver ut: hej hej Hur gör man för att byta värde på en variabel? Om man vill byta värde på en variabel som redan existerar behöver man inte skriva vilken typ av variabel det är utan man skriver helt enkelt bara variabelnamnet samt dess nya värde. apelsiner = 7 förnamn = "Kalle" Något som inte fungerar att skriva däremot är: apelsiner = "sju" Eftersom variabeln apelsiner redan är deklarerad sedan tidigare av typen heltal kan man inte ge den ett nytt värde av typen sträng. 4

Skulle man vilja skriva ut apelsiner och förnamn igen skulle de returnera ut sina nya värden, det vill säga 7 och Kalle. Matematiska uträkningar Matematiska uträkningar är en stor och viktig del i ett programmeringsspråk. Då gäller det även att man som programmerare vet vilka matematiska operatorer och begrepp som är giltiga i språket. De giltiga matematiska operatorerna i plätt är: + - * / ++ -- Som man kan gissa används + vid addering, - vid subtraktion, * vid multiplikation och / vid dividering. De operatorer som kan vara mer förvirrande är ++ och --. Dessa operatorer kan endast användas på redan deklarerade variabler av typen heltal och flyttal och ökar variabelns värde med 1. Något som också är viktigt att tänka på är att använda parenteser vid lämpliga ställen för att anpassa prioritet i uttrycket. Om man glömmer parenteser kan resultatet bli helt annorlunda mot vad man tror. 5*4-5 = 15 5*(4-5) = -5 Tilldelningsoperatorer Tidigare i dokumentet nämndes hur man kan ändra värde på en redan existerande variabel. Det var bara ett sätt av flera hur man kan ändra en variabels värde. Här listas de olika operatorerna som är tillgängliga för de olika typerna. Operator Heltal och flyttal Sträng Bool *= X X /= X += X X -= X ++ X -- X = X X X Men vad betyder då alla dessa operator? 5

*= Tar det ursprungliga värdet och multiplicerar det med ett nytt värde. /= Tar det ursprungliga värdet och dividerar det med ett nytt värde. += Tar det ursprungliga värdet och adderar det med ett nytt värde. -= Tar det ursprungliga värdet och subtraherar det med ett nytt värde. ++ Tar det ursprungliga värdet och adderar med 1. -- Tar det ursprungliga värdet och subtraherar med 1. = Ersätter det ursprungliga värdet med det nya. För att göra det hela lite tydligare visas här några exempel: flyttal x = 3.9 x = 3.9 x /= 3 x = 1.3 x++ x = 2.3 x += 4.7 x = 7.0 x = 13.37 x = 13.37 sträng y = "hej" y *= 2 y += ", vad kul att ses!" y = "hej då" y = "hej" y = "hejhej" y = "hejhej, vad kul att ses!" y = "hej då" bool z = "sant" z = "falskt" z = "sant" z = "falskt" Relationsuttryck och logiska uttryck Inom programmeringen kan det vara bra att jämföra olika värden för att få fram ett bool värde, dvs. "sant" eller "falskt". De flesta operatorerna känner du säkert igen från grundskolematematiken men det finns vissa som används mer vid programmering. De olika relationsoperatorerna är: < Mindre än > Större än <= Mindre än eller lika med >= Större än eller lika med == Är lika med!= Är inte lika med Här kommer några exempel på hur dessa kan användas: bool x = 1<2 x = "sant" heltal fyra = 4 fyra = 4 x = (fyra!= 4) x = "falskt" Hur gör man om man vill jämföra två relationsuttryck? Eftersom plätt är på svenska är det inte krångligare än att använda de logiska operatorerna och eller eller mellan två relationsuttryck. bool z = (1<2 och 2<3) z = (1==2 eller 2>3) z = "sant" z = "falskt" 6

Villkorssats En av de satser som finns i plätt (samt många andra programmeringsspråk) är en så kallad if-sats, men eftersom plätt är på svenska så kallas den istället för en ifall-sats. En ifall-sats fungerar som så att den tar ett uttryck och kontrollerar ifall uttrycket är sant eller falskt och utför vissa satser ifall uttrycket skulle vara sant, annars gör den ingenting. Här kommer några exempel: heltal fyra = 4 ifall (fyra<5) { skriv ut "Fyra är mindre än fem." annars ifall (fyra==4) { skriv ut "Variabeln har värdet fyra." avsluta ifall ifall ((5+3) == 8) { skriv ut "Japp, det stämmer!" annars { skriv ut "Nepp, stämmer inte!" avsluta ifall Utskriften blir: Fyra är mindre än fem. Japp, det stämmer! Repetitionssats Loopar är något som kan vara väldigt bra att använda i ett språk vid vissa tillfällen. Om man behöver skriva ut talen ett till hundra så vore det ju skönt att slippa skriva hundra stycken skriv ut satser. Därför kan man istället skriva så kallade för- eller under tidensatser. för (heltal i = 1: i < 11: i++) { skriv ut i avsluta för I en försats deklarerar man först en variabel av typen heltal eller flyttal med ett värde, därefter kommer ett relationsuttryck (med den tidigare nämnda variabeln som operand) följt av ett tilldelningsuttryck. Det som kommer hända nu är alltså att först har i värdet 1 vilket är mindre än 11. För varje gång relationsuttrycket blir sant kommer de satser som finns inom måsvingarna att utföras. När i har kommit upp i värdet 11 kommer försatsen att avbrytas då relationsuttrycket inte längre är sant. Detta kommer då alltså skriva ut talen 1-10 i följd. Nedan kommer ett litet krångligare exempel på hur man kan använda sig av under tidensatser. flyttal small_number = 0.4 7

under tiden (small_number < 1 och small_number > 0.2) { skriv ut small_number small_number -= 0.15 ifall (small_number == 718) { skriv ut "Något har blivit väldigt fel " avsluta ifall avsluta under_tiden Först deklareras flyttalsvariabeln small_number med värdet 0.4. Därefter kommer en under tiden loop som kontrollerar att small_number både är mindre än ett och större än 0.2. Om detta uppfylls kommer small_number att skrivas ut samt minska med 0.15 i värde. Skulle small_number mot all förmodan få värdet 718 kommer en varningstext skrivas ut. Detta kommer då alltså att returnera ut talen 0.4 och 0.25. Listor En lista är en variabel som kan innehålla en obestämd mängd med uttryck. Den kan innehålla vilken sorts uttryck som helst, t.ex. strängar blandat med heltal osv. Det viktigaste att komma ihåg är att listor omsluts av hakparenteser. Nedan följer några exempel på hur man skapar en lista samt några funktioner till listor. lista abc = ["a", "b", "c"] abc = ["a", "b", "c"] lägg till "d" i abc abc = ["a", "b", "c", "d"] skriv ut storlek på abc Returnerar: 4 ta bort index 2 i abc abc = ["a", "b", "d"] ta bort värde "d" i abc abc = ["a", "b"] skriv ut abc[0] Returnerar: a För att förklara lite noggrannare vad som händer börjar koden med att skapa variabeln abc av typen lista med värdena a, b och c. Därefter läggs d till i listan. Efteråt skrivs storleken ut på listan och som man kan se innehåller listan fyra uttryck. Nästa rad kan däremot vara lite förvirrande. I programmering börjar index i en lista med värdet noll. När man vill ta bort index två i listan kommer alltså det tredje uttrycket att tas bort från listan, dvs. d i det här fallet. Vidare tas uttrycket d bort från listan och sedan skrivs det första uttrycket ut ur listan. Funktioner För att göra sitt program ännu mer lättläsligt och smidigt kan man använda sig av funktioner. En funktion kan t.ex. vara bra så man slipper skriva om en sak flera gånger. Det finns mer avancerade funktioner än andra men här nedan kommer ett kort exempel på hur en funktion kan se ut. heltal funktion tal_plus_ett(n) { returnera n + 1 avsluta funktion heltal tre = tal_plus_ett(2) skriv ut tre Detta kommer då alltså att returnera ut talet 3. Lite mer förklaring på vad som händer: 8

Först skapas en funktion av typen heltal med namnet tal_plus_ett. Ett tips är att alltid försöka döpa funktionen så man vet vad den har för syfte. Man förstår ganska lätt att denna funktions uppgift är att addera sitt ursprungliga värde med ett. Funktionen tar sedan in en parameter n. n kommer sedan att ersättas med det värde som du anropar med, i det här fallet 2. Slutligen returnerar funktionen värdet man anropar med adderat med ett. Tänk på att alltid returnera ett värde av den typ du anger att funktionen har! Om du har skapat en funktion av typen heltal måste den returnera ett värde av typen heltal. Efter funktionen skapas en heltalsvariabel med namnet tre och har funktionen tal_plus_ett med anropet 2 som värde. Samma sak gäller här; ska man deklarera en heltalsvariabel med en funktion som värde så måste funktionen returnera ett heltal. Allra sist skrivs variabeln ut. Här kommer ett lite mer avancerat exempel på en funktion: heltal funktion fakultet(n) { ifall (n == 0) { returnera 1 annars { returnera n * fakultet((n-1)) avsluta ifall avsluta funktion för (heltal i = 0: i < 6: i++) { skriv ut fakultet(i) avsluta för Returnerar: 1 1 2 6 24 120 Ovan visas ett exempel på hur man kan beräkna fakultet i plätt. För er som inte vet vad fakultet är så kommer en kort beskrivning nedan. För ett heltal större än noll är fakulteten lika med produkten av alla heltal från ett upp till och med talet självt. Dvs. fakulteten för talet fem är 1 * 2 * 3 * 4 * 5 = 120. Funktionen tar alltså in ett värde och kontrollerar sedan ifall värdet är noll eller ett. Fakulteten för noll eller ett är alltid ett, därför finns denna ifall-sats. Skulle värdet vara större körs funktionen i sig självt men med värdet minus ett för att t.ex. få ut fakulteten av värdet fem måste man först veta vad värdet av fakulteten för värdet fyra är osv. Därefter skapas en för-sats som skriver ut vad fakulteten är för värdena noll till fem. Nedan följer ett annat exempel på hur man kan skriva en funktion. 9

sträng funktion beställning(mat) { ifall (mat == "Pizza") { returnera "Pizza på gång!" annars ifall (mat == "Hamburgare") { returnera "Hamburgare på gång!" annars { returnera "Restaurangen har tyvärr inte den maten..." avsluta ifall avsluta funktion skriv ut beställning("pizza") skriv ut beställning("sallad") sträng skräpmat = beställning("hamburgare") skriv ut skräpmat Utskriften kommer alltså att bli: Pizza på gång! Restaurangen har tyvärr inte den maten... Hamburgare på gång! Denna funktion tar i stället in en måltid som användaren önskar. Därefter kontrolleras det ifall restaurangen har denna måltid. Olyckligtvis serverar denna restaurang bara pizza och hamburgare så utbudet är inte särskilt stort. Om användaren har valt måltiden pizza eller hamburgare kommer beställningen att ropas ut, annars kommer restaurangen svara att de inte har den maten. Skapar man i stället en variabel med funktionen som värde så kommer variabeln att få retursatsen som värde, i det här fallet beställningen. Kommentarer Har man skrivit ett långt och krångligt program kan det vara en smart idé att ha kommentarer i sin fil som gärna förklarar vad som händer i koden. I plätt finns det två olika sätt att skriva kommentarer. // Detta är en enradskommentar /* Denna kommentar kan vara på flera rader. */ Vill man skriva en kommentar på endast en rad fungerar det bra att använda //. Vill man istället skriva en kommentar på flera rader börjar man med att skriva /* och avslutar med */ som exemplet ovan visar. 10

Systemdokumentation Språket plätt är byggt på parsern rdparse och utifrån den har jag byggt mitt egna språk med hjälp av olika exempel, bland annat från språket diceparser samt äldre projekt som finns på kurshemsidan. Som slutresultat består plätt av tre filer; rdparse.rb vilket är parsern för språket, platt.rb som innehåller alla regler och tokens samt node.rb som består av alla noder i språket. plätt är ett programmeringsspråk främst anpassat för nybörjare som föredrar svenska framför engelska. plätt liknar till grunden en blandning mellan C++ och Python vilket är en bra start för nybörjaren som planerar att fortsätta lära sig programmering. Lexikalisk analys Eftersom jag har använt mig av parsern rdparse så har min lexikaliska del endast bestått av tokens som beskrivs med reguljära uttryck i språket Ruby. Med hjälp av dessa reguljära uttryck kan jag returnera en sekvens med tokens som reglerna i plätt sedan får tolka. De olika tokens jag har är följande och är även matchade i ordningen nedan: Här matchas flerradskommentarer och returnerar ingenting vilket gör att de fungerar precis som jag vill att de ska göra, dvs. de ignorerar allt inom /* och */. token(/\/\*(. \n)*\*\//) Här matchas enradskommentarer och returnerar ingenting vilket gör att de fungerar precis som jag vill att de ska göra, dvs. de ignorerar allt efter // på samma rad. token(/\/\/(.)*$/) Här matchas blanksteg och returnerar ingenting eftersom likt kommentarer saknar de funktion. token(/\s+/) Här matchas flerradskommentarer och returnerar ingenting vilket gör att de fungerar precis som jag vill att de ska göra, dvs. de ignorerar allt inom /* och */. token(/\/\*(. \n)*\*\//) Här matchas siffror av olika slag, både flyttal och heltal, negativa som positiva. Dessa returneras sedan eftersom vi vill kunna använda de senare. token(/\d+[.]\d+/) { m m.to_f token(/-(\d+[.]\d+)/) { m m.to_f token(/\d+/) { m m.to_i Här matchas strängar och returneras, både de som skrivs med " och '. token(/"[^\"]*"/) { m m token(/'[^\']*'/) { m m Här matchas alla de olika nyckelorden i språket och returneras eftersom vi vill kunna använda de senare. token(/ifall/) { m m token(/annars ifall/) { m m 11

token(/annars/) { m m token(/avsluta ifall/) { m m token(/returnera/) { m m token(/skriv ut/) { m m token(/för/) { m m token(/avsluta för/) { m m token(/under tiden/) { m m token(/avsluta under tiden/) { m m token(/ta bort värde/) { m m token(/ta bort index/) { m m token(/i/) { m m token(/lägg till/) { m m token(/storlek på/) { m m Här matchas alla specialtecken som kan användas i plätt, t.ex. matematiska operatorer och jämförelseoperatorer. token(/(\+= -= \*= \/= \+\+ -- \+ \- \* \/!= \., \] \[ { \( \) \: <= >= < > == =)/) { m m Här matchas alla variabelnamn som går att använda i plätt. En variabel måste alltså börja med ett tecken mellan A-Ö följt av noll eller fler tecken mellan A-Ö samt 0-9 och _. token(/[a-za-zåäöåäö]+[a-za-zåäöåäö0-9_]*/) { m m Parsning På det sättet som plätt är uppbyggt på så består parsningen av ett stort antal BNF-regler där jag kan matcha vad reglerna ska stå för och sedan bestämma vad som ska hända om en regel matchas. Grundregeln statements är den regeln som säger vad ett program kan bestå av. Grundregeln statements kan innehålla flera statements följt av ett statement eller endast innehålla ett statement. Ett statement kan t.ex. vara deklaration av variabler, utskrift, loopar osv. Med hjälp av denna struktur så är vårt program rekursivt och fungerar som det ska. Alla regler som matchas i statements returnerar en nod till det abstrakta syntaxträdet. Evaluering Evalueringen i plätt sker genom att traversera det abstrakta syntaxträdet bestående av många noder. Dessa noder är egentligen objekt från klasser, som skapas för de olika konstruktionerna i språket. Varje klass har en initiering- och evalueringsmetod. Initieringsmetoden tar in värden för noden och lagrar dessa som instansvariabler. Evalueringsmetoden anger vad som händer då noden skall exekveras. Språket kan innehålla både globala och lokala variabler. Tack vare två funktioner som öppnar och stänger så kallade scopes kan variabler lagras djupare i olika scopes. Detta gör att variabler som deklareras i början på en för-satser endast är tillgänglig under försatsen men tas sedan bort automatiskt efteråt. Installation plätt kan köras i alla operativsystem som Ruby har stöd för. För att kunna köra plätt måste du först installera Ruby (version 1.9.2 rekommenderat). Detta gör du lättast genom att gå in på deras hemsida och följa instruktionerna där. Länken är http://www.rubylang.com 12

Efter att Ruby är installerat är det dags att hämta hem filerna för plätt. Dessa finns tillgängliga på http://www.skjortan.net/plätt.rar Efter att du har hämtat hem filen behöver du packa upp filen. Detta gör du lämpligast med t.ex. WinRAR för Windows-användare. Efter att plätt är uppackat ska du öppna upp en terminal och förflytta dig till den mapp där plätt ligger installerat. Därefter kan du köra plätt på två sätt, antingen genom en fil eller direkt i terminalen. Vill du köra direkt i terminalen skriver du på det här viset: ruby platt.rb Om du vill köra plätt från en fil får du först skapa en fil där du skriver din plätt-kod i. Spara den t.ex. till Testfil.platt och kör den på detta vis: ruby platt.rb Testfil.platt Har du gjort allt korrekt har du nu plätt installerat och kan nu börja skriva vacker plättkod. Grattis! Reflektion I början av kursen då vi skulle välja vad för sorts projekt vi ville göra samt vilka vi skulle jobba med så kände jag redan från början att det skulle vara kul att göra något helt själv och utforma ett språk precis på det sättet som jag vill. Jag valde då alltså att ge mig in på detta stora projekt på egen hand utan en aning om ifall det skulle vara svårt eller inte. Eftersom jag inte har något erfarenhet av programmering sen innan jag började på den här utbildningen så tänkte jag att jag inte skulle göra det för svårt för mig. Jag började med att försöka komma på en idé på ett språk som både kan vara kul att göra och som jag kan lära mig någonting på. Efter att ha hört mig för hos de andra i klassen och vad de hade för idéer så fick jag ju självklart en kommentar om min östgötska och då kom jag på idén att mitt språk skulle vara på svenska. Som östgöte använder jag ju ÅÄÖ lite mer än många andra när jag pratar så det vore ju kul att kunna skriva kod på samma sätt också. Jag började rätt tidigt med att försöka få ihop en grund till språket. Efter att ha kollat på diceroller parsern och några äldre projekt började jag förstå hur mycket av det fungerade. Efter någon vecka lyckades jag få min utskrift-sats att fungera och det gick att skriva ut lite enklare matematiska uttryck. Från början hade jag rätt många idéer på vad för delar jag ville få in på mitt svenska programmeringsspråk. Jag ville ha listor, funktioner, loopar och allt möjligt vilket man trodde att man skulle kunna klämma in ganska fort med tanke på hur fort jag lyckades få mina aritmetiska uttryck att fungera. Dock gick det ju inte riktigt så. Efter att ha hållit på med språket i några veckor började man inse att det fanns mycket som man var tvungen att tänka på och för varje handledningsmöte jag hade insåg jag nya problem som jag hade framför mig. Det första stora problemet jag hade var att satserna inuti en för-sats kördes på helt fel sätt. Hade jag endast en sats inuti en för-sats gick det alldeles utmärkt men så fort jag 13

skulle ha flera satser så kördes alltid andra satsen och vidare för många gånger jämfört med vad de skulle. Detta lyckades jag till slut lösa efter mycket om och men när jag insåg ett fel i min nod för alla satser. Mycket frustration fanns det över detta fel. Det andra stora problemet jag stötte på i mitt språk var scopingen. Efter att ha kollat på det tidigare projektet JAIL så försökte jag få in scoping i mitt språk på ungefär samma sätt som de hade gjort och jag fick skriva om väldigt mycket i min kod för att detta skulle funka. Jag tror jag kan ha fått det att fungera men då slutade nästlingen av loopar att fungera istället och jag satt väldigt länge med att försöka lösa detta. Till slut gav jag upp och ändrade mitt språk igen till hur det fungerade från början, utan scoping men med fungerande nästling. Efter sista handledningsmötet fick jag upplysning om igen att jag borde försöka få in scoping i mitt språk och då började jag fråga mina klasskompisar om de kunde ge mig något tips på hur jag kunde göra. Tipset var att kolla på det gamla projektet Gandalf och försöka göra ungefär som de hade gjort. Efter ett tag lyckades jag och tyvärr fanns det inte mycket tid kvar av projektet. Under sista handledningsmötet hade jag tre viktiga delar kvar i mitt språk: scoping, if-satser och diverse funktioner för listor. I uppgift fick jag att jag skulle prioritera if-satserna först, därefter scoping och i mån av tid skulle jag ordna funktionerna för listorna. Tyvärr hann jag bara med de två första så listorna fick lämnas utanför. Efter första inlämningen fick jag i respons att fixa diverse stavfel i rapporten samt att fixa rekursion och listor till språket för att få bättre betyg. Självklart ville jag ha ett bättre betyg och lyckades fixa alla dessa saker innan sista inlämning. Jag är nöjd! 14

Grammatik <STATEMENTS> ::= <STATEMENT> <STATEMENTS> <STATEMENT> <STATEMENT> ::= <ARRAY_ADD_ELEMENT> <ARRAY_REMOVE_BY_INDEX> <ARRAY_REMOVE_BY_VALUE> <RETURN> <LOOP> <PRINT> <DECLARE_FUNC> <FUNCTION_CALL> <DECLARE_VAR> <ASSIGN> <LOOP> ::= <FOR_LOOP> <WHILE_LOOP> <FOR_LOOP> ::= "för" "(" <DECLARE_VAR> ":" <PRED_EXPR> ":" <ASSIGN>")" "{" <STATEMENTS> "" "avsluta för" <WHILE_LOOP> ::= "under tiden" "(" <PRED_EXPR> ")" "{" <STATEMENTS> "" "avsluta under tiden" <DECLARE_VAR> ::= <TYPE> <IDENTIFIER> "=" <EXPR> "bool" <IDENTIFIER> "=" <BOOL> <TYPE> <IDENTIFIER> "=" <STRING> <TYPE> <IDENTIFIER> <DECLARE_FUNC> ::= <TYPE> "funktion" <IDENTIFIER> "(" <PARAMETERS> ")" "{" <STATEMENTS> <RETURN> "" "avsluta funktion" <TYPE> "funktion" <IDENTIFIER> "(" ")" "{" <STATEMENTS> <RETURN> "" "avsluta funktion" <TYPE> "funktion" <IDENTIFIER> "(" <PARAMETERS>")" "{" <RETURN> "" "avsluta funktion" 15

<TYPE> "funktion" <IDENTIFIER> "(" ")" "{" <RETURN> "" "avsluta funktion" <TYPE> ::= "heltal" "flyttal" "sträng" "bool" <IDENTIFIER> ::= /[a-za-zåäöåäö]+[a-za-zåäöåäö0-9_]*/ <EXPR> ::= <ARRAY_INDEXING> <ARRAY_SIZE> <PRED_EXPR> <ADDITION_EXPR> <STRING> <ARRAY> <FUNCTION_CALL> ::= <IDENTIFIER> "(" <ARGUMENTS> ")" <IDENTIFIER> "(" ")" <PRED_EXPR> ::= <LOGIC_EXPR> <REL_EXPR> <LOGIC_EXPR> ::= <BOOL> <LOGIC_OPERAND> <LOGIC_OPERATOR> <LOGIC_EXPR> <LOGIC_OPERAND> <LOGIC_OPERATOR> <LOGIC_OPERAND> <LOGIC_OPERAND> ::= <REL_EXPR> <BOOL> <LOGIC_OPERATOR> ::= "och" "eller" <REL_EXPR> ::= <REL_OPERAND> <REL_OPERATOR> <REL_OPERAND> <REL_OPERAND> ::= <ADDITION_EXPR> <REL_OPERATOR> ::= ">=" "<=" ">" "<" 16

"==" "!=" <ADDITION_EXPR> ::= <ADDITION_EXPR> <ADDITION_OPERAND> <MULTI_EXPR> <MULTI_EXPR> <ADDITION_OPERAND> ::= "+" "-" <MULTI_EXPR> ::= <MULTI_EXPR> <MULTI_OPERAND> <MULTI_EXPR> <ARITM_BRACKETS> <MULTI_OPERAND> ::= "*" "/" <ARITM_BRACKETS> ::= "(" <EXPR> ")" <STRING> <INT> <FLOAT> <FUNCTION_CALL> <INT> <FLOAT> <STRING> <BOOL> ::= Integer "-" Integer ::= Float "-" Float ::= /"[^\"]*"/ /'[^\']*'/ <FUNCTION_CALL> <IDENTIFIER> ::= "sant" "falskt" <PARAMETERS> ::= <PARAMETER> <PARAMETERS> "," <PARAMETER> <PARAMETER> ::= <IDENTIFIER> <ARGUMENTS> ::= <ARGUMENT> 17

<ARGUMENT> ::= <EXPR> <ARGUMENTS> "," <ARGUMENT> <ASSIGN> ::= <IDENTIFIER> "++" <IDENTIFIER> "--" <IDENTIFIER> <ASSIGN_OPERATOR> <EXPR> <IDENTIFIER> <ASSIGN_OPERATOR> <STRING> <ASSIGN_OPERATOR> ::= "*=" "/=" "+=" "-=" "=" <PRINT> ::= "skriv ut" <EXPR> <IF_BLOCK> ::= <IF_RULE> <IF_RULE> <IF> <ELSE_IF> <ELSE_> <RETURN> <ARRAY> ::= <IF> <ELSE_IF> <ELSE> "avsluta ifall" <IF> <ELSE_> "avsluta ifall" <IF> <ELSE_IF> "avsluta ifall" <IF> "avsluta ifall" ::= "ifall" "(" <PRED_EXPR> ")" "{" <STATEMENTS> "" ::= "annars ifall" "(" <PRED_EXPR> ")" "{" <STATEMENTS> "" ::= "annars" "{" <STATEMENTS> "" ::= "returnera" <EXPR> ::= "[" <ARRAY_VALUES> "]" <ARRAY_VALUES> ::= <ARRAY_VALUES> "," <STRING> <ARRAY_VALUES "," <EXPR> <STRING> <EXPR> <ARRAY_SIZE> ::= "storlek på" <IDENTIFIER> 18

<ARRAY_INDEXING> ::= <IDENTIFIER> "[" <INT> "]" <ARRAY_ADD_ELEMENT> ::= "lägg till" <STRING> "i" <IDENTIFIER> "lägg till" <EXPR> "i" <IDENTIFIER> <ARRAY_REMOVE_BY_INDEX> ::= "ta bort index" <INT> "i" <IDENTIFIER> <ARRAY_REMOVE_BY_VALUE> ::= "ta bort värde" <STRING> "i" <IDENTIFIER> "ta bort värde" <EXPR> "i" <IDENTIFIER> 19