jbujak / nl-zpp Goto Github PK

• Add field var_decl => ptd::rec({name => ptd::sim(), type => @tct::meta_type}) to nlasm::order_t
• Generate such order for each variable declaration in AST

Kompilator wywala się na poniższym kodzie podczas translacji do nlasma. Type checker powinien wychwycić błędne wywołanie funkcji wcześniej i zgłosić błąd. Żadnego owna nie powinno móc się przekazywać do funkcji, która oczekuje ima.

def main::main() {
	var a : own::arr(ptd::int()) = [];
	main::a(a);
}

def main::a(a : ptd::ptd_im()) {
}

Nie powinno się kompilować:

var arr : own::arr(ptd::int());
fora var a (arr) {
    a = 1; 
}

Anonimowe definicje own::rec powinny być kompilowane do struktur C o nazwach generowanych automatycznie. Dotyczy to też zagnieżdżonych rekordów. Na przykład w poniższym kodzie obie struktury own::rec powinny być nazwane i zdefiniowane, a w definicji zewnętrznej struktury powinna zostać użyta nazwa wewnętrznej, a nie pełna definicja.

var a : own::rec({
    x => own::rec({
        y => ptd::int()
    })
}) = ...;

Trzeba zabronić przekazywania dwóch poddrzew jednej zmiennej typu own jako argumentów funkcji.

Przykład, który nie powinien się skompilować:

def f(ref a, ref b) {}
...
var x : own::rec(...) = {...};
f(ref x->y, ref x->z);

• Change type of nast::fun_def_t->defines_type and nlasm::function_t->defines_type to ptd::var({no => ptd::none(), yes => @tct::meta_type})
• Set them to appropriate values

Type checker nie powinien zaakceptować deklaracji zmiennej typu own bez jej inicjalizacji:

• var zmienna : own::rec({...}) = {...}; jest ok
• var zmienna : own::rec({...}); jest nie ok

W tym momencie tablica zwraca im i możemy zobaczyć w wygenerowanym main.c w #39 że tablica zwraca im, który dodajemy do INTa, bo w typecheckerze przechodzi.

Chcemy mieć sytuację gdzie

var b = a[0]

produkuje rejestr o typie co wartość a[0] odpowiadający zmiennej b.

Trzeba zmienić sygnatury funkcji type_checker::check i type_checker::check_modules, tak żeby przyjmowały argument ref modules i zadbać, żeby typy odgadnięte przez type checker zostały zapisane w drzewie AST.

warning: passing argument 1 of ‘c_std_lib0int_to_string’ makes integer from pointer without a cast [-Wint-conversion]

Nazwy typów nie-anonimowych zawierają dwukrotnie nazwę modułu

np. main0main0arr0type0len dla funkcji

def main::arr() {
	return own::arr(ptd::int());
}

Poniższy kod powinien się skompilować do poprawnego C.

var a : own::rec({x => ptd::int()}) = {x => 1};
a->x = 2;
var b : ptd::int() = a->x;

• Replace all #TODOs in cases for :tct_own_int with valid handling

Powinniśmy mieć repo z benchmarkami i skryptem, który umożliwia odpalenie wszystkich benchmarków na jakoś danej liście wersji kompilatora.

Jeśli benchark się nie kompiluje lub się wywala na danej wersji, to powinno to być zaznaczone w wynikach, ale skrypt nie powinien się wywalić.

Podczas sprawdzania definicji funkcji w type checkerze trzeba weryfikować, że jej wszystkie argumenty typu own są przekazywane jako ref.

Przykład funkcji, która nie powinna się skompilować:

def f(a : own::rec({a=>ptd::int()});

Code style issues introduced by commit 92e2f81

• indent with spaces
• incorrect newlines in match statements

Przy czyszczeniu zmiennych typu own cała zaalokowana na nie pamięć powinna być zwalniana, a na wszystkich imach zawartych w strukturze powinna być wywołana funkcja c_rt_lib0clear.

Remove ptd::sim() and replace it with ptd::int() and ptd::string(). Change type deduction to match new types.

Add implementation of + - * / and ==

Depends on #25

Kiedy robimy porównanie czegoś ze stałą, translator najpierw emituje :load_const({dest : reg_t, val : im}), co przekłada się na przypisanie wartości do rejestru. W tym przypadku powinniśmy być w stanie złączyć to z porównaniem:

y = const ? z

zamiast

x = const
y = x ? z

Potrzebujemy sposobu, żeby jawnie konwerować owny do imów.

Dla każdego zdefiniowanego ownowego typu T powinna być wygenerowana funkcja ImmT T0type0to_im(const T* arg). Ma ona brać owna i na podstawie jego oraz jego znanego przy kompilacji typu zwracać odpowiadającego mu ima.

Trzeba też dodać w pliku own.nl funkcję own::to_im(ref arg), która będzie hackiem analogicznym do ptd::ensure_only_static(). W kodzie nl ma ona tylko zwracać podany jej argument, ale podczas kompilacji każde jej wywołanie ma być zamienione na wywołanie funkcji to_im() odpowiadającej typowi przekazanego argumentu.

Valid code doesn't compile:

def main::own_t() {
        return own::rec({
                bar => ptd::int()
        });
}
var foo : @main::own_t = {bar => 5};
var iii = foo->bar;

• Add field tct_type => @tct::meta_type to nast::variable_declaration
• Set it after all modules are parsed

Type checkout should not allow functions with own return type

Nie działają ujemne inty jako pola rekordu

Działa:

def main::main() {
	var a : own::rec({int => ptd::int()}) = {int => 1};	
}

Nie działa:

def main::main() {
	var a : own::rec({int => ptd::int()}) = {int => -1};	
}

Trzeba to poprawić i dodać testy

Trzeba przywrócić wykomentowaną funkcję przypisującą argumentom typu ref wartość po zakończeniu funkcji

• New field in nast::fun_def_t
  • defines_type => @boolean_t::type
• Set its value based on whether function defines type or not

Inicjalizacja struktury typu own powinna kompilować się do utworzenia lokalnej zmiennej typu struktury (w całości na stosie) i ciągu przypisań wartości na jej poszczególne pola. Nie powinno być możliwości częściowej inicjalizacji.

Depends on #23

test/test_nl.nl : testy z funkcji test_nl::test_only_compile powinny być przeniesione do test_nl::test_compile_and_run.

Following code:

def main::own_rec() {
        return own::rec({
                ttt => ptd::int()
        });
}

def main::bigger_own() {
        return own::rec({
                fst => @main::own_rec,
                snd => @main::own_rec
        });
}

def main::main() {
        var bigger : @main::bigger_own = {
                fst => {
                        ttt => 1
                },
                snd => {
                        ttt => 2
                }
        };
}

compiles, but bigger->snd has type :tct_empty instead if :tct_own_rec

• INT name; statement should be generated for nlasm order :var_decl({name => name, type => :tct_own_int})
• Other types don't need to be handled ‒ die is ok

Trzeba zmienić definicję funkcji get_func_type_struct w module generator_c, tak żeby zawierała wygenerowana struktura odpowiadała typowi, który ma definiować.

Pola:

• Zagnieżdżone struktury powinny być trzymane jako wartość a nie wskaźnik
• Imy (i tymczasowo stringi i boole) powinny być typu ImmT
• Tablice powinny być reprezentowane przez wskaźnik na typ, który jest w nich trzymany
• Inty powinny być typu INT

• New field in nast::fun_def_t
  • defines_type => @boolean_t::type
• Set its value during translation from AST

Trzeba w type checkerze dodać sprawdzanie, żeby przypisanie a = b było niepoprawne jeśli a i b są typu own.

Make following code compile to valid C

var a = 1;
var b = a;

Depends on #25

• Using information from nlasm generate in header file empty C structure for each function, marked as type definition

• Create test case which checks if structure is generated for type defining functions
• Create test case which checks if structure is not generated for other function