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...