notes.txt

------------First------------------

No extensions plz
0x65 -> not a hex constant
	actually has to be recognised as
		0		-> int const
		x65		-> identifier

Any new function should be private in one file (one class)

xml -> [position] token, lexeme (when needed) representation
	position line,column of first and last character  ---> starts with one

call log before returning from lexAn() function to get xml

put xml & xsl into chrome to get visual report

Report errors with function in report or throw CompilerError

oddaja: 63120275-01.zip

NEEDS TO BE THE SAME STRUCTURE AS IN prev-01.zip
ADD three positive and three negative examples to Moodle

LEXER:


------------Second------------------

Parser -> Syntax analysis ll(1) parser

recursive descent
there must not be any left recursive productions
transform into ll(1) form from of lr(1) grammar
	- left recursion elimination
	- left factoring

Tool to check -> mdaines.github.io/grammophone/
Check parsing table
	- Transform -> try to get ll(1)

	Trick for left recursive problems:
		E -> E+T | E-T | T

				|
				|
				V

		E  -> TE'
		E' -> +TE' | -TE' | epsilon

Get parsing table ---> fuct for symbol -> switch(input) case options .... default: error

When writing functions for rules -> begLog, endLog

Error recovery ->
	- insert random correct symbol
	- delete tokens from id until we match
	- inspect what follows th next non-termal symbols
		(if T skip until find a symbol in Follow(T) -> then remove from stack) -> example skip until next ; in Java


------------Third------------------
E -> E+T | T
	|
	V
E -> T E'
E' -> eps |+ T E'


parseE()
	Expr op1 = parseT();
	Expr e = parseE'(op1);
	return e;

parseE'(Expr op1)
	case '+':
		skip('+');
		Expr op2 = parseT();
		Expr e = parseE'(new BinExpr(+, op1, op2));
		return e;

a[i] ->  (arr, a, i)
a.i  ->  (rec, a, i)

------------Fourth------------------

Semantic analyisis notes:
	EvalDecl: namespace scope in evalDecl
	EvalType: tipi


		a.c
			a-> v evalDecl
			c-> v evalType

		DECL(i) -> vrne deklaracijo i-ja
		DECL_tau(c) -> pogleda dekl v rekordu ?

		[[DECL(typ-name)]]_typ = Tau
		-------------
		[[typ-name]]_typ = Tau

			&&&

		[[type]]_typ = Tau
		-------------
		[[typ name:type]]_typ = Tau

			pomeni

		typ int:integer

		pravilo 3.4.1 2 pravilo -> integer -> tip integer
		pravilo 3.4.3 1 pravilo -> deklaracija je tipa integer

		var i: int

		int -> ime zato DECL(int) = type int:integer (kaže na deklaracijo -> name resolver to dobi)
		tip int-a je integer
		zato je vse tipa integer (3.4.3 3 pravilo)


	ZA RECORDE

		[[expr]]_typ = Tau [[DECL_tau(comp-name)]]_typ = Tau'   #implicitno vemo da je Tau record tipa, ker samo record naredi namespace
		-------------
		[[expr.comp-name]]_typ = Tau'

		var r:rec{i: integer}
				| |		\
				| |		 integer
				| \------------- vse je istga tipa
				\--------rec(integer)
		\----vse je rec(integer)

		r.i? ce je r ime
		| \
		|
		 \ tip je rec(integer)


	WHERE
		pri deklaracijah (najprej imena)
		tipi -> spremenljivke -> funkcije
		2 preleta -> najprej deklaracije (imena), nato implementacije

		typ a:b
		typ b:integer

		Prvi prelet:  TypDef(a,?), TypDef(b,?)
		Drugi prelet: TypDef(a, ? -> TypDef(b,?)) ugotovimo da je TypName(b,? -> IntegerTyp))

		IntegerTyp je atribut AtomType(INTEGER) ki je obešen na TypeDef
		TypName(b) pod TypDef(a) ima atribut kazalec na TypeName(b,?)

Typ.java
	actualType -> naj bi vrnu dejanski tip

------------Fifth------------------

Klcini zazpisi
	Ne za prototipe -> tist je že skompilan
	za vsako spremenljivko določimo njen dostop
	a je lokalna/globalna ->
		lokalne ->
		globalne -> določi labele (kaj je to?)

------------Linearisation------------------ (izpit break za implementirat) :)

Linearisation:
	CJUMP(L1,L2)  LABEL(L2) ... LABEL(L1)
		spremeniš v
	lahko v dva brancha + un branch na koncu bloka S1

	Maybe do basic blocks? -> not that hard
		kako najdt permutacijo? Požrešna metoda -> fiksiraš prvega, iščeš dorega naslednika
		če nimaš naslednika (ker je že fiksiran) -> poiščeš recimo eno še ne fixirano iz prejšnjega skoka)
			laho iščeš tudi če na kakšnega 2x skočiš ga ne boš porabu



	if C then S1 else S2
		CJUMP(L1, L2) LABEL(L1) ... S1 ... JUMP(L3) LABEL(L2) ...S2... LABEL(L3) ...

------------Code generation------------------

For fragment:
	For everyCodeTree:
		generate code


MOVE -------------------|
 |						|
MEM						BINOP(+)--
 |						 |		 |
BINOP(+)				MEM		CONST(1024)
 |   |					 |
FP  CONST(4)			BINOP(+)
						|	 |
						FP	CONST(-4)

Za vsako vozlišče : - kater register vrača rezultat

VSI REGISTRI SO NOVI

FP - register ne ne naredimo ukaza
CONST(4) - SET T0, 4 | res =  T0
BINOP(+) - ADD T1, FP, T0 | res =  T1

MOVE - MEM spustimo zaenkrat

FP - register ne ne naredimo ukaza
CONST(-4) - SET T2,- 4 | res =  T2
BINOP(+) - ADD T3, FP, T2 | res =  T3
MEM	- LDO T4, T3, 0 | res =  T4
CONST(1024) - SET T5, 1024 | res =  T5
BINOP(+) - ADD T6, T4, T5 | res =  T5

MOVE-MEM - STO T6, T1, 0 | res = \

FINAL:
 1: SET T0, 4
 2: ADD T1, FP, T0
 3: SET T2,- 4
 4: ADD T3, FP, T2
 5: LDO T4, T3, 0
 6: SET T5, 1024
 7: ADD T6, T4, T5
 8: STO T6, T1, 0

LIVENESS:
 T0: 1-2
 T1: 2-8
 T2: 3-4
 T3: 4-5
 T4: 5-7
 T5: 6-7
 T6: 7-8


Potrebno je nardit kodo + interference graph

Reg uses:
_solve uses 344 registers.
_solve uses 511 instructions.

after basic adding constants to BINOP:
_solve uses 316 registers.
_solve uses 483 instructions.

after fix of null:
_solve uses 315 registers.
_solve uses 482 instructions.

after folding both negative and positive CONST into BINOP:
_solve uses 280 registers.
_solve uses 342 instructions.



write to return value RETURN VALUE !!!!
Boolean values are wrong
Conditional Assignments

------------Register allocation------------------
Barvamo grafe:

T17 gre v preliv:
					Liveness T17
|
| - SETL T17, 5			|
|						|
|						|
| - ADD T17,T17,1		|
|						|
|						|
|						|
|						|
| - STO T17,T0,0		|


SETL T17, 5 ->
	SET T100, 5
	STO T100, FP, -64 //ker je destination -> STORE
	
ADD T17,T17,1 ->
	LDO T101, FP, -64  //zaradi tega ker je sourcegi
	ADD T101,T101,1
	STO T101, FP, -64  //zaradi tega ker je destination
	
STO T17,T0,0 ->
	LDO T102, FP, -64
	STO T102, T0, 0		//ker je destination -> STORE
	


------------Register allocation------------------
SP <-- recimo na 8000 0000 0000 0000

zagonska "funkcija"
	FP, SP, prepare + PUSHJ _
	TRAP neki