Die Texte muessen weiter aufgesplittet werden:

Opaque Type
ED	    greift zu auf  LINE_LIST und auf LINE
LINE_LIST   greift zu auf  LINE

*****die Opaque Type LINE exportiert
succ = SetLine (&line, string)   ; Abspeichern einer Zeile in einem eigenen Format
succ = DelLine (&line)           ; Löschen einer Zeile
str  = GetLine (&line)           ; Umwandeln einer Zeile in einem Speziellen Format nach Text


*****die opaque Type LINE_LIST exportiert
succ	 InsEntry (List, Pos [,Value]); fuege an stelle pos einen Eintrag Entry in eine Liste ein
succ/old DelEntry (List, Pos);          Loesche einen Eintrag aus einer Liste ( ??? return success ??? gib seinen Value zurueck ??? )
APTR	 GetEntry (List, Pos);          Versuche auf einen Eintrag lesend Zuzugreifen;
succ/Old SetEntry (List, Pos, Value);   .... schreibend zuzugreifen

dir == richtung (+/-)
num == max anzahl elemente abzuarbeiten (abbruch ausserdem bei FOUND, endofList)
Pos	 SearchEntry  (List, Start, SearchProc, dir, num) Suche in einer Liste bis zum 1. return-TRUE mit der SearchProc
Succ	 ScanList     (List, Start, ScanProc, dir, num)   Arbeite die ganze Lste mit ScanProc ab



Wichtig:
Es wäre seeehr angenehm,
indenting auszubauen:

commandos: tabline 5,9,13,... oder 1+4+4+4+4+4+4+4+4....
	   um eine Tabulatorzeile einzugeben

do_indent [[+/-] num]
    do_indent bringt die aktuelle zeile in die gleiche Indention wie die darüberliegende
    do_indent -1 sucht	die nächste zeile oben, die weniger eingrückt ist,
		 und geht bis zu deren einrückung nach vorn (falls keine
		 gefunden, dann entweder voriger tabulatorschritt, oder
		 startofline)
    do_indent +1 rueckt ein entweder zum naechsten tabschritt, oder zu einem
		 Punkt der vom aktuellen genau so weit weg ist wie die
		 aktuelle indention, falls eine vorhanden ist.


jedesmal, wenn eine Zeile Weiter eingerückt ist, als ihr vorgaenger,
wird unter dem 1. Char des Vorgaengers ein dünner strich gezogen, der
darueber Auskuft gibt, bei welcher Position Indention greift

z.B. das könnte ein Beispiel sein
die mit "|" gezeichneten Linien stellen die jeweils erreichbaren
vorigen indention-punkte dar, die # die naechsten; die kommentare
am zeilenende, sagen, wie die vorigen erreicht werden koennen : die 1 angabe geht in die 1. spalte, die letzte nach firstnb

bei der var.deklaration ist ein sprung in der beechnung:
an allen anderen stellen war next_indent == next_tab
dort wurde nun next_indent == (up-firstnb)-wright verwendet
um zu zeigem dass sich dann auch die weiteren indentions danach verschieben

int main ()
{
|	int  a1;				 /* 0,garnicht?*/      <- berechnung ueber tabulatoren
|	int  i,#				 /* -1,0       */
|	|    j,#				 /* -1,0,garnicht? */  <- berechnung ueber SoW in der darueberliegenden Zeile
|	|    k;   #				 /* -2,-1,0    */
|	int  #2;  #				 /* -2,-1      */      <- # entstanden durch Übernahme des letzten abstandes
|		#	#	#
|	do_1stco#mand();                         /* -1,0       */
|		#	#	#
|	if ( a =# b ) {                          /* -1,0       */
|	|	for ( i # 0; i < a; i++) {       /* -1,0,+1    */
|	|	|	do_something();          /* -2,-1,0,+1 */
|	|	} /* for#*/			 /* -3,-2,-1   */
|	|		#	#
|	|	if (ok (#)                       /* -2,-1,0    */
|	|	|	do_sthelse();            /* -2,-1,0,+1 */
|	} /* if #/	#			 /* -3,-2      */
|		#	#	#
|	do_nochwas ();                           /* -1,0       */
} /* main */					 /* -1	       */


block-indention (pseudocode)
if (x>firstnb){
    firstnb;
    if (is_end_of_indention) {
	up;
	block-indention;
    } elif (is_start_of indention) {
	down;
	block-indention;
    } else {
	blockline;
    }
} else{
    while (!top && (!emptyline || x<firstnb)){
	up;
    }
    bstart;
    firstnb;
    down;
    while (!bottom && (emptyline || x>firstnb)){
	down;
    }
    if (x>firstnb){
	up;
    }
    bend;
}

mit so einem commando könnte man ziemlich einfach
ganze code-blöcke markieren, die einen gewissen
indention-level haben

(noch effektiver wäre es, dem editor sagen zu können,
 unter welchen umständen er selbst eine indention durchführen soll

 zum beispiel ist es in C ja so, dass ein "}" (in der zeile darüber) meist
 eine indention einleitet, dass mit "}" eine beendet wird, dass gewisse
 schlüsselworte eine einleiten koennen (case, if, else, for, ...) oder
 beenden/unterbrechen (case, else, default) .

 wenn dem Editor diese konditionen eingegeben werden könnten, ware es ideal.

wenn zB alle konstruktionen konsequent {}-geklammert werden, mit } an firstnb
ist der Aufwand füer C relativ gering, bei Modula noch geringer (da ist das END ja eh' zwingend)

ueber alle massen eignet sich dabei auch ein konsequentes kommentieren
(nach jedem }/END in kommentaren der Konstruktor, der es einleitete
so dass nur noch mit so etwas wie findmatch also unter berücksichtigung von nesting
das letzte vorkommen gesucht werden muss


ebenso sinnvoll idst es, wenn irgendwie festgestellt werden kann:
in_komment() einer programmiersprache ?

zB C:  last occurance of */ ist weiter weg als last occurance of /* (not nested)
       || // ist in akt. zeile vor x
   Pascal: findmatch auf *) liefert ein ergebnis		    (nested ????)
       || findmatch auf } liefert ein ergebnis			    (nested ????)
   M2: findmatch auf *) liefert ein ergebnis			    (nested)
   Asm:   ; ist in akt.Zeile vor x
   CBM-Shell (s.o Asm)
   ARexx: (s.o. C erste poss)
   AmigaBasic: REM oder ' ist in akt zeile vor x
   C-Shell   # ist in akt Zeile vor x
   Make (s.o C-Shell)
   DME	(s.o C-Shell)
   Ada	-- ist in akt Zeile vor x  ???
   Lisp ;  ist in akt Zeile vor x