\section{Das Pseudo-Modul {\tt SYSTEM}}

\label{SysMod}
Im folgenden wird das Modul {\tt SYSTEM} besprochen. Nicht besonders erkl"arte
Typen und Prozeduren haben die Eigenschaften,
wie sie in jedem Lehrbuch erkl"art
sind. "Anderungen oder Unterschiede sind beschrieben.

\begin{alltt}
DEFINITION MODULE SYSTEM;
TYPE
  BYTE;
  WORD;
  FFP;
  ADDRESS  = POINTER TO BYTE;
  BPTR     = BPOINTER TO BYTE;
  SHORTSET = SET OF [0..7];
  BITSET   = SET OF [0..15];
  LONGSET  = SET OF [0..31];

(*
 * T entspricht skalarem Typ mit Groesse <=4 Byte
 *)

PROCEDURE ADR (VAR x:{\cmsltt AnyType\/}): ADDRESS;

PROCEDURE ASSEMBLE (\{{\cmsltt Befehl\/}\} END);

PROCEDURE CAST ({\cmsltt AnyType1\/}; x:{\cmsltt AnyType2\/}): {\cmsltt AnyType1\/};

PROCEDURE LOADREGS (regs: BITSET);
(* regs=Konstante *)

PROCEDURE REG (reg: [0..15]): LONGINT;
(* reg=Konstante *)

PROCEDURE SAVEREGS (regs: BITSET);
(* regs=Konstante *)

PROCEDURE SETREG (reg: [0..15]; val: T);
(* reg=Konstante, SIZE(T)=4 *)

PROCEDURE SHIFT (x:T; n:LONGINT): T;

PROCEDURE TAG(VAR x:{\cmsltt AnyType\/}; val \{,val\}: ADDRESS):
  ADDRESS;

PROCEDURE TSIZE ({\cmsltt AnyType\/}): LONGINT;

PROCEDURE VAL (T; x:CARDINAL): T;

PROCEDURE ACOS(x:LONGREAL):LONGREAL; 
PROCEDURE ASIN(x:LONGREAL):LONGREAL; 
PROCEDURE ATAN(x:LONGREAL):LONGREAL; 
PROCEDURE COS(x:LONGREAL):LONGREAL; 
PROCEDURE COSH(x:LONGREAL):LONGREAL; 
PROCEDURE EXP(x:LONGREAL):LONGREAL; 

PROCEDURE LOG10(x:LONGREAL):LONGREAL; 
PROCEDURE LOGN(x:LONGREAL):LONGREAL; 

PROCEDURE SIN(x:LONGREAL):LONGREAL; 
PROCEDURE SINH(x:LONGREAL):LONGREAL; 
PROCEDURE SQRT(x:LONGREAL):LONGREAL; 
PROCEDURE TAN(x:LONGREAL):LONGREAL; 
PROCEDURE ATANH(x:LONGREAL):LONGREAL; 

PROCEDURE ETOXM1(x:LONGREAL):LONGREAL;
PROCEDURE LOG2(x:LONGREAL):LONGREAL;
PROCEDURE LOGNP1(x:LONGREAL):LONGREAL;
PROCEDURE TENTOX(x:LONGREAL):LONGREAL;
PROCEDURE TWOTOX(x:LONGREAL):LONGREAL;
PROCEDURE SQR(x:LONGREAL):LONGREAL; 
PROCEDURE TANH(x:LONGREAL):LONGREAL; 

END SYSTEM.
\end{alltt}

\begin{note}
Nicht mehr im Modul {\bf SYSTEM} sind enthalten:
\begin{itemize}
\item {\bf SIZE}: Diese Funktion ist nun Standardprozedur
\item {\bf PROCESS}, {\bf NEWPROCESS}, {\bf TRANSFER}:
Die Behandlung von Coroutinen ist mit dem Bibliotheksmodul
{\bf Coroutines} (Seite \pageref{Coroutines}) gegeben.

\end{itemize}
\end{note}


\begin{note}
Die Speichereinheit auf dem 68000, auf die individuell zugegriffen
werden kann, ist das Byte {\tt BYTE}. Der Parametertyp {\tt ARRAY OF WORD}
sollte nicht mehr verwendet und durch {\tt ARRAY OF BYTE} ersetzt werden.
\end{note}

Der Typ {\tt ADDRESS} ist mit allen Zeigervariablen, die mit {\tt POINTER
TO \rm\ldots} deklariert wurden, sowie mit dem Typ {\tt LONGINT} kompatibel.
Der Typ {\tt BPTR} ist mit allen Zeigervariablen, die mit {\tt BPOINTER
TO \rm\ldots} deklariert wurden, sowie mit dem Typ {\tt LONGINT} kompatibel.
Der Typ {\tt BITSET} entspricht dem bisher vordefinierten Typ {\tt BITSET}.
Da {\tt BITSET} ein Wort gross sein soll, ist dieser Typ maschinenabh"angig,
weshalb er nun vom Modul {\tt SYSTEM} importiert werden muss.

{\tt LONGSET} entspricht einem Set in Langwort-Gr"osse (32 Bit).
{\tt SHORTSET} entspricht einem Set in Byte-Gr"osse (8 Bit).

{\tt FFP} ist der 68000-spezifische Typ der Gleitpunktzahlen. Diesem Typ
k"onnen beliebige konstante Gleitpunktzahlen zugewiesen werden. F"ur diesen
Typ sind die gleichen mathematischen Grundfunktionen wie f"ur den Typ
{\tt REAL} definiert.

Die Funktion {\tt ADR} liefert die Adresse des angegebenen Objektes
zur"uck. Erlaubte Objekte sind Variablen, konstante Zeichenketten,
Prozeduren
und Library-Moduln (Abschnitt \ref{refCODE}, Seite \pageref{refCODE}).
Bei Library-Moduln liefert {\tt ADR} den Zeiger auf die ge"offnete
Library zur"uck (Library-Basis).

Die Prozedur {\tt ASSEMBLE} aktiviert den im Compiler integrierten
Assembler. Er ist in Abschnitt \ref{refAsm} beschrieben.

Die Funktion {\tt REG} gibt den Wert des angesprochenen Registers zur"uck.
Der Parameter {\tt reg} muss ein konstanter Ausdruck sein, dessen Wert
zwischen 0 und 15 liegt. Die Datenregister D0 bis D7 werden durch die
Werte 0 bis 7 angesprochen, die Adressregister A0 bis A7 durch die Werte
8 bis 15.

Die Prozedur {\tt SETREG} legt den angegebenen Wert im angegebenen Register
ab. F"ur den Parameter {\tt reg} gilt das gleiche wie bei {\tt REG}. Das
angesprochene Register wird dadurch nicht gesch"utzt, der n"achste Ausdruck
kann den Registerinhalt bereits wieder zerst"oren!

Die Prozeduren {\tt SAVEREGS} und {\tt LOADREGS}  retten die angegebenen
Register auf den Stack bzw.\ laden die Werte vom Stack in die Register.
Als Parameter erwarten beide Prozeduren ein {\tt BITSET}, dessen Elemente
die beteiligten Register angeben. Die Numerierung ist die gleiche
wie bei {\tt REG}. Die Operationen werden durch den
68000-Befehl {\tt MOVEM.L} ausgef"uhrt. Diese beiden Prozeduren
sind vornehmlich aus Kompatibilit"atsgr"unden vorhanden. Ihr Einsatz
d"urfte kaum n"otig sein, da alle Prozeduren die benutzten Register
selbst retten.

Die Prozedur {\tt TAG} erlaubt die Verwendung von sogenannten
{\bf TagItems}. Der genaue Aufbau ist im Abschnitt \ref{tags}
beschrieben.

Die Prozedur {\tt TSIZE} erlaubt {\em keine\/} Angabe von Kennfeldern
(tag fields) um die Gr"osse einer Variante zu ermitteln.
Diese Prozedur sollte ohnehin nicht mehr verwendet werden, da die
Definition der vordefinierten Prozedur {\tt SIZE} neu auch Typen
als Parameter zul"asst.

Die Prozedur {\tt SHIFT} verschiebt die Bitkombination des angegebenen
Wertes um soviele Stellen wie in {\tt n} vermerkt. Ein positiver
Wert von {\tt n} verschiebt nach links, ein negativer Wert nach rechts.
Ist der zu verschiebende Wert vorzeichenbehaftet (z.B.\ INTEGER), so
wird bei einer Rechtsverschiebung mit dem Vorzeichenbit aufgef"ullt%
\footnote{entsprechend der MC68000-Instruktion {\tt ASR}},
in allen anderen F"allen mit Null-Bits%
\footnote{MC68000-Instruktionen {\tt LSR}, bzw. {\tt ASL} oder {\tt LSL}}.

Die Prozedur {\tt CAST} f"uhrt einen Typentransfer durch. Dabei wird der
Typ der "ubergebenen Variablen an dieser Stelle umgeschaltet. Der
Ursprungstyp und der Zieltyp m"ussen beide den gleichen Speicherbedarf
haben. Mit der {\bf CAST}-Anweisung kann die Typenkontrolle umgangen
werden, ihr Einsatz sollte daher m"oglichst beschr"ankt bleiben.

Die Prozedur {\tt VAL} ist identisch mit der vordefinierten Prozedur
{\tt VAL}. Sie kann jedoch aus Kompatibilit"ats\-gr"un\-den auch
vom Modul {\tt SYSTEM} importiert werden.

\subsection{FPU-Unterst"utzung f"ur transzendente Funktionen}

Wer einen 6888x-Coprozessor besitzt kann die transzendenten
Funktionen in H"ochstgeschwindigkeit ausf"uhren.
Der Compiler kann neben den Grundrechenarten auch f"ur transzendente
{\tt LONGREAL}-Arithmetik direkten Code f"ur den Coprozessor erzeugen.

Die Prozeduren daf"ur m"ussen vom Modul {\tt SYSTEM}
importiert werden. Wird
dann {\em nicht} mit der Option "`{\tt -8}"' kompiliert,
importiert der Compiler selbst"andig das Modul {\tt MathLibLong},
welches die gew"unschten Prozeduren
"uber den Umweg der {\tt mathieeedoubtrans.library} und teilweise
ausprogrammierte Prozeduren ausf"uhrt.

Die Parameter und Ergebnisse dieser Prozeduren entsprechen denjenigen
des Moduls {\tt MathLibLong} (Seite \pageref{MathLibLong}).

