ein LITERAL ist ein WERT ohne NAME und ADRESSE.
Der WERT des LITERALS wird in den CODE direkt eingebettet.
Der WERT ist bei TEXT und PROC die ADRESSE der realen Daten / des realen Codes.
WERTE auf dem STACK sind LITERALE oder VARIABLEN REFERENZEN.

ein CONST ist ein WERT mit NAME und ohne ADRESSE.
CONST können als LITERAL oder VARIABLE realisiert sein.

eine VARIABLE ist ein SPEICHERORT mit einem NAMEN für WERTE eines bestimmten TYPES.
VARIABLEN werden mit der ADRESSE ihres SPEICHERORTES REFERENZIERT.


NUMBER_LITERAL: 	1234 | +123.45e67 | 0x1234 | 0b1010 | 'asdf' | 1234l | 1234u | ...
TEXT_LITERAL:		"abcde" | «abcde»
	Symbol: -
	Instr:  class ConstValue -> Ival

CONST:
	Symbol:	class ConstDef -> Name + Type + Ival
	Instr:  class ConstValue -> Ival	(wie Literal)

VARIABLE:
	Symbol:	class VarDef -> Name + Type
	Instr:	class VarRef -> VarDef
			(deref: opcode oGET -> Value)

PROC_LITERAL:		int(int a,int b) { return a<b?a:b; }
	Symbol: ProcDef mit name = ""
	Instr:  ProcRef -> ProcDef

CONST PROCEDURE:	int min(int a,int b) { return a<b?a:b; }
	Symbol: ProcDef mit name != ""
	Instr:  ProcRef -> ProcDef

VARIABLE:
	Symbol:	class VarDef -> Name + ProcType
	Instr:	class VarRef -> VarDef
			(deref: opcode oGET -> Value)
			(call:  opcode oCALL + arguments -> rvalue)






PROCEDURE_LITERAL / LAMBDA:
		TYPE ( TYPE NAME , ... ) { INSTRUCTIONS }
		z.B: int(int a,int b) { return a<b?a:b; }
	class ProcDef mit name = ""


	->	ProcDef mit name = ""
		TYPE ( ARGUMENTS ) { INSTRUCTIONS }
		z.B: int(int a,int b) { return a<b?a:b; }
	CONST / PROC:
	->	ProcDef mit name != ""
		TYPE NAME ( ARGUMENTS ) { INSTRUCTIONS }
		z.B: int min(int a,int b) { return a<b?a:b; }
	VARIABLE:
		TYPE(ARGUMENTTYPES) NAME = PROCVALUE;





	PROC:   TYPE ( ARGUMENTS ) { INSTRUCTIONS }
	ARRAY:  TYPE [ ] { VALUES }
	CLASS:  TYPE { NAME=VALUE, ... }

CONST:
	all:
		const NAME = VALUE ;
		const TYPE NAME = VALUE ;
	function:
		TYPE NAME ( ARGUMENTS ) { INSTRUCTIONS }

VARIABLE:
	TYPE NAME = VALUE ;
	e.g.:
		int a = 0;
		cstr s = "abcde";
		float(int,int) foo = Foo; // where Foo is a PROC CONST
		float(int,int) foo = float(int a,int b){...} // assign a PROC LITERAL