2D1373 Artificiella språk och syntaxanalys

7 december 1998 Numerisk analys och datalogi Lars Engebretsen Laborationer i 2D1373 Artificiella språk och syntaxanalys våren 1999 Namn:......................................................................................... Personnummer:................................................................................. Godkänd:...................................................................................... Kvitteras:...................................................................................... 1

2

Laboration 1 i Artificiella språk och syntaxanalys, våren 1999 Simulering av NFA I denna laboration ska du skriva ett program som simulerar en ickedeterministisk ändlig automat. Du kommer att behöva detta program i laboration 4 senare i kursen. En ickedeterministisk ändlig automat (förkortat NFA) beskrivs av en femtupel som består av: alfabetet Σ, mängden tillstånd Q, starttillståndet q 0 Q, mängden accepterande tillstånd F Q och övergångsrelationen N : Q (Σ {ε}) Q. Vad allt detta står för beskrivs i avsnitt 2.3 och 2.4 i Introduction to compiler construction. Vid simuleringen ställer vi för enkelhets skull några extra krav på automaten. Tillstånden är numrerade med naturliga tal där tillstånd nummer noll är starttillståndet. från varje tillstånd får det antingen gå ingen övergång alls, en teckenövergång, en epsilonövergång eller två stycken epsilonövergångar (det vill säga en ickedeterministisk förgrening). Detta är ingen svår begränsning alla ickedeterministiska ändliga automater kan enkelt skrivas om på ett sånt sätt. När (och om) automaten når ett accepterande tillstånd accepterar den, även om det finns inmatning kvar. Övergångsrelationen N ska realiseras med en vektor vars element har följande typ: typedef struct state_ { char symbol; int left, right; } state_t; Låt nu s vara en sådan vektor. Att (q 8,A,q 17 ) N ska lagras genom att s[8]={ A,17,-1}; och (q 5,ε,q 2 ) N lagras som s[5]={,2,-1}; Om det skulle ha funnits två epsilonövergångar från tillstånd q 5 skulle s[5].right ha använts för att lagra den andra. Automaten ε q A 5 q 6 C q ε 0 q 4 q 1 ε ε A q 2 q 3 ε B q ε 7 q D 8 q ε 9 q 10 lagras på följande sätt: Algoritmbeskrivning för simulatorn i 0 1 2 3 4 5 6 7 8 9 10 s[i].symbol A B A C D s[i].left 4 2 3 7 5 6 7 8 9 0-1 s[i].right -1-1 1-1 2-1 -1-1 -1-1 -1 Algoritmen vi kommer att använda är exakt den som beskrivs i kursbokens avsnitt 2.5, The Subset Construction. Vi simulerar den givna NFA:n genom att, vid varje position i indatasträngen, komma ihåg alla tillstånd som NFA:n kan befinna sig i vid denna position. Vi kommer alltså, i varje steg av NFA:ns simulering, att hålla reda på en delmängd av tillståndsmängden. (Nämligen den delmängd som består av de 3

tillstånd NFA:n kan befinna sig i just då.) Givet denna delmängd, övergångsrelationen och nästa indatasymbol ska vi kunna konstruera en ny delmängd: Mängden av de tillstånd NFA:n kan befinna sig i när den läst indatasymbolen. Om vi låter NFA:n ha tillstånden q 0,...,q n 1, F vara mängden av accepterande tillstånd och s vara vektorn med element av typen state_t får vi följande algoritm: M {q 0 } M EpsilonClosure(M) if F M /0 then return True repeat c NextSymbol() M SymbolTransition(M, c) M EpsilonClosure(M) if F M /0 then return True until M = /0 or NoMoreSymbols() return False Ovan är NextSymbol() en funktion som returnerar nästa indatasymbol. NoMoreSymbols() är en funktion som returnerar sant om det inte finns några fler indatasymboler. Funktionen SymbolTransition(M, c) ska givet en tillståndsmängd M och en indatasymbol c returnera en mängd som innehåller de symboler som kan nås om man från varje tillstånd i M följer de övergångar som är märkta med c. Funktionen kan beskrivas av följande algoritm: M /0 for each q i M do if s[i].symbol = c M M {q s[i].left } return M Nu återstår endast funktionen EpsilonClosure(M), som givet en tillståndsmängd M skall returnera mängden av de tillstånd man kan nå genom att följa ett godtyckligt antal ε-övergångar från något av tillstånden i M: repeat for each q i M do if s[i].symbol = if s[i].left 1 M M {q s[i].left } if s[i].right 1 M M {q s[i].right } until M does not change anymore return M Tecknet i ovanstående algoritm betecknar blanksteg. För att kunna implementera algoritmerna ovan måste vi kunna representera mängderna F, M och M. Ett enkelt sätt att göra detta är att låta dem representeras av var sin heltalsvektor med n element. En nolla i position i innebär att q i inte tillhör mängden, en etta att motsvarande element tillhör mängden. 4

Uppgifter Tips 1. Se till att du förstår de givna algoritmerna. 2. Skriv i en egen modul en procedur Automat() som simulerar en automat enligt beskrivningen ovan. Gränssnittet finns specificerat i filen /info/syntax99/labbar/1/nfasim.h. 3. I filen /info/syntax99/labbar/1/simulera.c finns ett huvudprogram som läser in an automat från fil, och sedan läser in text radvis och provkör simuleringsproceduren på texten. Använd detta huvudprogram för att provköra din simuleringsprocedur. Automaten i exemplet ovan finns i filen /info/syntax99/labbar/1/labb1.exempel. Testa exempelautomaten med några inmatningar. Vilket reguljärt uttryck motsvarar det språk exempelautomaten accepterar? 1. Det är mycket lärorikt att skriva ut innehållet i M lite då och då, och köra simulatorn på några olika indata. På detta sätt kan man få en känsla för hur en ickedeterministisk automat uppför sig. 2. I inledningen står det att varje ickedeterministisk ändlig automat kan skrivas om så att den passar algoritmen i denna laboration. Fundera igenom hur det går till. 3. De automater som behandlas i kursen fungerar normalt lite annorlunda än automaterna i denna laboration: Det normala är att automaten läser hela indata, och accepterar om den står i ett accepterande tillstånd när indata är slut. Fundera igenom hur algoritmerna ovan ska ändras för att man ska få det normala beteendet hos automaterna som simuleras. 5

Laboration 2 i Artificiella språk och syntaxanalys, våren 1999 Lexikal analys med Flex Flex är ett utmärkt verktyg om man vill göra lexikala ändringar i en text. I denna laboration ska du utnyttja Flex för att extrahera information ur en enkel databas över redovisningsbokningar och skapa en bokningslista. Databasen för bokningssystemet är på textformat. Först i databasen kommer deklarationer av några variabler. Den enda som är intressant för bokningslistan är variabeln RTID som anger hur många minuter en redovisning tar. Efter deklarationerna följer bokningshuvuden och bokningar. Varje bokningshuvud är en rad som inleds med tecknet > och följs av datum, starttid och sluttid för ett redovisningspass. Sist på raden kommer en sträng som anger i vilken sal redovisningarna ska äga rum och vem som ska ta hand om redovisningarna. Fälten skiljs av semikolon. Efter bokningshuvudet kommer de bokningar som hittills är gjorda till det redovisningstillfället, en bokning per rad. Varje bokningsrad inleds med tecknet : och följs av ordningsnumret (bokning 1 börjar på redovisningstillfällets starttid, bokning 2 börjar RTID minuter senare och så vidare), användarnamn samt vanligt namn på den som bokat in sig på tiden. Följande databasfil finns i filen /info/syntax99/labbar/ 2/bokning.db: NYBOK 15.00 AVBOK 1.00 RTID 40 >970129;8.10;10.00;Spelhallen;viggo :2;w93-fff;Byåker, Sölve :3;x96-tek;Ekrot, Torkel >970129;13.00;15.00;Sporthallen;viggo :1;a89-abc;Brylé, Anton >970130;8.05;23.00;Grön;enge :1;x94-gmy;Holm-Ström, Gottwolf :2;x94-gmy;Mysk 2, Gottward :3;x94-lbo;Bonn, Lissa :10;y94_ntn;Tessin, Nisse Utmatningen från programmet ska vara en bokningslista som anger namn, datum och tid för varje bokning. Ovanstående bokningsfil ska producera följande lista: Byåker, Sölve 970129 8.50 Ekrot, Torkel 970129 9.30 Brylé, Anton 970129 13.00 Holm-Ström, Gottwolf 970130 8.05 Mysk 2, Gottward 970130 8.45 Bonn, Lissa 970130 9.25 Tessin, Nisse 970130 14.05 6

Uppgifter Tips 1. Skriv en översättare enligt ovan i Flex. Programmet behöver inte hantera felaktiga indata. 1. Använd Flex möjlighet att märka de reguljära uttrycken med startvillkor (se avsnittet Start conditions i Flexmanualen i Info i Emacs och tal 2.8 i exempelsamlingen). Inför till exempel ett startvillkor för bokningshuvuden och ett för bokningar. 2. I databasen finns det fyra specialtecken: >, :, ; och \n. Använd dem så mycket som möjligt i dina reguljära uttryck. På så sätt slipper du begränsa innehållet i de olika fälten mer än nödvändigt. 7

Laboration 3 i Artificiella språk och syntaxanalys, våren 1999 Rekursiv medåkning Rekursiv medåkning (eng. recursive descent) är en metod att direkt från en grammatik skriva en enkel syntaxanalysator i ett vanligt programspråk, se avsnitt 3.3 i Introduction to compiler construction. I denna laboration ska du modifiera och bygga ut en rekursiv medåkningsanalysator för en enkel räknedosa. Du ska utgå från filen /info/syntax99/labbar/3/casio.c som innehåller en räknedosa med de fem räknesätten addition, subtraktion, multiplikation, division och exponentiering enligt nedanstående EBNF-grammatik. <start> ::= ENDSYM \n <start> <expr> \n <start> <expr> ::= <term> { ( + - ) <term> } <term> ::= <factor> { ( * / ) <factor> } <factor>::= <prim> [ ^ <factor> ] <prim> ::= NUMBERSYM - <prim> ( <expr> ) Uppgifter Tips 1. Se till att du förstår den givna analysatorn i detalj. 2. Bygg ut analysatorn med variabler och en tilldelningssats enligt följande tillägg till grammatiken: <start> ::= <assign> \n <start> <assign> ::= LET <variable> = <expr> <prim> ::= <variable> <variable> ::= VARIABLESYM Du måste alltså lägga till tre symboler LETSYM, ASSIGNSYM och VARIABLESYM till den lexikala analysatorn. Du får själv bestämma hur en variabel ska få se ut, men det räcker om du tillåter enbokstavsnamn. Du måste också hålla reda på variablernas värden i en symboltabell med hjälp av någon lämpligt vald datastruktur. 1. Se till att du följer reglerna för rekursiv medåkning slaviskt: Det ska finnas en procedur för varje ickeslutsymbol, och den proceduren ska titta på nästa tecken i indata, och jämföra det med de relevanta First- och Follow-mängderna. 8

Laboration 4 i Artificiella språk och syntaxanalys, våren 1999 Reguljära uttryck med Flex och Bison Denna laboration är en tillämpning av teorin för reguljära uttryck och kontextfria grammatiker. Du ska med hjälp av Flex och Bison skriva ett program som syntaxanalyserar ett reguljärt uttryck och skriver ut en beskrivning av en ickedeterministisk ändlig automat som känner igen språket som det reguljära uttrycket beskriver. När programmet är klart ska man kunna köra det och skriva in ett reguljärt uttryck, till exempel x(uv w)* som motsvarar x(uv w) med bokens notation. Programmet ska då på fil beskriva en ickedeterministisk ändlig automat som accepterar detta språk. Därefter ska man kunna använda programmet från laboration 1 för att simulera automaten och testa om olika inmatningssträngar accepteras. Reguljära uttryck beskrivs i avsnitt 2.6 i Introduction to compiler construction. Grammatiken för reguljära uttryck kan i BNF skrivas på följande sätt. <expression>::= <term> <expression> <term> <term>::= <factor> <term><factor> <factor>::= ( <expression> ) <factor> * v Lexikala regler: v betyder en bokstav (A Ö eller a ö); blanka får förekomma var som helst i uttrycket. Grammatiken ovan har medvetet skrivits vänsterrekursiv för Bisons skull, se sida 134 i Introduction to compiler construction och avsnittet Recursion i kapitlet Bison Grammar Files i Bisonmanualen. Uppgifter 1. Skriv om de kontextfria grammatiska reglerna ovan i Bison. Inför en extra regel < regexp > ::= < expression > och låt regexp vara startsymbol. Som lexikal analysator yylex() ska Flex användas. Låt LETTER vara slutsymbolen som motsvarar en bokstav. Låt huvudprogrammet bara kolla värdet av yyparse() och skriva korrekt (om det var ett riktigt reguljärt uttryck) eller felaktigt beroende på om värdet var 0 eller 1. Programmet är nu en färdig syntaxanalysator (parser) som känner igen språket av (korrekta) reguljära uttryck. Kör Flex och Bison, kompilera och prova att mata in några riktiga och felaktiga reguljära uttryck. För att tala om att ett uttryck är färdiginmatat måste man kanske (beroende på hur yylex() ser ut) trycka på CTRL-D, dvs filslut, först på en rad. 2. Nu ska syntaxanalysatorn byggas ut till en översättare, som givet ett reguljärt uttryck skapar och matar ut en ickedeterministisk automat. Uppgiften är alltså att skapa övergångsrelationen N dvs vektorerna nextch[], next1[] och next2[] från laboration 1 samt mängden F av accepterande tillstånd. Låt state vara en heltalsvariabel som håller reda på indexet för den första oanvända platsen i tillståndsvektorerna nextch[], next1[] och next2[]. Sätt state=1 från början. Starttillståndet, som har nummer 0, kommer att tillverkas sist av allt, i regexp-regeln. Läs om hur ett reguljärt uttryck översätts till en NFA i avsnitt 2.7 i Introduction to compiler construction. Varje regel i din grammatik känner igen ett reguljärt uttryck som är ett deluttryck i hela det reguljära uttrycket. Låt regeln bilda den delautomat som motsvarar det deluttrycket. Denna delautomat har ett starttillstånd och ett sluttillstånd. För att delautomaten ska kunna kopplas ihop med resten av automaten måste dess starttillstånd och sluttillstånd bli kända för de andra reglerna. Detta går att göra genom att regeln som semantiskt värde returnerar en post som innehåller de två heltalen enterstate och exitstate som anger numren på delautomatens starttillstånd och sluttillstånd. Alltså måste varje regel sätta värden på $$.enterstate och $$.exitstate. Skapa ett nytt tillstånd genom att anropa proceduren setstate(). 9

expression expression term term term factor term factor factor * factor v v Figur 1. Ovan anges hur en automat som svarar mot ett visst givet reguljärt uttryck byggs upp stegvis. Alla övergångar är epsilonövergångar utom den som läser en bokstav i den nedersta automaten. När man skapar en delautomats sluttillstånd vet man inte ännu vart uthoppet ska gå, utan övergången måste sättas av den regel som senare kombinerar den aktuella delautomaten med nästa delautomat. Enklast blir det om du alltid ser till att uthoppet från delautomaten går från next1[]. Initiera uthoppsövergången till 1 så är det lätt att se på automaten om något uthopp förblir otilldelat. Figur 1 talar för varje regel om hur motsvarande ändliga automat kan byggas. När vektorerna är färdiguppbyggda återstår bara att skriva ut dem på fil. Detta kan till exempel göras i main() efter anropet av yyparse(). När programmet är klart ska det kunna producera filer som kan läsas av simulatorn från laboration 1. Titta i de givna källkodsfilerna från laboration 1 för att ta reda på indatafilens format. Prova några reguljära uttryck och kolla att allt fungerar. Det är inte nödvändigt med någon felhantering. Tips 1. Det kan vara lite bökigt att få Flex och Bison att arbeta ihop som man vill, i synnerhet som man i både Flex- och Bison-filen behöver veta vilka slutsymboler som används. För att göra det lättar att komma igång finns det skelettfiler på kurskatalogen. Dessa filer innehåller deklarationer som gör att Flex och Bison samarbetar på ett smidigt sätt. I dessa filer finns också några kodsnuttar för att hjälpa dig på traven. Notera att några av raderna ska tas bort när du gör deluppgift 1. 2. Du ska inte använda den interna Bison-variabeln yylval i Bisonfilen. Den är bortabstraherad använd de olika $-variablerna istället. 10

Laboration 5 i Artificiella språk och syntaxanalys, våren 1999 En valfri översättare I denna laboration ska du få tillämpa det du har lärt dig i kursen på en egen praktiskt användbar översättare. Du ska antingen skriva en översättare från en välkänd notation till en annan eller en granskare som kollar syntaxen och ger vettiga felmeddelanden om inmatningen är felaktig. Du får själv välja uppgift bland förslagen nedan. Det är tillåtet att komma med egna förslag; de måste godkännas av den kursansvarige. Ditt program ska använda både lexikal och syntaktisk analys, men det är inget krav att du använder just Flex för den lexikala analysen och Bison för den syntaktiska. På kursens hemsida i webben finns det länkar till några olika syntaxanalyseringsverktyg. Kom ihåg att du inte kan förvänta dig att få hjälp av handledarna med andra verktyg än dem som använts i kursen. Uppgift 1. Välj en av nedanstående uppgifter. Uppgifterna 1 4 består i princip av att du själv ska utveckla en grammatik eller både en notation och en grammatik, och sedan tillämpa det du utvecklat. I uppgifterna 5 8 ska du sätta dig in i en färdig grammatik, som kan vara ganska stor, och sedan använda grammatiken för att lösa uppgiften. 2. Skriv ner en kravspecifikation för programmet. Eftersom uppgifterna ibland är vagt formulerade kan det finnas en del detaljer som bör fyllas i. Om du har valt någon uppgift som inte står med i listan nedan måste du visa upp din specifikation för någon av lärarna för att få klartecken att göra uppgiften. Annars räcker det att du tar med specifikationen när du redovisar programmet. 3. Ta reda på grammatiker för de språk ditt program ska behandla. Sök gärna information i Internet. På kursens hemsida finns en del pekare till användbar information. Du kanske till och med kan hitta en färdig grammatik i det format som det syntaxanalyseringsverktyg du valt vill ha. Däremot får du förstås inte kopiera färdiga program det är du som ska lösa uppgiften och inte någon annan. 4. Skriv med hjälp av det syntaxanalyseringsverktyg du valt ett program som löser uppgiften (det vill säga uppfyller kravspecifikationen). Programmet måste hålla god kvalitet (vara korrekt, effektivt, lättläst, flexibelt och robust). 5. Skriv en enkel användarhandledning för programmet. 6. Du kommer att redovisa för en handledare på kursen eller för den kursansvarige. Redovisningen är indelad i två delar. Den första delen, som är femton minuter lång, består av att du presenterar ditt program. Det ska då framgå vilka verktyg du har använt, vilka designval du har gjort samt vilka delar ditt program består av. Under den andra delen, som är tio minuter lång, kommer du att få svara på frågor angående ditt program. Du ska känna till ditt programs funktion i detalj och dessutom kunna motivera de eventuella designval du har gjort. Förslag på uppgifter 1. Verifiering av SGML-dokument. Verifieraren skall läsa in en DTD, som beskriver en godtycklig SGML-instans, och sedan verifiera dokument utifrån denna DTD. Prova gärna din verifierare med DTD:er för olika versioner av HTML. 2. En bättre Makedepend. Unix-programmet Makedepend går igenom alla c- och h-filer i en katalog och skapar en lista av beroenden som automatiskt stoppas in i filen Makefile, om den finns i katalogen. Följande är saxat från man-bladet till Makedepend: 11

BUGS If you do not have the source for cpp, the Berkeley C preprocessor, then makedepend will be compiled in such a way that all #if directives will evaluate to true regardless of their actual value. This may cause the wrong #include directives to be evaluated. Makedepend should simply have its own parser written for #if expressions. Du ska skriva en Makedepend som inte har dessa brister. Din Makedepend ska alltså innehålla en egen parser för #if-uttryck, och den ska alltid inkludera och analysera de #include-filer som inte är systemfiler. 3. Förbättrad Flex- och Bison-syntax. Uppfinn en snygg och lättläst syntax som gör det möjligt att skriva både lexikala och syntaktiska regler i en fil. Skriv sedan ett program som läser in en sådan fil och skriver ut en Flex- och en Bison-fil, som sedan kan kompileras på vanligt sätt. 4. Skriv en M3flex, dvs en variant av Flex som producerar kod i Modula-3. Du får själv hitta på en syntax om du vill, men det är fullt tillåtet att använda en syntax liknande den i Flex. M3flex ska generara en modul Scanner som innehåller proceduren GetToken, så att den genererade lexikala analysatorn kan användas av M3bison. Procedurhuvudet skall vara PROCEDURE GetToken(VAR lval: T): INTEGER RAISES {Error}; där särfallet Error ska genereras vid lexikala fel. Antag att Scanner.i3 genereras av M3bison, och anpassa innehållet i Scanner.m3 efter detta. Analysatorn behöver inte klara av det som med Flexterminologi kallas startvillkor (Start Conditions). 5. Skriv ett program som översätter från standard-pascal till C eller C++. Översättaren behöver varken klara av att hantera mängder, variantdelar i poster, procedurer i procedurer eller WITH-satser. Ditt program ska upptäcka om det ursprungliga Pascal-programmet inte är syntaktiskt korrekt, och i sådant fall avbryta med någon lämplig felutskrift. 6. Programförskönare för Javakod, Pascalkod eller liknande (dock ej C eller C++). Förskönaren skall bryta för långa rader på syntaktiskt lämpliga ställen, och indentera enligt någon lämplig konvention. Om programmet du försöker indentera inte är syntaktiskt korrekt, ska programförskönaren upptäcka detta och avbryta indenteringen. 7. Vacker utskrift av Javakod, Pascalkod eller liknande (dock ej C eller C++). Programmet ska ta en källkodsfil, och producera en TEX- eller LATEX-fil som ger en vackert formatterad utskrift av källkoden. Exempelvis bör kommentarer, nyckelord, variabler och preprocessordirektiv ges olika utseende. Om programmet du försöker behandla inte är syntaktiskt korrekt, ska programförskönaren upptäcka detta och avbryta indenteringen. 8. Konvertera Fortran till C. Det räcker om ditt program klarar av att översätta från Fortran 77 till ett C-program, som får innehålla goto-satser. Ditt program ska upptäcka om det ursprungliga Fortranprogrammet inte är syntaktiskt korrekt, och i sådant fall avbryta med någon lämplig felutskrift. 12