---- Zustand jetzt:

Var
{
	vtype		type;		// my type
	Var*		parent;		// my parent list or NULL
	uint		index;		// my index in parent's list
	NameHandle	name;		// my name
	long		data[];		// my data
}


---- Zustand neu: ------------------------------------------

Var
{
	long		type_and_lock;	// my type & lock_count
	Var*		parent;			// my parent list or NULL
	uint		index;			// my index in parent's list
	NameHandle	name;			// my name
	long		data[];			// my data
}


Schutzanforderungen:

	- Existenzschutz für die Variable:
	  füre alle Variablen, auf die man einen Pointer setzt
	  => globals, locals, privates, procedures, assignments

	- Typschutz: Typ darf nicht geändert werden
	  => globals, locals und privates

	- Wertschutz: Wert und Typ
	  => z.Zt. ausgeführte Prozeduren

Existenzschutz:

vtype type wird in ein type_and_lock aufgebohrt:
	Lock() => type_and_lock += 16
	Unlock()

In vipsi: Soll eine gesperrte Variable gelöscht werden, wird dies verweigert und mit einem Fehler abgebrochen.
In class Var: Enthält eine Liste ein gesperrtes Item, wird mit dem Löschen der Liste abgebrochen, sobald dieses an der Reihe ist.

Für den Existenzschutz genügt kein einzelnes Sperrbit:
Multithreading: Mehrfache gleichzeitige Zuweisungen können vorkommen und sinnvoll sein. Hierfür genügt ein kurzer Zähler.
Prozeduren müssen mehrfach sperrbar sein. Wg. Rekursion muss der Zähler sehr lang sein.

Typschutz:

1. Der Typschutz besteht für die gesamte Laufzeit, ein Zähler ist nicht erforderlich, nur ein Sperrbit.
2. Beim Kopieren dieser Variablen muss das Sperrbit gelöscht werden.
3. Man kann auf den Typschutz verzichten:
	Anlegen neuer Variablen klappt dann nicht, bis man ihnen wieder eine leere Liste zuweist.
	FindItem() hat einen stillen Test auf Typ Liste.
	Enthaltene Listen sind durch ihr Existenzschutz-Lock geschützt.

Wertschutz:

Kommt nur bei Prozeduren vor.
Existenzschutz und Wertschutz müssen getrennte Zähler haben.

type_and_lock:
	4	Bit Typ						~ 15 Typen. z.Zt. werden 4 genutzt
	8	Bit Existenzschutzzähler	~ 250 Threads, die alle gleichzeitig eine Variable beschreiben
	20	Bit Wertschutzzähler		~1e6 Rekursionen einer Prozedur.

Alternativ kann man auch den proc-String für die Laufzeit duplizieren. Dann wird kein Wertschutz für die Variable benötigt.




Zukunft:

Nach Reorganize ist ein Existenzschutz bei Zuweisungen nicht mehr nötig, weil die rechte Seite vor der linken ausgewertet werden kann. Auch dann müssen var_ref Resultate gesperrt werden. Außerdem muss die vip Sparchdefinition geändert werden, dass bei rechtsassoziativen Operatoren die rechte Seite zuerst ausgewertet wird. Das würde sich zB auch auf var a=n auswirken und das leidige var argc=count globals -1 erledigen.


Sharing:

Für das Variablen-Sharing würde wahrscheinlich der Existenzschutz aufgebohrt werden. Damit würde ein neues long int in den Variablen benötigt, außer der Wertschutz für Prozeduren erfolgt über Duplizieren des Strings. Ob aber Variablensharing oder ein Wertsharing implementiert wird, muss sich noch zeigen. Wertsharing wäre eigentlich sinnvoller, impliziert aber die Trennung des Wert von der Variablen.