0. Spis tresci
1- Analiza leksykalna
2- Analiza skladniowa
3- Analiza kontekstowa (semantyczna)
4- Generowanie kodu do asemblera (NASM)
1. Analiza leksykalna
Komentarze:
- /* komentarz w bloku */
- // komentarz w linni
- # komentarz w linni
Wartosci:
- [0-9]+.[0-9]* - wartosc typu double
- [0-9]+ - wartosc typu int
- true|false - wartosc typu boolean
- "[^"]" - wartosc typu string
Typy:
- "double", "int", "boolean", "string", "void"
Slowa kluczowe:
- "if", "else", "for", "while", "return"
Operatory:
- '+', '-', '*', '/', ...
Identyfikatory:
- [a-zA-Z][a-zA-Z0-9_]*
2. Analiza skladniowa
- Tablica nazw dla identyfikatorow
- Za pomoca regul w bisonie tworzone jest drzewo
- Rozszerzenia w jezyku:
- Rzutowanie, domyslne i jawne
- Zagniezdzone funkcje
- Przypisanie jako wyrazenie
3. Analiza kontekstowa (semantyczna)
Przed rozpoczeciem analizy, dolaczane sa do programu funkcje 'printString',
'printInt', 'printDouble', 'readInt', 'readDouble' i 'error'. Sa one
umieszczane w glownym kontekscie (struktura 'j_context_t') wraz z innymi
funkcjami zdefiniowanymi w programie (nie liczac zagniezdzonych). Funkcje
zdefiniowane globalnie sa widoczne w kazdym miejscu programu, o ile nie
zostana przykryte przez inna definicje zagniezdzonej funkcji o tej samej
nazwie. Na poziomie tego samego kontekstu nazwy funkcji musza byc unikalne.
Podobnie ze zmiennymi, w tym samym konteksie moze wystapic tylko jedna
deklaracja tej samej zmiennej. Ciekawy wyjatek - 'int x = (x = 11) + 1;' -
zadziala jesli kontekscie nizej jest zadeklarowana zmienna x, jej to zostanie
przypisana wartosc 11 a nastepnie nowemu x-owi 12.
Tablica symboli zostala podzielona na odrebna tablice zmiennych 'j_vartbl_t'
i tablice funkcji 'j_funtbl_t'. Mozliwe jest dzieki temu istnienie w tym
samym kontekscie zmiennej oraz funkcji o tej samej nazwie. Kazda struktura
'j_context_t' ma wlasna tablice symboli oraz wskaznik na kontekst nizej.
Dodatkowo kontekst wie w jakiej funkcji sie znajduje (potrzebne przy
intrukcji powrotu). Natomiast w tablicy symboli dla kazdego symbolu trzymany
jest wskaznik do wystapienia jego deklaracji w drzewie.
W wywolaniach funkcji, przypisaniach czy operacjach na wyrazeniach moga
wystapowac roznice typow. Wtedy tworzony zostaje dodatkowy wezel w drzewie
wykonujacy operacje rzutowania na wlasciwy typ.
Analiza przykladow z katalogu 'examples/':
- examples/good/core*.jl - ok
- examples/bad/bad{001,002,004,005,010,011,021}.jl - syntax error
- examples/bad/bad{006,007,012,017,018,019}.jl - context error
- examples/bad/bad009.jl - ok : dziala domyslne rzutowanie 'boolean' -> 'int'
- examples/bad/bad013.jl - ok : dziala domyslne rzutowanie 'int' -> 'double'
- examples/bad/bad015.jl - ok : dziala domyslne rzutowanie 'double' -> 'int'
- examples/bad/bad016.jl - ok : dziala domyslne rzutowanie 'int' -> 'double'
- examples/bad/bad020.jl - ok : dziala domyslne rzutowanie 'boolean' -> 'double'
- examples/bad/bad022.jl - ok : dziala domyslne rzutowanie 'double' -> 'int'
- examples/bad/bad023.jl - ok : dziala domyslne rzutowanie 'int' -> 'double'
- examples/bad/bad026.jl - ok : dziala domyslne rzutowanie 'double' -> 'int'
- examples/bad/bad027.jl - ok : dziala domyslne rzutowanie 'int' -> 'double'
- examples/extensions/typecast/explicit_cast.jl - context error: brak 'return'
Wlasne przyklady z katalogu 'tests/' (w plikach napisane co sprawdzaja)
- tests/correct{001-010}.jl - ok
- tests/explicit_cast.jl - ok: poprawiony 'return' z 'examples/extensions'
- tests/failure{001-040}.jl - error
4. Generowanie kodu do asemblera (NASM)
Kod w asemblerze dzieli sie na sekcje '.rodata' ze stalymi wartosciami
uzytymi w programie a takze innymi uzytymi do predefiniowanych funkcji.
Kazda uzyta wartosc w programie dostaje unikalny numer, ktory potem
umozliwia dostep.
Funkcje predefiniowane zostaly napisane w asemblerze, ze wspomozeniem
funkcjami z C jak printf czy scanf. Stad linkowac nalezy z bibliotekami
do C. np przez gcc. W kodzie jest zdefiniowana funkcja 'main', ktora
wywoluje funkcje 'main' zdefiniowana w programie.
4.1. Realizacja generowania kodu funkcji
Program w jezyku javalette, sklada sie z listy funkcji. Wystarczy zatem je
zdefiniowac pokolei w osobnych miejscach kodu. W tym celu kazda funkcja
dostaje unikalny identyfikator(takze te zagniezdzone). Jesli w pewnym
momencie programu jest jej wywolanie to jest jednoznacznie okreslona
etykieta funkcji. Nie trzeba sie przejmowac, czy funkcja jest zagniezdzona
czy nie. Zakladajac, ze analiza semantyczna jest poprawna nigdy nie wystapi
nieuprawnione wolanie funkcji.
Funkcja musi odkladac na stos wartosc ebp, aby w razie zagniezdzenia moc
odpowiednio trafic do zmiennych. Argumenty funkcji sa odkladane przy
jej wywolaniu, latwo wiec okreslic ich pozycje na stosie:
1 - [ebp+8], 2 - [ebp+12], 3 - [ebp+16], ...
Zmienne lokalne w funkcji beda rowniez odkladane na stosie, na biezaco:
1 - [ebp-4], 2 - [ebp-8], 3 - [ebp-12], ...
Musi byc spamietywany licznik ile zmiennych zostalo odlozonych na stosie
aby przy wyjsciu z funkcji odpowiednio przywrocic wielkosc stosu.
Dodatkowo kazda zmienna musi pamietac, skad pochodzi, aby tam jej szukac
a nie w bierzacym kontekcie - bowiem podczas generowania kodu mogloby sie
zdarzyc, ze odwolywalibysmy sie do zmiennej, ktora dopiero za chwile
bedzie zadeklarowana(ale w biezacym kontekscie, badz co badz...).
4.2. Realizacja instrukcji blokowej
Przy wejsciu do bloku tworzony jest nowy kontekst, moga byc definiowane
zmiennej o zdefiniowanej juz nazwie. Przy ich deklaracji stos jest
odpowiednio podnoszony oraz przy wyjsciu z bloku wierzcholek stosu przywracany.
Zatem rowniez trzeba zliczac aktualne przesuniecie na stosie.
4.3. Realizacja instrukcji warunkowej
Instrukcja warunkowa jest realizowana za pomoca skokow do odpowiednich
etykiet. Etykiety musza miec unikalne nazwy, wiec kazda instukcja warunkowa
ma unikalny numer (tak jak w przypadku funkcji).
< EXPRESION -> eax >
JZ NEAR C[0-9]+f[0-9]+else
< STATEMENT -> jesli prawda >
JMP NEAR C[0-9]+f[0-9]+fi
C[0-9]+f[0-9]+else:
< STATEMENT -> jesli falsz >
C[0-9]+f[0-9]+fi:
4.4. Realizacja instrukcji iteracji
Instrukcja iteracji rowniez wymaga unikalnych etykiet.
< EXPRESSION - wstepne przypisanie >
I[0-9]+f[0-9]+begin:
< EXPRESSION - warunek petli >
JZ NEAR I[0-9]+f[0-9]+end
< STATEMENT - tresc petli >
< EXPRESSION - przypisanie co obrot >
JMP NEAR I[0-9]+f[0-9]+begin
I[0-9]+f[0-9]+end:
4.5. Realizacja instrukcji powrotu
Wykonujac wyjscie z funkcji, nalezy zwinac stos, w tym celu w bierzacym
kontekscie jest trzymana informacja o wielkosci stosu oraz przywrocic
poprzednia wartosc rejestru ebp. Kazda funkcja musi miec instrukcje powrotu.
4.6. Realizacja instrukcji deklaracji
Na stosie jest rezerwowane miejsce na nowe zmienne oraz jesli trzeba
sa im przypisywane wartosci. W bierzacym kontekscie jest uwzgledniany
nowy rozmiar stosu.
Mozliwe jest uzycie nazwy zmiennej w jej deklaracji o ile tylko taka zmienna
byla juz wczesniej zadeklarowana i taka wartosc bedzie reprezentowala.
int i = 1; // i = 1
{
int i = i + 2; // i = 3
}
4.7. Realizacja wyrazen
Wyrazenia czesto moga przybierac forme drzewa zaleznosci. Konieczne
jest zatem utworzenie zmiennych tymczasowych dla wyliczenia posrednich
wartosci.
Tworzone jest drzewo zaleznosci wyrazen i na stosie jest rezerwowane
miejsce na zmienne tymczasowe. Wszystkie wyrazenia wystepujace w drzewie
umieszczamy na liscie od najbardziej lewego do najbardziej prawego.
Za kazdym razem obliczamy wyrazenie, z mozliwych do wyliczenia, najbardziej
na lewo. Dzieki temu latwo jest zadbac o leniwe wykonywanie operacji
'&&' i '||'. Skoro idziemy od lewej, to zostawiamy w kodzie odpowiednie
porownania oraz skoki. Porzadek na liscie zapewnia, ze beda pominiete tylko
te obliczenia, ktore trzeba. Gdy wszystkie wyrazenia zostana policzone
wynik jest odkladany na rejestr eax.
Aby odnlezc adres zmiennej, do ktorej sie odnosimy, trzeba odnalezc
kontekst jej deklaracji oraz skaczac po wartosci ebp dostac odpowiedni
adres - stamtad bierzemy/przypisujemy wartosc.
4.8. Zgodnosc testow z katalogu 'examples'.
Wszystkie wyniki sa zgodne ze wzorcowymi. Jest jednak kilka drobnych
roznic. Moje printInt, printDouble, printString same z siebie nie doklejaja
na koniec znaku nowej linni. Nieco inaczej tez zachowuja sie funkcje
dzialajace na doublach. Po pierwsze sa wypisywane w innym formacie (%g),
po drugie rzutowanie z double-a na int-a zaokragla do najblizszej liczby
calkowitej.
Dodatkowo sprawdzajac poprawnosc programu zapisalem kilka wlasnych testow
w 'tests/other'. Sprawdzaja poprawnosc operacji arytmetycznych, porownan,
rzutowan, wywolywan funkcji, deklaracji zmiennych, itd...