			errmsgio( name, errno )

	"error message, I/O-operations"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	errmsgio(name,errno)  char *name, *errno;
	name ist der Name einer fehlerhaften Funktion.
	errno ist ein string von maximal 7 Zeichen, der eine auf der
	Datei "errmsg" vorhandene Fehlernummer enthaelt.
	errmsgio druckt die entsprechende Fehlermeldung auf stderr.



			fgeta( pf )

	"file get atom"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	atom fgeta( pf )  FILE *pf;
	a = fgeta( pf );
	Das Atom a wird von der Datei *pf gelesen.
	Bei Fehler wird a = ERROR geliefert.



			fgetc( pf )                     (MACRO)

	"file get character"
	Quellbibliothek: srclib.C_sm
	Include-Datei    _list.h
	single fgetc(pf)  FILE *pf;
	c = fgetc( pf );
	Von der Datei *pf wird das naechste Zeichen nach c eingelesen.
	fgetc() ist identisch mit getc().
	Bei Auftreten des Entwertungszeichens \ wird dieses sowie das
	nachfolgende Zeichen ignoriert. Soll \ als signifikantes
	Zeichen interpretiert werden, so muss es doppelt eingegeben
	werden: \\
	Falls die Eingabe nicht vom Bildschirm erfolgt, wird der
	linke Rand (MARGIN) ueberlesen.
	Bei Fehler oder Dateiende ist c = EOF. Dabei wird keine
	Fehlermeldung ausgegeben.



			fgetcb( pf )

	"file get character, skipping blanks"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single fgetcb( pf )  FILE *pf;
	c = fgetcb( pf );
	Von der Datei *pf wird das naechste Zeichen, das kein Leer-
	zeichen ist, nach c eingelesen.
	Bei Auftreten des Entwertungszeichens \ wird dieses sowie
	das nachfolgende Zeichen ignoriert. Soll \ als signifikantes
	Zeichen interpretiert werden, so muss es doppelt eingegeben
	werden: \\
	Falls die Eingabe nicht vom Bildschirm erfolgt, wird der
	linke Rand (MARGIN) ueberlesen.
	Bei Fehler oder Dateiende ist c = EOF; dabei wird keine
	Fehlermeldung ausgegeben.



			fgetcs( pf )

	"file get character, skipping space"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single fgetcs( pf )  FILE *pf;
	c = fgetcs( pf );
	Von der Datei *pf wird das naechste Zeichen, das kein Zwi-
	schenraum ist, nach c eingelesen. Als Zwischenraum gelten:
	Leerzeichen (040), Tabulator (011, 013), Wagenruecklauf (015),
	Zeilenvorschub (012) und Seitenvorschub (014).
	Bei Auftreten des Entwertungszeichens \ wird dieses sowie
	das nachfolgende Zeichen ignoriert. Soll \ als signifikantes
	Zeichen interpretiert werden, so muss es doppelt eingegeben
	werden: \\
	Falls die Eingabe nicht vom Bildschirm erfolgt, wird der
	linke Rand (MARGIN) ueberlesen.
	Bei Fehler oder Dateiende ist c = EOF; dabei wird keine
	Fehlermeldung ausgegeben.



			fgetl( pf )

	"file get list" (rekursiv)
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list fgetl(pf)  FILE *pf;
	L = fgetl(pf);
	Die Liste L wird von der Eingabedatei *pf gelesen.
	Laeuft fgetl fehlerhaft ab, so ist L = ERROR.



			fgeto( pf )

	"file get object"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	obj fgeto(pf)  FILE *pf;
	a = fgeto( pf );
	Das Objekt a wird von der Eingabedatei *pf gelesen.
	Laeuft fgeto fehlerhaft ab, so wird a = ERROR geliefert.



			fgets( s, n, pf )               (MACRO)

	"file get string"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	char *fgets( s,n,pf )  char *s; single n; FILE *pf;
	str = fgets( s,n,pf );
	fgets() liest von der Datei *pf entweder n-1 Zeichen oder bis
	einschliesslich zum naechsten Zeilenende oder bis Dateiende,
	falls dies vorher eintrifft. Die eingelesenen Zeichen traegt
	fgets() in den Bereich ein, auf den s zeigt.
	fgets() schliesst die eingelesene Zeichenreihe mit '\0' ab.
	Bei Auftreten des Entwertungszeichens \ wird dieses sowie das
	nachfolgende Zeichen ignoriert. Soll \ als signifikantes
	Zeichen interpretiert werden, so muss es doppelt eingegeben
	werden: \\
	Falls die Eingabe nicht vom Bildschirm erfolgt, wird der
	linke Rand (MARGIN) ueberlesen.
	str ist der Zeiger auf das erste eingelesene Zeichen.
	Bei Fehler oder Dateiende ist str der Nullzeiger. Dabei wird
	keine Fehlermeldung ausgegeben.



			flines( k, pf )

	"file lines"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single flines(k,pf)  single k; FILE *pf;
	t = flines( k,pf );
	Fuer k<=0 zeigt flines keine Wirkung.
	Es werden k Zeilenvorschuebe auf die Datei *pf ausgegeben.
	Bei fehlerhaftem Ablauf ist t = ERROR, andernfalls t = 0.



			fprintf( pf, format[, arg]... ) (MACRO)

	"file print formated"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single fprintf( pf, format [,arg]... )  FILE *pf; char *format;
	t = fprintf( pf, format [,arg]... );
	Es duerfen hoechstens 26 Argumente uebergeben werden.
	(Dabei werden Dateizeiger und Formatstring nicht mitgezaehlt.)
	Sie werden gemaess den Formatanweisungen in "format" auf
	die Datei *pf ausgegeben.
	Bei Erfolg ist t=0, andernfalls ist t negativ.
	Zu den Formatangaben siehe CES-Buch 2, Seite 2-123.
	Dabei aendern sich folgende Parameter:
		l       (vor d,o,u,x) Format fuer ein Argument vom
			Typ "long int" ist redundant und wird
			v e r b o t e n.
		d,o,u,x beziehen sich auf Zahlen vom Typ "single".
	Zusaetzliche Formatangaben:
	    %a      	Dezimaldarstellung eines Atoms.
	    %b 	        Bitmuster einer Zahl vom Typ "single".
	    %i      	Dezimaldarstellung einer ganzen Zahl.
	    %l      	Liste.
	    %obj 	Objekt ( man unterscheide %o ! ).
	    %r      	Bruchdarstellung einer rationalen Zahl.
	    %.[m]r  	Dezimaldarstellung einer rationalen Zahl;
			m gibt die Anzahl der Nachkommastellen an
			( %.r entspricht %.10r ).  
	    %[m]p       Exponentdarstellung einer Fliesskommazahl; 
			m gibt die Anzahl der Mantissestellen an.
			( %p entspricht %8p ).
	    %[n].[m]p   Festkommadarstellung einer Fliesskommazahl;
			n+1 ist dabei die Laenge des Strings vor dem 
			Punkt ( n Ziffern und eine Stelle fuer ein 
			eventuelles Vorzeichen ). Falls weniger als n 
			Vorkommastellen vorhanden sind, werden Blanks
			vorangestellt, bei mehr als n Vorkommastellen
			werden alle Stellen ausgedruckt. m ist die 
			Anzahl der Nachkommatellen, die ausgegeben 
			werden ( Voreinstellung: n = 1, m = 8 ).
	    %t          zum Argument single n, n<LN_SIZE: Einruecken
			der aktuellen Zeile um n Zeichen, vom Zeilen-
			anfang an gerechnet (falls moeglich).



			fputa( a, pf )

	"file put atom"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single fputa(a,pf)  atom a; FILE *pf;
	t = fputa( a,pf );
	Das Atom a wird auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputbits( s, pf )

	"file put bits"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single fputbits(s,pf)  unsigned s; FILE *pf;
	t = fputbits( s,pf );
	Die bitweise Darstellung von s wird auf die Datei *pf ausgegeben.
	Eine Ueberpruefung des Typs von s wird nicht vorgenommen.
	t = 0 bei Erfolg, ERROR sonst.



			fputc( c, pf )                  (MACRO)

	"file put character"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single fputc(c,pf)  char c; FILE *pf;
	t = fputc( c,pf );
	fputc() ist identisch mit putc().
	Der character c wird auf die Datei *pf ausgegeben.
	Bei Erfolg ist t=c, andernfalls t = EOF.
	Das Zeichen \ gilt als Entwertungszeichen, d.h. beim Wiedereinlesen
	wird dieses sowie das nachfolgende Zeichen ignoriert.
	Will man \ als signifikantes Zeichen ausgeben, so muss es zweifach
	ausgegeben werden: \\



			fputl( L, pf )

	"file put list" (rekursiv)
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single fputl(L,pf)  list L; FILE *pf;
	t = fputl( L,pf );
	Die Liste L wird auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputlstruct( L, pf )

	"file put list structure" (rekursiv)
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single fputlstruct(L,pf)  list L; FILE *pf;
	t = fputlstruct(L,pf);
	Auf die Datei *pf wird die Struktur der Liste L ausgegeben, d.h.
	welche Adressen und Inhalte die einzelnen Listenzellen haben.
	Dabei wird der Inhalt der Variablen L, also die Adresse, wo die
	Liste anfaengt, nicht mit ausgegeben.
	t = 0 bei Erfolg und ERROR sonst.



			fputo( a, pf )                  (MACRO)

	"file put object"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single fputo(a,pf)  obj a; FILE *pf;
	t = fputo( a,pf );
	Das Objekt a wird auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			fputs( s, pf )                  (MACRO)

	"file put string"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single fputs(s,pf)  char *s; FILE *pf;
	t = fputs( s,pf );
	Der string s wird auf die Datei *pf ausgegeben.
	t = 0 bei Erfolg, EOF sonst.



			ftab( n, pf )

	"file tabulator"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single ftab(n,pf)  single n; FILE *pf;
	t = ftab( n,pf );
	Die aktuelle Zeile auf der Datei *pf wird bis einschliesslich
	der n-ten Spalte mit Leerzeichen aufgefuellt,
	falls MARGIN < n <= LN_SIZE.
	Andernfalls zeigt ftab keine Wirkung.
	t = 0 bei Erfolg, ERROR sonst.



			gc(  )

	"garbage collector"
	Quellbibliothek: srclib.kern
	Include-Datei:   _list.h
	!!! wird vom System automatisch benutzt !!!
	Alle Zellen im SPACE, die vom STACK erreichbar sind,
	werden markiert. Danach wird eine Liste aller freien Zellen
	angelegt (AVAIL), und die Markierungen werden entfernt.
	Die globalen Variablen GC_COUNT und GC_CC werden aktualisiert.
	Falls noetig wird der SPACE vergroessert. (*)
	Ist GC_TEST = 1, so werden alle Listen im SPACE auf Korrektheit
	ueberprueft. (**)
	Wenn bei (**) eine nicht korrekte Liste gefunden wird oder bei (*)
	SP_MAX erreicht ist, wird das Programm mit einer entsprechenden
	Meldung auf stdout abgebrochen.



			gccpr(  )

	"garbage collector: compressing"
	Quellbibliothek: srclib.kern
	Include-Datei:   _list.h      
	single gccpr();
	s = gccpr();
	Fuer jede Variable x, die im STACK durch init(),
	bind(), globinit() oder globbind() eingebunden 
	wurde und auf eine Liste zeigt, wird diese Liste 
	an den Anfang des SPACE kopiert. x erhaelt als 
	neuen Wert einen Zeiger auf diese Liste.       
	s ist die Anzahl der gebundenen Variablen. 
	Warnungen:  
	1)  Nicht gebundene Variablen, die vor dem Aufruf 
	    von gcpr() auf eine (gebundene) Liste
	    zeigten, haben nach gcpr() im allgemeinen keinen 
	    sinnvollen Wert mehr.                   
	2)  Zeigen verschiedene im STACK gebundenen Variablen 
	    auf die gleiche Liste, wird fuer jede dieser 
	    Variablen eine neue Liste erzeugt, was im extremen 
	    Fall zur Vergroesserung des Speicherbedarfs fuehren
	    kann.
	siehe auch gcfree().  



			gcfree(  )

	"garbage collector with freeing blocks"
	Quellbibliothek: srclib.kern
	Include-Datei:   _list.h               
	single gcfree( );
	a = gcfree( );
	Alle Zellen im SPACE, die vom STACK erreichbar sind,
	werden markiert. Danach wird eine Liste aller freien Zellen
	angelegt (AVAIL), und die Markierungen werden entfernt.
	Die globalen Variablen GC_COUNT und GC_CC werden aktualisiert.
	Falls noetig wird der SPACE vergroessert. (*)     
	Falls moeglich, wird der SPACE verkleinert, dergestalt dass
	die zuletzt allocierten Bloecke, die keine markierten Zellen
	enthalten, freigegeben werden. In diesem Fall wird eine 
	Meldung ausgegeben. 
	a ist die Anzahl der freigegebenen Bloecke.
	Mit gccpr() koennen Listen an den Anfang des SPACE kopiert 
	werden, so dass die Wahrscheinlichkeit, dass tatsaechlich 
	leere Bloecke entstehen, die freigegeben werden koennen, 
	erhoeht wird.
	Ist GC_TEST = 1, so werden alle Listen im SPACE auf Korrektheit
	ueberprueft. (**)
	Wenn bei (**) eine nicht korrekte Liste gefunden wird oder bei (*)
	SP_MAX erreicht ist, wird das Programm mit einer entsprechenden
	Meldung auf stdout abgebrochen.        
	Beispiel: 
	Sei foo( ) eine Funktion, die sehr viel Speicherplatz verbraucht,
	der wieder freigegeben werden soll. foo( ) soll als Rueckgabewert 
	eine Liste haben.     
	...
	L = foo( a, b, c )
	gcfree();        
	L = lcopy( L ); 
	gcfree();
	...                               
	Zeile 3 und 4 dienen dazu, L an den Anfang des SPACE zu kopieren. 



			gcreinit( bls, blnrm )

	"garbage collector reinitialization"
	Quellbibliothek: srclib.kern
	Include-Datei:   _list.h               
	single gcreinit(bls, blnrm)  single bls, blnrm;
	sp_max = gcreinit(bls, blnrm);                     
	Es muss gelten bls >= 0, blnrm >= 0.
	Der SIMATH-Listenspeicher (SPACE) wird neu angelegt. 
	Dabei erhalten die SIMATH-Variablen BL_SIZE und BL_NR_MAX die
	Werte bls beziehungsweise blnrm. Ist bls oder blnrm gleich
	Null, so werden die alten Werte von BL_SIZE beziehungsweise
	BL_NR_MAX beibehalten.
	Allen im STACK gebundenen Variablen, die vor dem Aufruf Zeiger
	auf Listen waren, wird der Wert 0 zugewiesen.
	BL_SIZE ist die Anzahl der Listenelemente, die ein Block
	enthaelt, BL_NR_MAX die maximale Anzahl von Bloecken, die
	waehrend eine Programmes angelegt werden kann. Werden mehr
	Listenelemente benoetigt, so wird das Programm in der Regel mit
	einer Fehlermeldung beendet.
	sp_max erhaelt den Wert SP_MAX.



			geta(  )                        (MACRO)

	"get atom"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	atom geta( )
	a = geta( );
	a wird von stdin gelesen.
	Bei Fehler wird a = ERROR geliefert.



			getc( pf )                      (MACRO)

	"get character"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single getc(pf)  FILE *pf;
	c = getc( pf );
	Von der Datei *pf wird das naechste Zeichen nach c eingelesen.
	getc() ist identisch mit fgetc().
	Bei Auftreten des Entwertungszeichens \ wird dieses sowie das
	nachfolgende Zeichen ignoriert. Soll \ als signifikantes
	Zeichen interpretiert werden, so muss es doppelt eingegeben
	werden: \\
	Falls die Eingabe nicht vom Bildschirm erfolgt, wird der
	linke Rand (MARGIN) ueberlesen.
	Bei Fehler oder Dateiende ist c = EOF. Dabei wird keine
	Fehlermeldung ausgegeben.



			getcb(  )                       (MACRO)

	"get character, skipping blanks"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single getcb( )
	c = getcb( );
	Von stdin wird das naechste Zeichen eingelesen, das kein
	Leerzeichen ist.
	Bei Fehler oder Dateiende ist c = EOF, andernfalls ist c das
	eingelesene Zeichen als positiver integer-Wert.



			getchar(  )                     (MACRO)

	"get character"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single getchar()
	c = getchar( );
	Von stdin wird das naechste Zeichen nach c eingelesen.
	Bei Auftreten des Entwertungszeichens '\' wird dieses sowie das
	nachfolgende Zeichen ignoriert.
	Bei Fehler oder Dateiende ist c = EOF.



			getcs(  )                       (MACRO)

	"get character, skipping space"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single getcs( )
	c = getcs( );
	Von stdin wird der naechste character eingelesen, der kein
	Zwischenraum ist. Als Zwischenraum gelten: Leerzeichen (040),
	Tabulator (011, 013), Wagenruecklauf (015), Zeilenvorschub
	(012) und Seitenvorschub (014).
	Bei Fehler oder Dateiende ist c = EOF, andernfalls ist c das
	eingelesene Zeichen als integer-Wert.



			getl(  )                        (MACRO)

	"get list"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list getl()
	L = getl ( );
	Die Liste L wird von stdin gelesen.
	Laeuft getl fehlerhaft ab, so ist L = ERROR.



			geto(  )                        (MACRO)

	"get object"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	obj geto()
	a = geto();
	Das Objekt a wird von stdin gelesen.
	Laeuft geto fehlerhaft ab, so wird a = ERROR geliefert.



			getocnt( pf )

	"get output-counter"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single getocnt(pf)  FILE *pf;
	n = getocnt( pf );
	n ist der momentane Wert des Zeichenzaehlers fuer die aktuelle
	Ausgabezeile der Datei *pf.



			gets( s )                       (MACRO)

	"get string"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	char *gets( s )  char *s;
	str = gets( s );
	gets() liest von der Standardeingabe Zeichen bis zum Zeilen-
	ende und speichert die gelesene Zeichenreihe in s. Das Zeilen-
	ende wird ersetzt durch das Nullbyte '\0'.
	Bei Auftreten des Entwertungszeichens \ wird dieses sowie das
	nachfolgende Zeichen ignoriert. Soll \ als signifikantes
	Zeichen interpretiert werden, so muss es doppelt eingegeben
	werden: \\
	Falls die Eingabe nicht vom Bildschirm erfolgt, wird der
	linke Rand (MARGIN) ueberlesen.
	str ist der Zeiger auf das erste eingelesene Zeichen.
	Bei Fehler oder Dateiende ist str der Nullzeiger. Dabei wird
	keine Fehlermeldung ausgegeben.



			globbind( pL )

	"bind for global and static variables"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single globbind( pL )  obj *pL;
	s = globbind( pL );    
	Die Adresse pL wird fuer immer im STACK eingetragen. 
	globbind dient dazu, globale Variablen oder static-
	Variablen zu sichern. 
	Der Aufruf globbind( &A ) fuer eine globale Variable
	oder static-Variable A entspricht dem Aufruf bind( A ) 
	fuer eine lokale Variable (siehe Handbuch).
	Wird globbind fuer dieselbe Adresse mehrmals aufgerufen, 
	so wird diese Adresse trotzdem nur einmal im STACK 
	eingetragen. globbind kann also mehrmals fuer dieselbe 
	Variable aufgerufen werden, ohne dass der STACK ueberlastet
	wird. Falls pL mit Hilfe von globbind im STACK schon 
	eingetragen war, ist s=1.
	Sonst s=0.
	*pL wird nicht veraendert.
	vgl. auch globinit



			globinit( pL )

	"init for global and static variables"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single globinit( pL )  obj *pL;
	s = globinit( pL );    
	Die Adresse pL wird fuer immer im STACK eingetragen. 
	globinit dient dazu, globale Variablen oder static-
	Variablen zu sichern. 
	Der Aufruf globinit( &A ) fuer eine globale Variable
	oder static-Variable A entspricht dem Aufruf init( A ) 
	fuer eine lokale Variable (siehe Handbuch).
	Wird globinit fuer dieselbe Adresse mehrmals aufgerufen, 
	so wird diese Adresse trotzdem nur einmal im STACK 
	eingetragen. globinit kann also mehrmals fuer dieselbe 
	Variable aufgerufen werden, ohne dass der STACK ueberlastet
	wird. Falls pL mit Hilfe von globinit im STACK schon 
	eingetragen war, ist s=1, und *pL wird nicht veraendert.
	Sonst s=0, *pL=0.
	vgl. auch globbind



			inocmp( dk1, dk2 )

	"i-node comparison"
	Quellbibliothek: srclib.kern
	Include-Datei:   _list.h
	single inocmp( dk1, dk2 )  single dk1, dk2;
	t = inocmp( dk1, dk2 );
	Die Indexnummern der Dateien mit Dateikennzahl dk1 und dk2
	werden verglichen. Bei Gleichheit ist t=0, andernfalls t=1.
	Laeuft der benutzte C-Systemaufruf fehlerhaft ab, so ist t=-1.



			isatom( a )                     (MACRO)

	"is atom ?"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single isatom(a)  obj a;
	n = isatom(a);
	n hat den Wert 1, falls a ein Atom ist,
		   und 0, falls a kein Atom ist.



			isbound( pL )

	"is bound in STACK ?"
	Quellbibliothek: srclib.kern
	Include-Datei:   _list.h
	single isbound(pL)  obj *pL;
	n = isbound(pL);
	n = 1, falls pL im STACK eingetragen ist,
	sonst n=0.



			islelt( L, a )

	"is list element ?"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single lelt( L, a )  list L; obj a;
	k = lelt( L, a );      
	Ist k = 0, so ist a nicht in L enthalten. 
	Ist k > 0, so ist a in L enthalten. 
	a steht dabei als k-ter Eintrag in L, und
	k ist minimal mit dieser Eigenschaft. 



			islist( L )

	"is list ?" (rekursiv)
	Quellbibliothek: srclib.kern
	Include-Datei:   _list.h
	single islist(L)  obj L;
	n = islist(L);
	n = 1, falls L eine korrekte Listenstruktur besitzt und zusaetzlich
	       AVAIL korrekt ist,
	und 0, sonst.
	AVAIL, der Bereich der freien Zellen, zaehlt hierbei nicht als
	Liste.
	Falls AVAIL fehlerhaft ist, bricht das Programm mit einer Meldung
	auf stdout ab.



			isobj( a )                      (MACRO)

	"is object ?"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single isobj(a)  unsigned a;
	t = isobj(a);
	t hat den Wert 1, falls a ein object ist, d.h. ein Atom oder eine
			  Liste,
		   und 0  sonst.



			issingle( a )                   (MACRO)

	"is single ?"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single issingle(a)  obj a;
	n = issingle(a);
	n hat den Wert 1, falls a ein single ist,
		   und 0, falls a kein single ist.



			lblength( L, b )

	"list bounded length"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single lblength(L)  list L; single b; 
	n = lblength( L );
	n = Min ( {Anzahl der Objekte in L}, b ).
	Im Gegensatz zu llength wird nicht die ganze 
	Liste durchlaufen, das heisst das Programmstueck 
	    if ( lblength(L, 6) > 5 ) { ...
	ist bei einer langen Liste L schneller als 
	    if ( llength( L ) > 5 ) { ...,
	da im ersten Fall nur die 6 ersten Listenelemente 
	"angesehen" werden. Siehe auch: llength 



			lcconc( L1, L2 )

	"list constructive concatenation"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lcconc(L1,L2)  list L1, L2;
	L = lcconc( L1, L2 );
	L ist die konstruktive Konkatenation von  L1 und L2, wobei
	L1 und L2 erhalten bleiben.



			lcinv( L )

	"list constructive inverse"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lcinv(L)  list L;
	L1 = lcinv( L );
	Fuer L = ( a1, a2, ... , an ) ist L1 = ( an, ... , a2, a1 ).
	L1 ist eine neue Liste, L wird nicht veraendert!



			lcomp( a, L )

	"list composition"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lcomp(a,L)  obj a; list L;
	L1 = lcomp( a, L );
	Fuer L = ( a1, a2, ... , an ) bzw. L = () ist
	L1 = ( a, a1, a2, ... , an ) bzw. L1 = ( a ).



			lcomp2( a, b, L )               (MACRO)

	"list composition, 2 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lcomp2(a,b,L) obj a,b; list L;
	L1 = lcomp2(a,b,L);
	Fuer L = ( a1, a2, ... , an ) bzw. L = () ist
	L1 = ( a, b, a1, a2, ... , an ) bzw. L1 = ( a, b ).



			lcomp3( a, b, c, L )            (MACRO)

	"list composition, 3 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lcomp3(a,b,c,L)  obj a,b,c; list L;
	L1 = lcomp3(a,b,c,L);
	Fuer L = ( a1, a2, ... , an ) bzw. L = () ist
	L1 = ( a, b, c, a1, a2, ... , an ) bzw. L1 = ( a, b, c ).



			lcomp4( a, b, c, d, L )         (MACRO)

	"list composition, 4 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lcomp4(a,b,c,d,L)  obj a,b,c,d; list L;
	L1 = lcomp4(a,b,c,d,L);
	Fuer L = ( a1, a2, ... , an ) bzw. L = () ist
	L1 = ( a, b, c, d, a1, a2, ... , an ) bzw. L1 = ( a, b, c, d ).



			lcomp5( a, b, c, d, e, L )      (MACRO)

	"list composition, 5 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lcomp5(a,b,c,d,e,L)  obj a,b,c,d,e; list L;
	L1 = lcomp5(a,b,c,d,e,L);
	Fuer L = ( a1, a2, ... , an ) bzw. L = () ist
	L1 = ( a, b, c, d, e, a1, a2, ... , an ) bzw.
	L1 = ( a, b, c, d, e ).



			lcomp6( a, b, c, d, e, f, L )   (MACRO)

	"list composition, 6 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lcomp6(a,b,c,d,e,f,L)  obj a,b,c,d,e,f; list L;
	L1 = lcomp6(a,b,c,d,e,f,L);
	Fuer L = ( a1, a2, ... , an ) bzw. L = () ist
	L1 = ( a, b, c, d, e, f, a1, a2, ... , an ) bzw.
	L1 = ( a, b, c, d, e, f ).



			lconc( L1, L2 )

	"list concatenation"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lconc(L1,L2)  list L1, L2;
	L = lconc( L1, L2 );
	Fuer L1 = ( a1, a2, ... , an ) und L2 = ( b1, b2, ... , bm )
	ist L die Konkatenation von l1 und L2:
		L = ( a1, a2, ... , an, b1, b2, ... , bm ).
	L1 wird veraendert.



			lcopy( L )

	"list copy" (rekursiv)
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lcopy(L)  list L;
	M = lcopy(L);
	M ist eine Kopie der Liste L.



			lecdel( L, n )

	"list element constructive delete"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list ledel (L,n)  single n; list L;
	K = ledel (L,n);
        Es muss gelten: n > 0, 
	L ist eine Liste mit mindestens n Elementen.
	K ist die gleiche Liste wie L ohne das n-te Element
	(L wird also teilweise kopiert). 
	siehe auch: ledel.



			lecins( L, k, a )

	"list element constructive insert"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list leins(L,k,a)  list L; single k; obj a;
	L1 = leins( L, k, a );
	Fuer 0 <= k <= Laenge von L und L = (a1,..,ak,..an)
	ist L1 = (a1,..,ak,a,..an).
	siehe auch: leins.



			ledel( pL, n )

	"list element delete"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	obj ledel (pL,n)  single n; list *pL;
	o = ledel (pL,n);
        Es muss gelten: *pL ist eine Liste mit mindestens n Elementen.
	o ist das n-te Element von *pL.
	o wird aus *pL entfernt.



			leins( L, k, a )

	"list element insert"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list leins(L,k,a)  list L; single k; obj a;
	L1 = leins( L, k, a );
	Fuer 0 <= k <= Laenge von L und L = (a1,..,ak,..an)
	ist L1 = (a1,..,ak,a,..an).
	L wird veraendert.



			leins2( a, L )

	"list element insert, 2nd position"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list leins2(a,L)  obj a; list L;
	L1 = leins2(a,L);
	Fuer L = (a1,a2,...,an) bzw. L = (a1) ist L1 = (a1,a,a2,...,an)
	bzw. L1 = (a1,a). L wird dabei veraendert.



			lelt( L, k )

	"list element"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	obj lelt(L,k)  list L; single k;
	a = lelt( L, k );
	Fuer 1 <= k <= Laenge von L ist a das k-te Objekt von L.



			lepermg( L )

	"list element permutations generator"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lepermg ( L )  list L;
	K = lepermg ( L );
	K ist eine Liste aller moeglichen Permutationen von L. 
	Beispiele:
	L = ( 1 2 3 )  =>  K =  ( ( 3  1  2 )  ( 3  2  1 )  
	    ( 2  1  3 )  ( 2  3  1 )  ( 1  2  3 )  ( 1  3  2 ) ), 
	L = ( 2 2 1 )  =>  K = ( ( 1 2 2 ) ( 2 2 1 ) ( 2 1 2 ) ), 
	L = ( 1 1 )  =>  K = ( ( 1 1 ) )



			lerot( L, k, l )

	"list element rotation"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single lerot(L,k,l)  list L; single k, l;
	n = lerot( L, k, l );
	L ist ungleich der leeren Liste und
	k, l mit 1 <= k <= l <= Laenge von L.
	L = (a1,..,ak,..,a(l-1),al,..,an) wird veraendert zu
	L = (a1,..,al,ak,..,a(l-1),..,an).
	n hat den Wert 0.



			leset( L, k, a )

	"list element set"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single leset(L,k,a)  list L; single k; obj a;
	n = leset( L, k, a );
	Fuer 1 <= k <= Laenge von L wird
	L = ( a1, a2, ... , a(k-1), ak, a(k+1), ... , an ) veraendert zu
	L = ( a1, a2, ... , a(k-1), a , a(k+1), ... , an).
	n hat den Wert 0.



			lfifth( L )                     (MACRO)

	"list fifth"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	obj lfifth(L)  list L;
	a = lfifth(L);
	Die Liste L muss mindestens 5 Objekte enthalten.
	a ist das fuenfte Objekt der Liste L.



			lfirst( L )                     (MACRO)

	"list first"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	obj lfirst(L)  list L;
	a = lfirst(L);
	Die Liste L darf nicht leer sein.
	a ist das erste Objekt der Liste L.



			lfourth( L )                    (MACRO)

	"list fourth"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	obj lfourth(L)  list L;
	a = lfourth(L);
	Die Liste L muss mindestens 4 Objekte enthalten.
	a ist das vierte Objekt der Liste L.



			lines( k )                      (MACRO)

	"lines"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single lines(k)  single k;
	t = lines( k );
	Fuer k<=0 zeigt lines keine Wirkung.
	Es werden k Zeilenvorschuebe auf stdout ausgegeben.
	Bei fehlerhaftem Ablauf ist t = ERROR, andernfalls t = 0.



			linv( L )

	"list inverse"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list linv(L)  list L;
	L1 = linv( L );
	Fuer L = (a1,...,an) mit n >= 0 ist L1 = (an,...,a1).
	L wird veraendert.



			lipairspmax( L )

        "list of integer pairs power maximum"
        Quellbibliothek: srclib.list
        Include-Datei:   _list.h
        int lipairspmax(L)  list L;
        M = lipairspmax(L);
	L = ( P1, E1, ... , Pr, Er ) mit
		- P1 , ... , Pr integer
		- E1 , ... , Er integer
		- llength(L) = 2r >= 2 .
	M = max{ Pi ^ Ei; i = 1, ... , r }.



			list1( a )                      (MACRO)

	"list of one object"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list list1(a)  obj a;
	L = list1(a);
	L ist die Liste ( a ).



			list2( a, b )                   (MACRO)

	"list of 2 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list list2(a,b)  obj a,b;
	L = list2(a,b);
	L ist die Liste ( a, b ).



			list3( a, b, c )                (MACRO)

	"list of 3 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list list3(a,b,c)  obj a,b,c;
	L = list3(a,b,c);
	L ist die Liste ( a, b, c ).



			list4( a, b, c, d )             (MACRO)

	"list of 4 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list list4(a,b,c,d)  obj a,b,c,d;
	L = list4(a,b,c,d);
	L ist die Liste ( a, b, c, d ).



			list5( a, b, c, d, e )          (MACRO)

	"list of 5 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list list5(a,b,c,d,e)  obj a,b,c,d,e;
	L = list5(a,b,c,d,e);
	L ist die Liste ( a, b, c, d, e ).



			list6( a, b, c, d, e, f )       (MACRO)

	"list of 6 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list list6(a,b,c,d,e,f)  obj a,b,c,d,e,f;
	L = list6(a,b,c,d,e,f);
	L ist die Liste ( a, b, c, d, e, f ).



			llast( L )

	"list last object"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list llast(L)  list L;
	L1 = llast( L );
	L1 ist die Liste, die aus dem letzten Objekt von L besteht.
	Ist L die leere Liste, so ist L1 = L.



			llconc( L )

        "list of lists concatenation"
        Quellbibliothek: srclib.list
        Include-Datei:   _list.h
        list llconc(L)  list L;
        L1 = llconc(L);
        L ist eine Liste von Listen, L = ( L_1, ..., L_n ), n>=0.
        L1 ist die Konkatenation der L_i fuer i = 1, ..., n.
        !! Achtung: Die L_i werden veraendert.



			llength( L )

	"list length"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single llength(L)  list L;
	n = llength( L );
	n ist die Anzahl der Objekte in L.



			lmemb( a, L )

	"list member"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single lmemb(a,L)  obj a; list L;
	n = lmemb( a, L );
	n ist 1, falls a ein Objekt aus L ist, und 0 sonst.



			lpair( L1, L2 )

	"list pair"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lpair(L1,L2)  list L1, L2;
	L = lpair( L1, L2 );
	Fuer L1 = (a1,...,an) und L2 = (b1,...,bm) und m,n >=0 ist
	L = (a1,b1,...,al,bl), wobei l = min(n,m).



			lpermut( L, PI )

	"list permutation"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lpermut(L,PI) list L,PI;
	L1 = lpermut(L,PI);
	L ist eine Liste mit n (0<=n<BASIS) Elementen:
	    L = ( l(1) ,..., l(n) ).
	PI ist eine Liste der Laenge n, die aus den n verschiedenen
	Zahlen 1,...,n besteht:
	    PI = ( pi(1) ,..., pi(n) )
	L1 ist das Bild von L unter der von PI beschriebenen
	Permutation, d. h.
	    L1 = ( l(pi(1)) ,..., l(pi(n)) ).



			lred( L )                       (MACRO)

	"list reductum"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lred(L)  list L;
	L1 = lred(L);
	Die Liste L = ( a1, a2, ... , an ) darf nicht leer sein.
	L1 = ( a2, a3, ... , an ) oder die leere Liste, falls
	L = ( a1 ).



			lred2( L )                      (MACRO)

	"list reductum, 2 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lred2(L)  list L;
	L1 = lred2(L);
	Die Liste L = ( a1, a2, a3, ... , an ) muss mindestens
	zwei Objekte enthalten.
	L1 = ( a3, a4, ... , an ) oder die leere Liste, falls
	L = ( a1, a2 ).



			lred3( L )                      (MACRO)

	"list reductum, 3 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lred3(L)  list L;
	L1 = lred3(L);
	Die Liste L = ( a1, a2, a3, a4, ... , an ) muss mindestens
	drei Objekte enthalten.
	L1 = ( a4, a5, ... , an ) oder die leere Liste, falls
	L = ( a1, a2, a3 ).



			lred4( L )                      (MACRO)

	"list reductum, 4 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lred4(L)  list L;
	L1 = lred4(L);
	Die Liste L = ( a1, a2, a3, a4, a5, ... , an ) muss
	mindestens 4 Objekte enthalten.
	L1 = ( a5, a6, ... , an ) oder die leere Liste, falls
	L = ( a1, a2, a3, a4 ).



			lred5( L )                      (MACRO)

	"list reductum, 5 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lred5(L)  list L;
	L1 = lred5(L);
	Die Liste L = ( a1, a2, a3, a4, a5, a6, ... , an ) muss
	mindestens 5 Objekte enthalten.
	L1 = ( a6, a7, ... , an ) oder die leere Liste, falls
	L = ( a1, a2, a3, a4, a5 ).



			lred6( L )

	"list reductum, 6 objects"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lred6(L)  list L;
	L1 = lred6(L);
	Die Liste L = ( a1, a2, a3, a4, a5, a6, a7, ... , an )
	muss mindestens 6 Objekte enthalten.
	L1 = ( a7, a8, ... , an ) oder die leere Liste, falls
	L = ( a1, a2, a3, a4, a5, a6 ).



			lrednext( L )

	"list of reductants next"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lrednext( L )  list L;
	R = lrednext( L );
	L ist eine Liste ( L(1), ..., L(n) ) mit n>0, wobei jeweils L(i)
	eine nicht-leere echte Reduktante (=Reduktum) von L(i+1) ist fuer
	1<=i<n.
	R ist die "lexikographisch naechste solche Liste derselben Laenge",
	falls eine solche existiert, und die leere Liste, falls keine
	solche existiert; genauer:
	Man sucht in L die erste Liste von links, die sich reduzieren
	laesst, ohne dass sich dadurch an der Tatsache "L(i) ist nicht-
	leere echte Reduktante von L(i+1) fuer 1<=i<n" etwas veraendert.
	Wenn es eine solche Liste in L gibt, etwa L(i0), dann ist fuer
	   L=(...,  L(i0-2)   ,  L(i0-1)   ,   L(i0)   ,L(i0+1),...,L(n))
	   R=(...,lred3(L(i0)),lred2(L(i0)),lred(L(i0)),L(i0+1),...,L(n)).
	Falls keine solche Liste L(i0) in L existiert, d.h. falls es zu
	L keine "lexikographisch naechste solche Liste derselben Laenge"
	gibt, ist R die leere Liste.



			lreduct( L, k )

	"list reductum, general"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lreduct(L,k)  list L; single k;
	L1 = lreduct( L, k );
	Es muss gelten : 0 <= k <= Laenge von L.
	L1 ist das k-te Reduktum von L.



			lsbmsort( L )

	"list of single precisions bubble merge sort"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lsbmsort(L)  list L;
	L1 = lsbmsort( L );
	L ist Liste aus einfachgenauen Zahlen oder die leere Liste.
	L1 besteht aus den Elementen aus L in aufsteigender Ordnung
	sortiert.
	L wird veraendert.
	Das Programm ist fuer das Sortieren von grossen Listen gedacht.



			lsbsort( L )

	"list of single precision bubble sort"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single lsbsort(L)  list L;
	n = lsbsort( L );
	L ist Liste aus einfachgenauen Zahlen oder die leere Liste.
	L wird in aufsteigender Ordnung umsortiert.
	L wird veraendert.
	n hat den Wert 0.



			lscomp( L1, L2 )

	"list of singles comparison, lexicographical order"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single lscomp(L1,L2) list L1,L2;
	a = lscomp(L1,L2);
	L1 und L2 sind zwei gleich lange Listen von einfachgenauen
	Zahlen.
	a =  0, falls L1 und L2 gleich sind;
	     1, falls L1 bzgl. der lexikographischen Ordnung
		groesser als L2 ist;
	    -1, falls L1 bzgl. der lexikographischen Ordnung
		kleiner als L2 ist.



			lscomps( L1, L2 )

	"list of singles comparison special version"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single lscomps(L1,L2) list L1,L2;
	n = lscomps(L1,L2);
	L1 = (m1,...,mr) und L2 = (n1,...,nr) sind nichtleere Listen
	gleicher Laenge von singles.
	lscomps liefert als Ergebnis
		0   falls L1 gleich L2;
		1   falls L1 ungleich L2 und mi<=ni fuer 1<=i<=r;
		2   falls L1 ungleich L2 und ni<=mi fuer 1<=i<=r;
		3   sonst.



			lsecond( L )                    (MACRO)

	"list second"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	obj lsecond(L)  list L;
	a = lsecond(L);
	Die Liste L muss mindestens 2 Objekte enthalten.
	a ist das zweite Objekt der Liste L.



			lsfirst( L, a )                 (MACRO)

	"list set first"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	obj lsfirst(L,a)  list L; obj a;
	b = lsfirst(L,a);
	Die Liste L darf nicht leer sein.
	Das erste Objekt in L wird durch a ersetzt.
	b = a;
	L wird dabei veraendert.



			lsins( n, L )

	"list of single precisions insert"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lsins(n,L)  single n; list L;
	L1 = lsins( n, L );
	L ist in aufsteigender Ordnung sortierte Liste aus einfachgenauen
	Zahlen oder die leere Liste.
	n wird so in L eingefuegt, dass L1 wieder in aufsteigender
	Ordnung sortiert ist. Dabei wird L veraendert.



			lsixth( L )

	"list sixth"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	obj lsixth(L)  list L;
	a = lsixth(L);
	Die Liste L muss mindestens 6 Objekte enthalten.
	a ist das sechste Objekt der Liste L.



			lsize( l )                      (MACRO)

	"list size"
	Quellbibliothek: srclib.list
	Include-Datei:	 _list.h
	single lsize (l)  list l;
	len = lsize (l);
	len ist die Anzahl der ASCII-Zeichen (einschliesslich eines
	abschliessenden '\0'), die notwendig sind, um die Liste l 
	(als Zeichenreihe interpretiert) darzustellen.



			lsizerec( l, n )

	"list size recursive part"     (rekursiv)
	Quellbibliothek: srclib.list
	Include-Datei:	 _list.h
	single lsizerec (l,n)  list l, single n;
	len = lsizerec (l,n);
	lsizerec ist der rekursive Teil von -> lsize.



			lsmaxs( L1, L2 )

	"list of singles maximum special version"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lsmaxs(L1,L2) list L1,L2;
	L = lsmaxs(L1,L2);
	L1 = (m1,...,mr) und L2 = (n1,...,nr) sind nichtleere Listen
	gleicher Laenge von singles.
	L = (max(m1,n1),...,max(mr,nr)).



			lsmerge( L1, L2 )

	"list of single precisions merge"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lsmerge(L1,L2)  list L1, L2;
	L = lsmerge( L1, L2 );
	L1 und L2 sind aufsteigend sortierte Listen aus einfachgenauen
	Zahlen. L1 und oder L2 koennen auch die leere Liste sein.
	L ist die aufsteigend geordnete Konkatenation von L1 und L2.
	L1 und L2 werden veraendert.



			lsmins( L1, L2 )

	"list of singles minimum special version"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lsmins(L1,L2) list L1,L2;
	L = lsmins(L1,L2);
	L1 = (m1,...,mr) und L2 = (n1,...,nr) sind nichtleere Listen
	gleicher Laenge von singles.
	L = (min(m1,n1),...,min(mr,nr)).



			lsrandperm( n )

	"list of singles random permutation"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lsrandperm(n)  single n;
	L = lsrandperm(n);
	n ist nicht negativ.
	Es wird eine Zufallspermutation p(1), ..., p(n) der Zahlen 1,...,n
	erstellt mit Hilfe der C-Funktion "rand()".
	L = ( p(1), ..., p(n) ).



			lsrch( a, L )

	"list search"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single lsrch(a,L)  obj a; list L;
	n = lsrch( a, L );
	L ist ungleich der leeren Liste.
	n ist Null, falls a kein Listenobjekt von L ist, sonst
	bezeichnet n das erste Vorkommen von a in L.
	Warnung: Die Liste L auf Parameterposition wird waehrend der
		 Berechnung zerstoert!



			lsred( L1, L2 )                 (MACRO)

	"list set reductum"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lsred(L1,L2)  list L1,L2;
	L = lsred(L1,L2);
	Die Liste L1 darf nicht leer sein.
	Ist L1 =( a1, a2, ... , an ) und  L2 = ( b1, b2, ... , bn ), so
	wird L1 veraendert zu L1 = ( a1, b1, b2, ... , bn ).
	Als Funktionswert wird L = L2 geliefert.



			lsuffix( L, a )                 (MACRO)

	"list suffix"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list lsuffix(L,a)  list L; obj a;
	L1 = lsuffix(L,a);
	Das Objekt a wird an die Liste L = ( a1, a2, ... , an )
	angehaengt.
	L1 = ( a1, a2, ... , an, a ).
	L wird dabei veraendert.



			lthird( L )                     (MACRO)

	"list third"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	obj lthird(L)  list L;
	a = lthird(L);
	Die Liste L muss mindestens 3 Objekte enthalten.
	a ist das dritte Objekt der Liste L.



			ltop( L )                       (MACRO)

	"list to pointer"
	Quellbibliothek: srclib.kern
	Include-Datei:   _list.h
	!!! wird nur vom System benutzt !!!
	PCELL ltop(L)  list L;
	pc = ltop(L);
	pc ist der Pointer auf die Liste L.



			oequal( a, b )

	"object equal" (rekursiv)
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single oequal(a,b)  obj a,b;
	n = oequal( a, b );
	n ist 0, falls a ungleich b ist und 1 sonst.



			oextent( a )

	"object extent" (rekursiv)
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single oextent(a)  obj a;
	n = oextent( a );
	n ist die Anzahl der Zellen im SPACE, die a belegt.



			printf( format[, arg]... )      (MACRO)

	"print formated"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single printf( format [,arg]... )  char *format;
	t = printf( format [,arg]... );
	Es duerfen hoechstens 26 Argumente uebergeben werden.
	(Dabei wird der Formatstring nicht mitgezaehlt.)
	Sie werden gemaess den Formatanweisungen in "format" auf
	stdout ausgegeben.
	Bei Erfolg ist t=0, andernfalls ist t negativ.
	Zu den Formatangaben siehe CES-Buch 2, Seite 2-123.
	Dabei aendern sich folgende Parameter:
		l       (vor d,o,u,x) Format fuer ein Argument vom
			Typ "long int" ist redundant und wird
			v e r b o t e n.
		d,o,u,x beziehen sich auf Zahlen vom Typ "single".
	Zusaetzliche Formatangaben:
	    %a      	Dezimaldarstellung eines Atoms.
	    %b 	        Bitmuster einer Zahl vom Typ "single".
	    %i      	Dezimaldarstellung einer ganzen Zahl.
	    %l      	Liste.
	    %obj 	Objekt ( man unterscheide %o ! ).
	    %r      	Bruchdarstellung einer rationalen Zahl.
	    %.[m]r  	Dezimaldarstellung einer rationalen Zahl;
			m gibt die Anzahl der Nachkommastellen an
			( %.r entspricht %.10r ).  
	    %[m]p       Exponentdarstellung einer Fliesskommazahl 
			m gibt die Anzahl der Mantissestellen an.
			( %p entspricht %8p ).  
	    %[n].[m]p   Festkommadarstellung einer Fliesskommazahl;
			n+1 ist dabei die Laenge des Strings vor dem 
			Punkt ( n Ziffern und eine Stelle fuer ein 
			eventuelles Vorzeichen ). Falls weniger als n 
			Vorkommastellen vorhanden sind, werden Blanks
			vorangestellt, bei mehr als n Vorkommastellen
			werden alle Stellen ausgedruckt. m ist die 
			Anzahl der Nachkommatellen, die ausgegeben 
			werden ( Voreinstellung: n = 1, m = 8 ).
	    %t          zum Argument single n, n<LN_SIZE: Einruecken
			der aktuellen Zeile um n Zeichen, vom Zeilen-
			anfang an gerechnet (falls moeglich).



			ptol( pc )                      (MACRO)

	"pointer to list"
	Quellbibliothek: srclib.kern
	Include-Datei:   _list.h
	!!! wird nur vom System benutzt !!!
	list ptol(pc)  PCELL pc;
	L = ptol(pc);
	L ist die Liste, auf die pc zeigt.



			puta( a )                       (MACRO)

	"put atom"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single puta(a)  atom a;
	t = puta( a );
	a wird auf stdout ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			putbits( s )                    (MACRO)

	"put bits"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single putbits(s)  unsigned s;
	t = putbits( s );
	Die bitweise Darstellung von s wird auf stdout ausgegeben.
	Eine Ueberpruefung des Typs von s wird nicht vorgenommen.
	t = 0 bei Erfolg, ERROR sonst.



			putc( c, pf )                   (MACRO)

	"put character"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single putc(c,pf)  char c; FILE *pf;
	t = putc( c, pf );
	putc() ist identisch mit fputc().
	Der character c wird auf die Datei *pf ausgegeben.
	Bei Erfolg ist t=c, andernfalls t = EOF.
	Das Zeichen \ gilt als Entwertungszeichen, d.h. beim Wiedereinlesen
	wird dieses sowie das nachfolgende Zeichen ignoriert.
	Will man \ als signifikantes Zeichen ausgeben, so muss es zweifach
	ausgegeben werden: \\



			putchar( c )                    (MACRO)

	"put character"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single putchar(c)  char c;
	t = putchar( c );
	Das Zeichen c wird auf stdout ausgegeben.
	Bei Erfolg ist t=c, andernfalls t = EOF.



			putl( L )                       (MACRO)

	"put list"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single putl(L)  list L;
	t = putl( L );
	Die Liste L wird auf stdout ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			putlstruct( L )                 (MACRO)

	"put list structure"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single putlstruct(L)  list L;
	t = putlstruct(L);
	Auf stdout wird die Struktur der Liste L ausgegeben, d.h.
	welche Adressen und Inhalte die einzelnen Listenzellen haben.
	Dabei wird der Inhalt der Variablen L, also die Adresse, wo die
	Liste anfaengt, nicht mit ausgegeben.
	t = 0 bei Erfolg und ERROR sonst.



			puto( a )                       (MACRO)

	"put object"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single puto(a)  obj a;
	t = puto( a );
	Das Objekt a wird auf stdout ausgegeben.
	t = 0 bei Erfolg, ERROR sonst.



			puts( s )                       (MACRO)

	"put string"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	single puts(s)  char *s;
	t = puts( s );
	Der string s wird auf stdout ausgegeben.
	t = 0 bei Erfolg, EOF sonst.



			sdiff( L1, L2 )

	"set difference"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list sdiff(L1,L2)  list L1, L2;
	L = sdiff( L1, L2 );
	L1 und L2 sind aufsteigend geordnete Listen einfachgenauer
	Zahlen.
	L ist die Liste der Zahlen von L1, die nicht in L2 enthalten
	sind.



			setocnt( pf, n )

	"set output-counter"
	Quellbibliothek: srclib.C_sm
	Include-Datei:   _list.h
	!!  setocnt() zieht Inkonsistenzen im Format der aktuellen
	    Ausgabezeile nach sich !!
	single setocnt(pf,n)  FILE *pf; single n;
	t = setocnt( pf, n );
	Fuer 0 <= n < LN_SIZE wird der Zeichenzaehler fuer die aktuelle
	Ausgabezeile der Datei *pf durch n ersetzt.
	Bei Erfolg ist t=0, andernfalls ist t=EOF.



			setspace( anz )

	"set SPACE"
	Quellbibliothek: srclib.kern
	Include-Datei:   _list.h
	setspace( anz )  single anz;
	im Groben :
	   Der SPACE wird auf anz Zellen vergroessert, falls dies moeglich
	   ist.
	im Detail :
	   Sei n die kleinste natuerliche Zahl mit n * BL_SIZE >= anz ,
	   und sei anz1 = n * BL_SIZE.
	   Falls anz <= SPACE-Groesse, wird setspace ignoriert.
	   Ansonsten wird zunaechst SP_MAX auf das naechstgroessere Viel-
	   fache von BL_SIZE gesetzt bzw. auf den maschinenbedingten
	   Hoechstwert, falls es diesen uebersteigt.
	   Dann wird der SPACE auf anz1 Zellen vergroessert, falls anz
	   <= SP_MAX, bzw. auf SP_MAX Zellen, falls anz > SP_MAX und
	   SP_MAX > SPACE-Groesse.
	   Entsprechende Meldungen werden auf stderr abgesetzt.
	   SPACE-Ueberlauf wird auf stdout gemeldet.



			setstack( anz )

	"set STACK"
	Quellbibliothek: srclib.kern
	Include-Datei:   _list.h
	setstack( anz )  single anz;
	Falls der STACK weniger als anz Elemente hat, so wird er auf
	anz Elemente erhoeht; andernfalls zeigt setstack( anz ) keine
	Wirkung. Eine Meldung ueber den neuen ST_SIZE wird nach stderr
	abgesetzt. Bei Speicherueberlauf wird das Programm abgebrochen
	mit einer entsprechenden Meldung auf stdout.



			settime(  )

	"set time"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single settime()
	n = settime()
	Bei der ersten Ausfuehrung von settime() wird die seit
	Programmbeginn verbrauchte Rechenzeit ermittelt,
	bei jedem weiteren Aufruf die seit dem letzten settime()
	verstrichene Rechenzeit.
	n gibt die Zeitdifferenz in hundertstel Sekunden an.



			sgeta( ps )

	"string get atom"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	atom sgeta( ps )  char **ps;
	a = sgeta( ps );
	Das Atom a wird vom String *ps gelesen, *ps 
	zeigt anschliessend auf das Zeichen hinter 
	dem zuletzt gelesenen Zeichen.
	Bei Fehler wird a = ERROR geliefert.



			sgetc( ps )

	"string get character"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single sgetc(ps)  char **ps;
	c = sgetc( ps );
	Vom String *ps wird das naechste Zeichen nach 
	c eingelesen. *ps zeigt anschliessend auf das 
	Zeichen hinter dem zuletzt gelesenen Zeichen. 
	Bei Fehler wird c = ERROR geliefert.



			sgetcb( pf )

	"string get character, skipping blanks"   
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single sgetcb( ps )  char **ps;
	c = sgetcb( ps );
	Vom String *ps wird das naechste Zeichen, das kein Leer-
	zeichen ist, nach c eingelesen.
	*ps zeigt anschliessend auf das Zeichen hinter dem zuletzt 
	gelesenen Zeichen. 
	Bei Fehler wird c = ERROR geliefert.



			sgetcs( ps )

	"string get character, skipping space"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single sgetcs( ps )  char **ps;
	c = sgetcs( ps );
	Vom String *ps wird das naechste Zeichen, das kein Zwischenraum 
	ist, nach c eingelesen. Als Zwischenraum gelten:
	Leerzeichen (040), Tabulator (011, 013), Wagenruecklauf (015),
	Zeilenvorschub (012) und Seitenvorschub (014).
	*ps zeigt anschliessend auf das Zeichen hinter dem zuletzt 
	gelesenen Zeichen. 
	Bei Fehler wird c = ERROR geliefert.



			sgetl( ps )

	"string get list" (rekursiv)
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list sgetl(ps)  char **ps;
	L = sgetl(ps);
	Die Liste L wird vom String *ps gelesen.
	*ps zeigt anschliessend auf das Zeichen hinter 
	dem zuletzt gelesenen Zeichen. 
	Laeuft sgetl fehlerhaft ab, so ist L = ERROR.



			sinter( L1, L2 )

	"set intersection"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list sinter(L1,L2)  list L1, L2;
	L = sinter( L1, L2 );
	L1 und L2 sind aufsteigend geordnete Listen einfachgenauer Zahlen.
	L ist die Schnittmenge von L1 und L2.



			sputa( a, str )                 (MACRO)

	"string put atom"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	char *sputa(a,str)  atom a; char *str;
	ptr = sputa( a,str);
	Das Atom a wird auf den Bereich geschrieben, auf den str zeigt.
	!!! sputa ueberprueft nicht, ob der Bereich, auf den str zeigt,
	    fuer das Ergebnis gross genug ist !!!
	ptr liefert den Zeiger auf die Ergebniszeichenreihe.



			sputl( l, str )

	"string put list"
	Quellbibliothek: srclib.list
	Include-Datei:	 _list.h
	char* sputl(l, str)  list l; char *str;
	ptr = sputl(l, str);
	Die Liste l wird als Zeichenreihe interpretiert und in den
	Bereich geschrieben, auf den str zeigt.
	Es ist ptr = str.
!!!	sputl ueberprueft nicht, ob der Bereich, auf welchen str zeigt,
	fuer das Ergebnis lange genug ist.
	Einen geeigneten Zeiger str erhaelt man mittels -> lsize; etwa:
	   char *str;
	   str = (char*) calloc (lsize (l), sizeof (char));



			stoptime( a )

	"stop and print time"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single stoptime(a)  single a;
	n = stoptime(a);        
 	Mit stoptime(a) fuer a ungleich 0 wird die seit dem 
	letzten Aufruf von stoptime(0) verstrichene Zeit auf 
	stdout ausgegeben. 
	Mit anderen Worten: 
	  a = 0 : Initialisierung
	  a > 0 : Die seit dem letzten Aufruf von stoptime(0)
		  verstrichene Zeit wird ausgegeben in Stunden,
		  Minuten, Sekunden und Hundertstel-Sekunden, 
		  z.B. (a=1):
		  "t(1): 4 h 29 m 35 s 11 cs"
	  a < 0 : Die seit dem letzten Aufruf von stoptime(0)
		  verstrichene Zeit wird in Hundertstel-Sekunden
		  ausgegeben, z.B. (a=-7):
		  "t(7): 2976 cs"
	n hat als Wert die Zeit, die ausgegeben wird (in hundertstel 
	Sekunden).



			sunion( L1, L2 )

	"set union"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list sunion(L1,L2)  list L1, L2;
	L = sunion( L1, L2 );
	L1 und L2 sind aufsteigend geordnete Listen von einfachgenauen
	Zahlen.
	L ist die Vereinigungsmenge von L1 und L2.



			tab( n )                        (MACRO)

	"tabulator"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single tab(n)  single n;
	t = tab( n );
	Die aktuelle Zeile auf stdout wird bis einschliesslich
	der n-ten Spalte mit Leerzeichen aufgefuellt,
	falls MARGIN < n <= LN_SIZE.
	Andernfalls zeigt tab keine Wirkung.
	t = 0 bei Erfolg, ERROR sonst.



			unsgetc( c, ps )

	"undo string get character"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	single unsgetc( c, ps )  char c; char **ps;
	a = unsgetc( c, ps );     
	Diese Funktion existiert als Analogon zur Funktion 
	ungetc. Es kann allerdings nur ein Charakter dem String
	"zurueckgegeben" werden, der zuvor auch eingelesen wurde.
	Der String, auf den ps zeigt, wird also keinesfalls veraendert.
	Genauer: 
	Ist c == *(*ps - 1) so ist a = 1, 
	sonst ist a = ERROR, und es wird eine Fehlermeldung ausgegeben.
	*ps erhaelt den Wert *ps - 1. 



			usdiff( L1, L2 )

	"unordered set difference"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list usdiff(L1,L2)  list L1, L2;
	L = usdiff( L1, L2 );
	L1 und L2 sind ungeordnete Listen.
	L ist die ungeordnete Liste der Objekte von L1, die nicht
	in L2 enthalten sind.



			usinter( L1, L2 )

	"unordered set intersection"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list usinter(L1,L2)  list L1, L2;
	L = usinter( L1, L2 );
	L1 und L2 sind ungeordnete Listen.
	L ist die ungeordnete Liste der Objekte, die sowohl L1 als auch
	L2 enthaelt.



			ussdiff( L1, L2 )

	"unordered set symmetrical difference"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list ussdiff(L1,L2)  list L1,L2;
	L = ussdiff(L1,L2);
	L1 und L2 sind ungeordnete Listen.
	L ist die ungeordnete symmetrische Differenz von 
	L1 und L2.



			usunion( L1, L2 )               (MACRO)

	"unordered set union"
	Quellbibliothek: srclib.list
	Include-Datei:   _list.h
	list usunion(L1,L2)  list L1,L2;
	L = usunion(L1,L2);
	L1 und L2 sind ungeordnete Listen.
	L ist die ungeordnete Vereinigung von L1 und L2.



