Emacs-Mode:  -*- Mode: Text -*-

Hinweise ueber die Benutzerschnittstelle von p3 (kann mal in eine
Man-Page erweitert werden. 

p3 erkennt anhand der Extensions der Files, um welchen Filetyp es sich
handelt:

.pd:  	Parallaxis V3, DEFINITION MODULE
.pm:  	Parallaxis V3, IMPLEMENTATION MODULE oder (program) MODULE
.h:	C-Quelltext, Headerfile (z.B. uebersetztes .pd-File), i.a.
        nicht direkt auf der Kommandozeile angegeben sondern implizit
        ueber Praeprozessor (#include) eingebunden.
.c:	C-Quelltext, Programmfile (z.B. uebersetztes .pm-File)

Hat ein Filename keine Extension, wird er ebenfalls an de
Parallaxis-Compiler weitergeleitet.

Alle Files mit einer anderen Extension als .pd oder .pm werden an den
C-Compiler weitergereicht.

p3 benutzt defaultmaessig den Compiler p3c zum compilieren. Wird die
Option -mpl, -C oder -pvm angegeben, dann wird entsprechend der
Compiler p3c_MPL, p3c_C bzw. p3c_PVM benutzt, wenn es diese gibt

Environment-Variablen:
----------------------
P3LIB:  Pfadliste (getrennt durch ":"), wo sich die Parallaxis V3
	Libraries (z.B. libp3) befinden.
	Default: aus Makefile, sonst /usr/local/lib
P3INC:  Pfadliste (getrennt durch ":"), wo sich die Parallaxis V3
	Includes (z.B. SYSTEM_C.h) befinden.
	Default: aus Makefile, sonst /usr/local/include
P3CC:   Name des zu verwendenden C-Compilers (z.B. gcc, cc), muss
        Strukturen als gesamtes kopieren koennen. Sinnvoll ist ein
	ANSI-C-Compiler. Der Compiler muss im Standard-Suchpfad sein
	oder mit vollem Pfad angegeben werden. Es wird einfach der
        Inhalt der Variablen zum Aufruf benutzt. Es koennen also auch
	Optionen mit angegeben werden. (Also z.B. 
		setenv P3CC gcc -ansi)
	Default: aus Makefile, sonst cc
P3MPLCC:	Name des zu verwendenden MPL-Compilers. Wie P3CC.
	Default: aus Makefile, sonst mpl



Folgende Optionen sollten von p3 unterstuetzt werden:
------------------------------------------------------
-casts	p3 generiert type casts (noetig fuer lint).

-cc name  Name des zu verwendenden C-Compilers (falls nicht angegeben,
        dann wird der Name aus der Environment-Variablen P3CC
        genommen. Gibt es diese auch nicht, dann wird der hartcodierte
        Name aus dem Makefile oder "cc" benutzt.

-mplcc name  Name des zu verwendenden MPL-Compilers (falls nicht
	angegeben, dann wird der Name aus der Environment-Variablen
	P3MPLCC genommen. Gibt es diese auch nicht, dann wird der
	hartcodierte Name aus dem Makefile oder "mpl" benutzt.

-o name Name des erzeugten Executables (wird an Backend weitergereicht)

-p      Nur Parallaxis-Compiler, kein C-Compiler dahinter.

-P dir  Pfad, in dem nach .pd-Files gesucht wird (nur Parallaxis)

-I dir	Pfad, in dem nach .pd-Files gesucht wird. Wird auch an
	C-Compiler weitergereicht

-L dir  Pfad, in dem nach lib-Files gesucht wird. Wird nur an C-Compiler
	weitergereicht.

-nop3inc   An die mit -p und -I erzeugte Pfadliste werden *nicht* die
	Defaultincludepfade (aus Environment bzw. Compiler) angehaengt.

-nop3lib   Die ueber P3LIB gesetzten Pfade werden nicht an den
	C-Compiler weitergereicht

-nodefaults  entspricht -nop3inc -nop3lib

-v	Gebe die Versionsnummer des Compiler Drivers aus (nur Parallaxis)

-vv     Wie -v, zusaetzlich Commandline-Aufrufe ausgeben

-vvv	Wie -vv, jedoch wird -v an alle Compiler weitergereicht, d.h.
	jeder Compilerpass gibt seine Versionsnummer aus und gcc wird
	gespraechig.

-nocompile
-n	Nichts compilieren, d.h. Compileraufrufe unterdruecken. Setzt
	automatisch eine Art -vv. (Achtung: cc von HP benutzt -n)

-g	Generiere Debugging-Info. Wird auch an C-Compiler
	weitergereicht.

-usage
-help
-h
-H
-?	Usage ausgeben.

-headers
	Generiert Header-Files fuer alle Importierten Module

-indent n  Einrueckung um jeweils n Zeichen (Default: n=2)

-mem
-m	Statistik ueber Speicherbedarf ausgeben


-MPL
-mpl	Erzeuge MPL-Code

-C
	Erzeuge C-Code

-PVM
-pvm    Erzeuge PVM-Code (Paragon)

-rchecks
-r	Erzeuge Runtime-Checks

-small
-s	Small Model auf MasPar (nur MPL)

-time
-t	Zeitbedarf fuers compilieren (nur Parallaxis)

-total
-tt	Zeitbedarf einschliesslich C-Compiler

-w	Keine Warnings ausgeben (nur Parallaxis)

-ww	Keine Warnings ausgeben, wird als -w an den C-Compiler
	weitergereicht. (Entspricht -w -kw)

-koption  Reiche Option weiter an C-Compiler. Bsp: -kv wuerde nur an
	den C-Compiler das -v weiterreichen, p3 selbst haette kein -v.
	Falls Optionen Parameter haben, muessen sie als Gesamtes in
	der -k-Option sein, also ggf. in der Shell quoten. (Es wird
	nur das k entfernt und der Rest weitergereicht.) Unbekannte
	Optionen werden sowieso weitergereicht.

-Zw	Code-Baum schreiben

-Zs	Symbol-Baum schreiben

-Zq	Code-Baum befragen

-Zc	Code-Baum pruefen

-Z1	nur Parser

-Z2	nur Parser und Semantische Pruefung, keine Codeerzeugung

Alle anderen Optionen werden ignoriert und an den C-Compiler
weitergereicht. Bei Optionen mit einem abgesetzten Parameter kann dies
zu Problemen fuehren. Diese muessen dann zusammen mit dem Parameter
gequotet werden. Bsp: -imacros file muss als "-imacros file" gequoted
werden. p3 reicht den Text dann ungequoted weiter.

Beispiele fuer Weiterreichen:

-llibrary Library einbinden
-c	Nur bis zum .o-File compilieren
-ansi	Bei gcc ANSI-Mode einschalten
-Wall   Bei gcc ausfuehrliche Warnings ausgeben
-S	Bei gcc vor dem Assembler-Schritt anhalten
-O	Optimieren, entsprechend auch -O2




Moegliche Erweiterungen:

-M:	Regel fuer Makefile generieren.



evtl. frei:	-a, -b
frei: -d -e -h -i -m -r (-t)
             ^     ^  ^  ^

Optionen mit Parametern in einem extra Argument:

gcc:  	-x language
      	-o file
	-include file
	-imacros file
	-iprefix file
	-iwithprefix dir
	-Xlinker option
	-u symbol
	-b machine
	-V version
	-G num (MIPS)

SUN cc:	-align block
	-o outputfile
	-Qoption progopt
	-Qpath pathname
	-target target_arch

maspar cc:
	-feedback file
	-ko output
	-o output
	-G num
	-Olimit num
	-fill number

maspar ampl:
	-o output

hp cc:	-W specific
	-L dir


Beginn einer moeglichen Man-Page (war zu  lang fuer die Usage)
--------------------------------------------------------------

     printf("NAME\n\t");
     printversion();
     printf("\nSYNOPSIS\n");
     printf("	%s [options] file [ [options] file ...]\n", program);
     printf("\nDESCRIPTION\n");
     printf("	%s is the user interface to the Parallaxis 3.0 compiler.\n",
	    program);
     printf("	Its only purpose is to collect the overall options and call\n");
     printf("	the appropriate compiler steps. Every argument on the command\n");
     printf("	line beginning with a \"-\" is interpreted as an option, probably\n");
     printf("	with an additional parameter. Every other argument is treated as a\n");
     printf("	filename, probably extended by \".pd\" and/or \".pm\" if the name\n");
     printf("	has no extension and those files exist. From the resulting\n");
     printf("	list of files every file ending in \".pd\" or \".pm\" is fed into\n");
     printf("	the Parallaxis compiler and is converted to a C program. The\n");
     printf("	resulting C files and any other not yet recognized file from the\n");
     printf("	command line are then fed into the C compiler to build an\n");
     printf("	executable program.\n");

     printf("\nOPTIONS\n");
     printf("	%s accepts several options determining the behaviour of the\n",
	    program);
     printf("	compiling process. Every unknown option is passed unchanged to\n");
     printf("	the C compiler. This allows to use practically every C compiler\n");
     printf("	as backend to Parallaxis.\n");

     printf("NAME\n\t");
     printversion();
     printf("\nSYNOPSIS\n");
     printf("	%s [options] file [ [options] file ...]\n", program);
     printf("\nDESCRIPTION\n");
     printf("	%s is the user interface to the Parallaxis 3.0 compiler.\n",
	    program);
     printf("	Its only purpose is to collect the overall options and call\n");
     printf("	the appropriate compiler steps. Every argument on the command\n");
     printf("	line beginning with a \"-\" is interpreted as an option, probably\n");
     printf("	with an additional parameter. Every other argument is treated as a\n");
     printf("	filename, probably extended by \".pd\" and/or \".pm\" if the name\n");
     printf("	has no extension and those files exist. From the resulting\n");
     printf("	list of files every file ending in \".pd\" or \".pm\" is fed into\n");
     printf("	the Parallaxis compiler and is converted to a C program. The\n");
     printf("	resulting C files and any other not yet recognized file from the\n");
     printf("	command line are then fed into the C compiler to build an\n");
     printf("	executable program.\n");

     printf("\nOPTIONS\n");
     printf("	%s accepts several options determining the behaviour of the\n",
	    program);
     printf("	compiling process. Every unknown option is passed unchanged to\n");
     printf("	the C compiler. This allows to use practically every C compiler\n");
     printf("	as backend to Parallaxis.\n");

