Indhold 1 Compilerens opbygning 2 Leksikalsk analyse 3 Grammatikker 4 LL-parsing 5 LR-parsing 6 Det abstrakte syntaks-træ 7 Attribut-grammatikker

Transkript

1 Indhold 1 Compilerens opbygning Compilerensfunktion Fasericompileringen TinyogC Leksikalsk analyse Strengeogsprog Regulæreudtryk Deterministiskeendeligeautomater Non-deterministiskeendeligeautomater FraregulærtudtryktilNFA FraNFAtilDFA FraDFAtilregulærtudtryk Lexer-generatorer Grammatikker Begrundelse Grammatikker Engrammatikforaritmetiskeudtryk EngrammatikforTiny Andrespecifikationerafgrammatikker LL-parsing Recursivedescent LL(1)-parseren First-ogfollow-mængder LR-parsing Bottom-upparsing LR(0)-parsing SLR(1)-parsing LR(1)-parsing LALR(1)-parsing Parsingaftvetydigegrammatikker Det abstrakte syntaks-træ Parsergeneratorer Detabstraktesyntakstræ ImplementeringafAST Semantiskehandlinger TraverseringafAST Attribut-grammatikker Attributter og attribut-grammatikker Synthetiserede og nedarvede attributter Algoritmer til beregning af attributter

2 8 Symboltabellen Scopeoglevetid Implementeringafsymboltabellen D Typer og typecheck Simpledatatyper Enumererededatatyper Arrays,recordsogpointere Objekter Assignments Typecheck Procedurer Hukommelsensorganisering Fuldtstatiskekøretidsomgivelser Stak-baseredekøretidsomgivelser Stak-baseredekøretidsomgivelsermed lokaleprocedurer Fuldtdynamiskekøretidsomgivelser Parameteroverførselsmekanismer RISC-ogCISC-processorer Mellemrepræsentationen Begrundelseformellemrepræsentationen Instruktioneri3AC Udtryki3AC Kontrolstrukturerogprocedurekald i3ac Datatyperi3AC Implementeringaf3AC Kodegenerering RISC-processorer CISC-processorer Javasvirtuellemaskine Registerallokering Ideenbagregisterallokering Levetidsanalyse Opbygningafinterferens-grafen Farvningafinterferens-grafen Optimering af kode Overblik Foldning af konstanter og konstant-propagation Kopi-propagation Eliminationafdød kode Fællesdeludtryk Løkke-invarianter Reduktionistyrke Løsninger til udvalgte opgaver 154 2

3 Litteratur 168 3

4 1 Compilerens opbygning Vi skal i dette skrift se på, hvorledes en compiler fungerer og på, hvorledes den kan implementeres. Vi starter derfor meden kort oversigt over, hvaden compiler faktisk gør. 1.1 Compilerens funktion En typisk compiler modtager et program, f.eks. et C++-program, i den ene ende og producerer en binær, eksekverbar fil i den anden. Faktisk gemmer der sig i ovenstående sætning to formål meden compiler: 1) Compileren skal, for et korrekt kildeprogram, producere den tilsvarende, korrekte eksekverbare fil 2) Compileren skal kunne detektere eventuelle fejl i kildekoden, gøre opmærksom på disse fejl, og undlade at producere en eksekverbar fil, hvis der faktisk var fejl Ordet korrekt er her meget vigtigt. Det ville være katastrofalt, hvis compileren bare spiste alt det, man fodrede den med og, i tilfælde af fejl, spyttede noget sludder ud igen det ville være alt for nemt at komme til at anvende den ukorrekte, eksekverbare fil til et eller andet. Endelig er man naturligvis interesseret i, at resultatet den eksekverbare fil er så hurtig, så effektiv som mulig. Men dette må siges at være et sekundært mål. Compiler-teknologi anvendes faktisk også i en lang række af andre typer programmer. Mest nærliggende er det nok at se på oversættere, dvs. programmer, der oversætter en fil i en repræsentation til en fil i en anden repræsentation. Således indeholder de fleste tekstbehandlingsprogrammer mulighedfor at kunne læse og skrive filer i adskillige filformater. Ofte er det rimeligt trivielt at transformere tekst fra et format til et andet, men i mange tilfælde får man brug for større eller mindre dele af en compiler. Med udbredelsen af XML vil det blive almindeligt med programmer, der kan transformere fra et XML-format til et andet. XML har en så kompliceret struktur, at her har man brug for en parser for at kunne gennemføre disse transformationer. Men compilerteori anvendes også i enhver browser. En browser er i virkeligheden at opfatte som en compiler, der modtager et HTML-dokument, og oversætter dette. Outputtet er ikke eksekverbar kode, men derimod grafik på en skærm. Brugere af L A TEX vil også være vant til, at L A TEX modtager en kildekode-fil, som så oversættes til grafik på skærmen eller papiret. I begge tilfælde anvendes der algoritmer og metodikker fra compilerteorien. 1.2 Faser i compileringen En compiler er et meget stort og kompliceret program, og for at reducere kompleksiteten er det en fordel at kunne modularisere compileren. Det viser sig at være nemt at lave denne opdeling, idet compileringsprocessen naturligt kan opdeles i en række faser. Gennem tiderne har man fået analyseret sig frem til følgende faser i compileringen: 4

5 1) Leksikalsk analyse 2) Syntaktisk analyse 3) Semantisk analyse 4) Generering af mellemrepræsentationen 5) Optimering af mellemrepræsentationen 6) Generering og optimering af målkoden leksikalsk analyse syntaktisk analyse semantisk analyse gen. af mellemrep optimering kildekode tokens det abstrakte syntakstræ dekoreret abstrakt syntakstræ mellemrepræsentation kodegenerering mellemrepræsentation målkode Figur 1 Hver enkelt fase modtager et input og leverer et output se figur 1 for en grafisk oversigt. Inden vi gennemgår de enkelte faser, skal der defineres nogle begreber: De tre første faser i compileringen kaldes analysen, eller compilerens front-end. I disse faser undersøges kildekodens opbygning, der tjekkes for en lang række fejl, og hvis de ikke findes, ender vi op med det dekorerede abstrakte syntakstræ, som er en (mere eller mindre) abstrakt beskrivelse af kildekoden. 5

6 De tre sidste faser er syntesen eller compilerens back-end. Her genereres, i flere trin, målkoden eller den eksekverbare fil ud fra det dekorerede, abstrakte syntakstræ. To andre begreber, som det er vigtigt at skelne imellem, er syntaks og semantik. Syntaksen for en stump kildekode henviser til den grammatiske opbygning af kildekoden, mens semantikken refererer til selve betydningen af kildekoden. F.eks. har følgende tre sætninger: = 4, Summen af tallene 2 og 2 er 4, Man får resultatet 4, når man plusser 2 og 2 en meget forskellig syntaks, men semantikken er den samme. I princippet er der ingen sammenhæng mellem syntaks og semantik, men da det i virkeligheden er meget svært algoritmisk at kunne finde semantikken af en vilkårlig sætning, vælger man indenfor compilerteorien af arbejde med syntaks-styret semantik. Dette betyder, at man nemt kan afgøre semantikken af et program udfra syntaksen af programmet samt de semantiske regler for programmeringssproget. Man opnår herved, at betydningen af et program bliver klar så klar, at en computer kan arbejde med den men prisen, man betaler, er, at programmeringssproget bliver meget ufleksibelt i forholdtil daglig tale. I den første fase af compileringen, den leksikalske analyse, opdeles kildekoden i et antal tokens, og overflødig information smides væk. Et token er en størrelse, som repræsenterer et symbol, et reserveret ord, en identifier eller lignende. Betragt f.eks. følgende stump Java-kode: public static void main(string[] args) { // dette er en kommentar if (x == 34) y++; Lexeren vil opdele dette i følgende tokens: public static identifier(void) identifier(main) lparen identifier(string) lbracket rbracket identifier(args) rparen if lparen identifier(x) equals numeral(34) rparen identifier(y) increment semicolon rbrace De fleste tokens svarer til reserverede ord eller symboler i Java, men f.eks. increment er et token, der svarer til symbolkombinationen ++. Andre tokens svarer til identifiers navne på metoder, variable etc. eller til literale værdier i programmet, f.eks. tallet 34. Kommentarer og white spaces som mellemrum, linieskift eller tabulatorspring ignoreres, da de ikke har videre betydning for compileringen. I den næste fase, den syntaktiske analyse eller parsingen, sættes de forskellige tokens sammen i det abstrakte syntakstræ. Ideen er her at få opbygget en todimensional repræsentation af programmet finde ud af, hvilke statements der hører til hvilken metode, undersøge, hvornår en løkke-struktur starter og slutter, etc. Både den leksikalske og den syntaktiske analyse er blevet undersøgt intenst gennem de sidste 50 år. Dette betyder, at der findes en række sofistikerede algoritmer, som man skal sætte sig ind i. Heldigvis betyder dette også, at disse faser er forstået så godt, at de kan automatiseres... 6

7 I den semantiske analyse tilføjer vi ekstra information til den abstrakte syntakstræ vi dekorerer det. Denne information er af semantisk karakter vi skal bl.a. have fundet ud af, hvilke variable, der anvendes i programmet, hvilke typer de har, og hvor i programmet de er synlige. Vi skal også have foretaget det såkaldte typecheck. Her undersøger vi, om samtlige assignments, sammenligninger og metodekald er lovlige man kan f.eks. ikke på fornuftig vis multiplicere en boolean meden char. Efter den semantiske analyse er vi nu færdige med analyse-delen af compileren, og vi har det dekorerede, abstrakte syntakstræ for et korrekt program hvis vi da ikke konstaterede nogle fejl undervejs. Næste fase er en oversættelse af det abstrakte syntakstræ til mellemrepræsentationen. Da vi i sidste ende skal have genereret noget maskinkode, skal vi på et eller andet tidspunkt have transformeret høj-niveau-konstruktioner i kildekoden, som f.eks. en for-sætning, til nogle lavniveau-konstruktioner, som en CPU faktisk kan udføre, f.eks. sammenligninger og betingede hop. Det viser sig at være smart ikke allerede nu at generere den konkrete maskinkode dette vil komme til at afhænge alt for meget af mål-cpu ens særheder. I stedet vælger man at transformere til en form for abstrakt maskinkode, mellemrepræsentationen, som man derefter kan arbejde videre med. Vi skal se på flere forskellige former for mellemrepræsentation, men især anvende den såkaldte three adress code. Dernæst skal mellemrepræsentationen optimeres, og endelig genererer vi den konkrete maskinkode, målkoden. Vi vil dog snyde lidt og ikke generere målkode direkte til vores mål-cpu, men nøjes med at generere assembler-kode. Denne skal så assembles en ekstra gang. 1.3 Tiny og C- Vi vil anvende to sprog som eksempel på, hvorledes man kan implementere en compiler, nemlig Tiny og C-. Begge sprog er taget fra [Lou]. Tiny er, som navnet antyder, et meget simpelt sprog. I sin syntaks minder det meget om Pascal. I Tiny kan man kun arbejde med hele tal, og der findes ikke procedurer eller funktioner. Tiny indeholder kun statements som if, if-else, repeat-until, read, write og assignments. Et eksempel på et Tiny-program er følgende: read x; if x > 0 then fact := 1; repeat fact := fact * x; x := x - 1; until x = 0; write fact end Sin simpelhed til trods er Tiny komplekst nok til, at det ikke er en helt triviel opgave at skrive en compiler til Tiny. 7

8 C- er en simplificeret variant af C. Man kan i C- arbejde med hele tal, arrays af hele tal, funktioner, procedurer også rekursive funktioner og procedurer lokale og globale variable. Der er statements som if, if-else og while. Et eksempel på et program skrevet i C- er: int fact( int x ) { /* recursive factorial function */ if (x>1) return x*fact(x-1); else return 1; void main( void ) { int x; x = read(); if (x>0) write (fact (x)); 8

9 2 Leksikalsk analyse Vi går straks i gang med den første fase i compileringen, nemlig den leksikalske analyse. Formålet med den leksikalske analyse er dels at få selve kildekoden opdelt i tokens: Reserverede ord, identifiers, literale strenge og tal-konstanter, symboler etc., og dels at få fjernet symboler, der i virkeligheden er irrelevante for compileringen, f.eks. white spaces som mellemrum og linieskift, samt kommentarer. Outputtet af denne fase er en sekvens af tokens, som leveres videre til parsingen, compileringens næste fase. Vi skal i det følgende se på, hvorledes de forskellige tokens kan specificeres dette sker vedde såkaldte regulære udtryk og vi skal undersøge de konkrete algoritmer, hvorved opsplitningen i tokens foregår. Herunder kommer vi ind på d e såkaldte endelige automater. Endelig ser vi på ensåkaldt lexer-generator, JLex, som er et program, der ud fra en liste af regulære udtryk skriver programkoden til en færdig lexer. Materialet i dette kapitel er at finde i stort set alle bøger om compilerteori, f.eks. [ASU], [Lou] eller [App]. Endvidere indeholder [Sip] en mere formalistisk gennemgang af teorien for regulære udtryk og endelige automater. 2.1 Strenge og sprog Det grundlæggende begreb indenfor sprogteorien er strengen. Viskalnusekortpå, hvorledes strenge og sprog kan defineres formelt: Et alfabet er en endelig mængde af symboler. Vi betegner ofte alfabetet ved Σ. Som regel afhænger valgte af alfabet af, hvilken situation vi er i. Snakker vi om sproget dansk, så er alfabetet mængden {a, b, c,..., x, y, z, æ, ø, å. I de fleste programmeringssprog, som f.eks. C++ og Pascal, anvendes alfabetet ASCII i hvert tilfælde så længe vi er i den leksikalske analyse. (Under den syntaktiske analyse er vores alfabet lig medmængden af tokens) En streng x over alfabetet Σ er en endelig sekvens af symboler fra Σ. Den tomme streng er en streng bestående af 0 symboler og betegnes ofte ɛ. Længden af strengen x er lig medantallet af symboler i symbolsekvensen x og betegnes x. Konkatenationen af strengene x = a 1 a 2...a m og y = b 1 b 2...b n er strengen x y = a 1 a 2...a m b 1 b 2...b n Ofte skriver vi xy i stedet for x y. (I de fleste programmeringssprog, som f.eks. Java, angives konkatenation ved symbolet +. Vi vælger dog at anvende i stedet, idet plus-symbolet også optræder med andre betydninger senere.) Mængden af strenge over Σ betegnes Σ. Eksempel 1 Lados betragte alfabetet Σ = {a, b. Nedenfor er angivet nogle strenge fra Σ : aababbbb = a 2 bab 4, aaaaa = a 5,ɛ Bemærk, at vi anvender multiplikativ (eksponentiel) skrivemåde for strenge. Længderne af disse tre strenge er henholdsvis 8, 5 og 0. 9

10 Definition 2 Et sprog over alfabetet Σ er en mængde af strenge over Σ, dvs. en delmængde af Σ. Sagt på enandenmåde et sprog består af en række strenge, som er lovlige. F.eks. indeholder sproget dansk strengene hest, bro og oversætter, men ikke strengene aslglkahf eller xzxzxzxzxzxz. Sprog kan defineres på adskillige måder enten direkte, vha. brug af mængdebyggernotationen, rekursivt vha. grammatikker, eller vha. regulære udtryk. Vi vil i de følgende kapitler se nærmere på disse definitionsmåder. 2.2 Regulære udtryk Vi skal nu se på regulæreudtrykogpå, hvorledes disse kan definere sprog. Vi starter med at betragte nogle operationer, hvorvedvi kan danne nye sprog udfra gamle: Definition 3 Lad L og M være sprog over alfabetet Σ. Så defineres a) Foreningsmængden L M = {x Σ x L eller x M b) Konkatenationen L M = {x Σ x kan skrives som lm med l L og m M c) Lukningen L = {ɛ L L 2 L 3...= i=0 Li Sagtiord:Ved L M vælger man en streng fra enten L eller M, vedlm tager vi en vilkårlig streng fra L og konkatenerer meden vilkårlig streng fra M, ogvedl konkatenerer vi et vilkårligt antal strenge fra L. Da sprog er mængder, så kan vi naturligvis også tage fællesmængder, mængdedifferenser og komplementærmængder, men disse operationer spiller ingen rolle i sprogteorien. Lados give et eksempel på lukningen af et sprog: Eksempel 4 Betragt Σ = {a, b. {a, b er mængden af alle mulige strenge, som kun består af a og b. {ab er mængden {(ab)n n N 0 Vi kan nu definere et regulært udtryk ved følgende rekursive definition: Definition 5 Et regulært udtryk R over alfabetet Σ er af en af følgende former: a) a for et vilkårligt symbol a Σ b) ɛ, den tomme streng c) R S, hvorr og S er regulære udtryk d) R S, hvorr og S er regulære udtryk e) R,hvorR er et regulært udtryk 10

11 Ligesom ved aritmetiske udtryk undlader man helst parenteser dette kræver, at de tre operationer, og sættes indi et operator-hierarki. Vi vælger at lade have højst prioritet, dernæst kommer, og får så laveste prioritet. (Sammenlign medpotensopløftning, med multiplikation og med addition). Eksempel 6 Betragt udtrykket a (ab ɛ) (ab) a. Dette er et regulært udtryk, og den nemmeste måde at se dette på er at opbygge udtrykket fra bunden i et såkaldt syntakstræ. I bladene i dette træ står der kun symboler fra Σ eller ɛ, og i de indre knuder står der enten, eller ; vi taler her om stjerne-, konkatenation- og streg-knuder. En stjerne-knude har kun en efterfølger, mens de to andre typer indre knuder altid har to efterfølgere. Træetervistpåfigur2... * * * a.. a a b a b Figur 2 Til et regulært udtryk R kan vi tilknytte et sprog, L(R). Dette er igen defineret rekursivt: Definition 7 a) Hvis R = a, såerl(r) ={a b) Hvis R = ɛ, såerl(r) ={ɛ c) Hvis R = R 1 R 2,såerL(R) =L(R 1 ) L(R 2 ) d)hvisr = R 1 R 2,såerL(R) =L(R 1 ) L(R 2 ) e) Hvis R = R 1,såerL(R) =L(R 1 ) Sagt på enandenmåde: I et regulært udtryk betyder valg, konkatenation, og * et vilkårligt antal gentagelser. Eksempel 8 Nogle regulære sprog over alfabetet Σ = {a, b er 1) L(a ba )={w Σ w indeholder netop et b 11

12 2) L((a b) b(a b) )={w Σ w indeholder mindst ét b 3) L((a b) aab(a b) )={w Σ w indeholder delstrengen aab 4) L(((a b)(a b)) )={w Σ w indeholder et lige antal karakterer 5) L(((a b)(a b)(a b)) )={w Σ w er et multiplum af 3 6) L(ab ba) ={ab, ba 7) L(a(a b) a b(a b) b)={w Σ w begynder og ender med samme symbol 8) L((a ɛ)b )=L(ab b )={ab n n 0 {b n n 0 9) L((a ɛ)(b ɛ)) = {ɛ, a, b, ab 2.3 Deterministiske endelige automater Vi skal nu beskrive genkendelsesmaskiner for regulære udtryk, nemlig de såkaldte endelige automater. Endelige automater forekommer i to varianter, deterministiske og non-deterministiske, og vi beskriver først de deterministiske automater: Eksempel 9 a b a b a,b Figur 3 På figur 3 ovenfor er vist en deterministisk endelig automat. Den består af tre tilstande hver cirkel angiver en tilstand. Tilstanden 1 er starttilstanden, hvilket man kan se på den indkommende pil fra venstre. Tilstand 2 er en sluttilstand, og den tilsvarende cirkel er derfor fedt optrukket. Mellem tilstandene er der overgange, symboliseret vedpilene. Til hver overgang er der tilknyttet et symbol, hvilket betyder, at overgangen kun er tilladt, hvis det pågældende symbol er forrest i den streng, vi er ved at behandle. Lados fodre automaten medstrengen abbab. Vi starter i tilstand 1, og da det første symbol i strengen er et a, udfører vi overgangen fra 1 til 1, hvorved a et spises, og vi har nu strengen bbab tilbage. Det forreste b fører os over i tilstand2, og endnu et b fører os fra tilstand2 til tilstand2. Den resterende streng er nu ab, og vi går fra tilstand2 til tilstand 3, og det sidste b fører os tilbage til tilstand 2. Da vi ender i en sluttilstand, så har automaten accepteret strengen abbab. Vi kan også fodre automaten med aabba. Vi bevæger os så imellem tilstandene i rækkefølgen , og da vi ikke ender i sluttilstanden 2, så accepterer automaten ikke strengen aabba. Lad os angive den formelle definition af en deterministisk endelig automat forkortet DFA (Deterministic Finite Automaton): Definition 10 En deterministisk endelig automat består af størrelserne (Q, Σ,δ,q 0,F),hvor Q er en endelig mængde af tilstande 12

13 Σ er et alfabet δ : Q Σ Q er overgangsfunktionen q 0 Q er begyndelsestilstanden F Q er mængden af sluttilstande Automaten virker på en streng s = a 0 a 1...a n af symboler fra Σ således: Vi danner en sekvens af tilstande q 0,q 1,q 2,...,q n,q n+1 ved q 1 = δ(q 0,a 0 ),q 2 = δ(q 1,a 1 )...,q n+1 = δ(q n,a n ) Automaten accepterer strengen, hvis q n+1 F. Vi er specielt interesseret i mængden af de strenge, som accepteres af en given DFA. Som vi senere skal se, kan vi til ethvert regulært sprog konstruere en DFA, som netop accepterer strengene i sproget, og omvendt er et sprog, som accepteres af en DFA altid et regulært sprog. Regulære sprog (eller regulære udtryk) og endelige automater er derfor i virkeligheden to sider af samme sag. Eksempel 11 Lados beskrive DFA en fra eksempel 9 formelt: Mængden af tilstande er Q = {1, 2, 3, og alfabetet er Σ = {a, b. Det er nemmest at angive overgangsfunktionen veden tabel: a b Starttilstanden er q 0 = 1, og sluttilstandene er F = {2. Det regulære udtryk, der accepteres af automaten, er givet ved a b((aa ab) b ).Lad os argumentere for dette: For at komme fra starttilstanden 1 til sluttilstanden 2 skal vi først gennemløbe et antal a er og dernæst netop ét b. Dette betyder, at vores streng skal starte med a b. Vi er nu i sluttilstanden 2, og kan komme tilbage hertil ved enten at tage nogle b-ture eller, via tilstand3, (aa ab)-ture. Da disse kan komme i vilkårlig rækkefølge, svarer dette til ((aa ab) b ),ogtilsammenfår vi altså resultatet a b((aa ab) b ). Vi skal senere se en generel algoritme til at rekonstruere det regulære udtryk ud fra DFA en. Det er ikke altid, at man angiver en overgang fra en tilstand for alle symboler i alfabetet. I dette tilfælde accepteres en streng ikke, hvis man pludselig kommer ud for en overgang, der ikke findes: Eksempel 12 Betragt DFA en på figur 4. Det ses, at når automaten først når nedi tilstanden 4, så kan den aldrig slippe væk igen vi kalder tilstand 4 for en fælde. Vi kunne derfor ligeså godt anvende automaten på figur 5. Her er fælde-tilstanden 4 udeladt, og vi får en meget simplere figur. 13

14 a a b b b a 4 a,b Figur 4 a a b b Figur Non-deterministiske endelige automater En variant af den deterministiske endelige automat er den non-deterministiske endelige automat forkortet NFA (Non-deterministic Finite Automaton). I en NFA kan der være flere forskellige overgange ud fra den samme tilstand med det samme symbol, og der kan tilmed være overgange, som kan finde sted spontant uden at spise et symbol fra strengen de såkaldte ɛ-overgange. Som følge heraf kan vi ikke sige, at NFA en er i en bestemt tilstand, men derimod i en mængde af tilstande samtidigt. Eksempel 13 a,b 1 b 2 a, 3 Figur 6 b a,b 4 På figur 6 er vist en NFA. Den har 4 tilstande, hvoraf 1 er starttilstanden og 4 er en sluttilstand. Det er en non-deterministisk automat, da f.eks. tilstand 1 har to b-overgange udfra sig, og der er en ɛ-overgang mellem tilstand2 og 3. Lad os fodre denne automat med strengen ababba. Til at begynde med er vi kun i starttilstanden 1, og efter at have spist det første a kan vi kun stadigvæk være i tilstand 1. Nu kommer et b, og herefter er vi i tilstand1 eller 2. Men automaten kan spontant spise et ɛ altså ingenting og ende i tilstand 3, så vieraltså i tilstandene 1, 2 eller 3. Endnu et a, og tilstand1 forbliver tilstand1, tilstand2 bliver til tilstand3, og da der ingen a-overgange er fra tilstand 3, dør denne. Vi er altså i tilstand1 eller 3. Så kommer et b, ogvienderitilstandene1,2,3og4.endnuetb, og vi er igen i 1, 2, 3 og 4. Endelig kommer det sidste a, som fører os over i tilstandene 1, 3 eller 4. Da tilstand 4 er en sluttilstand, så accepterede automaten strengen. 14

15 Vi vil ikke give en formel definition af en NFA, da denne definition nok vil forvirre mere, endden forklarer. Heldigvis anvender man sjældent NFA er i praksis det viser sig, at de er komplicerede at implementere, og endvidere er udførelsestiden høj: Har automaten m tilstande, så tager det for en streng med længde n tiden O(mn) at se, om strengen accepteres. For en DFA er situationen meget bedre her tager det kun tiden O(n). Men NFA er spiller en vigtig rolle inden for den videre teori. 2.5 Fra regulært udtryk til NFA Der gælder følgende resultat: Sætning 14 Til enhver NFA findes der en DFA, som accepterer det samme sprog. Et sprog er regulært, hvis og kun hvis der findes en DFA, som accepterer det. Vi vil ikke bevise denne sætning, men i stedet eksemplificere den ved et par eksempler. Gennemfører man faktisk beviset, så skal man anvende følgende strategi: a) Beskriv en algoritme, som tildeler en NFA til et regulært udtryk. b) Beskriv en algoritme, som kan omdanne en NFA til en DFA c) Beskriv en algoritme, som, givet en DFA, kan fortælle, hvilket regulært udtryk, der accepteres af denne. I den første algoritme husker man på, at et regulært udtryk er defineret rekursivt: a (for a Σ) og ɛ er regulære udtryk, og hvis R og S er regulære udtryk, så err S, R S og R det også. Det er nemt at konstruere automater for udtrykkene a og ɛ sefigur7 Antag nu, at vi har konstrueret non-deterministiske automater for udtrykkene R og S således, at disse kun har en sluttilstand. Som figur 7 viser, kan vi konstruere en ny nondeterministisk automat for R S, for R S og for R. Eksempel 15 Lados konstruere en NFA for udtrykket (a b) abb. Dette gøres nemt medalgoritmen fra før. Nogle af trinene på vejen er vist på nedenstående figur 8: Den færdige automat er vist nederst på figur 8. Som det ses, er der masser af ɛ- overgange, der jo kun er til besvær. Det er derfor en fordel at kunne lave denne NFA om til en DFA. 2.6 Fra NFA til DFA Når man skal transformere en NFA til en DFA er det en god ide at huske på, at en tilstandi en NFA i virkeligheden er en mængde af tilstande. Vi kan således lave en NFA om til en DFA ved at tage samtlige delmængder af tilstande i NFA en og lade disse være tilstandene i den nye DFA. 15

16 a a R R S S RS R S R* R Figur 7 16

17 a ab b a b b abb a ( )* ab b a 3 4 ( )* a b abb 1 2 a b b b 6 Figur 8 17

18 Dette viser sig dog ikke at være så smart, da der for en NFA med n tilstande kommer en DFA med2 n tilstande og de fleste af disse kommer vi aldrig i berøring med. I stedet for opbygger man langsomt DFA en tilstandfor tilstand. I denne forbindelse får man brug for begrebet ɛ-lukning: Definition 16 Betragt en NFA, og en mængde T af tilstande i denne NFA. ɛ-lukningen ɛ(t ) defineres som den delmængde af tilstande, som kan nås fra T kun ved ɛ-overgange. Eksempel 17 Betragt NFA en fra figur 8. ɛ-lukningen af mængden {7 er ɛ({7) ={2, 3, 5, 7, 8. Vi kan nu beskrive, hvorledes man transformerer en NFA til en DFA: Den første tilstandi DFA en er mængden ɛ({q 0 ) altså ɛ-lukningen af starttilstanden. ForhverenestetilstandS = s 1,s 2,...,s n idfa enogsymbola i alfabetet finder vi en (måske ny) tilstandsom ɛ-lukningen P af foreningsmængden δ(s 1,a) δ(s 2,a) δ(s n,a). Vi finder altså mængden af NFA-tilstande, som vi kan nå fra S vha. a-overgange, og ɛ-lukker denne. Samtidigt med, at vi opbygger nye tilstande finder vi også overgangstabellen for DFA en: Symbolet a fører fra tilstand S til tilstand P ovenfor. Denne proces fortsætter, indtil vi har fundet overgangstabellen for alle overgange, og der ikke opstår nye tilstande. Eksempel 18 Lados konstruere DFA en svarende til NFA en fra figur 6. Vores starttilstander A = ɛ({1) ={1, 2, 3, 5, 8. Denne tilstandgiver to nye, nemlig og δ(a, a) =ɛ({4, 9) ={2, 3, 4, 5, 7, 8, 9 = B δ(a, b) =ɛ({6) ={2, 3, 5, 6, 7, 8 = C Vi fortsætter med B og C: δ(b,a) =ɛ({4, 9) ={2, 3, 4, 5, 7, 8, 9 = B δ(b,b) =ɛ({6, 10) ={2, 3, 5, 6, 7, 8, 10 = D δ(c, a) =ɛ({4, 9) ={2, 3, 4, 5, 7, 8, 9 = B δ(c, b) =ɛ({6) ={2, 3, 5, 6, 7, 8 = C Vi har en ny tilstand D: δ(d, a) =ɛ({4, 9) ={2, 3, 4, 5, 7, 8, 9 = B δ(d, b) =ɛ({6, 11) ={2, 3, 5, 6, 7, 8 = E 18

19 Den nye tilstand E tages kærligt under behandling: δ(e,a)=ɛ({4, 9) ={2, 3, 4, 5, 7, 8, 9 = B δ(e,b)=ɛ({6) ={2, 3, 5, 6, 7, 8 = C Hurra, vi har ikke flere tilstande, og er derfor færdige! Da E er den eneste tilstand, der indeholder den gamle sluttilstand 11, så ere den eneste sluttilstand. Selve overgangstabellen for DFA en er: DFA en er vist på figur9. a b A = {1, 2, 3, 5, 8 B C B = {2, 3, 4, 5, 7, 8, 9 B D C = {2, 3, 5, 6, 7, 8 B C D = {2, 3, 5, 6, 7, 8, 10 B E E = {2, 3, 5, 6, 7, 8, 11 B C C b A b a a B a b a b D a b E Figur Fra DFA til regulært udtryk Vi skal nu se, hvorledes man kan rekonstruere det regulære udtryk ud fra en DFA (eller en NFA). Metoden illustreres med et eksempel: Eksempel 19 Betragt automaten til venstre på figur 10. Vi vil finde det tilsvarende regulære udtryk: Først tilføjer vi en ny starttilstand, B, og en ny sluttilstand S, og ɛ-overgange, så automaten accepterer de samme strenge som før. Ideen er nu at fjerne tilstandene 1, 2 og 3 én efter én, og tilsvarende modificere overgangene, indtil vi kun har B og S tilbage. Vi kan så aflæse det regulære udtryk direkte. Vi fjerner først tilstand1. Dette kræver, at vi laver nye overgange eller modificerer allerede eksisterende overgange mellem samtlige tilstande, som er forbundet via tilstand1. Da B, 2 og 3 sender overgange ind til 1, og 2 og 3 modtager overgange fra 1, såskalvialtså modificere overgangene B 2, B 3, 2 2, 2 3, 3 2og

20 a b 1 a 2 B a b 1 a 2 b b 3 a b b 3 a S B b 3 a ab 2 ba a aa b S B a( aa b)* ab b aaab ( )* 3 S ( ba a)( aa b)* bb ( ba a)( aa b)* ab bb B ( a( aa b)* ab b)(( ba a)( aa b)* ab bb)*(( ba a)( aa b)* ) a( aa b)* Figur 10 Der er ingen oprindelig overgang fra B til 2, og den kombinerede overgang fra B via 1til2svarertilkonkatenationenɛa = a. Tilsvarende fås en overgang fra B til3med værdien ɛb = b. Fra2til2erderalleredeovergangenmed værdienb. Vifår nu en ny nemlig fra 2 via 1 til 2. Denne giver værdien aa, ogdennyeovergangfra2til2får altså værdienaa b. Tilsvarende gælder for de tre sidste overgange, og vi får den tredie automat på figuren. Vi fjerner nu tilstanden 2. Her er der en komplikation, idet der findes en løkke en overgang fra 2 til sig selv. Denne giver anledning til et mellemled af formen (aa b) ide nye overgange. En af de nye overgange går fra B til S, ogdenfår værdien a(aa b) ɛ = a(aa b). Efter at have elimineret tilstand 3 kan vi direkte aflæse, at automaten svarer til det regulære udtryk (a(aa b) ab b)((ba a)(aa b) ab bb) ((ba a)(aa b) ɛ) a(aa b) Dette kan formentligt omskrives til noget simplere... Denne algoritme er i praksis af begrænset værdi som regel ønsker man at konstruere en endelig automat ud fra et givet regulært udtryk, ikke omvendt. 2.8 Lexer-generatorer I praksis vil man ikke implementere endelige automater for at få foretaget sin leksikalske analyse. I stedet anvender man en såkaldt lexer-generator et program, som fodres med de 20 S