Schutzanforderungen:
--------------------

ref_var, Assignment:
				Existenzschutz für Variable; "Zombi" akzeptabel -> parent=error, index=egal/0
				Typ und Wert dürfen geändert werden.

Procedure execution:
				Existenzschutz für Variable (oder der Parent); "Zombi" akzeptabel -> this=error
				Existenzschutz für den Wert (der proc body):
				=> Typ & Wert schützen  oder
				=> den String duplizieren, dann dürfen Wert und Typ geändert werden.

globals, locals, privates:
				Existenzschutz für Variable; "Zombi" akzeptabel -> parent=error, index=egal/0
				Der Typ 'Liste' muss geschützt werden.
				Der Wert, d.h. der Inhalt der Liste darf geändert werden.

=>	Existenzschutz-Counter für Variablen:		für assignments
	Typschutz-Bit 		   für Variablen:		für globals, locals, privates
	Typ/Wertschutz		   für Variablen:		proc body (string) duplizieren

=>	Var::type hat noch viele freie Bits für Counter und Typschutzbit.
=>	Var wird nicht größer.



Optionen:
---------

Var:	{Name,Data}
		{Name,Data*}

Data:	DataUnion
		DataDerivedClass

List:	liste[Var]
		liste[Var*]

Type:	TypeInVar
		TypeInData

Share:	Unshared
		ShareList
		ShareData



{Name,Data} DataUnion liste[Var*]
	- Zus. Stufe der Indirektion, zus. new/delete
	- Ø Platzbedarf für Daten etwas größer als bei DataDerivedClass
	- Datasharing nicht möglich, evtl. aber ein Listvektorsharing
	- index wird benötigt (oder funktion 'index' wird langsam)

{Name,Data*} DataUnion liste[Var]
	- Vor Löschen einer Liste muss der gesamte Vektor nach geschützten Variablen durchsucht werden
	- Zus. Stufe der Indirektion, zus. new/delete
	- Ø Platzbedarf für Daten etwas größer als bei DataDerivedClass
	- ListenVektoren benötigen sofort viel Platz
	+ Datentyp 'long int' möglich

{Name,Data*} DataUnion liste[Var*]
	-- 2x Zus. Stufe der Indirektion, zus. new/delete
	- Ø Platzbedarf für Daten etwas größer als bei DataDerivedClass
	- index wird benötigt (oder funktion 'index' wird langsam)
	+ Datentyp 'long int' möglich

{Name,Data*} DataDerivedClass liste[Var]
	- Vor Löschen einer Liste muss der gesamte Vektor nach geschützten Variablen durchsucht werden
	- Zus. Stufe der Indirektion, zus. new/delete
	- ListenVektoren benötigen sofort viel Platz
	+ Datentyp 'long int' möglich

{Name,Data*} DataDerivedClass liste[Var*]
	-- 2x Zus. Stufe der Indirektion, zus. new/delete
	- index wird benötigt (oder funktion 'index' wird langsam)
	+ Datentyp 'long int' möglich




{Name,Data} DataDerivedClass liste[Var]
{Name,Data} DataDerivedClass liste[Var*]
	Gehen nicht: Var würde damit variable length

{Name,Data} DataUnion liste[Var]
	- Vor Löschen einer Liste muss der gesamte Vektor nach geschützten Variablen durchsucht werden
	- Ø Platzbedarf für Daten etwas größer als bei DataDerivedClass
	-- ListenVektoren benötigen sofort sehr viel Platz
	- Datasharing nicht möglich, evtl. aber ein Listvektorsharing

















{Name,Data*} DataDerivedClass liste[Var*]
	-- 2x Zus. Stufe der Indirektion, zus. new/delete
	- index wird benötigt (oder funktion 'index' wird langsam)
	+ Datentyp 'long int' möglich




Var
{
	long		type_and_lock;		// type, ref_cnt and type_lock
	long		index;				// opt.
	Var*		parent;
	NameHandle	name;
	size_t		data;				// 'long int' possible
};

CountedData { long ref_count; };

DataNum  : public CountedData { double number; };
DataText : public CountedData { String text; };
DataProc : public CountedData { String proc; };
DataList : public CountedData
{
	Var**	array;					// NULL == unnamed_var(0.0)  possible
	uint	size;
	uint	used;
};


note:
	number, text und proc als shared data ist nicht so wichtig:
	number: immer kopieren dürfte eh schneller sein
	text,proc: String duplizieren nicht so viel langsamer, entscheidender schon der platzverbrauch. aber: ohne ref_count spart man immer. also?

wichtig aber zumindest data sharing für Listen.

immer shareable
=>	assignments benötigen nur ref auf Data
/>	das benötigt aber Data_Union
=>	procs können Data locken
?>	globals=0 => könnte eigentlich gehen. (wenns schee macht..)
	die listen selbst sind gelockt und bleiben solange wie benötigt gültig
=>	type muss in Data

index(var_ref)
name(var_ref)
setname var_ref = text

vielfach, außer assignments, wird tatsächlich ein ref auf die var benötigt.