Kompiliatorių kūrimas: leksinės analizės pagrindai

Kompiliatorių kūrimas yra įdomi ir esminė informatikos sritis, kuria remiasi didelė dalis šiuolaikinės programinės įrangos kūrimo. Kompiliatorius yra tiltas tarp žmogui skaitomo pirminio kodo ir mašinai vykdomų instrukcijų. Šiame straipsnyje gilinsimės į leksinės analizės, pradinio kompiliavimo proceso etapo, pagrindus. Išnagrinėsime jos tikslą, pagrindines sąvokas ir praktines pasekmes būsimiems kompiliatorių kūrėjams ir programinės įrangos inžinieriams visame pasaulyje.

Kas yra leksinė analizė?

Leksinė analizė, dar vadinama skenavimu arba tokenizavimu, yra pirmasis kompiliatoriaus etapas. Jos pagrindinė funkcija yra skaityti pirminį kodą kaip simbolių srautą ir grupuoti juos į prasmingas sekas, vadinamas leksemomis. Kiekviena leksema vėliau klasifikuojama pagal savo vaidmenį, sukuriant tokenų seką. Galima tai įsivaizduoti kaip pradinį rūšiavimo ir žymėjimo procesą, kuris paruošia įvesties duomenis tolesniam apdorojimui.

Įsivaizduokite, kad turite sakinį: `x = y + 5;` Leksinis analizatorius jį suskaidytų į šiuos tokenus:

• Identifikatorius: `x`
• Priskyrimo operatorius: `=`
• Identifikatorius: `y`
• Sudėties operatorius: `+`
• Sveikojo skaičiaus literalas: `5`
• Kabliataškis: `;`

Leksinis analizatorius iš esmės identifikuoja šiuos pagrindinius programavimo kalbos statybinius blokus.

Pagrindinės leksinės analizės sąvokos

Tokenai ir leksemos

Kaip minėta anksčiau, tokenas yra kategorizuotas leksemos atvaizdavimas. Leksema yra faktinė simbolių seka pirminiame kode, kuri atitinka tokeno šabloną. Panagrinėkime šį Python kodo fragmentą:

if x > 5:
    print("x yra didesnis nei 5")

Štai keletas tokenų ir leksemų pavyzdžių iš šio fragmento:

• Tokenas: KEYWORD, Leksema: `if`
• Tokenas: IDENTIFIER, Leksema: `x`
• Tokenas: RELATIONAL_OPERATOR, Leksema: `>`
• Tokenas: INTEGER_LITERAL, Leksema: `5`
• Tokenas: COLON, Leksema: `:`
• Tokenas: KEYWORD, Leksema: `print`
• Tokenas: STRING_LITERAL, Leksema: `"x yra didesnis nei 5"`

Tokenas reiškia leksemos *kategoriją*, o leksema yra *faktinė eilutė* iš pirminio kodo. Sintaksinis analizatorius (parser), kitas kompiliavimo etapas, naudoja tokenus programos struktūrai suprasti.

Reguliariosios išraiškos

Reguliariosios išraiškos (regex) yra galinga ir glausta notacija, skirta aprašyti simbolių šablonus. Jos plačiai naudojamos leksinėje analizėje, siekiant apibrėžti šablonus, kuriuos leksemos turi atitikti, kad būtų atpažintos kaip konkretūs tokenai. Reguliariosios išraiškos yra pagrindinė sąvoka ne tik kompiliatorių kūrime, bet ir daugelyje informatikos sričių, nuo teksto apdorojimo iki tinklo saugumo.

Štai keletas įprastų reguliariųjų išraiškų simbolių ir jų reikšmių:

• `.` (taškas): Atitinka bet kurį vieną simbolį, išskyrus naujos eilutės simbolį.
• `*` (žvaigždutė): Atitinka prieš tai einantį elementą nulį ar daugiau kartų.
• `+` (pliusas): Atitinka prieš tai einantį elementą vieną ar daugiau kartų.
• `?` (klaustukas): Atitinka prieš tai einantį elementą nulį arba vieną kartą.
• `[]` (laužtiniai skliaustai): Apibrėžia simbolių klasę. Pavyzdžiui, `[a-z]` atitinka bet kurią mažąją raidę.
• `[^]` (neigiami laužtiniai skliaustai): Apibrėžia neigiamą simbolių klasę. Pavyzdžiui, `[^0-9]` atitinka bet kurį simbolį, kuris nėra skaitmuo.
• `|` (statusis brūkšnys): Reiškia alternatyvą (ARBA). Pavyzdžiui, `a|b` atitinka `a` arba `b`.
• `()` (skliausteliai): Grupuoja elementus ir juos užfiksuoja.
• `\` (atvirkštinis brūkšnys): Ekranuoja specialiuosius simbolius. Pavyzdžiui, `\.` atitinka tiesioginį tašką.

Pažvelkime į keletą pavyzdžių, kaip reguliariosios išraiškos gali būti naudojamos tokenams apibrėžti:

• Sveikojo skaičiaus literalas: `[0-9]+` (Vienas ar daugiau skaitmenų)
• Identifikatorius: `[a-zA-Z_][a-zA-Z0-9_]*` (Prasideda raide arba pabraukimo brūkšniu, po kurio eina nulis ar daugiau raidžių, skaitmenų ar pabraukimo brūkšnių)
• Slankiojo kablelio literalas: `[0-9]+\.[0-9]+` (Vienas ar daugiau skaitmenų, po kurių eina taškas, po kurio eina vienas ar daugiau skaitmenų) Tai supaprastintas pavyzdys; tvirtesnė reguliarioji išraiška apdorotų laipsnio rodiklius ir pasirenkamus ženklus.

Skirtingos programavimo kalbos gali turėti skirtingas taisykles identifikatoriams, sveikųjų skaičių literalamams ir kitiems tokenams. Todėl atitinkamas reguliariąsias išraiškas reikia atitinkamai pritaikyti. Pavyzdžiui, kai kurios kalbos gali leisti Unicode simbolius identifikatoriuose, o tai reikalauja sudėtingesnės reguliariosios išraiškos.

Baigtiniai automatai

Baigtiniai automatai (BA) yra abstrakčios mašinos, naudojamos atpažinti šablonus, apibrėžtus reguliariosiomis išraiškomis. Tai yra pagrindinė koncepcija įgyvendinant leksinius analizatorius. Yra du pagrindiniai baigtinių automatų tipai:

• Deterministinis baigtinis automatas (DFA): Kiekvienai būsenai ir įvesties simboliui yra lygiai vienas perėjimas į kitą būseną. DFA yra lengviau įgyvendinti ir vykdyti, bet gali būti sudėtingiau sukonstruoti tiesiogiai iš reguliariųjų išraiškų.
• Nedeterministinis baigtinis automatas (NFA): Kiekvienai būsenai ir įvesties simboliui gali būti nulis, vienas ar keli perėjimai į kitas būsenas. NFA yra lengviau sukonstruoti iš reguliariųjų išraiškų, bet reikalauja sudėtingesnių vykdymo algoritmų.

Tipinis leksinės analizės procesas apima:

1. Kiekvieno tokeno tipo reguliariųjų išraiškų konvertavimą į NFA.
2. NFA konvertavimą į DFA.
3. DFA įgyvendinimą kaip lentele valdomą skenerį.

Tada DFA naudojamas skenuoti įvesties srautą ir identifikuoti tokenus. DFA prasideda pradinėje būsenoje ir skaito įvestį simbolis po simbolio. Remdamasis dabartine būsena ir įvesties simboliu, jis pereina į naują būseną. Jei DFA pasiekia priėmimo būseną perskaitęs simbolių seką, seka atpažįstama kaip leksema ir sugeneruojamas atitinkamas tokenas.

Kaip veikia leksinė analizė

Leksinis analizatorius veikia taip:

1. Skaito pirminį kodą: Lekseris skaito pirminį kodą simbolis po simbolio iš įvesties failo ar srauto.
2. Identifikuoja leksemas: Lekseris naudoja reguliariąsias išraiškas (arba, tiksliau, iš reguliariųjų išraiškų išvestą DFA), kad identifikuotų simbolių sekas, kurios sudaro galiojančias leksemas.
3. Generuoja tokenus: Kiekvienai rastai leksemai lekseris sukuria tokeną, kuris apima pačią leksemą ir jos tokeno tipą (pvz., IDENTIFIER, INTEGER_LITERAL, OPERATOR).
4. Apdoroja klaidas: Jei lekseris susiduria su simbolių seka, kuri neatitinka jokio apibrėžto šablono (t. y. negali būti tokenizuota), jis praneša apie leksinę klaidą. Tai gali būti netinkamas simbolis arba neteisingai suformuotas identifikatorius.
5. Perduoda tokenus sintaksiniam analizatoriui: Lekseris perduoda tokenų srautą kitam kompiliatoriaus etapui – sintaksiniam analizatoriui (parser).

Panagrinėkime šį paprastą C kodo fragmentą:

int main() {
  int x = 10;
  return 0;
}

Leksinis analizatorius apdorotų šį kodą ir sugeneruotų šiuos tokenus (supaprastintai):

• KEYWORD: `int`
• IDENTIFIER: `main`
• LEFT_PAREN: `(`
• RIGHT_PAREN: `)`
• LEFT_BRACE: `{`
• KEYWORD: `int`
• IDENTIFIER: `x`
• ASSIGNMENT_OPERATOR: `=`
• INTEGER_LITERAL: `10`
• SEMICOLON: `;`
• KEYWORD: `return`
• INTEGER_LITERAL: `0`
• SEMICOLON: `;`
• RIGHT_BRACE: `}`

Praktinis leksinio analizatoriaus įgyvendinimas

Yra du pagrindiniai leksinio analizatoriaus įgyvendinimo būdai:

1. Rankinis įgyvendinimas: Rašyti lekserio kodą rankiniu būdu. Tai suteikia daugiau kontrolės ir optimizavimo galimybių, bet reikalauja daugiau laiko ir yra labiau linkę į klaidas.
2. Naudojant lekserių generatorius: Naudoti įrankius, tokius kaip Lex (Flex), ANTLR ar JFlex, kurie automatiškai generuoja lekserio kodą pagal reguliariųjų išraiškų specifikacijas.

Rankinis įgyvendinimas

Rankinis įgyvendinimas paprastai apima būsenų mašinos (DFA) sukūrimą ir kodo rašymą, kad būtų galima pereiti tarp būsenų, atsižvelgiant į įvesties simbolius. Šis metodas leidžia smulkiai valdyti leksinės analizės procesą ir gali būti optimizuotas pagal konkrečius našumo reikalavimus. Tačiau tai reikalauja gilaus reguliariųjų išraiškų ir baigtinių automatų supratimo, o jį gali būti sudėtinga prižiūrėti ir derinti.

Štai konceptualus (ir labai supaprastintas) pavyzdys, kaip rankinis lekseris galėtų apdoroti sveikųjų skaičių literalamus Python kalboje:

def lexer(input_string):
    tokens = []
    i = 0
    while i < len(input_string):
        if input_string[i].isdigit():
            # Rastas skaitmuo, pradedamas kurti sveikasis skaičius
            num_str = ""
            while i < len(input_string) and input_string[i].isdigit():
                num_str += input_string[i]
                i += 1
            tokens.append(("INTEGER", int(num_str)))
            i -= 1 # Pataisoma dėl paskutinio padidinimo
        elif input_string[i] == '+':
            tokens.append(("PLUS", "+"))
        elif input_string[i] == '-':
            tokens.append(("MINUS", "-"))
        # ... (apdorojami kiti simboliai ir tokenai)
        i += 1
    return tokens

Tai yra elementarus pavyzdys, tačiau jis iliustruoja pagrindinę idėją, kaip rankiniu būdu skaityti įvesties eilutę ir identifikuoti tokenus pagal simbolių šablonus.

Lekserių generatoriai

Lekserių generatoriai yra įrankiai, kurie automatizuoja leksinių analizatorių kūrimo procesą. Jie priima specifikacijos failą kaip įvestį, kuriame apibrėžiamos reguliariosios išraiškos kiekvienam tokeno tipui ir veiksmai, kuriuos reikia atlikti atpažinus tokeną. Tada generatorius sukuria lekserio kodą tiksline programavimo kalba.

Štai keletas populiarių lekserių generatorių:

• Lex (Flex): Plačiai naudojamas lekserių generatorius, dažnai naudojamas kartu su Yacc (Bison), sintaksės analizatoriaus generatoriumi. Flex yra žinomas dėl savo greičio ir efektyvumo.
• ANTLR (ANother Tool for Language Recognition): Galingas sintaksės analizatorių generatorius, kuris taip pat apima lekserių generatorių. ANTLR palaiko platų programavimo kalbų spektrą ir leidžia kurti sudėtingas gramatikas ir lekserius.
• JFlex: Lekserių generatorius, specialiai sukurtas Java kalbai. JFlex generuoja efektyvius ir labai pritaikomus lekserius.

Lekserių generatoriaus naudojimas suteikia keletą privalumų:

• Sutrumpintas kūrimo laikas: Lekserių generatoriai žymiai sumažina laiką ir pastangas, reikalingas leksiniam analizatoriui sukurti.
• Pagerintas tikslumas: Lekserių generatoriai sukuria lekserius remdamiesi gerai apibrėžtomis reguliariosiomis išraiškomis, sumažindami klaidų riziką.
• Priežiūros paprastumas: Lekserio specifikaciją paprastai lengviau skaityti ir prižiūrėti nei ranka rašytą kodą.
• Našumas: Šiuolaikiniai lekserių generatoriai sukuria labai optimizuotus lekserius, kurie gali pasiekti puikų našumą.

Štai paprastos Flex specifikacijos pavyzdys, skirtas atpažinti sveikuosius skaičius ir identifikatorius:

%%
[0-9]+      { printf("INTEGER: %s\n", yytext); }
[a-zA-Z_][a-zA-Z0-9_]* { printf("IDENTIFIER: %s\n", yytext); }
[ \t\n]+  ; // Ignoruoti tarpus
.           { printf("ILLEGAL CHARACTER: %s\n", yytext); }
%%

Ši specifikacija apibrėžia dvi taisykles: vieną sveikiems skaičiams ir vieną identifikatoriams. Kai Flex apdoroja šią specifikaciją, jis generuoja C kodą lekseriui, kuris atpažįsta šiuos tokenus. Kintamajame `yytext` yra atitikusi leksema.

Klaidų apdorojimas leksinėje analizėje

Klaidų apdorojimas yra svarbus leksinės analizės aspektas. Kai lekseris susiduria su netinkamu simboliu ar neteisingai suformuota leksema, jis turi pranešti apie klaidą vartotojui. Dažniausios leksinės klaidos apima:

• Netinkami simboliai: Simboliai, kurie nėra kalbos abėcėlės dalis (pvz., `$` simbolis kalboje, kuri neleidžia jo naudoti identifikatoriuose).
• Neužbaigtos eilutės: Eilutės, kurios nėra uždarytos atitinkama kabute.
• Netinkami skaičiai: Neteisingai suformuoti skaičiai (pvz., skaičius su keliais dešimtainiais taškais).
• Viršytas maksimalus ilgis: Identifikatoriai ar eilučių literalai, viršijantys maksimalų leistiną ilgį.

Aptikus leksinę klaidą, lekseris turėtų:

1. Pranešti apie klaidą: Sugeneruoti klaidos pranešimą, kuriame nurodomas eilutės ir stulpelio numeris, kur įvyko klaida, taip pat klaidos aprašymas.
2. Bandyti atsigauti: Pabandykite atsigauti po klaidos ir tęsti įvesties skenavimą. Tai gali apimti netinkamų simbolių praleidimą arba dabartinio tokeno užbaigimą. Tikslas yra išvengti kaskadinių klaidų ir suteikti vartotojui kuo daugiau informacijos.

Klaidų pranešimai turėtų būti aiškūs ir informatyvūs, padedantys programuotojui greitai nustatyti ir ištaisyti problemą. Pavyzdžiui, geras klaidos pranešimas apie neužbaigtą eilutę galėtų būti: `Klaida: Neužbaigtas eilutės literalas 10 eilutėje, 25 stulpelyje`.

Leksinės analizės vaidmuo kompiliavimo procese

Leksinė analizė yra esminis pirmasis kompiliavimo proceso žingsnis. Jos išvestis, tokenų srautas, tarnauja kaip įvestis kitam etapui – sintaksiniam analizatoriui (parser). Sintaksinis analizatorius naudoja tokenus, kad sukurtų abstrakčią sintaksės medį (AST), kuris atspindi programos gramatinę struktūrą. Be tikslios ir patikimos leksinės analizės sintaksinis analizatorius negalėtų teisingai interpretuoti pirminio kodo.

Ryšį tarp leksinės analizės ir sintaksinės analizės galima apibendrinti taip:

• Leksinė analizė: Suskaido pirminį kodą į tokenų srautą.
• Sintaksinė analizė (parsing): Analizuoja tokenų srauto struktūrą ir kuria abstraktų sintaksės medį (AST).

AST vėliau naudojamas tolimesniuose kompiliatoriaus etapuose, tokiuose kaip semantinė analizė, tarpinio kodo generavimas ir kodo optimizavimas, siekiant sukurti galutinį vykdomąjį kodą.

Pažangios leksinės analizės temos

Nors šiame straipsnyje apžvelgiami leksinės analizės pagrindai, yra keletas pažangių temų, kurias verta išnagrinėti:

• Unicode palaikymas: Unicode simbolių tvarkymas identifikatoriuose ir eilučių literaluose. Tam reikalingos sudėtingesnės reguliariosios išraiškos ir simbolių klasifikavimo metodai.
• Leksinė analizė įterptosioms kalboms: Leksinė analizė kalboms, įterptoms į kitas kalbas (pvz., SQL, įterptas į Java). Tam dažnai reikia persijungti tarp skirtingų lekserių, priklausomai nuo konteksto.
• Inkrementinė leksinė analizė: Leksinė analizė, kuri gali efektyviai iš naujo nuskaityti tik tas pirminio kodo dalis, kurios pasikeitė, o tai naudinga interaktyviose kūrimo aplinkose.
• Kontekstui jautri leksinė analizė: Leksinė analizė, kurioje tokeno tipas priklauso nuo aplinkinio konteksto. Tai gali būti naudojama kalbos sintaksės dviprasmybėms spręsti.

Internacionalizacijos aspektai

Kuriant kompiliatorių kalbai, skirtai naudoti visame pasaulyje, leksinei analizei reikėtų atsižvelgti į šiuos internacionalizacijos aspektus:

• Simbolių kodavimas: Įvairių simbolių koduočių (UTF-8, UTF-16 ir kt.) palaikymas, siekiant apdoroti skirtingas abėcėles ir simbolių rinkinius.
• Lokalės specifinis formatavimas: Lokalės specifinių skaičių ir datų formatų tvarkymas. Pavyzdžiui, dešimtainis skyriklis kai kuriose lokalėse gali būti kablelis (`,`), o ne taškas (`.`).
• Unicode normalizavimas: Unicode eilučių normalizavimas, siekiant užtikrinti nuoseklų palyginimą ir atitikimą.

Netinkamas internacionalizacijos tvarkymas gali lemti neteisingą tokenizavimą ir kompiliavimo klaidas dirbant su pirminiu kodu, parašytu skirtingomis kalbomis ar naudojant skirtingus simbolių rinkinius.

Išvada

Leksinė analizė yra fundamentalus kompiliatorių kūrimo aspektas. Gilus šiame straipsnyje aptartų sąvokų supratimas yra būtinas kiekvienam, kas kuria ar dirba su kompiliatoriais, interpreteriais ar kitais kalbos apdorojimo įrankiais. Nuo tokenų ir leksemų supratimo iki reguliariųjų išraiškų ir baigtinių automatų įsisavinimo, leksinės analizės žinios suteikia tvirtą pagrindą tolesniam kompiliatorių konstravimo pasaulio tyrinėjimui. Pasitelkdami lekserių generatorius ir atsižvelgdami į internacionalizacijos aspektus, kūrėjai gali sukurti tvirtus ir efektyvius leksinius analizatorius plačiam programavimo kalbų ir platformų spektrui. Programinės įrangos kūrimui toliau evoliucionuojant, leksinės analizės principai išliks kalbos apdorojimo technologijos kertiniu akmeniu visame pasaulyje.