\batchmode
\documentstyle[a4,german,alltt,m2amiga]{book}

\let\providecommand\newcommand
\RequirePackage{ifthen}


\title{M2Amiga Dokumentation}
\author{R. Degen, C. Nieder, B. Preusing, M. Schaub, J. Straube}\date{4. September 1992}

\hyphenation{
  an-schlie-ssend
  An-wei-sung
  ARexx
  Aus-gangs-code
  Be-triebs-sy-stem
  Da-tei-na-men
  De-fi-ni-tions-mo-dul
  De-fi-ni-tions
  De-fi-ni-tion
  Ein-gangs-code
  ein-zu-le-sen
  Haupt-spei-cher
  Im-ple-men-ta-tions-mo-dul
  Im-ple-men-ta-tions
  Im-ple-men-ta-tion
  in-itia-li-siert
  in-itia-li-sie-ren
  kei-ner-lei
  Kom-man-do
  Kom-man-do-zei-le
  Lese-ope-ra-ti-on
  Li-bra-ry
  Pro-gramm-ende
  Pro-ze-dur
  Pro-ze-dur-en
  Pro-zessor-ebene
  Re-gi-ster
  re-la-tiv
  re-si-dent
  Schreib-ope-ra-ti-onen
  Such-stra-te-gie
  Sy-stem
  sy-stem-eige-nen
  Teil-moduln
  Text-spei-cher
  Va-ria-ble
  Va-ria-blen
  Zei-len-en-de
  Zei-len-um-bruch
}

\setcounter{secnumdepth}{2}\setcounter{tocdepth}{2}
\newcounter{filefmt}





\usepackage[latin1]{inputenc}



\makeatletter
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/m2amiga.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/intro.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/userif.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/editor.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/comp.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/assem.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/linker.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/m2debug.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/tools.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/xtools.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/progm2.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/interna.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/modules.aux
\makeatother
}
\AtBeginDocument{\makeatletter
\input /home/claudio/M2Amiga/SRC/Doku/ifmod.aux
\makeatother
}

\makeatletter
\count@=\the\catcode`\_ \catcode`\_=8 
\newenvironment{tex2html_wrap}{}{}%
\catcode`\<=12\catcode`\_=\count@
\newcommand{\providedcommand}[1]{\expandafter\providecommand\csname #1\endcsname}%
\newcommand{\renewedcommand}[1]{\expandafter\providecommand\csname #1\endcsname{}%
  \expandafter\renewcommand\csname #1\endcsname}%
\newcommand{\newedenvironment}[1]{\newenvironment{#1}{}{}\renewenvironment{#1}}%
\let\newedcommand\renewedcommand
\let\renewedenvironment\newedenvironment
\makeatother
\let\mathon=$
\let\mathoff=$
\ifx\AtBeginDocument\undefined \newcommand{\AtBeginDocument}[1]{}\fi
\newbox\sizebox
\setlength{\hoffset}{0pt}\setlength{\voffset}{0pt}
\addtolength{\textheight}{\footskip}\setlength{\footskip}{0pt}
\addtolength{\textheight}{\topmargin}\setlength{\topmargin}{0pt}
\addtolength{\textheight}{\headheight}\setlength{\headheight}{0pt}
\addtolength{\textheight}{\headsep}\setlength{\headsep}{0pt}
\setlength{\textwidth}{349pt}
\newwrite\lthtmlwrite
\makeatletter
\let\realnormalsize=\normalsize
\global\topskip=2sp
\def\preveqno{}\let\real@float=\@float \let\realend@float=\end@float
\def\@float{\let\@savefreelist\@freelist\real@float}
\def\liih@math{\ifmmode$\else\bad@math\fi}
\def\end@float{\realend@float\global\let\@freelist\@savefreelist}
\let\real@dbflt=\@dbflt \let\end@dblfloat=\end@float
\let\@largefloatcheck=\relax
\let\if@boxedmulticols=\iftrue
\def\@dbflt{\let\@savefreelist\@freelist\real@dbflt}
\def\adjustnormalsize{\def\normalsize{\mathsurround=0pt \realnormalsize
 \parindent=0pt\abovedisplayskip=0pt\belowdisplayskip=0pt}%
 \def\phantompar{\csname par\endcsname}\normalsize}%
\def\lthtmltypeout#1{{\let\protect\string \immediate\write\lthtmlwrite{#1}}}%
\newcommand\lthtmlhboxmathA{\adjustnormalsize\setbox\sizebox=\hbox\bgroup\kern.05em }%
\newcommand\lthtmlhboxmathB{\adjustnormalsize\setbox\sizebox=\hbox to\hsize\bgroup\hfill }%
\newcommand\lthtmlvboxmathA{\adjustnormalsize\setbox\sizebox=\vbox\bgroup %
 \let\ifinner=\iffalse \let\)\liih@math }%
\newcommand\lthtmlboxmathZ{\@next\next\@currlist{}{\def\next{\voidb@x}}%
 \expandafter\box\next\egroup}%
\newcommand\lthtmlmathtype[1]{\gdef\lthtmlmathenv{#1}}%
\newcommand\lthtmllogmath{\lthtmltypeout{l2hSize %
:\lthtmlmathenv:\the\ht\sizebox::\the\dp\sizebox::\the\wd\sizebox.\preveqno}}%
\newcommand\lthtmlfigureA[1]{\let\@savefreelist\@freelist
       \lthtmlmathtype{#1}\lthtmlvboxmathA}%
\newcommand\lthtmlpictureA{\bgroup\catcode`\_=8 \lthtmlpictureB}%
\newcommand\lthtmlpictureB[1]{\lthtmlmathtype{#1}\egroup
       \let\@savefreelist\@freelist \lthtmlhboxmathB}%
\newcommand\lthtmlpictureZ[1]{\hfill\lthtmlfigureZ}%
\newcommand\lthtmlfigureZ{\lthtmlboxmathZ\lthtmllogmath\copy\sizebox
       \global\let\@freelist\@savefreelist}%
\newcommand\lthtmldisplayA{\bgroup\catcode`\_=8 \lthtmldisplayAi}%
\newcommand\lthtmldisplayAi[1]{\lthtmlmathtype{#1}\egroup\lthtmlvboxmathA}%
\newcommand\lthtmldisplayB[1]{\edef\preveqno{(\theequation)}%
  \lthtmldisplayA{#1}\let\@eqnnum\relax}%
\newcommand\lthtmldisplayZ{\lthtmlboxmathZ\lthtmllogmath\lthtmlsetmath}%
\newcommand\lthtmlinlinemathA{\bgroup\catcode`\_=8 \lthtmlinlinemathB}
\newcommand\lthtmlinlinemathB[1]{\lthtmlmathtype{#1}\egroup\lthtmlhboxmathA
  \vrule height1.5ex width0pt }%
\newcommand\lthtmlinlineA{\bgroup\catcode`\_=8 \lthtmlinlineB}%
\newcommand\lthtmlinlineB[1]{\lthtmlmathtype{#1}\egroup\lthtmlhboxmathA}%
\newcommand\lthtmlinlineZ{\egroup\expandafter\ifdim\dp\sizebox>0pt %
  \expandafter\centerinlinemath\fi\lthtmllogmath\lthtmlsetinline}
\newcommand\lthtmlinlinemathZ{\egroup\expandafter\ifdim\dp\sizebox>0pt %
  \expandafter\centerinlinemath\fi\lthtmllogmath\lthtmlsetmath}
\newcommand\lthtmlindisplaymathZ{\egroup %
  \centerinlinemath\lthtmllogmath\lthtmlsetmath}
\def\lthtmlsetinline{\hbox{\vrule width.1em \vtop{\vbox{%
  \kern.1em\copy\sizebox}\ifdim\dp\sizebox>0pt\kern.1em\else\kern.3pt\fi
  \ifdim\hsize>\wd\sizebox \hrule depth1pt\fi}}}
\def\lthtmlsetmath{\hbox{\vrule width.1em\kern-.05em\vtop{\vbox{%
  \kern.1em\kern0.8 pt\hbox{\hglue.17em\copy\sizebox\hglue0.8 pt}}\kern.3pt%
  \ifdim\dp\sizebox>0pt\kern.1em\fi \kern0.8 pt%
  \ifdim\hsize>\wd\sizebox \hrule depth1pt\fi}}}
\def\centerinlinemath{%
  \dimen1=\ifdim\ht\sizebox<\dp\sizebox \dp\sizebox\else\ht\sizebox\fi
  \advance\dimen1by.5pt \vrule width0pt height\dimen1 depth\dimen1 
 \dp\sizebox=\dimen1\ht\sizebox=\dimen1\relax}

\def\lthtmlcheckvsize{\ifdim\ht\sizebox<\vsize 
  \ifdim\wd\sizebox<\hsize\expandafter\hfill\fi \expandafter\vfill
  \else\expandafter\vss\fi}%
\providecommand{\selectlanguage}[1]{}%
\makeatletter \tracingstats = 1 


\begin{document}
\pagestyle{empty}\thispagestyle{empty}\lthtmltypeout{}%
\lthtmltypeout{latex2htmlLength hsize=\the\hsize}\lthtmltypeout{}%
\lthtmltypeout{latex2htmlLength vsize=\the\vsize}\lthtmltypeout{}%
\lthtmltypeout{latex2htmlLength hoffset=\the\hoffset}\lthtmltypeout{}%
\lthtmltypeout{latex2htmlLength voffset=\the\voffset}\lthtmltypeout{}%
\lthtmltypeout{latex2htmlLength topmargin=\the\topmargin}\lthtmltypeout{}%
\lthtmltypeout{latex2htmlLength topskip=\the\topskip}\lthtmltypeout{}%
\lthtmltypeout{latex2htmlLength headheight=\the\headheight}\lthtmltypeout{}%
\lthtmltypeout{latex2htmlLength headsep=\the\headsep}\lthtmltypeout{}%
\lthtmltypeout{latex2htmlLength parskip=\the\parskip}\lthtmltypeout{}%
\lthtmltypeout{latex2htmlLength oddsidemargin=\the\oddsidemargin}\lthtmltypeout{}%
\makeatletter
\if@twoside\lthtmltypeout{latex2htmlLength evensidemargin=\the\evensidemargin}%
\else\lthtmltypeout{latex2htmlLength evensidemargin=\the\oddsidemargin}\fi%
\lthtmltypeout{}%
\makeatother
\setcounter{page}{1}
\onecolumn

% !!! IMAGES START HERE !!!

\setcounter{secnumdepth}{2}
\setcounter{tocdepth}{2}
\stepcounter{chapter}
\stepcounter{section}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{ttscript49}%
\begin{ttscript}{\keyf1$\ldots$\keyf{10}}
\   \item[{\keyctrl}]
    Dieses Symbol bezeichnet die ,,Control``-Taste auf
    der Tastatur des Amigas.
  \item[{\keyalt}]
    Die ,,ALT``-Taste.
  \item[{\keyshift}]
    Die ,,SHIFT``-Taste.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{ttscript54}%
\begin{ttscript}{\keyf1$\ldots$\keyf{10}}
\item[{\keyret}]
\   Die ,,RETURN``- oder auch ,,ENTER``-Taste.
\item[{\keydel}]
  Die ,,DELETE``-Taste.
\item[{\keybs}]
  Die ,,BACKSPACE``-Taste, auf den meisten Amigas als
  \keyleft\ vorhanden. Um Verwechslungen mit der \"{a}hnlich
  aussehenden
  Pfeiltaste zu verhindern, ziehen wir diese Darstellung vor.
\item[{\keyup\,, \keydown\,, \keyleft\,, \keyright}]
  Die vier Pfeiltasten.
\item[{\keyhelp}]
  Die ,,HELP``-Taste, die in den eingabeorientierten
  Anwendungen dem Benutzer eine Hilfestellung bietet.
\item[{\keytab}]
  Die Tabulator-Taste, auf einigen Amiga auch als \keyTab\ vorhanden.
\item[{\keyf1$\ldots$\keyf{10}}]
\   Die Funktionstasten F1 bis F10.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note59}%
\begin{note}
Abschnitte, die mit dem Wort ,,Anmerkung`` beginnen, geben weitere
Informationen oder n\"{u}tzliche Hinweise.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning61}%
\begin{warning}
Abschnitte, die mit ,,Wichtiger Hinweis`` beginnen, sprechen
schwerwiegendere Probleme des gegenw\"{a}rtigen Themas an.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example63}%
\begin{example}
Beispiele sind im Text erw\"{a}hnt. Zus\"{a}tzlich ist
eine Randmarkierung angebracht.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{chapter}
\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript122}%
\begin{ttscript}{.sym}
\item[.def]
  Textdatei eines Definitions-Moduls
\item[.mod]
  Textdatei eines Implementations- oder Programm-Moduls
\item[.sym]
  \"{u}bersetztes Definitions-Modul
\item[.obj]
  \"{u}bersetztes Implementations- oder Programm-Modul, compiliert
  f\"{u}r MC68000
\item[.ob{\cmsltt n}]
  \"{u}bersetztes Implementations- oder Programm-Modul, je
  nach Endung f\"{u}r einen h\"{o}heren Prozessor der MC68000-Familie
  compiliert. M\"{o}gliche Endungen sind {\tt ob1}, {\tt ob2},
  {\tt ob3}, {\tt ob4} und schliesslich {\tt ob8}.
\item[.ref]
  Datei, welche die Debuggerinformation enth\"{a}lt
\item[~]
  die Datei des gelinkten Programms hat keine Endung.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{ttscript134}%
\begin{ttscript}{xxx}
\item[bin]
  Dieses Verzeichnis enth\"{a}lt alle fertig gelinkten Amiga-Programme.
\item[obj]
  Wie der Name schon sagt, befinden sich hier alle
  Objektdateien. Alle Objektdateien werden {\em unabh\"{a}ngig\/}
  von der Prozessorversion hierin abgelegt.
\item[ref]
  Hier befinden sich alle Referenzdateien.
\item[sym]
  Hier sind alle Symboldateien zu finden.
\item[txt]
  Schliesslich sind hier alle Programmtexte abgelegt,
  d.h.\ die ,,{\tt .def}``- und ,,{\tt .mod}``-Dateien.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{figure145}%
\begin{figure}\begin{center}
\unitlength0.5cm
\begin{picture}(16,10)
\put(5,5){\framebox (5,4){Compiler}}
\put(5,8){\framebox (3,1){\bf Projekt}}
\multiput(0,0)(4,0){4}{\framebox (3,2){}}
\put(0,1){\framebox (2,1){\bf txt}}
  \put(4,1){\framebox (2,1){\bf sym}}
  \put(8,1){\framebox (2,1){\bf obj}}
  \put(12,1){\framebox (2,1){\bf ref}}
\put(1.5,2){\line(3,2){4.45}}
\put(5.5,2){\line(1,2){1.45}}
\put(9.5,2){\line(-1,2){1.45}}
\put(13.5,2){\line(-3,2){4.45}}
\end{picture}
\end{center}
\end{figure}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example189}%
\begin{example}
Beispiele f\"{u}r gleichwertige Aufrufe an Compiler und Linker,
wobei die Unterverzeichnisse ,,{\tt txt}`` und ,,{\tt obj}``
vorhanden sind:
\par\begin{alltt}
\relax{}   m2c modul
\\m2c txt/modul
\\m2c txt/modul.mod
\\m2l datei
\\m2l obj/datei
\\m2l obj/datei.obj
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example218}%
\begin{example}
Einige Beispiele:
\begin{quote} \tt befehl -i +x +l\cmsltt Name\/ \tt +b \end{quote} 
ist gleichwertig mit
\begin{quote} \tt befehl -i+xl\cmsltt Name\/ \tt +b \end{quote} 
Der Aufruf
\begin{quote} \tt befehl \cmsltt datei1\/ \tt -x -l\cmsltt name datei2\/
  \tt -r \cmsltt datei3 \end{quote} 
bearbeitet {\cmsltt datei1\/} mit den Standard-Optionen,
l\"{o}scht daraufhin die Option {\tt x},
besetzt die Option {\tt l} mit dem Wert ,,{\cmsltt name}``,
bearbeitet {\cmsltt datei2}, l\"{o}scht die Option
{\tt r} und bearbeitet {\cmsltt datei3}.
\par\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline20905}%
$ enthalten.<tex2html_comment_mark>2$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\setcounter{footnote}{3}
{\newpage\clearpage
\lthtmlfigureA{example252}%
\begin{example}
So belegt ,,{\ttSetEnv m2c -1nzh+y}`` die Standardeinstellung
des Compilers. Ben\"{o}tigen die Programme eines Projektes
in jedem Fall die Option ,,{\tt+n}``, muss die Datei
,,{\ttm2c.opt}`` im Projektverzeichnis die Zeichenkette
,,{\tt+n}`` enthalten.%%
\footnotemark 
Sollte man nun ausnahmsweise f\"{u}r dieses Projekt
doch einmal die Option ,,{\tt-n}``
w\"{u}nschen, gibt man diese einfach auf der Kommandozeile an.
F\"{u}r die sich ergebende Kombination, die ,,{\tt-n}``, 
,,{\tt+n}`` und ,,{\tt-n}`` 
enth\"{a}lt, ist die {\emletzte\/} Einstellung ,,{\tt-n}`` g\"{u}ltig.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript285}%
\begin{ttscript}{COMPILE Arg}
\item[QUIT] beendet den Compiler.
\item[COMPILE \cmsltt Arg] Das Argument ,,{\cmsltt Arg}`` enth\"{a}lt eine 
Zeichenkette, die einem Aufruf
von der Kommandozeile oder interaktiv entspricht.
Es besteht also aus beliebig vielen Optionen und Dateinamen. Es sollte
jedoch
immer nur eine Datei gleichzeitig kompiliert werden, damit im Fehlerfall
die Quelle lokalisierbar ist.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{ttscript289}%
\begin{ttscript}{COMPILE Arg}
\item[QUIT] beendet den Linker. 
\item[LINK {\cmsltt Arg}] Das Argument ,,{\cmsltt Arg}`` enth\"{a}lt die
Parameter, wie sie vom Aufruf
von der Kommandozeile oder interaktiv her bekannt sind,
bestehend aus beliebig vielen Optionen und Dateinamen.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example295}%
\begin{example}
\medskip\noindent
Das folgende Beispiel zeigt ein einfaches ARexx-Programm. Es versucht,
das angegebene Modul zu kompilieren und anschliessend zu linken.
\par\begin{verbatim}

/*
 *  CompLink.rexx
 *  usage: complink name [compopts [linkopts]]
 */
parse arg modname compopts linkopts .
/* z.B.:
 modname='Demo'
 compopts='-yzgm2:demos'
 linkopts='+rcdgm2:Demos'
*/
options failat 11
IF ~show('Ports','M2C') then exit
address 'M2C' 'compile' compopts modname
IF RC ~= 0 then exit
IF ~show('Ports','M2L') then exit
address 'M2L' 'link' linkopts modname
exit\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{section}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline1360}%
$\cdots$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline1362}%
$\rightarrow$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{ttscript817}%
\begin{ttscript}{/oldsrc/txt}
\item[/oldsrc/txt]
  ist ein relativer Pfadname, und
\item[M2:Modules]
  enth\"{a}lt einen Ger\"{a}tenamen; darum ist er vom aktuellen
  Verzeichnis unabh\"{a}ngig.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax844}%
\begin{m2esyntax}
\item
  linker Mausknopf
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax848}%
\begin{m2esyntax}
\item
  rechter Mausknopf
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax852}%
\begin{m2esyntax}
\item
  linker / rechter Mausknopf
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax856}%
\begin{m2esyntax}
\item
  linker und rechter Mausknopf
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax861}%
\begin{m2esyntax}
\item
  Projekt-Menu
\item
  \mbox{\keyctrl[X]\keyctrl[R]}
\item
  \mbox{\keyf1}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax874}%
\begin{m2esyntax}
\item
  Projekt-Menu
\item
  \mbox{\keyctrl[X]\keyctrl[V]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax879}%
\begin{m2esyntax}
\item
  Projekt-Menu
\item
  \mbox{\keyctrl[X]\keyctrl[I]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax883}%
\begin{m2esyntax}
\item
  Projekt-Menu
\item
  \mbox{\keyctrl[X]\keyctrl[S]}
\item
  \mbox{\kkey[Shift/F1]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax889}%
\begin{m2esyntax}
\item
  Projekt-Menu
\item
  \mbox{\keyctrl[X]\keyctrl[W]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax893}%
\begin{m2esyntax}
\item
  Projekt-Menu
\item
  \mbox{\keyctrl[X]\keyctrl[F]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax897}%
\begin{m2esyntax}
\item
  Projekt-Menu
\item
  \mbox{\keyctrl[Z]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax903}%
\begin{m2esyntax}
\item
  Projekt-Menu
\item
  \mbox{\keyctrl[X]\keyctrl[C]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax911}%
\begin{m2esyntax}
\item
  Projekt-Menu
\item
  \mbox{\keyctrl[X]\key{B}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax915}%
\begin{m2esyntax}
\item
  Projekt-Menu
\item
  \mbox{\keyctrl[X]\key{K}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax920}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\keyctrl[B]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax926}%
\begin{m2esyntax}
\item
  \mbox{\keyesc\keybs}
\item
  \mbox{\kkey[Alt/BS]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax931}%
\begin{m2esyntax}
\item
  \mbox{\keyesc\key{D}}
\item
  \mbox{\kkey[Alt/Del]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax936}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\keyctrl[K]}
\item
  \mbox{\keyctrl[X]\keydel}
\item
  \mbox{\keyf{10}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax943}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[K]}
\item
  \mbox{\kkey[Shift/Del]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax948}%
\begin{m2esyntax}
\item
  \mbox{\kkey[Shift/BS]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax952}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\keyctrl[J]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax956}%
\begin{m2esyntax}
\item
  rechter Mausknopf
\item
  \mbox{\keyctrl[\verb*'@']}
\item
  \mbox{\keyesc\key{.}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax962}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\keyctrl[X]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax967}%
\begin{m2esyntax}
\item
  Edit-Menu
\item
  \mbox{\keyctrl[W]}
\item
  linker \& rechter Mausknopf
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax971}%
\begin{m2esyntax}
\item
  Edit-Menu
\item
  \mbox{\keyesc\key{W}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax975}%
\begin{m2esyntax}
\item
  Edit-Menu
\item
  \mbox{\keyctrl[Y]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax979}%
\begin{m2esyntax}
\item
  Edit-Menu
\item
  \mbox{\keyesc\key{Y}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax983}%
\begin{m2esyntax}
\item
  Edit-Menu
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax988}%
\begin{m2esyntax}
\item
  Befehle-Menu
\item
  \mbox{\keyctrl[S]}
\item
  \mbox{\keyf3}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax994}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[R]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax998}%
\begin{m2esyntax}
\item
  Befehle-Menu
\item
  \mbox{\keyesc\key{\%}}
\item
  \mbox{\kkey[Shift/F3]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1010}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\keyctrl[L]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1014}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\keyctrl[U]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1018}%
\begin{m2esyntax}
\item
  \mbox{\keyesc\key{L}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1022}%
\begin{m2esyntax}
\item
  \mbox{\keyesc\key{U}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1026}%
\begin{m2esyntax}
\item
  \mbox{\keyesc\key{C}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1030}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[T]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline1364}%
$\surd$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1038}%
\begin{m2esyntax}
\item
\   Optionen-Menu
\item
  \mbox{\keyctrl[X]\key{I}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1042}%
\begin{m2esyntax}
\item
  Optionen-Menu
\item
  \mbox{\keyctrl[X]\key{C}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1047}%
\begin{m2esyntax}
\item
  Befehlszeile, Option i, Vorgabe +i
\item
  Optionen Menu
\item
  \mbox{\keyctrl[X]\key{W}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1052}%
\begin{m2esyntax}
\item
  Befehlszeile, Option b, Vorgabe +b
\item
  Optionen-Menu
\item
  \mbox{\keyctrl[X]\key{S}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1060}%
\begin{m2esyntax}
\item
  Befehlszeile, Option c, Vorgabe +c
\item
  Optionen-Menu
\item
  \mbox{\keyctrl[X]\key{T}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1065}%
\begin{m2esyntax}
\item
  Befehlszeile, Option r, Vorgabe -r
\item
  Optionen-Menu
\item
  \mbox{\keyctrl[X]\key{R}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1069}%
\begin{m2esyntax}
\item
  Befehlszeile, Option d, Vorgabe -d
\item
  Optionen-Menu
\item
  \mbox{\keyctrl[X]\keyctrl[T]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline1366}%
$\gg$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1073}%
\begin{m2esyntax}
\item
\   Befehlszeile, Option l, Vorgabe -l
\item
  Optionen-Menu
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1076}%
\begin{m2esyntax}
\item
  Befehlszeile, Option {\tt g\cmsltt Directory}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1081}%
\begin{m2esyntax}
\item
  Befehlszeile, Option {\tt p\cmsltt Project}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1086}%
\begin{m2esyntax}
\item
  Befehlszeile, Option {\tt t\cmsltt TabWidth}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1100}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[L]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1104}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\keyctrl[N]}
\item
  \mbox{\keyf9}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1109}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\keyctrl[P]}
\item
  \mbox{\kkey[Shift/F9]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1114}%
\begin{m2esyntax}
\item
  \mbox{\keyesc\key{H}}
\item
  \mbox{\keyesc\key{!}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1119}%
\begin{m2esyntax}
\item
  \mbox{\keyesc\key{M}}
\item
  \mbox{\kkey[Shift/F6]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1124}%
\begin{m2esyntax}
\item
  Befehle-Menu
\item
  \mbox{\keyctrl[X]\key{2}}
\item
  \mbox{\keyf7}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1129}%
\begin{m2esyntax}
\item
  Befehle-Menu
\item
  \mbox{\keyctrl[X]\key{0}}
\item
  \mbox{\kkey[Shift/F7]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1134}%
\begin{m2esyntax}
\item
  Befehle-Menu
\item
  \mbox{\keyctrl[X]\key{1}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1138}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\key{Z}}
\item
  \mbox{\kkey[Shift/F8]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1143}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\keyctrl[Z]}
\item
  \mbox{\keyf8}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1150}%
\begin{m2esyntax}
\item
  Befehle-Menu
\item
  \mbox{\keyctrl[X]\key{(}}
\item
  \mbox{\keyf4}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1156}%
\begin{m2esyntax}
\item
  Befehle-Menu
\item
  \mbox{\keyctrl[X]\key{)}}
\item
  \mbox{\kkey[Shift/F4]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1161}%
\begin{m2esyntax}
\item
  Befehle-Menu
\item
  \mbox{\keyctrl[X]\key{E}}
\item
  \mbox{\keyf5}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1174}%
\begin{m2esyntax}
\item
  Modula-2-Menu
\item
  \mbox{\keyf2}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1179}%
\begin{m2esyntax}
\item
  Modula-2-Menu
\item
  \mbox{\kkey[Shift/F2]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1183}%
\begin{m2esyntax}
\item
  Modula-2-Menu
\item
  \mbox{\keyctrl[$\backslash$]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1190}%
\begin{m2esyntax}
\item
\   Ohm-Menu
\item
  \mbox{\keyctrl[X]\key{o}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1197}%
\begin{m2esyntax}
\item
  Ohm-Menu
\item
  \mbox{\keyhelp}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1205}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[G]}
\item
  \mbox{\kkey[Shift/F5]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1211}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\key{=}}
\item
  \mbox{\kkey[Shift/F6]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1218}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[U]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning1228}%
\begin{warning}
  Versuchen Sie nicht, den Z\"{a}hler mit \keybs\ zu \"{a}ndern! Die
  Funktion wird entsprechend dem Z\"{a}hler ausgef\"{u}hrt, d.h.\ soviele
  Zeichen, wie der Z\"{a}hler zeigt, werden gel\"{o}scht. Sie sind
  allerdings noch im Zwischenspeicher verf\"{u}gbar.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1231}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[Q]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1237}%
\begin{m2esyntax}
\item
  Befehle-Menu
\item
  \mbox{\keyctrl[X]\key{D}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1243}%
\begin{m2esyntax}
\item
  \mbox{\keyctrl[X]\key{!}}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{m2esyntax1248}%
\begin{m2esyntax}
\item
  Befehle-Menu
\item
  \mbox{\keyctrl[C]}
\end{m2esyntax}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript1255}%
\begin{ttscript}{rcImportantNotFound}
\item[rcOk]
  Es wurden keine Dateien ver\"{a}ndert.
\item[rcWarn]
  Mindestens eine der Dateien wurde ver\"{a}ndert.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure2234}%
\begin{figure}\begin{center}
\unitlength1cm
\begin{picture}(8,3)
\put(4,0.7){\oval(2.0,1.4)} \put(3,0){\makebox(2.0,1.4){\tt m2c}}
\put(2,0.7){\vector(1,0){1}}
  \put(2.6,1){\makebox(0,0)[rb]{\cmsltt Modul\/\tt .def}}
\put(5,0.7){\vector(1,0){1}}
  \put(5.4,1){\makebox(0,0)[lb]{\cmsltt Modul\/\tt .sym}}
\put(4,1.5){\line(2,1){0.6}}
  \put(4.6,1.8){\line(-1,0){0.3}}
  \put(4.3,1.8){\line(0,1){0.4}}
\put(4,1.5){\line(-2,1){0.6}}
  \put(3.4,1.8){\line(1,0){0.3}}
  \put(3.7,1.8){\line(0,1){0.4}}
\put(3.7,2.2){\line(1,0){0.6}}
\put(4,2.4){\makebox(0,0)[b]{{\tt sym}-Dateien}}
\end{picture}
\end{center}
\end{figure}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example2302}%
\begin{example}
Zum Beispiel hat die bereichsbezogene Option {\tt LoadA4}
den Vorgabewert {\tt FALSE},
darf also nur auf {\tt TRUE} gesetzt werden.
\begin{verbatim}

  PROCEDURE Handler;
  (*$ LoadA4:=TRUE *)
  BEGIN
  ...
  END Handler;\end{verbatim}
Die Option hat im Normalfall den Wert {\tt FALSE},
innerhalb der Prozedur den Wert {\tt TRUE} und
wird danach automatisch wieder zu {\tt FALSE}.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning2312}%
\begin{warning}
Bei verschachtelten Prozeduren ist Vorsicht geboten! Der Ort der
Compiler-Anweisung muss genau \"{u}berlegt sein. Beispielsweise wird
der folgende Programmtext nicht erreichen, was vom Programmierer
beabsichtigt war
und sp\"{a}ter zu einem Programm-Absturz f\"{u}hren:
\par\begin{example}
\begin{verbatim}

(*$ LoadA4:=TRUE *) (* FALSCH!!! *)
PROCEDURE Handler;
  PROCEDURE Intern;
  END Intern;
BEGIN
  ...
END Handler;\end{verbatim}
In diesem Fall wird die Prozedur {\tt Intern} {\em mit\/} der Option
{\tt LoadA4} \"{u}bersetzt, die Prozedur {\tt Handler} jedoch {\em ohne\/},
auch wenn {\tt Intern} lokal ist und kein {\tt BEGIN} enth\"{a}lt! Richtig ist
vielmehr folgende Schreibweise:
\begin{verbatim}

PROCEDURE Handler;
  PROCEDURE Intern;
  END Intern;
(*$ LoadA4:=TRUE *) (* RICHTIG!! *)
BEGIN
END Handler;\end{verbatim}
\end{example}
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example2364}%
\begin{example}
\begin{verbatim}

(*$ POP StackChk *)\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example2376}%
\begin{example}
\begin{verbatim}

(*$ DEFINE Demo:=FALSE *)\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note2389}%
\begin{note}
% latex2html id marker 2389
 Es gibt noch weitere Anweisungen, die bei der bedingten
Kompilierung eine Rolle spielen (Abschnitt \ref{refCondComp}, Seite
\pageref{refCondComp}). Haupts\"{a}chlich daf\"{u}r wurde auch die
,,{\tt DEFINE}``-Anweisung implementiert.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example2397}%
\begin{example}
\begin{alltt}
\relax{}   (*$ IF m68020 \dq{}ich kompiliere fur 68020!\verb*|\|n\dq{}  *)
\\...
\\(*$ ELSE \dq{}ich kompiliere nicht fur 68020!\verb*|\|n\dq{}  *)
\\...
\\(*$ ENDIF *)
\\\relax \end{alltt}\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}

%
\providecommand{\compopt}[5]{\par
\bigskip\noindent
\begin{tabular}{l|l|l|l}
\multicolumn{4}{l}{\bf #1} \\\hline
#2 & #3 & #4 & #5 \\\hline
\end{tabular}\nopagebreak\par
\medskip\noindent}%

{\newpage\clearpage
\lthtmlfigureA{example2435}%
\begin{example}
\begin{verbatim}

  VAR i: INTEGER;
      zwerg: ARRAY[1..7] OF INTEGER;
  BEGIN
  FOR i:=1 TO 7 DO
    (*$ RangeChk:=FALSE *)
    zwerg[i]:=0;
    (*$ POP RangeChk *)
  END;\end{verbatim}
Die Bereichskontrolle wird hier unmittelbar vor der Zuweisung der
Feldvariablen abgeschaltet und anschliessend wieder auf den alten Wert
zur\"{u}ckgesetzt.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example2439}%
\begin{example}
So f\"{u}hrt beispielsweise der folgende Text normalerweise
zu zwei Fehlermeldungen des Compilers:
\begin{verbatim}

  VAR range: [-2..5];
      i:INTEGER;
  ...
  range:=7;
  i:=12345678H;\end{verbatim}
Bei ausgeschalteter Option wird keine Fehlermeldung erfolgen und die
Variable {\tt range} zur Laufzeit auf 7, sowie die Variable {\tt i} auf
den Wert 5678H gesetzt.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning2445}%
\begin{warning}
Die Laufzeit\"{u}berpr\"{u}fung von Zuweisungen zweier Variablen gleichen Typs
w\"{u}rde den Code extrem vergr\"{o}ssern und wird vom Compiler deshalb nicht
generiert! Eine \"{U}berpr\"{u}fung erfolgt nur bei impliziten oder expliziten
Konvertierungen.
\par\begin{example}
\begin{verbatim}

  TYPE Farbe = (rot, gelb, gruen);
  VAR a,b: Farbe;
  a:=b; (* hier KEIN Laufzeittest! *)\end{verbatim}
\end{example}
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning2466}%
\begin{warning}
Globale Variablen sind beim Programmstart immer mit 0 initialisiert,
lokale Variablen liegen jedoch auf dem Stack und enthalten ohne
spezielle Initialisierung zu
Beginn der Prozedur unsinnige, aber im allgemeinen von 0 verschiedene Werte.
Deshalb wird im Normalfall der Stack entsprechend initialisiert.
Wird jedoch dies mit der untenstehenden  Option {\tt EntryClear}
unterbunden, kann die
\"{U}berpr\"{u}fung nicht greifen!
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning2476}%
\begin{warning}
Dies gilt jedoch {\em nicht\/} f\"{u}r Register-Variablen und auch nicht,
wenn die Anzahl der lokalen Variablen 32kByte \"{u}bersteigt!
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note2498}%
\begin{note}
Da der Sprungoptimierer (siehe Seite \pageref{refOpti}) auch unbenutzten Code
entfernt, wird der \"{U}berpr\"{u}fungscode bei Nichtbedarf wegoptimiert. Ist
also eine Funktionsprozedur ,,sauber``, d.h.\ f\"{u}hrt sie korrekte
{\tt RETURN}-Anweisungen aus und l\"{a}uft nicht einfach bis zum Ende durch, so ist
der \"{U}berpr\"{u}fungscode unbenutzt (tot). Wenn eine
zweimalige Compilation --- einmal mit ,,{\tt -df}``, einmal mit
,,{\tt -d}`` ---
in beiden F\"{a}llen die gleiche Codegr\"{o}sse erzeugt,
ist alles in Ordnung.
Andernfalls sind irgendwo in dem Modul noch ,,unsaubere``
Funktionsprozeduren!
Die Gr\"{o}sse des Codes wird am Schluss vom Compiler
angegeben.
\par\begin{example}
\begin{verbatim}

  MODULE FTest;
  PROCEDURE ret(i:INTEGER):INTEGER;
  BEGIN
    IF i=1 THEN
      RETURN 5
    END;
  END ret;
  END FTest.\end{verbatim}
Nach der Kompilierung mit ,,{\tt -d}`` meldet der Compiler
,,{\tt CODE:44}``, nach
nochmaliger Kompilierung mit ,,{\tt -df}`` sagt er ,,{\tt CODE:36}``.
Wir sehen
also, dass der \"{U}berpr\"{u}fungscode im ersten Fall nicht wegoptimiert werden
konnte, weil er f\"{u}r den Fall {\tt i\#1} ben\"{o}tigt wird.
\end{example}
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example2521}%
\begin{example}
\begin{verbatim}

PROCEDURE Ret0():LONGINT;
(*$ EntryExitCode:=FALSE *)
BEGIN
  ASSEMBLE(
     MOVEQ #0,D0
     RTS
  END);
END Ret0;

PROCEDURE Daten;
(*$ EntryExitCode:=FALSE *)
BEGIN
  ASSEMBLE(
    DC.W 1,2,3
    DC.B 'Moin, Moin!',0 EVEN
  END);
END Daten;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example2534}%
\begin{example}
\begin{verbatim}

(*$ CopyDyn:=FALSE *)
PROCEDURE Show(s:ARRAY OF CHAR);
BEGIN
  Write('"'); WriteString(s); Write('"');
END Show;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning2538}%
\begin{warning}
Besonders, wenn mehrere Parameter \"{u}bergeben werden, sollte man diese
Option mit \"{a}usserster Vorsicht einsetzen, da der Benutzer der
Prozedur eventuell die {\em selbe\/} Variable einmal als
Werte- und einmal als VAR-Parameter \"{u}bergeben k\"{o}nnte! Wenn dann der
VAR-Parameter ver\"{a}ndert wird, wird gleichzeitig unbemerkt auch der
Wert-Parameter ver\"{a}ndert.
\par\begin{example}
Das Ausschalten der Option w\"{u}rde im folgenden Beispiel zu einem falschen
Ergebnis f\"{u}hren:
\begin{alltt}
\relax{} PROCEDURE Swap(VAR dest:ARRAY OF CHAR;
\\source:ARRAY OF CHAR);
\\BEGIN
\\dest[0]:=source[1]; (* {\rm {} Hier wird source[0] unabsichtlich} *)
\\dest[1]:=source[0]; (* {\rm {} uberschrieben, falls source und} *)
\\dest[2]:=0C;        (* {\rm {} dest die gleiche Variable enthalten} *)
\\END Swap;
\\...
\\Swap(name,name);
\\...
\\\relax \end{alltt}
\end{example}
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example2556}%
\begin{example}
% latex2html id marker 2556

Ein Beispiel aus der Graphik-Bibliothek {\tt graphics.library}.
Man beachte auch die umgekehrte Anordnung
der Parameter; C legt die Parameter in umgekehrter Reihenfolge als
\mtwo{} auf dem Stack ab (siehe \ref{refParaC}, Seite \pageref{refParaC},
Einbindung von C)! Die {\tt CAST}-Anweisung ist notwendig, weil
{\tt SetCollision}
als Parameter eine {\tt PROC} erwartet --- was dem allgemeinsten
Fall einer Prozedur entspricht ---, {\tt BorderPatrol} jedoch Parameter hat.
\begin{verbatim}

  PROCEDURE BorderPatrol(mask:LONGSET; spr:ExtSpritePtr);
  (*$ ParDealloc:=FALSE *)
  BEGIN
    ...
  END BorderPatrol;
  ...
  SetCollision(0,CAST(PROC,ADR(BorderPatrol)),GInfo);
  ...\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note2658}%
\begin{note}
Es wird empfohlen, alle Moduln mit der Option ,,{\tt -y}`` zu
kompilieren. Am besten nehmen Sie diese Option in ,,{\tt ENV:m2c}``
(z.B. durch ,,{\tt SetEnv m2c -y}``) mit auf.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning2663}%
\begin{warning}
Werden in einem Definitionsmodul globale Variablen deklariert, so
muss es mit der gleichen Option wie das Implementationsmodul kompiliert
werden, andernfalls erfolgt eine Fehlermeldung. Dies muss auch
befolgt werden, wenn keine Variablen in der Implementation 
deklariert wurden, da sich eine versteckte, f\"{u}r den Benutzer nicht
zugreifbare Variable darin befindet!
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning2677}%
\begin{warning}
Diese Option \"{u}berlagert {\em stillschweigend\/} die Option {\tt LargeVars}!
Wenn Sie obige Option angeben, wird automatisch auf das \far-Modell
umgeschaltet, woraufhin das Programm nicht mehr residentf\"{a}hig sein
kann. Wenn Sie unbedingt beides (Residentf\"{a}higkeit und CHIP-Daten)
ben\"{o}tigen, nutzen Sie f\"{u}r {\em unver\"{a}nderliche\/} Daten entweder
externe Variablen oder die untenstehende Option {\tt ChipCODE}. F\"{u}r
{\em ver\"{a}nderliche\/} Daten im Chip-Memory alloziert man den Speicher
besser zur Laufzeit!
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning2715}%
\begin{warning}
Die jeweils letzte Ziffer auf der Kommandozeile hat das ,,letzte Wort``,
,,\hbox{\tt -38}`` ist also das gleiche wie ,,\hbox{\tt -8}``! Durch jede
Ziffer werden immer alle Optionen gesetzt. Die Angabe ,,{\tt -18}`` ist also
unsinnig. Eine FPU~MC68881 impliziert f\"{u}r den Compiler immer auch
mindestens eine MC68020-CPU.
Wenn Sie in Ihrem System einen 68010 mit 68881
haben --- was sehr unwahrscheinlich ist ---
kann der Compiler f\"{u}r Sie nur 68010-Code
generieren.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{note2765}%
\begin{note}
Warnungen k\"{o}nnen auch auftreten, wenn ein ASSEMBLE-Teil mit
Hexadezimalzahlen
auskommentiert wurde, da diese ebenfalls mit ,,{\tt\$}`` beginnen!
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{warning4027}%
\begin{warning}
% latex2html id marker 4027

Der Assembler macht keinen  Unterschied
zwischen den per Compiler-Option eingestellten Prozessoren; hier
ist immer alles erlaubt. Man sollte die bedingte Compilierung
benutzen, um den optimalen Code f\"{u}r den jeweils eingestellten
Prozessor zu erzeugen. Lesen Sie hierzu bitte Abschnitt \ref{prozComp}
auf Seite \pageref{prozComp}.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript4102}%
\begin{ttscript}{RELOCATION}
  \item[{END}] beendet den Assembler-Text, danach muss noch
    eine abschliessende Klammer ,,{\tt )}`` folgen.
\par\item[{RELOCATION}] erlaubt es, PC-relative Objekte absolut zu adressieren.
  Hierbei wird ein ``{\tt RELOC32}`` oder ,,{\tt REF32}``
  f\"{u}r den Linker und AmigaDos
  erstellt.
  Dies ist dann sehr n\"{u}tzlich, wenn Zeiger gleich beim Programmstart
  initialisiert sein sollen. Schreibt man z.B.\ {\tt DC.L MenuItem1}, so
  befindet sich an dieser Position im Objektcode die absolute Adresse
  von {\tt MenuItem1}. Dieser Modus bleibt bis
  zum Ende des aktuellen Assembler-Textes g\"{u}ltig.
  Nun h\"{a}tte man dies nat\"{u}rlich
  {\em immer\/} erlauben k\"{o}nnen, doch die Erfahrung hat gezeigt,
  dass Schreibfehler
  leicht zu unbeabsichtigten Adressierungsarten f\"{u}hren k\"{o}nnen!
  \item[{EVEN}] zwingt den n\"{a}chsten Befehl auf eine gerade Adresse, z.B.\
  nach {\tt DC.B \verb*|"|Text\verb*|"|,0}. Falls diese Anweisung vergessen
  wird, erzeugt der Compiler eine Fehlermeldung!
\par\item[{XREF}] hat beliebig viele Parameter, durch Kommata getrennt. Die\-se
  Parameter sind Bezeichner, die ausserhalb des Moduls definiert sein
  m\"{u}ssen und im Assembler wie Label, absolute 
  oder globale \near- oder \far-Variablen
  benutzt werden k\"{o}nnen.
\par\item[{DC}] ist die wohl von jedem anderen Assembler bekannte M\"{o}glichkeit,
  Daten als Byte, Worte oder Langworte in den Code einzuf\"{u}gen.
  ,,{\tt DC.B}`` bietet ausserdem die M\"{o}glichkeit, Zeichenketten zu definieren,
  wobei hier die gleiche Syntax wie in \mtwo{} gilt. Es wird allerdings
  kein Null-Byte am Ende angef\"{u}gt!
  \end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example4134}%
\begin{example}
Ein paar Beispiele:
\begin{verbatim}

  {3+4}*5            (* = 35 *)
  30 & $F -7 | {3+5} (* = 15 *)
  -4*{-6}            (* = 24 *)\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline4367}%
${\tt arr1}+4$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example4175}%
\begin{example}
\begin{verbatim}

   PROCEDURE OADemo(VAR arr1: ARRAY OF INTEGER;
                    arr2: ARRAY OF CHAR);
   ...
   MOVE.L  arr1(A5),A0   (* ADR(arr1)  *)
   MOVE.L  arr1+4(A5),D0 (* HIGH(arr1) *)
   MOVE.L  arr2(A5),A1   (* ADR(arr2)  *)
   MOVE.L  arr2+4(A5),D1 (* HIGH(arr2) *)
   ...\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example4180}%
\begin{example}
\begin{verbatim}

  PROCEDURE Lev0(int:INTEGER);
    PROCEDURE Lev1;
      PROCEDURE Lev2;
        ...
        MOVE.L  8(A5),A0   (* A0:=A5  von Lev1 *)
        MOVE.L  8(A0),A0   (* A0:=A5  von Lev0 *)
        MOVE.W  int(A0),D0 (* D0:=int von Lev0 *)
        ...\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example4184}%
\begin{example}
\begin{verbatim}

  MOVE.L  DosL(A4),A6
  MOVEQ   #50,D1
  JSR     Delay(A6) (* warte 1 Sekunde *)\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline4369}%
$\pm$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{warning4225}%
\begin{warning}
 Die Register A4 und A5 werden {\em niemals\/} automatisch auf den Stack
 gerettet, auch wenn sie innerhalb eines Assembler-Teils ver\"{a}ndert
 wurden! Diese beiden Register sollten daher auch nie ver\"{a}ndert werden.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline4373}%
$-4$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline4375}%
$+3*4$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example4238}%
\begin{example}
Ein Beispiel, das die Problematik erl\"{a}utert:
\begin{verbatim}

PROCEDURE Extreme(ptr:RecPtr; y{R.D3}:LONGINT);
VAR i{R.D7}:CARDINAL;
BEGIN
  WITH ptr^ DO
    FOR i:=1 TO max+3 DO
      CASE value OF
      | 3:
          ASSEMBLE(
          (* simuliert: * y:=ptr^.field1 *)
            MOVE.L A0,-(A7)
            MOVE.L ptr(A5),A0
            MOVE.L Rec.field1(A0),y
            MOVE.L (A7)+,A0
          END);
      | ELSE
      END;
    END;
  END;\end{verbatim}
\noindent
Beim Start von {\tt ASSEMBLE} weiss man nur sicher, dass
{\tt D3} und {\tt D7} belegt sind,
irgendein Adressregister den Zeiger ,,{\tt ptr}`` enth\"{a}lt und {\tt A7}
unbekannt
ist. Da aber nicht bekannt ist, {\em welches\/} Adressregister {\tt ptr}
 enth\"{a}lt,
muss ein Adressregister ,,freigemacht`` und {\tt ptr} neu geladen werden.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{warning4271}%
\begin{warning}
Es gibt
auch eine kleine Falle, wie folgendes Beispiel zeigt:
\begin{verbatim}

      BRA   weiter
      ...
      DC.W  fehlerFall
FehlerTabelle:
      DC.W ok1
      ...
weiter:
      ADD.W D1,D1
      MOVE.W FehlerTabelle(PC,D1.W),D2
      ...\end{verbatim}
Hier soll der Eintrag ,,{\tt fehlerFall}``f\"{u}r den Fall \hbox{{\tt D1}=--1}
geladen werden. Da aber
keine Referenz auf den Bereich zwischen der Anweisung {\tt BRA}
und dem Label {\tt FehlerTabelle}
vorhanden ist, scheint dieser Teil f\"{u}r den Optimierer unbenutzt und er
l\"{o}scht ihn! Somit wird das Programm dann fehlerhaft laufen.
Auch ein
\begin{verbatim}

      ADDQ.W #2,D1
      MOVE.W FehlerTabelle-2(PC,D1.W),D2\end{verbatim}
hilft hier {\em nicht\/} weiter! Solche Konstrukte m\"{u}ssen unterbleiben.
Eine L\"{o}\-sung des Problems w\"{a}re:
\begin{verbatim}

FehlerTabelle:
      DC.W  fehlerFall
      DC.W ok1
      ...
weiter:
      ADD.W D1,D1
      MOVE.W FehlerTabelle+2(PC,D1.W),D2
      ...\end{verbatim}
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{warning4289}%
\begin{warning}
 Hierzu gibt es
Folgendes zu bedenken: Prozeduren gelten als CODE, d.h.\ die darin
enthaltenen Daten d\"{u}rfen w\"{a}hrend des Programmlaufes {\em nicht ver\"{a}ndert
werden\/}! Nun ist so etwas auf den momentan existierenden Amigas
zwar doch m\"{o}glich, aber eine sp\"{a}tere Version k\"{o}nnte mit Hilfe einer
Memory Management Unit diese Tatsache als Programmfehler dem Guru
\"{u}bergeben. Bereits heute ist es {\em unm\"{o}glich},
dieses in einem {\em residenten\/}
Programm zu tun.
\par Beispielsweise werden {\tt NewWindow}-Strukturen von
Intuition nicht ver\"{a}n\-dert,
{\tt Menu}- oder {\tt Gadget}-Strukturen hingegen sehr wohl.
\par In der aktuellen Compiler-Version ist das Anlegen initialisierter,
{\em ver\"{a}nder\-licher\/} Daten nur mit Hilfe
eines fremden Assemblers und der Deklaration externer Variablen m\"{o}glich,
wobei diese initialisierten Daten als {\tt DATA} abgelegt sein m\"{u}ssen.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example4299}%
\begin{example}
Auf der Demo-Diskette befindet sich im Verzeichnis {\tt Trails} ein
ausf\"{u}hrliches Beispiel f\"{u}r eine initialisierte Menu-Struktur,
die mit Hilfe eines fremden Assemblers erstellt und durch den
Gebrauch externer Variablen in den \mtwo-Code eingebunden wurde.
\par Ein Beispiel f\"{u}r eine {\tt IntuitionD.NewWindow}-Struktur folgt hier:
\begin{verbatim}

PROCEDURE MyNewWin; (*$ EntryExitCode:=FALSE *)
CONST myIDCMP=CAST(LONGINT,IDCMPFlagSet{closeWindow})
      myWinFlags=CAST(LONGINT,WindowFlagSet{windowDrag});
      wbWin=CAST(INTEGER,ScreenFlagSet{wbenchScreen});
BEGIN
  ASSEMBLE(
    RELOCATION (* nur wegen DC.L title *)
    DC.W  0,0,300,100
    DC.B  2,3
    DC.L  myIDCMP, myWinFlags,
          0,0,
          title,
          0,0
    DC.W  100,50,640,256
    DC.W  wbWin
title:
    DC.B  "Mein Fenster",0 EVEN
  END);
END MyNewWin;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example4332}%
\begin{example}
Das folgende Beispiel zeigt gleichzeitig die Ausnutzung eines
Coprozessors, einer 68020-CPU und die ausdr\"{u}ckliche
Erzeugung von Eingangs- und
Ausgangscode, falls vor dem {\tt BEGIN} der Prozedur die Compiler-Anweisung
{\tt EntryExit:=FALSE} angegeben wurde.
\par Zun\"{a}chst wird \"{u}berpr\"{u}ft, ob der Eingangscode bereits 
automatisch erzeugt wurde.
War dies nicht der Fall ({\tt EntryExitCode=FALSE}), so muss der Code selbst
erzeugt werden. Hierzu ,,linken`` wir das Register A5, um einfach
auf die Parameter zugreifen zu k\"{o}nnen und retten alle im folgenden
ver\"{a}nderten Register auf den Stack.
\par Danach soll die Anweisung {\tt Zahl2:=Zahl1*Para0} ausgef\"{u}hrt werden. Da es
sich in diesem Beispiel um {\tt LONGINT}s handelt, k\"{o}nnen wir f\"{u}r die
Prozessoren ab 68020 den {\tt MULS.L}-Befehl verwenden, andernfalls
rufen wir die Arts-Prozedur {\tt Muls32} auf.
\par Drittens soll eine Gleitkommazahl-Berechnung, die etwa der \mtwo-Anweisung
{\tt longr1:=sin(longr1)} --- {\tt longr1} vom Typ {\tt LONGREAL} ---
entspricht,
durchgef\"{u}hrt werden. Eine 68881-FPU
kann diese Berechnung direkt ausf\"{u}hren. Ist keine vorhanden,
genauer gesagt, sofern nicht f\"{u}r die FPU compiliert wird,
muss eine Prozedur der {\tt mathieeedoubtrans.library} genutzt werden.
\par Schliesslich beenden wir die Prozedur. Wird der Ausgangscode vom
Compiler erzeugt , ist nichts zu tun, andernfalls
m\"{u}ssen wir den Code selbst erzeugen. Dazu stellen wir die Register
wieder her, ,,befreien`` A5, bauen die Parameter ab und kehren
zu der aufrufenden Prozedur zur\"{u}ck. In diesem
Beispiel nehmen wir an, die Parameter der Prozedur belegen 10 Byte.
Alle Prozessoren ab 68010 beherrschen den {\tt RTD}-Befehl, f\"{u}r eine
einfache 68000-CPU m\"{u}ssen wir hier etwas mehr Aufwand treiben.
\par\begin{verbatim}

(*$ IF NOT EntryExitCode *)
  LINK   A5,#0 (* der Einfachheit halber! *)
  MOVEM.L Dx.../A6,-(SP)
(*$ ENDIF *)
  ...
  MOVE.L Zahl1(A4),D0 (* globale NEAR-VAR *)
(*$ IF m68020 *)
  MULS.L Para0(A5),D0 (* Parameter *)
(*$ ELSE *)
  MOVE.L Para0(A5),D1
  JSR    Arts.Muls32(PC)
(*$ ENDIF *)
  MOVE.L D0,Zahl2  (* globale FAR-VAR,importiert *)
  ...
(*$ IF m68881 AND NOT m68040 *)
  FSIN.D  longr1(A4),FP0
  FMOVE.D FP0,longr1(A4)
(*$ ELSE *)
  MOVEM.L longr1(A4),D0-D1
  MOVE.L  MathIEEEDoubTrans(A4),A6
  JSR     MathIEEEDoubTrans.Sin(A6)
  MOVEM.L D0-D1,longr1(A4)
(*$ ENDIF *)
  ...
(*$ IF NOT EntryExitCode *)
  MOVEM.L (A7)+,Dx.../A6
  UNLK   A5
(*$ IF m68010 *)
  RTD    #10 (* 10 Byte Parameter *)
(*$ ELSE *)
  MOVE.L (A7)+,A0
  LEA    10(A7),A7
  JMP    (A0)
(*$ ENDIF *) (* m68010 *)
(*$ ENDIF *) (* EntryExit *)\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{figure4902}%
\begin{figure}\begin{center}
\unitlength1cm
\begin{picture}(8,3)
\put(4,0.7){\oval(2.0,1.4)} \put(3,0){\makebox(2.0,1.4){\tt m2l}}
\put(2,0.7){\vector(1,0){1}}
  \put(2.6,1){\makebox(0,0)[rb]{\cmsltt prog\/\tt .ob\cmsltt n}}
\put(5,0.7){\vector(1,0){1}}
  \put(5.4,1){\makebox(0,0)[lb]{\cmsltt prog}}
\put(4,1.5){\line(2,1){0.6}}
  \put(4.6,1.8){\line(-1,0){0.3}}
  \put(4.3,1.8){\line(0,1){0.4}}
\put(4,1.5){\line(-2,1){0.6}}
  \put(3.4,1.8){\line(1,0){0.3}}
  \put(3.7,1.8){\line(0,1){0.4}}
\put(3.7,2.2){\line(1,0){0.6}}
\put(4,2.4){\makebox(0,0)[b]{{\tt ob\cmsltt x\/}-Dateien}}
\end{picture}
\end{center}
\end{figure}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note4923}%
\begin{note}
Der Linker kann nur Programm-Moduln linken, aus einem
Implementationsmodul kann --- im Gegensatz zu fr\"{u}heren Versionen ---
{\em kein\/} lauff\"{a}higes
Programm erstellt werden!
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example4934}%
\begin{example}
Ein Beispiel:
\begin{quote}\tt m2l -i+rcd Modul1 -rlHilfsdatei Modul2
\end{quote}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example4978}%
\begin{example}
Ein Beispiel f\"{u}r eine sortierte Datei:
\begin{alltt}
\relax{}   Hunk  0:  $000005AC Byte,  Typ: CODE
\\Hunk  1:  $0000000C Byte,  Typ: CHIPDATA
\\Hunk  2:  $0000000C Byte,  Typ: BSS
\\Hunk  3:  $000000A8 Byte,  Typ: MERGBSS
\\Hunk:  0  Offset: $000002D6  (rel)   Arts$19
\\Hunk:  0  Offset: $0000031C  (rel)   Arts$22
\\Hunk:  0  Offset: $0000048C  (rel)   Arts$16
\\Hunk:  0  Offset: $00000560  (rel)   Arts_Exit
\\Hunk:  0  Offset: $00000568  (rel)   Arts_Terminate
\\Hunk:  0  Offset: $00000570  (rel)   Arts_12C1028006AB
\\Hunk:  0  Offset: $00000572  (rel)   Arts_END
\\Hunk:  0  Offset: $00000574  (rel)   __main
\\Hunk:  0  Offset: $0000059E  (rel)   __mainEnd
\\Hunk:  0  Offset: $000005A4  (rel)   MapTest_BY
\\Hunk:  1  Offset: $00000000  (rel)   MapTest_IN
\\Hunk:  2  Offset: $00000000  (rel)   MapTest_VAR
\\Hunk:  3  Offset: $00000000  (rel)   Arts_VAR
\\Hunk:---  Wert:   $00000000  (drel)  _LinkerDB
\\Hunk:---  Wert:   $00000000  (drel)  __BSSBAS
\\Hunk:---  Wert:   $0000002A  (abs)   __BSSLEN
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example4988}%
\begin{example}
 Ein Beispiel, in dem die zwei Dateien {\tt Menu.o} und
  {\tt demos:Requester.o} explizit angegeben werden sollen;
  zus\"{a}tzlich wird hierbei die Option m gesetzt und r gel\"{o}scht:
\begin{quote}\tt  m2l +m-rlMenu.o -ldemos:Requester.o MyDemo
\end{quote}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example4997}%
\begin{example}
Der Compiler f\"{u}r die 68020-CPU wird beispielsweise so erzeugt:
\begin{verbatim}

 m2l -2s20000 -tm2c68020 m2c\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example5004}%
\begin{example}
 Ein Beispiel, in dem der Compiler mit einem Minimalstack von
 20000 Byte gelinkt wird:
\begin{quote}\tt  m2l -s20000 m2c
\end{quote}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\addtocounter{footnote}{-1}
\stepcounter{footnote}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{note5083}%
\begin{note}
Da jeweils das aktuelle Projekt, danach den Eintr\"{a}gen
in der Datei ,,{\tt path}`` entsprechend
und danach denen von ,,{\tt m2:path}`` entsprechend gesucht wird, kann dies
unter Umst\"{a}nden  sehr
langwierig werden; insbesondere wenn Pfad-Listen
lang und weitverzweigt sind.
Man sollte sich dann f\"{u}r den gew\"{u}nschten
Prozessor die richtigen Objektdateien compilieren, auch wenn einige
Moduln etwa auf einem 68020--Prozessor gar keinen Code sparen. Danach
d\"{u}rfte jedoch das Linken einiges schneller gehen!
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example5125}%
\begin{example}
Ruft nun eine Prozedur die Funktion {\tt Arts.Mulu32} auf und Arts ist
sp\"{a}ter im fertigen Programm weiter als 32\,KByte ,,entfernt``, wird
folgender Code erzeugt:
\begin{verbatim}

eigener Hunk:
        JSR   ALVArts_Mulu32(PC)
        ...
   ALVArts_Mulu32:
        JMP   Arts_Mulu32

anderer Hunk:
   Arts_Mulu32:
        ...
        RTS\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example5134}%
\begin{example}
Angenommen, man m\"{o}chte nach obigen Beispiel das erste Wort der Prozedur
{\tt Arts.Mulu32} in ein Register laden, so wird man nur das erste Wort
des ALV-Sprunges (also eine {\tt JMP}-Instruktion) erreichen! In diesem
Fall muss von vornherein eine absolute Referenz erzeugt werden:
\begin{verbatim}

eigener Hunk:
        MOVE.W  Arts_Mulu32,D0
oder
        LEA     Arts_Mulu32,A0
        MOVE.W  (A0),D0
        ...
anderer Hunk:
   Arts_Mulu32:
        ...
        RTS\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example5145}%
\begin{example}
Beipiel:
\begin{verbatim}

  VAR MyMenu [ < "MyMenu_Strip" ]: Menu;
  ASSEMBLE(
     XREF PointerImage
     LEA  MyMenu(A4),A0
     LEA  PointerImage,A1
  END);\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning5159}%
\begin{warning}
 W\"{a}hrend man durch ,,Umdrehen`` der Parameter-Reihenfolge in der
 Definition die erste H\"{u}rde \"{u}berwinden k\"{o}nnte, macht der fehlende
 Parameter-Abbau einen Aufruf von C-Prozeduren mit Stack-Parametern
 nur vom Assembler aus m\"{o}glich! Die Parameter muss man
 nach dem Aufruf dann allerdings selbst abbauen. Einfacher
 lassen sich Prozeduren mit reinen Register-Parametern
 einbinden.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{section}
\stepcounter{subsubsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{note5679}%
\begin{note}
Sie k\"{o}nnen mit der rechten Maustaste
ebenfalls selektieren, wie Sie es mit der linken Maustaste gewohnt sind.
Weil der Amiga aber normalerweise den rechten Mausknopf f\"{u}r die Menus
reserviert hat, d\"{u}rfen Sie sich durch den oben eingeblendeten Menubalken
nicht irritieren lassen, solange Sie den rechten Mausknopf gedr\"{u}ckt haben.
Beim Loslassen des rechten Knopfes reagiert der Debugger wie erwartet.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{note5685}%
\begin{note}
Der Zeichensatz, mit dem der Debugger die
Fenster\"{u}ber\-schrif\-ten und den Fensterinhalt schreibt,
ist der vom System vorgegebene Zeichensatz (system default font).
Ab Workbench 2.0 k\"{o}nnen Sie diesen Zeichensatz auch \"{a}ndern,
wenn Sie wollen.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{note5737}%
\begin{note}
Der Menuzeichensatz ist fest ,,{\tt topaz.8}``. Eine
\"{A}nderung ist vorl\"{a}ufig nicht vorgesehen.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline5944}%
$\copyright$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning5835}%
\begin{warning}
Die Darstellung der Daten kann in wenigen F\"{a}llen unangenehme
Folgen haben: so darf die {\tt RECORD}-Variable {\tt Hardware.Custom}
{\em nicht\/} im Debugger angeschaut werden, da gewisse
Elemente auf blossen Zugriff reagieren. Ein Absturz ist damit
garantiert! Zwar erscheint das Modul {\tt Hardware} als
implementationsloses Modul nicht in der Modultabelle, aber es
lassen sich in eigenen Moduln problemlos Zeiger auf 
{\tt Hardware.Custom} deklarieren. 
\par\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{note5861}%
\begin{note}
Neuerdings sind bei den Library-Moduln die Prozeduren
und die Datenstrukturen in zwei verschiedene Moduln aufgeteilt; so sind zum
Beipiel die Typen in {\tt DosD} und die Prozeduren in {\tt DosL}.
Im Debugger muss f\"{u}r die Typen\"{a}nderung {\em immer\/} der Typ
via {\cmsltt Modul\tt L} angesprochen werden, also in unserem Beispiel
qualifiziert aus dem Modul {\t DosL}.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsection}
\stepcounter{chapter}
\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example6631}%
\begin{example}
Nachfolgend ein Ausschnitt aus der Ausgabe von {\tt m2error}.
In diesem Beispiel wurde versucht, einen nicht exportierten
Bezeichner zu importieren.
\par\\[3]\begin{alltt}
\relax{} Amiga Modula-2 Fehlerlister, 4.0d, 23.02.91
\\
\\1   MODULE err;
\\2
\\3   FROM InOut IMPORT
\\4    WriteChar,WriteInt,WriteLn;
\\|^
\\|     55: Bezeichner nicht sichtbar
\\\ldots
\\\relax \end{alltt}
\par Je nach gew\"{a}hlter Option wird nun an dieser Stelle weitergefahren oder
aber erst die n\"{a}chste fehlerhafte Stelle angezeigt; diese schliesst
sich unmittelbar an, wenn sie weniger als
100 Zeichen entfernt ist.
\par\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript6640}%
\begin{ttscript}{xxx}
\item[?]
  zeigt die Version und die Syntax des Fehlerlisters-Aufruf an.
\item[x]
  (extract) ,,{\tt +x}`` zeigt nur die Umgebung der Fehlerstelle
  wie oben beschrieben. Mit ,,{\tt -x}`` wird nicht nur der Programmtext
  an einer Fehlerstelle, sondern das gesamte Abbild des
  Ursprungtextes erstellt. 
\item[l{\cmsltt n}]
  (listing) Wird die Option ,,{\tt -l}`` oder ,,{\tt +l}`` ohne
  Argument  angegeben,
  wird keine Eingabedatei erwartet, sondern die gesamte
  Fehlerliste aller m\"{o}glichen Fehlernummern und der dazugeh\"{o}rigen
  Texte ausgegeben. Diese recht lange Liste kann mit \keyctrl[C] 
  unterbrochen werden. Ist unmittelbar daran eine Nummer
  angegeben, wird nur der entsprechende Fehlercode ausgegeben.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript6656}%
\begin{ttscript}{rcImportantNotFound}
\item[rcIllOpt]
  Eine ung\"{u}ltige Option wurde \"{u}bergeben.
\item[rcActionErr]
   Die Fehlerdatei ({\cmsltt Quelle\/\tt E}) konnte nicht gefunden werden.
 \item[rcImportantNotFound]
   Die Datei ,,{\tt M2:Fehler-Meldungen}`` kann nicht ge\"{o}ff\-net werden.
 \item[rcMainNotFound]
   Der Quelltext wurde nicht gefunden.
 \end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure6770}%
\begin{figure}\centering\unitlength5mm
\begin{picture}(18,14)
\newsavebox{\module}\savebox{\module}(0,0)[bl]{
  \put(0,0){\framebox (3,2)[br]{}}
  \put(0,0.1){\makebox(2.9,1.9)[br]{{\footnotesize def}}}
  \put(1,0){\line(0,-1){1}} \put(1,-1){\line(1,0){3}}
    \put(4,-1){\line(0,1){2}} \put(4,1){\line(-1,0){1}}
}
\put(0,1){\usebox{\module}\makebox(3,2){M4}}
\put(7,1){\usebox{\module}\makebox(3,2){M5}}
\put(14,1){\usebox{\module}\makebox(3,2){M6}}
\put(3,6){\usebox{\module}\makebox(3,2){M2}}
\put(10,6){\usebox{\module}\makebox(3,2){M3}}
\put(6,10){\framebox (4,3){M1}}
\put(1.5,3){\vector(3,2){3}}
\put(8.5,3){\vector(-3,2){3}}
\put(15.5,3){\vector(-4,3){4}}
\put(4.5,8){\vector(3,2){3}}
\put(11.5,8){\vector(-3,2){3}}
\end{picture}
\end{figure}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline6942}%
$< 20\,000$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example6883}%
\begin{example}
Nun folgt ein Beispiel eines Make-Aufrufs, bei dem eine vorhandene
Abh\"{a}ngigkeitendatei benutzt wird, zwei benutzerdefinierte Optionen
des Compilers gesetzt werden und schliesslich Prozessor und
Stack vorgegeben sind.
\begin{quote}
\begin{verbatim}

m2make +d-c"+oDemo -oDebug" -0-s20000 test\end{verbatim}
\end{quote}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript6904}%
\begin{ttscript}{rcImportantNotFound}
\item[rcIllOpt]
  Eine ung\"{u}ltige Option oder ,,{\tt ?}`` wurden angegeben.
\item[rcMainNotFound]
  Das Hauptmodul, das zu bearbeiten und schliesslich zu erstellen
  ist, wurde nicht gefunden.
\item[{\cmsltt rc\/\rm\ldots}]
  Kann eine Compilation oder der Linkvorgang nicht fehlerfrei
  durchgef\"{u}hrt werden, wird dieser letzte R\"{u}ckgabe\-wert an
  den Aufrufer von {\tt m2make} weitergereicht.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript7205}%
\begin{ttscript}{sym}
\item[bin]
  Die gelinkten, ausf\"{u}hrbaren Programme. Diese haben im Normalfall
  {\em keine} Endung.
\item[obj]
  Die Objektdateien aller in diesem Projekt vorhandenen Quelldateien.
  Jene haben die Endungen ,,{\tt obj}``, ,,{\tt ob1}``, ,,{\tt ob2}``,
  ,,{\tt ob3}``, ,,{\tt ob4}``, ,,{\tt ob8}``. Unabh\"{a}ngig von
  der Prozessorversion werden alle Objektdateien also in {\em einem\/}
  Unterverzeichnis des Projekts abgelegt.
\item[ref]
  Die Referenzdateien, welche die Informationen f\"{u}r Debugger,
  Profiler und \"{a}hnliche Programme beinhalten. Die entsprechende
  Endung ist ,,{\tt .ref}``.
\item[sym]
  Die Symboldateien, d.h.\ die compilierten Versionen der
  Definitionsmoduln. Der Compiler vergibt hierf\"{u}r die
  Endung ,,{\tt .sym}``.
\item[txt]
  Die Quelldateien, d.h.\ in erster Linie
  Definitions-, Implementations- und
  Programm-Moduln. Erstere sollten die Endung ,,{\tt .def}``
  haben, die anderen die Endung ,,{\tt .mod}``. Ausserdem
  werden Dateien mit der Endung ,,{\tt .asm}`` als Assembler-Quelldateien
  interpretiert.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript7225}%
\begin{ttscript}{xxx}
\item[?]
  zeigt die Version und die Syntax von {\tt m2project} an.
\item[b]
  Mit der Option ,,{\tt -b}`` wird {\em kein\/} Unterverzeichnis
  {\tt bin} erzeugt. Vorgabe ist, alle Verzeichnisse zu erzeugen.
\item[i]
  F\"{u}r das Projektverzeichnis und alle zu erzeugenden Unterverzeichnisse
  werden mit ,,{\tt +i}`` Ikonen erzeugt. Ohne Angabe werden nur dann
  Ikonen erzeugt, wenn {\tt m2project} von der Workbench aufgerufen
  wurde.
\item[m]
  (move) Legen Sie in einem bereits angelegten Projekt {\em neue\/}
  Unterverzeichnisse an, werden alle bestehenden Dateien, die
  direkt im Projektverzeichnis liegen, in die neuen
  Unterverzeichnisse ({\tt bin}, {\tt obj}, \ldots)
  verschoben. Dabei gelten folgende Konventionen, welche
  Dateitypen in welche Unterverzeichnisse verschoben werden.
  \begin{ttscript}{xxxx}
  \item[obj{\rm :}]
    {\tt\#?.ob?(\%|.info)}
  \item[ref{\rm :}]
    {\tt\#?.ref(\%|.info)}
  \item[sym{\rm :}]
    {\tt\#?.sym(\%|.info)}
  \item[txt{\rm :}]
    {\tt\#?.(def|mod|asm)(\%|.info)}
  \item[bin{\rm :}]
    alle, die keinen Punkt enthalten oder nur mit {\tt .info}
    enden, ausser {\tt path(\%|.info)}, {\tt obj}, {\tt ref}, {\tt sym},
    {\tt txt}.
  \end{ttscript}
  Dieses Umkopieren kann mit ,,{\tt -m}`` unterbunden werden.
\item[o]
  Die Option ,,{\tt -o}`` unterdr\"{u}ckt das Erzeugen des
  {\tt obj}-Verzeichnisses, Vorgabe ist ,,{\tt +o}``.
\item[r]
  Steuert die Erzeugung des {\tt ref}-Verzeichnisses.
\item[s]
  Beeinflusst die Erzeugung des {\tt sym}-Verzeichnisses.
\item[t]
  Analog zu den Optionen {\tt b}, {\tt o}, {\tt r} und
  {\tt s} f\"{u}r das {\tt txt}-Verzeichnis zust\"{a}n\-dig.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript7272}%
\begin{ttscript}{rcImportantNotFound}
\item[rcIllOpt]
  Eine ung\"{u}ltige Option oder ,,{\tt ?}`` wurden angegeben.
\item[rcActionErr]
  Ein gefordertes Verzeichnis kann nicht kreiert werden
  oder beim Umkopieren von Dateien in die Unterverzeichnisse
  (z.B.\ {\tt\#?.mod $\rightarrow$\  txt/}) ist ein Fehler aufgetreten.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript7471}%
\begin{ttscript}{xxxxxxxxx}
\item[?] Zeigt die Version und die Syntax an.
\item[l] (list) Die Option ,,{\tt +l}`` oder ,,{\tt -l}`` erwirkt
  die Ausgabe des Cache-Inhalts auf den Bildschirm.
\item[q] (quiet) Die Option ,,{\tt -q}`` unterdr\"{u}ckt alle Meldungen
  mit ausschliesslich beschreibendem Charakter.
\item[f] (flush) Diese Option dient dem L\"{o}schen der im Cache
  vorhandenen Objekte. Mit ,,{\tt -f}`` werden alle {\em lokalen\/}
  Objekte gel\"{o}scht; lokal sind diejenigen Objekte des aktuellen
  Projekts. Die Option ,,{\tt +f}`` l\"{o}scht
  {\em alle\/} Objekte aus dem Cache.
\item[n{\cmsltt Gr\"{o}sse\/}]
  Hiermit kann die Cache-Gr\"{o}sse bestimmt werden. Der Wert
  {\cmsltt Gr\"{o}sse\/} muss eine (positive) ganze Zahl sein.
  Je nach einleitendem Zeichen (,,{\tt +}`` oder ,,{\tt -}``)
  wird dabei der {\em maximal belegte\/} oder der {\em minimal
  freibehaltene\/} Speicher bezeichnet:
  \begin{quote}\tt   m2cache +n{\cmsltt Gr\"{o}sse}
  \end{quote}
  Der Cache h\"{a}lt maximal {\cmsltt Gr\"{o}sse\/} Byte im Speicher.
  \begin{quote}\tt   m2cache -n{\cmsltt Gr\"{o}sse}
  \end{quote}
  Der Cache h\"{a}lt mindestens {\cmsltt Gr\"{o}sse\/} Byte des Speichers
  frei. Die Angabe des mindestens verf\"{u}gbar zu haltenden Speichers
  ist im allgemeinen die sicherere Methode; die Vorgabe ist,
  300\,000 Byte {\em freizuhalten}.
\item[d{\rm ,}m{\rm ,}r{\rm ,}o{\rm ,}s]
  Die nachfolgende Aktion betreffen die Dateien der Typen
  {\tt def}, {\tt mod}, {\tt ref}, {\tt ob\cmsltt ?} und {\tt sym}.
  Diese Optionen haben nur Einfluss auf die nachfolgenden
  Argumente {\tt *} und {\cmsltt ModulName}. Die Einleitung
  ,,{\tt +}``  aktiviert den Typ, ,,{\tt -}`` deaktiviert ihn. Die
  Voreinstellung ist {\tt -dmr +os}.
\item[*]
  Das Argument {\tt *} {\em l\"{o}scht\/} alle Objekte
  der aktivierten Dateitypen
\par\item[{\cmsltt ModulName}]
  Wird {\cmsltt ModulName\/} als Argument \"{u}bergeben,
  werden alle aktivierten Dateitypen des Moduls {\cmsltt ModulName\/}
  gel\"{o}scht. Der Name muss eine Zeichenkette ohne
  Pfad und Erweiterung sein, Gross-
  und Kleinschreibung werden {\em nicht\/} unterschieden.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript7517}%
\begin{ttscript}{rcImportantNotFound}
\item[rcIllOpt]
  Eine ung\"{u}ltige Option oder ,,{\tt ?}`` wurde \"{u}bergeben.
 \item[rcMainNotFound]
   Das gew\"{u}nschte Modul wurde nicht gefunden.
 \end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript7660}%
\begin{ttscript}{rcImportantNotFound}
\item[rcIllOpt]
  Eine ung\"{u}ltige Option oder ,,{\tt ?}`` wurden angegeben.
\item[rcActionErr]
  Eine der folgenden Bedingungen ist {\em nicht\/} erf\"{u}llt:
  \begin{itemize}
  \item Die Datei kann mittels {\tt Dos.LoadSeg} geladen werden
  \item Der erste Hunk enth\"{a}lt eine Resident-Struktur
  \item Der Typ der Resident-Struktur ist library, device oder resource
  \item Ein Objekt gleichen Namens ist noch nicht im System vorhanden
  \end{itemize}
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{chapter}
\stepcounter{section}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript7780}%
\begin{ttscript}{0{\rm\ldots}8}
\item[?] zeigt die Version und Aufruf-Syntax des Dekoders an.
\item[0{\rm\ldots}8] bestimmt die Endung der Objektdatei, nach der
gesucht werden soll ({\tt obj}, {\tt ob1}, {\tt ob2}, {\tt ob3},
{\tt ob4}, {\tt ob8}). Die Zeichen ,,{\tt +}`` oder
,,{\tt -}`` f\"{u}r das Einleiten der Optionen ist hier ohne Wirkung.
Standardeinstellung ist ,,0``.
\item[c{\cmsltt n\/}]
  erm\"{o}glicht die Farbeinstellung des angezeigten Quelltextes.
  Die Ziffer gibt die zu verwendende Farbe an, der Wert 0
  steht f\"{u}r keine Farb\"{a}nderung, wie sie bei Dateiumlenkungen
  verwendet werden soll\-te.
  Vorgabem\"{a}ssig wird der Quelltext in der Farbe 2 angezeigt.
  Der Code wird in Standardfarbe --- normalerweise Farbe 1 ---
  angezeigt.
\item[o]
  (object) ,,{\tt +o}`` erzeugt in jeder Zeile vor dem
  Assembler-Code noch den Objektcode in Hexadezimaldarstellung.
  ,,{\tt -o}`` unterdr\"{u}ckt die Anzeige. Standardeinstellung ist ,,{\tt -o}``.
\item[q] (quiet) ,,{\tt -q}`` unterdr\"{u}ckt s\"{a}mtliche Zusatzmeldungen.
 Dies ist besonders n\"{u}tzlich, wenn eine Ausgabeumleitung benutzt
 wird, sodass die Datei nur den reinen Assembler-Code enth\"{a}lt.
 ,,{\tt +q}`` schaltet diese Meldungen ein. Ohne Angabe werden
  Zusatzmeldungen ausgegeben.
\item[s] (source) ,,{\tt +s}`` zeigt zus\"{a}tzlich zum Assembler-Code
  den Quelltext, der zum entsprechenden Code gef\"{u}hrt hat. 
  Standardm\"{a}ssig wird der Quelltext mit angezeigt, wenn
  eine Referenz-Datei vorhanden ist.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example7799}%
\begin{example}
,,{\tt m2decobj +1o Test -o0 Demo}`` sucht im aktuellen Projekt
nach der Datei
{\tt Test.ob1} und disassembliert diese auf dem Bildschirm mit
Anzeige des Objektcodes. Danach wird die Datei {\tt Demo.obj} ohne Anzeige
des Objektcodes dargestellt und das Programm verlassen.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript7805}%
\begin{ttscript}{rcImportantNotFound}
\item[rcWarn]
  In der Ausgabe wurde der Quelltext verlangt aber nicht gefunden.
\item[rcIllOpt]
  Eine ung\"{u}ltige Option oder ,,{\tt ?}`` wurden angegeben.
\item[rcActionErr]
  Das Objektformat ist nicht korrekt.
\item[rcMainNotFound]
  Das Hauptmodul wurde nicht gefunden.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example7897}%
\begin{example}
Abschreckendes Beispiel:
\begin{verbatim}

  VAR compilerHorror: POINTER TO ARRAY [0..15] OF
    POINTER TO RECORD h,l: INTEGER END;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline7915}%
$2^{31}$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript7910}%
\begin{ttscript}{rcImportantNotFound}
\item[rcIllOpt]
  Eine ung\"{u}ltige Option wurde \"{u}bergeben.
\item[rcActionErr]
   Bei der Dekodierung ist ein Fehler aufgetreten.
\item[rcMainNotFound]
   Die Symboldatei wurde nicht gefunden.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript7970}%
\begin{ttscript}{rcImportantNotFound}
\item[rcIllOpt]
  Eine ung\"{u}ltige Option wurde \"{u}bergeben.
\item[rcActionErr]
   Bei der Dekodierung ist ein Fehler aufgetreten.
\item[rcMainNotFound]
   Die Referenzdatei wurde nicht gefunden.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{warning8019}%
\begin{warning}
Da das Profiler-Modul im \far-Modell compiliert
ist, kann ein solches Programm niemals reentrant sein.
Davon abgesehen ist es wie gewohnt ablauff\"{a}hig.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}


\renewcommand{\baselinestretch}{0.8}

\renewcommand{\baselinestretch}{1}

\renewcommand{\baselinestretch}{0.8}

\renewcommand{\baselinestretch}{1}

\renewcommand{\baselinestretch}{0.8}

\renewcommand{\baselinestretch}{1}
\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example8208}%
\begin{example}
\noindent
Ein Beispiel:
\begin{verbatim}

M2LibLink +mf DemoLib\end{verbatim}
\noindent
Durch diesen Befehl wird die Library {\tt demo.library}, ein Schnittstellenmodul
{\tt txt/Demo.def} und die Beschreibung der Library {\tt demo\_lib.fd}
erzeugt.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example8246}%
\begin{example}
Beispiel: Ein Device soll gleich im richtigen Verzeichnis abgelegt
werden:
\begin{verbatim}

 M2LibLink -tdevs:myfirst.device MyFirstDev\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning8253}%
\begin{warning}
Da Libraries, Devices und Resources auf jedem Amiga lauff\"{a}hig sein m\"{u}ssen,
und das Betriebssystem keine Verwaltung unterschiedlicher Libraries
mit gleichen Namen vorsieht,
sollten diese Optionen m\"{o}glichst {\em nicht\/} benutzt und immer
Code f\"{u}r den MC68000-Prozessor erzeugt werden!
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{note8297}%
\begin{note}
Der Modulname des Schnittstellenmoduls ist immer der Name des Moduls
ohne die spezielle Endung. Man sollte darauf achten, dass kein
Modul doppelt vorhanden ist. Falls man etwa auf die Idee kommt, auch
ein Device namens ,,{\tt MyTest}`` zu erstellen, ist die Schnittstelle
{\tt MyTest.def} zweimal vorhanden, bzw.\ die alte wird gel\"{o}scht.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{note8309}%
\begin{note}
Der Library-Linker ben\"{o}tigt zum Arbeiten unbedingt die zugeh\"{o}rige
Referenz-Datei. Diese wird vom Compiler erzeugt, wenn die Option
,,{\tt d}`` gesetzt ist (Normalfall). In diesem Fall wird aber der erzeugte
Code nicht optimiert. Speziell f\"{u}r den Library-Linker bietet der Compiler
die Option ,,{\tt +@}``, die bewirkt, dass sowohl der Code optimiert, als
auch eine Referenz-Datei erzeugt wird. Eine dadurch erzeugte
Referenz-Datei ist aber {\em f\"{u}r den Debugger\/} ung\"{u}ltig, weil die
darin enthaltenen Relationen zwischen Programmz\"{a}hler und Quelltext-Position
nicht korrekt sind!
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example8314}%
\begin{example}
\begin{verbatim}

DEFINITION MODULE MyTestLib;

FROM ExecD IMPORT Library,List;

TYPE
  MyTestBasePtr = POINTER TO MyTestBase;
  MyTestBase = RECORD
    lib:Library; (* Pflicht! *)
    users:List (* z.B.: Liste der Benutzer *)
    ...
  END;

CONST
  version = 33; (* Pflicht! *)
  baseSize = SIZE(MyTestBase); (* Pflicht! *)
...
...
IMPLEMENTATION MODULE MyTestLib;
...
CONST
  revision = 10; (* Pflicht! *)
...\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript8322}%
\begin{ttscript}{LibExpunge}
\item[LibOpen] wird beim \"{O}ffnen der Library aufgerufen. Hier sollte
mindestens der in der Library-Struktur enthaltene \"{O}ffnungs-Z\"{a}hler erh\"{o}ht
und das Expunge-Flag gel\"{o}scht werden. Weitergehende Operationen sind
m\"{o}glich, aber nur bei einigen Libraries notwendig. Nach korrekter
Ausf\"{u}hrung wird im Register D0 die Basis der eigenen Library zur\"{u}ckgegeben,
im Fehlerfall enth\"{a}lt D0 den Wert 0 ({\tt NIL}).
\item[LibClose] wird beim Schliessen der Library aufgerufen. Sie muss
mindestens den \"{O}ffnungsz\"{a}hler erniedrigen und danach testen, ob er 0
ist, d.h.\ kein Prozess die Library ge\"{o}ffnet hat. In diesem Fall
muss bei gesetztem Expunge-Flag die nachfolgend beschriebene
Prozedur {\tt LibExpunge}
aufgerufen und deren Resultat zur\"{u}ckgegeben werden. In allen
anderen F\"{a}llen gibt man 0 zur\"{u}ck.
\item[LibExpunge] wird vom Betriebssystem aufgerufen, wenn die Library
komplett aus dem System entfernt werden soll, um Speicher frei zu machen.
Falls der \"{O}ffnungsz\"{a}hler nicht 0 ist, wird von
dieser Prozedur das Expunge-Flag gesetzt und 0 zur\"{u}ckgegeben,
andernfalls wird aufger\"{a}umt und die Library aus dem System entfernt.
Hierzu wird zun\"{a}chst die Basis aus der Library-Liste des Betriebssystems
entfernt, dann die Prozedur {\tt Arts.Terminate} aufgerufen,
welche die {\tt CLOSE}-Teile der Moduln
aufruft und somit auch alle ge\"{o}ffneten
Libraries schliesst. Daraufhin wird der von der Library-Struktur belegte
Speicher einschliesslich der Sprungliste freigegeben
--- zu beachten ist, dass die Exec-Library
nun bereits geschlossen ist --- und der Inhalt der Variablen
{\tt Arts.dosCmdBuf} im Register D0 zur\"{u}ckgeliefert. Diese Variable
enth\"{a}lt die sogenannte SegList der Library. Danach kann auch diese SegList
vom Betriebssystem wieder freigegeben werden.
\par\item[LibExtFunc] erf\"{u}llt keine Funktion. Sie ist f\"{u}r Erweiterungen
der Amiga-Entwickler vorgesehen und muss gegenw\"{a}rtig immer 0 zur\"{u}ckgeben.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript8332}%
\begin{ttscript}{Devexpunge}
\par\item[DevOpen] erh\"{a}lt im Register A1 einen Zeiger auf den zugeh\"{o}rigen
IORequest, in D0 die Nummer der Unit und in D1 die Flags. Hier muss
\"{a}hnlich wie bei Libraries verfahren werden, jedoch sind noch weitergehende
Operationen erforderlich. Die R\"{u}ckgabe des Resultates erfolgt hierbei indirekt
\"{u}ber den IORequest.
\par\item[DevClose] erh\"{a}lt in A1 einen Zeiger auf den zugeh\"{o}rigen IORequest.
Sie muss die zugeh\"{o}rige Unit schliessen und danach so verfahren
wie {\tt LibClose}, also unter Umst\"{a}nden auch die Prozedur
{\tt DevExpunge} aufrufen.
R\"{u}ckgabewert ist also ebenfalls 0 (NIL) oder die zugeh\"{o}rige SegList.
\par\item[DevExpunge] ist identisch mit {\tt LibExpunge}. Bei Devices sind aber
meist noch mehr ,,Aufr\"{a}umarbeiten`` erforderlich.
\par\item[DevExtFunc] ist f\"{u}r Erweiterungen reserviert und muss immer
0 zur\"{u}ckgeben.
\par\item[DevBeginIO] startet eine Ein- oder Ausgabe, die durch einen
{\tt IORequest} beschrieben ist, auf den Register A1 zeigt.
\par\item[DevAbortIO] bricht eine Ein- oder Ausgabe ab. Register A1
zeigt auf den zugeh\"{o}rigen {\tt IORequest}.
\par\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript8362}%
\begin{ttscript}{dosCmdBuf}
\item[dosCmdBuf] enth\"{a}lt die SegList, die bei der Initialisierung vom
Betriebssystem \"{u}bergeben wurde. Sie wird nur von der Expunge-Prozedur
ben\"{o}tigt.
\par\item[dosCmdLen] ist ein Flag f\"{u}r die Initialisierungsphase. Sie enth\"{a}lt
den Zeiger
auf die Library und wird von {\tt Arts.Startup} an Dos/Exec zur\"{u}ckgegeben.
Falls w\"{a}hrend der Initialisierung ein Fehler auftritt, m\"{u}ssen alle bis
dahin allozierten Dinge wieder freigegeben und {\tt dosCmdLen} auf Null gesetzt
werden. Die CLOSE-Teile aller beteiligten Module werden dann auf
jeden Fall auch aufgerufen! Diese sind {\em sehr sorgf\"{a}ltig und sicher\/}
zu programmieren!
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{note8382}%
\begin{note} ,,Guru`` bedeutet in der gegenw\"{a}rtigen Implementation:
{\tt ASSEMBLE(ILLEGAL END)}.
Der daraus resultierende ,,Guru`` wird von einem M2Amiga-Programm
selbstverst\"{a}ndlich abgefangen!
Man sollte also unbedingt sehr ,,sauber`` programmieren, da jeder
Laufzeitfehler zu einem Guru f\"{u}hrt. Nach dem ausf\"{u}hrlichen Testen
sollten alle Laufzeit-Tests abgeschaltet werden.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{warning8419}%
\begin{warning}
Nicht nur der Zugriff auf die globalen Variablen, sondern auch Aufrufe
an die importierten Libraries setzen ein korrekt initialisiertes
Register A4 voraus! Dies wird allzu leicht vergessen und f\"{u}hrt zum Guru!
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{warning8445}%
\begin{warning}
Die exportierten Library-Prozeduren d\"{u}rfen {\em auf keinen Fall\/} das
Register A6 als Parameter benutzen, sonst sind Abst\"{u}rze vorprogrammiert!
Devices und Resources hingegen {\em m\"{u}ssen} (zumindest im
Schnittstellen-Modul) f\"{u}r ihre exportierten Prozeduren das Register
A6 mit der eigenen Basis belegen.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{chapter}
\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{note9069}%
\begin{note}
 Genau wie f\"{u}r die Initialisierungsphase, w\"{a}hrend der die Modulr\"{u}mpfe
 aller importierten Moduln automatisch aufgerufen werden, wird auch
 f\"{u}r die  Close-Phase vom Compiler
 ein Aufruf an alle {\tt CLOSE}-Teile der
 importierten Moduln generiert. Durch die Art der Aufrufe mit Hilfe
 einer (versteckten) Z\"{a}hler-Variablen ist garantiert, dass tieferliegende
 Moduln nicht vor dem Hauptmodul geschlossen werden. Dadurch bleiben
 importierte Prozeduren auch w\"{a}hrend der  Close-Phase benutzbar.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning9072}%
\begin{warning}
Alle {\tt CLOSE}-Teile sollten sehr robust und mehrfach aufrufbar programmiert
sein! Es kann vorkommen, dass nach einem Programm-Absturz w\"{a}hrend
der  Close-Phase ein weiterer Laufzeitfehler auftritt. In diesem Fall
wird die Close-Phase erneut durchlaufen, was bei unsauberer Programmierung
zur unvollst\"{a}ndigen Betriebsmittel-Freigabe oder gar zu
einer endlosen Schleife f\"{u}hren kann!
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9075}%
\begin{example}
Beispiel:
\begin{verbatim}

IMPLEMENTATION MODULE Terminal;
IMPORT Arts,DosD,DosL;

CONST window="CON:0/0/640/100/out";

VAR out: DosD.FileHandlePtr;

BEGIN (* Hauptmodul *)
  out:=DosL.Open(ADR(window),DosD.newFile);
  Arts.Assert(out#NIL,ADR("Fehler: Dos.Open"));
CLOSE
  IF out <> NIL THEN
    DosL.Close(out);
    out:=NIL;
  END;
END Terminal.\end{verbatim}
Bei der Initialisierung des Moduls {\tt Terminal} wird ein Fenster ge\"{o}ffnet,
auf das \"{u}ber {\tt out} zugegriffen werden kann. Bei Programmende schliesst
der Close-Teil dieses Fenster wieder. Die Abfrage \verb*|out<>NIL| verhindert,
dass es {\em mehrfach\/} geschlossen werden kann, was zu einem Systemabsturz
f\"{u}hren w\"{u}rde. Das Modul {\tt DosL} ist noch benutzbar,
weil es erst geschlossen
wird, wenn kein anderes Modul es mehr ben\"{o}tigt.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example9108}%
\begin{example}
\begin{alltt}
\relax{} PROCEDURE ForwProc(i: INTEGER); FORWARD;
\\{\rm\ldots}
\\(* Aufruf von ForwProc innerhalb einer Prozedur *)
\\{\rm\ldots}
\\PROCEDURE ForwProc(i: INTEGER);
\\BEGIN
\\(* {\cmsltt{} Anweisungen} *)
\\END ForwProc;
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example9147}%
\begin{example}
Beispiel:
\begin{verbatim}

VAR
 p:ProcessPtr;
BEGIN
 p:=CAST(ProcessPtr,FindTask(NIL));
 Assert(p^.stackSize>4000,ADR("Zuwenig Stack"));\end{verbatim}
Neu ist erlaubt:
\begin{verbatim}

 Assert( CAST(ProcessPtr,FindTask(NIL))^.stackSize>4000,
   ADR("Zuwenig Stack"));\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{ebnf9153}%
\begin{ebnf}{Designator}
\item[Factor]
  {\tt NOT Factor \verb*'|' number \verb*'|' string \verb*'|' set
  \verb*'|' \dq(\dq\ Expression \dq)\dq\ \verb*'|' Designator.}
\item[Designator]
  {\tt qualident \{\dq.\dq ident \verb*'|' \dq[\dq\ ExpList \dq]\dq\
  \verb*'|' \dq\verb*'^'\dq\ \verb*'|' ActualParameter\}.}
\end{ebnf}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9775}%
$-2^{31}$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9777}%
$2^{31}-1$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9779}%
$2^{32}-1$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmldisplayA{displaymath9769}%
\begin{displaymath} x \mbox{~DIV~} y = q \quad:\quad q \le x / y \end{displaymath}%
\lthtmldisplayZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmldisplayA{displaymath9770}%
\begin{displaymath} x \mbox{~MOD~} y = r \quad:\quad 0 \le r < y \mbox{~f\"{u}r~} y > 0\mbox{~;~}
\   y < r \le 0 \mbox{~f\"{u}r~} y < 0 \end{displaymath}%
\lthtmldisplayZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmldisplayA{displaymath9771}%
\begin{displaymath} q \ast y + r = x \end{displaymath}%
\lthtmldisplayZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9781}%
$-1.0*10^{38}$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9783}%
$1.0*10^{38}$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9785}%
$-1.0*10^{308}$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9787}%
$1.0*10^{308}$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9789}%
$-1.0*10^{19}$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9791}%
$1.0*10^{19}$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{paragraph}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9793}%
$0$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline9795}%
$n+1$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9253}%
\begin{example}
Ein Beispiel:
\begin{alltt}
\relax{} PROCEDURE WriteS(s: ARRAY OF CHAR);
\\BEGIN
\\DosL.Write(file, ADR(s), Length(s))
\\END WriteS;
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{paragraph}
{\newpage\clearpage
\lthtmlfigureA{example9266}%
\begin{example}
Beispiel: Existiert bereits die konstante Zeichenkette ,,{\tt verschoben}``
im Konstantenbereich, wird eine neu zu vermerkende Zeichenkette
,,{\tt oben}`` {\em nicht\/} neu abgelegt, sondern nur ein Verweis
auf den f\"{u}r beide gemeinsamen Teil ,,{\tt oben}``
erzeugt. F\"{u}r die Zeichenketten ,,{\tt D\"{u}bel}`` und
,,{\tt \"{u}bel} m\"{u}ssen zwei Bereiche verwendet werden, da das Wort
,,{\tt D\"{u}bel}`` auf einer geraden Adresse liegt, und die so zu
bildende Teilzeichenkette ,,{\tt \"{u}bel}`` auf einer ungeraden Adresse zu
liegen k\"{a}me.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{paragraph}
\stepcounter{paragraph}
{\newpage\clearpage
\lthtmlfigureA{note9307}%
\begin{note}
Da diese Art der Codierung zu Inkompatibilit\"{a}ten f\"{u}hren kann, besteht die
M\"{o}glichkeit, durch die Compiler-Anweisung
\begin{displaymath}\verb*|(*$ CStrings:=FALSE *)|\end{displaymath}
die Interpretation des Backslash als einleitendes Sonderzeichen auszuschalten.
Danach werden alle Zeichenketten also wieder ganz normal behandelt.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9309}%
\begin{example}
\  Diese M\"{o}glichkeit kann unter Umst\"{a}nden
eine Menge Code sparen. Zum Beispiel kann die Anweisungsfolge
\begin{verbatim}

    WriteString("Zeile 1");
    WriteLn;
    WriteString("Zeile 2");
    WriteLn; WriteLn;\end{verbatim}
\noindent
durch die einzelne Anweisung
\begin{verbatim}

    WriteString("Zeile 1\nZeile 2\n\n");\end{verbatim}
\noindent
ersetzt werden.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmldisplayA{displaymath9803}%
\begin{displaymath}\verb*|WriteString("Eis\oWasser");|\end{displaymath}%
\lthtmldisplayZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{warning9375}%
\begin{warning}
Wird statt einer Typenkonversion ein Typentransfer mit {\tt CAST}
durchgef\"{u}hrt, wird der Wert {\em nicht\/} angepasst!
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example9397}%
\begin{example}
Beispiele:
\begin{verbatim}

CONST
  li = LONGINT{-50};
  r  = REAL{1.5};
  c  = Farbe{gruen};\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9411}%
\begin{example}
Beispiele:
\par\begin{alltt}
\relax{} CONST
\\\verb*|a1 = ADDRESS{ADR($VER: prog 1.0 32-Aug-1805\n)};|
\\a2 = {\cmsltt{} Typ}Ptr {ADR(GlobVar)}; (* Programm NICHT reentrant! *)
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning9417}%
\begin{warning}
Durch dieses Feature werden leicht Referenzen erzeugt, die
ein Programm nicht mehr reentrant werden lassen. Jede Referenz von
Nicht-MERGED auf MERGED verhindert reentrant! MERGED sind alle
globalen Variablen, wenn die Option {\tt LargeVars} nicht
gesetzt ist (Kommandozeilenoption {\tt -y}).
Sobald Konstanten mit Referenzen (aus {\tt ADR}) im Konstantenpuffer
abgelegt wurden wird die optimierende Ablage der
Zeichenketten abgeschaltet.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example9430}%
\begin{example}
Beispiele:
\begin{verbatim}

TYPE
  Color  = (red, green, blue, white);
  BigArr = ARRAY [5..100] OF INTEGER;
  ColArr = ARRAY Color    OF Color;
  Str80  = ARRAY [0..79]  OF CHAR;
CONST
  Big = BigArr {-1, -10, 5, 100, ..};
  Col = ColArr {blue, green, red, red};
  str = Str80  {"Text"};\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example9439}%
\begin{example}
Beispiele:
\begin{verbatim}

TYPE
  Rec1 = RECORD
    a, b: INTEGER;
    c: Color;
  END;
  Rec2 = RECORD
    hoehe: LONGCARD;
    CASE type: Color OF
    | red:   length: INTEGER;
    | green: next:   Color;
    | blue:  drink:  Alcoholics;
    | white: depth:  REAL;
    END;
  END;
CONST
  r1a = Rec1 {}; (* unsinnig, aber moeglich *)
  r1b = Rec1 {c: green,  a: 3, b: 5+6};
  r1c = Rec1 {c: white};
  r2a = Rec2 {hoehe: 4, type: white, depth: 7.8E8};
  r2b = Rec2 {type: green, next: red};\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example9448}%
\begin{example}
Beispiele:
\begin{verbatim}

  TYPE
    Str16 = ARRAY[0..16] OF CHAR;
    Rec = RECORD x:INTEGER; y:CHAR; str:Str16; END;
  CONST
    rec1 = Rec{y:"A", x:3, str:"Hallo"};
    rec2 = Rec{str:Str16{"H","A","L","L","O","\o",..}, x: 4};
    HexArray = Str16{"0123456789ABCDEF"};
  BEGIN
    char1 := rec1.y;
    char2 := HexArray[nr MOD 16];
    Proc(3, Rec{x:5, y:"Z", str: "Welcome"});\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example9463}%
\begin{example}
Beispiele:
\begin{verbatim}

VAR
  x, y: INTEGER; (* Normale Variablen, mit 0 vorbelegt. *)
  y   := LONGINT{-4};
  v   := rec1; (* siehe Beispiel oben *)
  w   := Rec{x:4, str: "abc"};\end{verbatim}
Weitere Beispiele sind im Demo-Programm Talker zu finden.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example9480}%
\begin{example}
\begin{alltt}
\relax{} VAR
\\buffer: ARRAY [0..8] OF TagItem;
\\...
\\buffer[0].tag:=waLeft; (* Konstante *)
\\buffer[0].data:=20;
\\...
\\buffer[5].tag:=waPubScreenFallBack;
\\buffer[5].data:=ADDRESS(TRUE);
\\buffer[6].tag:=waTitle;
\\buffer[6].data:=ADR(MyWindow);
\\buffer[7].tag:=waIDCMP;
\\buffer[7].data:=CAST(LONGINT,IDCMPFlagSet{...});
\\buffer[8].tag:=tagEnd;
\\(* Kennung: Feld ist zu Ende, data egal *)
\\...
\\win:=OpenWindowTagList(NIL,ADR(buffer));
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9502}%
\begin{example}
Beispiel:
\begin{verbatim}

  Format("Name: %s, Geschlecht: %lc, Alter: %03ld\n",
     TAG(buffer,ADR("Klaus Klaps"),sex,age));\end{verbatim}
ergibt die Ausgabe
\begin{verbatim}

   "Name: Klaus Klaps, Geschlecht: m, Alter: 021\n"\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example9539}%
\begin{example}
Zu Beginn gleich ein Beispiel, an dem die exakte Vorgehensweise
des Compilers erl\"{a}utert werden soll:
\begin{verbatim}

CONST
  (*$ DEFINE Demo:=TRUE *)
  (*$ IF Demo *)
    str = "Demo Version";
    (*$ DEFINE Help:=TRUE *)
  (*$ ELSE *)
    str = "Normale Version";
    Dies Zeile liefert keinen Syntaxfehler!
    (*$ DEFINE Help:=FALSE *)
  (*$ ENDIF *)\end{verbatim}
Falls von der Kommandozeile nichts Gegenteiliges bestimmt wurde (durch
,,\verb*|-oDemo|``), ist nach der ersten {\tt DEFINE}-Anweisung die Option
 ,,{\tt Demo}`` wahr.
Folglich f\"{a}llt der Test ,,{\tt IF Demo}`` positiv aus, die Konstante
{\tt str} erh\"{a}lt den Wert ,,Demo Version`` und eine neue Benutzer-Option
,,{\tt Help}`` wird definiert und mit dem Wert {\tt TRUE} initialisiert. Danach
trifft der Compiler auf die {\tt ELSE}-Anweisung und
unterbindet die Compilation.
Er \"{u}berliest folglich die zweite Deklaration von {\tt str} und den Text
,,Diese Zeile liefert\ldots`` --- der bei durchgef\"{u}hrter Compilation einige
Fehlermeldungen erzeugen w\"{u}rde \mbox{---,} und trifft auf eine weitere
Compiler-Anweisung, die ausgewertet werden muss; dies k\"{o}nnte ja das zugeh\"{o}rige
,,{\tt ENDIF}`` sein. Diese Anweisung wird nur syntaktisch \"{u}berpr\"{u}ft,
aber {\em nicht ausgef\"{u}hrt}. Andernfalls k\"{a}me die Fehlermeldung
,,\ldots doppelt definiert``)! Zum Schluss trifft er auf die Compiler-Anweisung
,,{\tt ENDIF}`` und schaltet die Compilation wieder ein.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9557}%
\begin{example}
\begin{verbatim}

(*$ IF FALSE *)
  (*$ EntryExitCode:=FALSE *)
  PROCEDURE DemoDaten;
  ...
  END DemoDaten;
(*$ ENDIF *)

PROCEDURE Normal;
...\end{verbatim}
St\"{u}nde die Compiler-Anweisung ,,EntryExit\ldots`` {\em vor\/}
der {\tt IF-}Anweisung,
w\"{u}rde die n\"{a}chste kompilierte Prozedur (,,{\tt Normal}``) ohne Eingangs-
und Ausgangscode erzeugt, was wahrscheinlich zu einem Programm-Absturz
f\"{u}hrte! Wenn es so wie oben angegeben geschrieben
wird, kann jedoch nichts passieren, da die Option {\tt EntryExitCode} nicht
ver\"{a}ndert wird, bzw. nur dann, wenn auch die Prozedur ,,{\tt DemoDaten}``
kompiliert und danach die Option wieder automatisch auf {\tt TRUE} gesetzt wird.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example9580}%
\begin{example}
Anhand einiger Beispiele soll dieser
Mechanismus nun etwas verst\"{a}ndlicher gemacht und verschiedene
M\"{o}glichkeiten aufgezeigt werden:
\begin{verbatim}

(*$ DEFINE German:=TRUE DEFINE English:=FALSE *)
(*$ DEFINE Debug:=FALSE *)
CONST
  (*$ IF german *) (* Benutzer-Option *)
    msg = "deutsche Version"
  (*$ ELSIF english *) (* Benutzer-Option *)
    msg = "english version"
  (*$ ELSE *)
    msg = "Cfsoe Qsfvtjoh"
  (*$ ENDIF *) ;
BEGIN
  ...
  (*$ IF Debug *)  (* Benutzer-Option *)
    FormatNr("Debug: Variable x ist: %ld\n",x);
  (*$ ENDIF *)
  ...
  (*$ IF LargeVars *) (* Compiler-Option *)
  MOVE.W myInteger,D0
  (*$ ELSE *)
  MOVE.W myInteger(A4),D0
  (*$ ENDIF *)
  ...
  (*$ IF NOT StackChk *) (* Compiler-Option *)
  Arts.StkChk(-25000);
  (*$ ENDIF *)
  ...
  (*$ DEFINE NonSens:= LongAlign AND NOT Debug *)
  (*$ IF nonsens *)
    (*$ IF NilChk AND m68020 *)
    TRAPEQ
    (*$ ELSIF NilChk *)
    BNE.S ok
    TRAP #13
   ok:
  (*$ ENDIF ENDIF *)
  (*$ IF NOT NoNSeNs *)
  WriteString("Zu einfach!\n"); Terminate;
  (*$ ENDIF *)\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{note9588}%
\begin{note} Der Compiler selbst macht
 zwischen dem 68020 und 68030 {\em keinen}
 Unterschied. Wenn Sie im Assembler keine speziellen Befehle dieser
 Prozessoren benutzen, sind die erzeugten Objektdateien identisch.
 \end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{warning9616}%
\begin{warning}
  Wenn Sie bei {\tt LONGREAL}-Berechnungen eine ,,saubere`` Verarbeitung,
  d.h.\ im Fehlerfall einen Programm-Abbruch w\"{u}nschen, m\"{u}ssen Sie
  das Modul {\tt FPUExc} (Seite \pageref{FPUExc}) importieren.
  Der einfache Import gen\"{u}gt,
  das Modul stellt jedoch noch weitergehende Prozeduren zur Steuerung
  der FPUs bereit.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example9632}%
\begin{example}
\begin{verbatim}

  VAR val : INTEGER;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9636}%
\begin{example}
\begin{verbatim}

  VAR reg0 {R.D0} : INTEGER;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9640}%
\begin{example}
\begin{verbatim}

  VAR vhposr [0DFF006H]: INTEGER;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9644}%
\begin{example}
\begin{verbatim}

  VAR myMenu [ < "Ext_Menu"]: Menu;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9648}%
\begin{example}
\begin{verbatim}

  VAR imageData ["Ext_ChipData"]: ARRAY ... ;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example9656}%
\begin{example}
Das folgende Beispiel zeigt auf extreme Weise
den Nutzen von Register-Variablen.
Die Prozedur ist bei eingeschalteter Optimierung (,,{\tt -d}``) genau 8 Byte
lang. Ohne Register-Variablen belegt sie 44 Byte
und ist sehr viel langsamer.
\begin{verbatim}

IMPORT R;
PROCEDURE Swap(VAR a{R.A0},b{R.A1}:LONGINT);
VAR temp{R.D0}:LONGINT;
BEGIN
  temp:=a; a:=b; b:=temp
END Swap;
(* erzeugter Code:  MOVE.L  (A0),D0
                    MOVE.L  (A1),(A0)
                    MOVE.L  D0,(A1)
                    RTS
*)\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example9677}%
\begin{example}
Beispiel:
\begin{quote}\tt   VAR absExecBase[4]:ExecBasePtr;
\end{quote}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example9698}%
\begin{example}
\begin{alltt}
\relax{} DEFINITION MODULE MyInOut;
\\
\\PROCEDURE WriteLn; CODE Terminal_WriteLn;
\\PROCEDURE WriteBin(nr:LONGINT);
\\
\\{\rm {} \ldots}
\\
\\END MyInOut.
\\\relax \end{alltt}\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example9711}%
\begin{example}
\begin{quote}\tt   DEFINITION MODULE IconL{\dq icon.library\dq,33};
\end{quote}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9719}%
\begin{example}
\begin{verbatim}

  ...
  IMPORT IntuitionL;
  VAR
    intuiBase: IntuitionBasePtr;
  BEGIN
    intuiBase:=ADR(IntuitionL);\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example9732}%
\begin{example}
\begin{verbatim}

  PROCEDURE GetDiskObject(name{8}:ADDRESS):DiskObjectPtr;
    CODE -78;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example9739}%
\begin{example}
\begin{verbatim}

  PROCEDURE AddTime(timer{14}:ADDRESS;
              dest{8},source{9}:TimeValPtr); CODE -42;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{section}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{note10945}%
\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.
\par\end{itemize}
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note10956}%
\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}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline22922}%
$ Debugger-Version$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\setcounter{footnote}{8}
{\newpage\clearpage
\lthtmlfigureA{ttscript11205}%
\begin{ttscript}{MRArts:}
\item[Arts:] Nichtresidentf\"{a}hige Vollversion
\item[RArts:] Residentf\"{a}hige Vollversion
\item[MArts:] Nichtresidentf\"{a}hige Minimalversion
\item[MRArts:] Residentf\"{a}hige Minimalversion
\item[DArts:] Nichtresidentf\"{a}hige Debugger-Version
\item[DRArts:] Residentf\"{a}hige Debugger-Version\footnotemark 
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example11233}%
\begin{example}
F\"{u}r das folgende Programmst\"{u}ck wird demnach nicht direkt der Maschinencode
der Multiplikation, sondern nur ein Prozeduraufruf erzeugt:
\begin{verbatim}

  VAR
    x, y, z: LONGINT;
  BEGIN
    z:=x*y;
    (*
     * Dies entspricht exakt der Anweisung
     * z:=Arts.Muls32(x,y);
     *)
  END\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example11259}%
\begin{example}
\begin{alltt}
\relax{} i:=2;
\\CASE i OF (* getesteter Ausdruck: i *)
\\| 1: Write('1'); (* kleinstes Label: 1 *)
\\| 3: Write('3'); (* grosstes Label: 3 *)
\\END;
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{note11280}%
\begin{note}
Es gibt eine Ausnahme, bei der eine ung\"{u}ltige Instruktion
nicht auf einen Fehler zur\"{u}ckzuf\"{u}hren ist:
Das Wort {\tt 4AFCH} (bin\"{a}r 0100101011111100) entspricht
dem ,,g\"{u}ltigen`` Befehl ,,{\tt ILLEGAL}``. Es ist das einzige
Bitmuster, das auch nach zuk\"{u}nftigen Erweiterungen der
MC680{\sl x\/}0-Familie ,,{\tt ILLEGAL}`` bleibt.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example11287}%
\begin{example}
\begin{alltt}
\relax{} VAR
\\i,j:INTEGER;
\\r,s:REAL;
\\{\rm {} \ldots}
\\i:=0; r:=0.0;
\\(*
\\* Folgende Anweisungen fuhren zum
\\* beschriebenen Laufzeitfehler
\\*)
\\j:=j DIV i;
\\j:=j / i;
\\j:=j MOD i;
\\j:=j REM i;
\\s:=s / r;
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{subsubsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline11445}%
$2^{15}$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example11316}%
\begin{example}
Beispiel:
\begin{alltt}
\relax{} VAR
\\a:ARRAY [0..5] OF INTEGER;
\\sub:[0..10];
\\i:INTEGER;
\\{\rm {} \ldots}
\\i:=11;
\\sub:=i;         (* Bereichsfehler, da  11 > MAX(sub) *)
\\sub:=-i;        (* Bereichsfehler, da -11 < MIN(sub) *)
\\i:=a[i];        (* Bereichsfehler, da kein a[11] *)
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example11323}%
\begin{example}
Beispiel:
\begin{alltt}
\relax{} VAR
\\i,j,k:INTEGER;
\\{\rm {} \ldots}
\\i:=30000;
\\j:=20000;
\\k:=-30000;
\\IF (i+j)<0 THEN {\rm {} \ldots} END; (* Uberlauf *)
\\IF (k-j)>0 THEN {\rm {} \ldots} END; (* Unterlauf *)
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
\stepcounter{section}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{figure11364}%
\begin{figure}\begin{center}

\begin{tabular}{l|c|cl|c|}
\         &            &\hfill &            &    \\
        & Parameter  &\hfill &            & \\\cline{2-2}
        & static link&\hfill &          & Parameter\\\cline{2-2} \cline{5-5}
        & return adr.&\hfill &  & return adr. \\\cline{2-2} \cline{5-5}
\framebox{\ \ \ \  A\bf Variablenparameter\ \ \ \ }5$\longrightarrow$\  & dynamic link &\hfill & \framebox{\ \ \ \  A\tt HIGH\ \ \ \ }5$\longrightarrow$\  & dynamic link \\\cline{2-2}\cline{5-5}
        &            &\hfill &             &  \\
        & lokale     &\hfill &             & lokale    \\
        & Variablen  &\hfill &             &  Variablen   \\\cline{2-2} \cline{5-5}
        &            &\hfill &             &      \\
        & gerettete  &\hfill &        &  gerettete \\
\framebox{\ \ \ \  A7\ \ \ \ }$\longrightarrow$\  & Register &\hfill & \framebox{\ \ \ \  A7\ \ \ \ }$\longrightarrow$\  & Register\\\cline{2-2} \cline{5-5}
        &          &\hfill &             &          \\
\multicolumn{5}{c}{\ } \\
\multicolumn{2}{c}{lokale Prozedur}&\hfill &\multicolumn{2}{c}{globale Prozedur}\\
\end{tabular}
\end{center}
\end{figure}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{warning11414}%
\begin{warning}
 Trotz des intensiven vom Compiler erzeugten Pr\"{u}fcodes ist es
 m\"{o}glich, dass ein Programm ,,abst\"{u}rzt`` und dabei systemeigenen
 Speicher zerst\"{o}rt! H\"{a}ufigste Ursache f\"{u}r derartige Fehler
 sind nicht-initialisierte Zeiger und Prozedurvariablen
 (z.B. lokale Variablen) oder
 der fehlerhafte Aufruf von Prozeduren des Betriebssystems.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example11420}%
\begin{example}
\begin{verbatim}

CONST
  Count = 1000000;

PROCEDURE RangeCheck;
VAR
  cnt: LONGINT;
  i: INTEGER;
  a: ARRAY[0..7] OF INTEGER;
BEGIN
  i:=5;
  FOR cnt:=0 TO Count DO
    (*$ RangeChk:=TRUE *)
    a[i]:=2;

        MOVE.W  -6(A5),D7
-->     CHK.W   #$0007,D7
        ASL.W   #1,D7
        LEA     -22(A5),A3
        MOVE.W  #$0002,0(A3,D7.W)

    (*$ POP RangeChk *)
  END;
END RangeCheck;

PROCEDURE RangeCheckLong;
VAR
  cnt,j: LONGINT;
  a: ARRAY[0..7] OF INTEGER;
BEGIN
  j:=5;
  FOR cnt:=1 TO Count DO
    (*$ RangeChk:=TRUE *)
    a[j]:=2;

        MOVE.L  -8(A5),D7
-->     CMPI.L  #$00000007,D7
-->     BLS.S   L000003
-->     TRAP    #14
  L000003:
        ASL.L   #1,D7
        LEA     -24(A5),A3
        MOVE.W  #$0002,0(A3,D7.L)

    (*$ POP RangeChk *)
  END;
END RangeCheckLong;

PROCEDURE OverflowCheck;
VAR
  i,cnt: LONGINT;
BEGIN
  i:=0;
  FOR cnt:=1 TO Count DO
    (*$ OverflowChk:=TRUE *)
    i:=i+1;

         MOVE.L   -4(A5),D7
         ADDQ.L   #1,D7
-->      TRAPV
         MOVE.L   D7,-4(A5)

    (*$ POP OverflowChk *)
  END;
END OverflowCheck;

(*$ StackChk:=TRUE *)
PROCEDURE StackCheck;
VAR
  a: ARRAY[0..99] OF LONGINT;
BEGIN

-->     MOVE.L   #$FFFFFE70,D0
-->     JSR      Arts_StkChk(PC)
        RTS

END StackCheck;
(*$ POP StackChk *)

PROCEDURE NilCheck;
VAR
  cnt,i: LONGINT;
  p: POINTER TO LONGINT;
BEGIN
  p:=ADR(i);
  FOR cnt:=1 TO Count DO
    (*$ NilChk:=TRUE *)
    p^:=3;

       MOVEA.L  -12(A5),A3
-->    MOVE.L   A3,D7
-->    BNE.S    L000010
-->    TRAP     #13
  L000010:
       MOVEQ    #3,D7
       MOVE.L   D7,(A3)

    (*$ POP NilChk *)
  END;
END NilCheck;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example11872}%
\begin{example}
\begin{verbatim}

  TYPE
    Tag = (mo, di, mi, do, fr, sa, so);
    Temperatur = [-50..100];
    Set = SET OF [0..7];\end{verbatim}
\noindent
Alle oben genannten Typen nehmen nur ein Byte in Anspruch
und folgen im Speicher unmittelbar aneinander.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example11876}%
\begin{example}
Der Typ
\begin{verbatim}

   ARRAY [0..0] OF CHAR;\end{verbatim}
\noindent
belegt also nur ein Byte ({\tt SIZE}=1). Ein Record-Element oder eine Variable
dieses Typs wird aber immer auf einer geraden Adresse liegen.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example11881}%
\begin{example}
Der Typ
\begin{verbatim}

   RECORD si:SHORTINT END;\end{verbatim}
\noindent
belegt hingegegen {\em zwei Byte}. Nach dem eigentlichen Datenbyte wird
{\em automatisch\/} ein sogenanntes ,,{\bf pad}``-Byte (F\"{u}llbyte) eingef\"{u}gt.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning11889}%
\begin{warning}
Aufgrund der eben erl\"{a}uterten Fakten ist es unm\"{o}glich, dass innerhalb eines
Records zwei strukturierte Elemente mit ungerader Gr\"{o}sse direkt
 aufeinanderfolgen. Es wird immer ein F\"{u}llbyte dazwischen liegen.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline11925}%
$n$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example11898}%
\begin{example}
\begin{verbatim}

  VAR                      rel. Adresse
  (*$ LongAlign:=FALSE *)
    i:INTEGER;                 2..3
    c:CHAR;                    4
    s:SHORTINT;                5
    a:ARRAY[0..2] OF CHAR;     6..8
    l:LONGINT;                10..13
  (*$ LongAlign:=TRUE *)
    i:INTEGER;                16..17
    l:LONGINT;                20..23
    a:ARRAY[0..2] OF CHAR;    24..26
    c:CHAR;                   28
    s:SHORTINT;               32\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example11902}%
\begin{example}
\begin{verbatim}

  DEFINITION MODULE Demo;
  VAR                      rel. Adresse
  (*$ LongAlign:=FALSE *)
    c:CHAR;                    2
  END Demo.

  IMPLEMENTATION MODULE Demo;
  (*$ LongAlign:=FALSE *)
  VAR
    s:SHORTINT;                3\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example11910}%
\begin{example}
\begin{verbatim}

  VAR                      rel. Adresse zu A5
    i:INTEGER;                 -2..-1
    c:CHAR;                    -3
    s:SHORTINT;                -4
    a:ARRAY[0..2] OF CHAR;     -8..-6
    k:SHORTCARD;               -9
    l:LONGINT;                 -14..-11\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsubsection}
{\newpage\clearpage
\lthtmlfigureA{example11919}%
\begin{example}
Das Beispiel einer globalen Prozedur:
\begin{verbatim}

  PROCEDURE Demo(         rel. Adresse
       arr:ARRAY OF CHAR     18..21 und 22..25
         s:SHORTINT;         16
         b:BOOLEAN;          14
         i:INTEGER;          12..13
     VAR c:CHAR);             8..11\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{chapter}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{ebnf12155}%
\begin{ebnf}{A}
\item[A] {\tt B\,C.} \\
  Diese Regel besagt, dass {\tt A} durch die Folge {\tt B\,C} ersetzt
  werden soll.
\item[A] {\tt B\,\verb*'|'\,C.} \\
  {\tt A} soll durch {\tt B} oder {\tt C} ersetzt werden.
\item[A] {\tt [B].} \\
  {\tt A} soll durch {\tt B} ersetzt oder weggelassen werden.
\item[A] {\tt\{B\}.} \\
  {\tt A} soll durch eine Folge von 0, 1 oder mehreren {\tt B}
  ersetzt werden.
\item[A] {\tt\dq ARRAY [0..31] OF CHAR\dq.} \\
  {\tt A} besteht aus einer Zeichenkette von 32 Buchstaben.
\item[A] {\tt\dq INTEGER(7)\dq.} \\
  {\tt A} besteht aus der Konstanten 7, wobei in der
  Datei gleich viel Platz wie f\"{u}r einen {\tt INTEGER} verwendet wird,
  in diesem Fall also 2 Byte. \\
\end{ebnf}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\setcounter{filefmt}{1}
{\newpage\clearpage
\lthtmlfigureA{ebnf12188}%
\begin{ebnf}
% latex2html id marker 12188
{NumBlocks}
\item[Datei] {\tt ID NumBlocks \{Block\} [Name].} \hfill(\arabic{filefmt}\stepcounter{filefmt})
\item[ID] {\tt\dq LONGINT(17)\dq.} \hfill(\arabic{filefmt}\stepcounter{filefmt})
\item[NumBlocks] {\tt\dq INTEGER\dq.}
  \hfill(\arabic{filefmt}\stepcounter{filefmt}) \\
  Dieser Wert enth\"{a}lt die Anzahl der folgenden Bl\"{o}cke. 
\item[Block] {\tt Size(CodeId \verb*'|' DataId) \{Word\}.}
  \hfill(\arabic{filefmt}\stepcounter{filefmt})
\item[Size] {\tt\dq LONGINT\dq.} \hfill(\arabic{filefmt}\stepcounter{filefmt}) \\
  Die Gr\"{o}sse des folgenden Blocks ohne die {\tt CodeId} bzw.
  {\tt DataId}. 
\item[CodeId] {\tt\dq INTEGER(1)\dq.} \hfill(\arabic{filefmt}\stepcounter{filefmt})
\item[DataId] {\tt\dq INTEGER(2)\dq.} \hfill(\arabic{filefmt}\stepcounter{filefmt})
\item[Word] {\tt\dq INTEGER\dq.} \hfill(\arabic{filefmt}\stepcounter{filefmt})
\item[Name] {\tt\dq ARRAY [0..7] OF CHAR\dq.}
  \hfill(\arabic{filefmt}\stepcounter{filefmt})
\end{ebnf}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript12272}%
\begin{ttscript}{CODE, BSS}
\item[{\cmsltt modul}] ist jeweils durch den Modulnamen zu ersetzen.
\item[{\cmsltt nr}] ist eine interne Prozedurnummer. Da diese Prozeduren nicht
 exportiert sind, sollten sie auch nicht durch fremden Code angesprochen
 werden k\"{o}nnen!
\item[{\cmsltt version}] ist die Version der Library als Dezimalzahl.
\item[{\cmsltt xxx\ldots}] steht f\"{u}r den Modul-Schl\"{u}ssel, der als 12stellige
 Hexadezimalzahl aus dem Zeitpunkt der Compilation des Definitionsmoduls
 erzeugt wird.
\item[CODE, BSS] muss jeweils bei entsprechender, 
eingeschalteter Compileroption
durch CHIPCODE bzw.\ CHIPBSS ersetzt werden.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example12279}%
\begin{example}
\noindent
Ein Implementations-Modul ,,Demo`` k\"{o}nnte beispielsweise folgende
Linker-Symbole exportieren:
\begin{itemize}
\item ,,Demo\_Init`` ist eine im Definitionsmodul
  angegebene Prozedur {\tt Init}.
\item ,,Demo\$3`` bezeichnet eine interne (nicht exportierte) Prozedur.
\item ,,Demo\_123456789ABC`` kennzeichnet den Beginn des Hauptmoduls.
\item ,,Demo\_END`` kennzeichnet den CLOSE-Teil des Hauptmoduls. Dies
Symbol liegt mit Demo\_123\ldots im selben Hunk.
\item ,,Demo\_BY`` sind die konstanten Zeichenketten in einem CODE-Hunk.
\item ,,Demo\_VAR`` bestimmt den Beginn der globalen Variablen im BSS-Hunk
\end{itemize}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline23073}%
$ Bezeichnerkontrolle$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\setcounter{footnote}{1}
{\newpage\clearpage
\lthtmlfigureA{ebnf12285}%
\begin{ebnf}{ReferenceFile}
\item[ReferenceFile]
  {\ttREFFILE ModAnchor \{ModAnchor\} \\
  \{ObjList ModTag \verb*'|' ObjList ProcTag\} \\
  ObjList RefTag.}
\item[ObjList]
  {\tt\{Structure \verb*'|' Component \verb*'|' Object \verb*'|' Linkage \verb*'|' PC-Block\}.}
\item[Structure]
  {\ttEnum \verb*'|' Range \verb*'|' Pointer \verb*'|' Set \verb*'|' ProcTyp \verb*'|' FuncTyp \verb*'|'
  Array \verb*'|' DynArray \verb*'|' Record \verb*'|' Opaque.}
\item[Component]
  {\ttParRef \verb*'|' Par \verb*'|' Field.}
\item[Object]
  {\ttVarRef \verb*'|' Var \verb*'|' Constant \verb*'|' Type \verb*'|' Procedure \verb*'|' Function \verb*'|'
  Module \verb*'|' Code.}
\item[PC-Block]
  {\ttPCPos SourcePos.}
\item[ModAnchor]
  {\ttBYTE(0H) key name modmode [libname].} \\
  Der Wert ,,{\ttlibname}``
  erscheint, wenn ,,{\ttmodmode}`` den Wert ,,{\ttLIB}`` hat.
\item[ModTag]
  {\ttBYTE(1H) ModNo.}
\item[ProcTag]
  {\ttBYTE(2H) ProcNo.}
\item[RefTag]
  {\ttBYTE(3H) adr pno.} \\
  ,,{\ttadr}`` bezeichnet die Adresse, von welcher an die Variablen des
  Implementationsmoduls alloziert werden d\"{u}rfen. \\
  ,,{\ttpno}`` bezeichnet die Anzahl der deklarierten Prozeduren.
\item[Linkage]
  {\ttBYTE(4H) StrRef BaseRef.} \\
  Der Zeigertyp ,,{\ttStrRef}`` zeigt auf den Typ
  ,,{\ttBaseRef}``.
\item[Enum]
  {\ttBYTE(10H) size NoConst.} \\
  ,,{\ttsize}`` bezeichnet die Anzahl der Byte, die f\"{u}r eine
  Variable dieses Typs ben\"{o}tigt wird. Dies gilt auch f\"{u}r die
  n\"{a}chsten neun Eintr\"{a}ge. \newline
  Die Anzahl der Elemente in diesem Aufz\"{a}hlungstyp wird durch ,,{\ttNoConst}``
  angegeben.
\item[Range]
  {\ttBYTE(11H) size BaseRef min max sign.} \newline
  ,,{\ttBaseRef}`` bezeichnet den Grundtyp dieses Unterbereichtyps. \newline
  ,,{\ttmin}`` ist die untere Bereichsgrenze, ,,{\ttmax}`` die obere. \newline
  ,,{\ttsign}`` gibt an, ob es sich um einen vorzeichenbehafteten Typ
  handelt oder nicht.
\item[Pointer]
  {\ttBYTE(12H) size.}
\item[Set]
  {\ttBYTE(13H) size BaseRef.} \newline
  ,,{\ttBaseRef}`` bezeichnet den Elementtyp dieses Mengentyps.
\item[ProcTyp]
  {\ttBYTE(14H) size.}
\item[FuncTyp]
  {\ttBYTE(15H) size ResRef.} \newline
  Der Resultatstyp dieser Prozedur steht in ,,{\ttResRef}``.
\item[Array]
  {\ttBYTE(16H) size ElemRef IndexRef.} \newline
  ,,{\ttElemRef}`` gibt den Elementtyp dieses Feldes. \newline
  ,,{\ttIndexRef}`` bezeichnet den Indextyp.
\item[DynArray]
  {\ttBYTE(17H) size ElemRef.} \\
  ,,{\ttElemRef}`` enth\"{a}lt den Elementtyp des Feldes.
\item[Record]
  {\ttBYTE(18H) size.}
\item[Opaque]
  {\ttBYTE(19H) size.}
\item[BPointer]
  {\ttBYTE(1AH) size.}
\item[ParRef]
  {\ttBYTE(20H) StrRef parmode name.} \\
  ,,{\ttStrRef}`` bezeichnet den Typ des Parameters. \\
  ,,{\ttparmode}`` ist 0, falls es sich um einen Parameter handelt, der auf
  dem Stack \"{u}bergeben wird. Andernfalls hat ,,{\ttparmode}`` einen Wert
  zwischen 1 und 8 f\"{u}r die Datenregister D0 -- D7 oder
  zwischen 9 und 17 f\"{u}r die Adressregister A0 -- A7. \\
  ,,{\ttname}`` enth\"{a}lt den Namen des Parameters. Dieser Name ist leer,
  wenn das Definitionsmodul ohne
  Bezeichnerkontrolle\footnotemark 
  compiliert wurde, oder es sich um ein Schnittstellenmodul handelt.
\item[Par]
  {\ttBYTE(21H) StrRef parmode name.} \\
  mit den analogen Bedeutungen wie bei ,,{\ttParRef}``.
\item[Field]
  {\ttBYTE(22H) StrRef offset name.} \\
  ,,{\ttStrRef}`` gibt den Typ dieses Record-Elementes an. \\
  ,,{\ttoffset}`` ist die Adresse des Feldes relativ
  zur Anfangsadresse des Records. \\
  ,,{\ttname}`` ist der Name des Feldes. \\
\item[VarRef]
  {\ttBYTE(30H) StrRef level address varmode [extname] name exported.} \\
  ,,{\ttStrRef}``: Typ dieser Variable. \\
  ,,{\ttlevel}`` gibt die Schachtelungstiefe der Prozedur an, in der
  diese Variable deklariert wurde; f\"{u}r globale Variablen
  ist dieser Wert 0. \\
  ,,{\ttaddress}`` enth\"{a}lt die Adresse dieser Variablen, die genaue
  Bedeutung muss dem folgenden Wert entnommen werden. \\
  ,,{\ttvarmode}`` kennt folgende Werte:
  \begin{itemize}
  \item[0:] globale Variable im \near-Modell, ,,{\ttaddress}`` bezeichnet
    den Offset
  \item[1:] absolute Variable, ,,{\ttaddress}`` ist die Absolut-Adresse
  \item[2:] Register-Variable, ,,{\ttaddress}`` enth\"{a}lt die Registernummer
  \item[3:] globale Variable im \far-Modell, ,,{\ttaddress}`` bezeichnet den
    Offset
  \item[4:] externe Variable ({\tt[\dq{\cmsltt Name\/}\dq]}), ,,{\ttaddress}``
    enth\"{a}lt den F\"{u}llwert 0, die Variable wird absolut adressiert
  \item[5:] externe Variable im \near-Modell
    ({\tt[<\dq{\cmsltt Name\/}\dq]}), ,,{\ttaddress}``
    enth\"{a}lt den F\"{u}llwert 0, die Variable wird A4-relativ
    adressiert.
  \end{itemize}
  ,,{\ttextname}`` ist der externe Name, unter der diese Variable vom Linker
  gesucht wird. Dieses Feld ist nur im Fall von externen Variablen
  vorhanden (,,{\ttvarmode}`` = 4 oder ,,{\ttvarmode}`` = 5).
  ,,{\ttname}`` ist der Name der Variablen.
  ,,{\ttexported}`` schliesslich gibt an, ob die Variable exportiert
  wird.
\item[Var]
  {\ttBYTE(31H) StrRef level address varmode [extname] name exported.} \\
  Der Aufbau ist analog zu den Feldern von ,,{\ttVarRef}``.
\item[Constant]
  {\ttBYTE(32H) StrRef ModRef value name exported.} \\
  ,,{\ttStrRef}``, ,,{\ttname}`` und ,,{\ttexported}``
  siehe ,,{\ttVarRef}``. \\
  ,,{\ttModRef}`` ist die Nummer des Moduls, in der diese
  Konstante deklariert wurde. \\
  ,,{\ttvalue}`` gibt den Wert der Konstante. \\
\item[String]
  {\ttBYTE(33H) StrRef string name exported.} \\
  ,,{\ttstring}`` enth\"{a}lt den Text dieser Zeichenkettenkonstante. \\
\item[Type]
  {\ttBYTE(34H) StrRef ModRef name exported.}
\item[Procedure]
  {\ttBYTE(35H) ProcNo level address size registers name exported.} \\
  ,,{\ttProcNo}`` ist die Nummer der Prozedur. \\
  ,,{\ttlevel}`` bezeichnet die Schachtelungstiefe der Prozedur,
  wobei globale Prozeduren den {\ttlevel} 0 haben. \\
  ,,{\ttaddress}`` ist die Adresse der Prozedur. \\
  ,,{\ttsize}`` gibt an, wieviel Platz die lokalen Variablen ben\"{o}tigen. \\
  ,,{\ttregisters}`` ist ein {\ttBITSET}, der die als Parameter verwendeten
  Register markiert.
\item[Function]
  {\ttBYTE(36H) ResRef ProcNo level address size registers name exported.} \\
  ,,{\ttResRef}`` ist der Resultatstyp der Funktion, die anderen Elemente
  sind wie bei ,,{\ttProcedure}``.
\item[Module]
  {\ttBYTE(37H) ModNo name exported.} \\
  ,,{\ttModNo}``: Nummer dieses lokalen Moduls.
\item[Code]
  {\ttBYTE(38H) cnum name exported.}` \\
  ,,{\ttcnum}`` gibt den Offset dieser CODE-Prozedur.
\item[CodeFunc]
  {\ttBYTE(39H) ResRef cnum name exported.} \\
  ,,{\ttResRef}`` ist der Resultatstyp dieser CODE-Funktion.
\item[REFFILE]
  {\ttSYMFILE \verb*'|' REF68000 \verb*'|' REF68010 \verb*'|' REF68020
  \verb*'|' REF68030 \verb*'|' REF68040 \verb*'|' REF68881
  \verb*'|' REFNoPC.}
\item[SYMFILE]
  {\ttLONGINT(10).}
\item[REF68000]
  {\ttLONGINT(10).}
\item[REF68010]
  {\ttLONGINT(11).}
\item[REF68020]
  {\ttLONGINT(12).}
\item[REF68030]
  {\ttLONGINT(13).}
\item[REF68040]
  {\ttLONGINT(14).}
\item[REF68881]
  {\ttLONGINT(18).}
\item[REFNoPC]
  {\ttLONGINT(19).} \\
  Dieser Wert wird f\"{u}r Referenzdateien {\emohne\/} PC-Informationen
  vergeben (Option ,,{\tt+@}``). Die Datei kann nur f\"{u}r den
  Library-Linker und den Profiler
  verwendet werden.
\item[key]
  {\ttARRAY [0..2] OF INTEGER.}
\item[name]
  {\ttstring.}
\item[string]
  {\ttlength \{char\}.} \\
  ,,{\ttlength}`` zeigt die L\"{a}nge der Zeichenkette an.
\end{ebnf}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example12405}%
\begin{example}
\begin{table}[h]
\begin{tabular}{rrl}
Zahl & Codierung (Hex) & Codierung (bin\"{a}r) \\\hline
5 & 05 & 0000 0101 \\
-5 & 3B & 0011 1011 \\
40 & C128 & 1100 0001 0010 1000 \\
300 & 412C & 0100 0001 0010 1100 \\
-300 & 7ED4 & 0111 1110 1101 0100 \\
65236 & C20ED4 & 1100 0010 0000 1110 1101 0100 \\
\end{tabular}
\end{table}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ebnf12453}%
\begin{ebnf}{SourcePos}
\item[ErrorFile]
  {\tt ERRFILE \{Error\}. End}
\item[Error]
  {\tt ErrorPos \{ErrorPart\}.}
\item[ErrorPos]
  {\tt ERR SourcePos.}
\item[ErrorPart]
  {\tt ErrorNum \verb*'|' String.}
\item[ErrorNum]
  {\tt INTEGER.} \\
  Nur positive Zahlen sind zugelassen.
\item[String]
  {\tt STR \{CHAR\}.} 
\item[SourcePos]
  {\tt LONGINT.}
\item[ERRFILE]
  {\tt LONGINT(3).}
\item[ERR]
  {\tt LONGINT(0C1457272H).}
\item[STR]
  {\tt CHAR(0C2H).}
\item[End]
  {\tt INTEGER(-1).}
\end{ebnf}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{ebnf12471}%
\begin{ebnf}{MessageFile}
\item[MessageFile]
  {\tt\{Message\} End.}
\item[Message]
  {\tt Next Number String.}
\item[Next]
  {\tt LONGINT.} \\
  Adresse der n\"{a}chsten Fehlermeldung relativ zum Dateianfang.
\item[Number]
  {\tt INTEGER.} \\
  Fehlernummer.
\item[String]
  {\tt\{CHAR\}.} \\
  Der Fehlertext, abgeschlossen mit einem 0C-Zeichen.
  Die n\"{a}chste Meldung muss auf einer geraden Adresse liegen; dazu
  wird unter Umst\"{a}nden ein weiteres 0C-Zeichen eingef\"{u}gt.
\item[End]
  {\tt LONGINT(0) INTEGER(0).}
\end{ebnf}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{note13151}%
\begin{note}
% latex2html id marker 13151

   Beim Umstellen vorhandener Moduln auf die Version 4.0 des Compilers ist
   in diesem Punkt besondere Vorsicht geboten. Alte {\tt INLINE}-Prozeduren
   d\"{u}rfen nicht einfach eins zu eins umgesetzt, sondern m\"{u}ssen entsprechend
   angepasst werden. Bitte lesen Sie hierzu den Abschnitt \"{u}ber den
   Assembler (\ref{refAsm} ab Seite \pageref{refAsm}), insbesondere
   Abschnitt \ref{refINLASS}!
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example13171}%
\begin{example}
Am Beispiel eines Inputhandlers wollen wir nun versuchen, dies alles
etwas verst\"{a}ndlicher zu machen:
\par\begin{verbatim}

IMPORT R; (* Register-Konstanten! *)
...
TYPE
  MyDataPtr = POINTER TO MyData;
  MyData = RECORD
    qualifier: QualifierSet;
    code:CARDINAL;
    oldA4:ADDRESS;
  END;
VAR
  intr: ExecD.Interrupt;
  handlerData: MyData;
  ...
   handlerData.oldA4:=SYSTEM.REG(R.A4);
   intr.code:=ADR(Handler);
   intr.data:=ADR(handlerData);
  ...
PROCEDURE Handler(events{R.A0}:EventPtr;
                  data{R.A1}:MyDataPtr):EventPtr;
(*$ SaveA4:=TRUE *)
BEGIN
  ASSEMBLE(
    MOVE.L MyData.oldA4(A1),A4
  END);
  (* oder: ... SETREG(R.A4,data^.oldA4) *)
  ...
  RETURN ...;
END Handler;\end{verbatim}
Nun k\"{o}nnte man nat\"{u}rlich meinen, ein InputHandler ben\"{o}tige keinen Zugriff
auf die globalen Daten, aber wie gesagt: die Libraries werden {\em auch\/}
via A4 addressiert; und ein solcher Handler wird mit ziemlicher Sicherheit
die eine oder andere Exec-Funktion aufrufen!
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example13188}%
\begin{example}
Ein Beispiel, bei dem der Compiler ohne die angegebene Option
einen Fehler melden wird:
\begin{verbatim}

  PROCEDURE Val():LONGINT;
  END Val;
  PROCEDURE Reg0(val1{R.D0},val2{R.D6}:LONGINT);
  END Reg0;
  ...
  (*$ StackParms:=TRUE *)
  Reg0(Val(),Val());
  (*$ POP StackParms *)
  ...\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example13194}%
\begin{example}
\begin{verbatim}

   TYPE writeProc = PROCEDURE(CHAR{0});
   PROCEDURE Min(a{7},b{6}: INTEGER):INTEGER;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning13220}%
\begin{warning}
Ein anderes ,,Problem`` stellen lokale Prozeduren dar. Sie haben
zwar korrekten Zugriff auf die Registerparameter der weiter aussen liegenden
Prozeduren, doch weil sich {\em jede\/} Prozedur an den Register-Standard
halten muss, bleiben Zuweisungen an {\em zu rettende\/} Register ausserhalb
dieser lokalen Prozedur wirkungslos, weil beim Verlassen
derselben die urspr\"{u}nglichen Werte wiederhergestellt werden m\"{u}ssen!
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example13224}%
\begin{example}
 Ein Beispiel zu den Register-Parametern:
\begin{verbatim}

PROCEDURE Demo(b{2}: BOOLEAN; li{3}: LONGINT;
               adr{10B}: ADDRESS;
               lr1{4}, lr2{20B}: LONGEAL)\end{verbatim}
\parbox[t]{3.5cm}{\sloppy Die Register sind folgendermassen belegt:}\hfill
\begin{tabular}{lll}
Variable & Register & Typ \\\hline
b & D2 & {\tt BOOLEAN}\\
li & D3 & {\tt LONGINT} \\
lr1 & D4, D5 & {\tt LONGREAL} \\
adr & A0 & {\tt ADDRESS} \\
lr2 & FP0 & {\tt LONGREAL} \\
\end{tabular}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example13241}%
\begin{example}
Durch die Deklaration
,,\verb*|VAR i{2}:INTEGER;|`` wird eine Re\-gis\-ter-Va\-ria\-ble im Register
D2 vom Typ {\tt INTEGER} angelegt.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example13258}%
\begin{example}
Ein Beispiel, bei dem die Option ,,Volatile:=FALSE`` zu fehlerhaftem
Programmverhalten f\"{u}hrt:
\begin{verbatim}

VAR
 scr:IntuitionD.ScreenPtr;
 win:IntuitionD.WindowPtr;
 height:INTEGER;
 ...
 win^.screen:=scr;
 ...
 size:=scr^.height; (* scr wird in Register gemerkt *)
 CloseScreen(win^.screen);  (* win^.screen = scr *)
 win^.screen:=NIL;          (* aber Register unver"andert *)
 IF scr#NIL THEN            (* Alter Wert im Register wird *)
  CloseScreen(scr);         (* getestet => Fehler *)
 END;\end{verbatim}
Die Zuweisung \verb*|win^.screen:=NIL| ver\"{a}ndert indirekt (f\"{u}r den Compiler
unbemerkt) die Variable {\tt scr}!
Da die Variable {\tt scr} bereits benutzt wurde, ist sie
in einem Register und der neue Inhalt wird in der
{\tt IF}-Anweisung nicht aus dem
Speicher geladen, somit wird {\tt CloseScreen} nochmals ausgef\"{u}hrt,
was zu einem --- schwierig zu findenden ---
Programmfehler f\"{u}hrt.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{chapter}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example13578}%
\begin{example}
Beispiele:
{\tt Dieser Text }\ldots
,,{\tt Dieser}`` wird zur\"{u}ckgegeben.
{\tt Dies``mal ist's`` besser}
,,{\tt Diesmal ist's}`` wird zur\"{u}ckgegeben.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note13584}%
\begin{note}
% latex2html id marker 13584

AMScan ist eine Variante des Moduls Scan (\ref{Scan}),
die urspr\"{u}nglich nur intern
(z.B.\ im Compiler) verwendet wurde.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example13597}%
\begin{example}
So zeigt
\begin{quote} \tt dir \dq all\dq \end{quote}
den Inhalt des Verzeichnisses ,,{\tt all}``, w\"{a}hrend
\begin{quote} \tt dir all \end{quote}
den gesamten Verzeichnisbaum des aktuellen Verzeichnisses
ausgibt.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{warning13619}%
\begin{warning}
Verwenden Sie diese Prozeduren und Variablen nur, wenn Sie genau
wissen, welchem Zweck sie dienen! Jede Fehlmanipulation kann zu
unvorhersehbaren Resultaten f\"{u}hren.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{note13651}%
\begin{note}
Auf dem Amiga hat das Steuerzeichen ``line feed`` ({\tt lf}) die Funktion
des Zeilenendes ({\tt eol}).
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note13655}%
\begin{note}
Das Zeichen ``command sequence introducer`` ({\tt csi}) ist
kein ASCII-Kontrollzeichen, sondern ein spezielles
Bildschirmsteuerungs-Zeichen, das oft in Kontroll-Sequenzen
wie f\"{u}r die Ausgabe auf das {\tt RAW:}-Device ben\"{o}tigt
wird.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note13659}%
\begin{note}
Es existiert {\em keine\/} Objektdatei zum Modul ASCII.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline23218}%
$
Meldungen$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\setcounter{footnote}{3}
{\newpage\clearpage
\lthtmlfigureA{warning13672}%
\begin{warning}
Ein asynchroner Programm-Abbruch kann zum Sy\-stem-Ab\-sturz f\"{u}hren, wenn
das Programm zur Zeit auf ausstehende
Meldungen\footnotemark  wartet.
Man sollte in
diesem Fall kurzzeitig durch {\ttRemoveException} die M\"{o}glichkeit
ausschalten! Der durch
{\ttInstallException} installierte Handler kann nur das Warten auf Dos-Signale
\"{u}berpr\"{u}fen und in diesem Fall den Wunsch des Benutzers nach Abbruch
ignorieren.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{section}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example13732}%
\begin{example}
\begin{alltt}
\relax{} str:=03F9;
\\large:=3000000000; \hfill{} (* $>2^{31}$ *)
\\StrToVal(str,number,signed,16,err);
\\(* number: 1017
\\signed: FALSE
\\err:    FALSE *)
\\StrToVal(str,number,signed,10,err);
\\(* number: {\rm {} undefiniert}
\\signed: {\rm {} undefiniert}
\\err:    TRUE {\rm {} Zeichenkette fur Basis 10 ungultig} *)
\\StrToVal(large,number,signed,16,err);
\\(* number: -1294967296
\\signed: FALSE (* {\rm {} Ursprungszahl war positiv} *)
\\err:    FALSE *)
\\
\\ValToStr(27,FALSE,str,8,5,'*',err);
\\(* str: `***33'
\\err: FALSE *)
\\ValToStr(45054,FALSE,str,16,-10,' ',err);
\\(* str: `AFFE      '
\\err: FALSE *)
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note13741}%
\begin{note}
Die interne Darstellung (Zweierkomplement) der
Zahl {\tt 3'000'000'000} ({\tt LONGCARD}) ist gleich
der internen Darstellung der Zahl {\tt -1'294'967'296}
({\tt LONGINT}).
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{ttscript13790}%
\begin{ttscript}{xx}
\item[\%E] Escape Zeichen ({\tt ASCII.esc}).
\item[\%N] Neue Zeile ({\tt ASCII.eol}).
\item[\%T] Tabulator ({\tt ASCII.ht}).
\item[\%\%] wird als ein einzelnes Prozentzeichen weitergegeben.
\item[\%d] Tag als zweistellige Ziffer mit f\"{u}hrender 0.
\item[\%m] Monat als zweistellige Zahl mit f\"{u}hrender 0.
\item[\%t] Monat als Text. Die Monatsnamen werden
  dem Parameter {\tt monthText} entnommen.
  {\tt monthtext} muss dazu zw\"{o}lf Worte enthalten,
  die durch ein ,,{\verb*/|/}`` voneinander
  getrennt sind und die Namen der Monate Januar bis Dezember enthalten.
  Zwei m\"{o}gliche Zeichenketten f\"{u}r {\tt monthText} sind
  in den Konstanten {\tt month}
  und {\tt month3} enthalten.
\item[\%y] Einer- und Zehnerstelle des Jahrs als
  zweistellige Zahl mit f\"{u}hrender 0.
\item[\%Y] Jahr als vierstellige Zahl.
\item[\%H] Stunde als zweistellige Zahl mit f\"{u}hrender 0.
\item[\%M] Minute als zweistellige Zahl mit f\"{u}hrender 0.
\item[\%S] Sekunde als zweistellige Zahl mit f\"{u}hrender 0.
\item[\%1] Zehntelsekunde als einstellige Zahl mit f\"{u}hrender 0.
\item[\%2] Hundertstelsekunde als zweistellige Zahl mit f\"{u}hrender 0.
\item[\%3] Tausendstelsekunde als dreistellige Zahl mit f\"{u}hrender 0.
\item[{\rm\ldots}]
\item[\%6] Millionstelsekunde als sechsstellige Zahl mit f\"{u}hrender 0.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example13803}%
\begin{example}
Beispiele: Das Beispiel nimmt an,
dass die aktuelle Zeit 22 Uhr 33 Minuten
21.423178 Sekunden und das Datum der 25. Juli 1989 ist.
\par\begin{verbatim}

 DateToStr(di,"Date: %d. %t %Y  Time: %H:%M:%S.%3%N",
   month,str);
 WriteString(str);
 DateToStr(di,"%Y%m%d%H%M/cn%N","",str);
 WriteString(str)
 DateToStr(
  di,"Der Name dieses Monats beginnt mit einem %t.%N",
  "J|F|M|A|M|J|J|A|S|O|N|D",str
 );
 WriteString(str)\end{verbatim}
\par Die Ausgabe dieser Programmzeilen ist:
\par\begin{verbatim}

 Date: 25 July 1989  Time: 22:33:21.423
 198907252233/cn
 Der Name dieses Monats beginnt mit einem J.\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example13837}%
\begin{example}
Der Aufruf sieht typischerweise so aus:
\par\begin{verbatim}

  IF AllesKlarZumAbheben THEN
    DetachNorm("con:0/20/400/100/Test/CLOSE/AUTO", "");
    Hauptprozedur();
  END;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{warning13850}%
\begin{warning}
{\tt FileHandle}s und {\tt Lock}s, die mit Prozeduren dieses Moduls erzeugt
 werden, d\"{u}rfen  auch nur mit diesen wieder
 freigegeben werden.
\par Solche, die mit Prozeduren des Moduls {\tt DosL}
 erzeugt wurden, d\"{u}rfen nur mit Prozeduren von {\tt DosL} wieder
 freigegeben werden.
\par Bei Nichtbeachtung dieser Regeln muss mit einem unerwarteten
 Besuch des Gurus gerechnet werden.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example13897}%
\begin{example}
\begin{alltt}
\relax{} r:=12.976;
\\RealToStr(r,str,5,2,FALSE,err);
\\(* str: `12.98'
\\err: FALSE *)
\\RealToStr(r,str,4,2,FALSE,err);
\\(* str: `13.0'
\\err: FALSE *)
\\RealToStr(r,str,3,2,FALSE,err);
\\(* str: ` 13'
\\err: FALSE *)
\\RealToStr(r,str,2,2,FALSE,err);
\\(* str: `13'
\\err: FALSE *)
\\RealToStr(r,str,1,2,FALSE,err);
\\(* str: {\rm {} undefiniert}
\\err: TRUE *)
\\RealToStr(r,str,-8,2,FALSE,err);
\\(* str: `12.98   '
\\err: FALSE *)
\\RealToStr(r,str,10,2,TRUE,err);
\\(* str: `  1.30E+01'
\\err: FALSE *)
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example13924}%
\begin{example}
Aufruf:
\begin{alltt}
\relax{} VAR
\\f: File;
\\p: StrPtr;
\\{\rm\ldots}
\\ResponseText(f.res, p);
\\WriteString(p^); WriteLn;
\\{\rm\ldots}
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note13930}%
\begin{note}
{\tt ResponseText} weist dem Parameter {\tt p} die
Adresse der Zeichenkette im Konstantenbereich zu. Daher
darf diese Zeichenkette nicht ver\"{a}ndert werden! Die Zeichenkette
darf auch nicht auf 256 Zeichen aufgef\"{u}llt werden.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example13937}%
\begin{example}\begin{verbatim}

ReadFileName(fname, len, Terminal.Read, noEcho);
Benutzereingabe: df1:exec/sym/Alerts.sym <RETURN>
fname="df1:exec/sym/Alerts.sym"; len=23;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example13977}%
\begin{example}
\\VAR
\\f: file; ch: CHAR;
\\BEGIN
\\Lookup(f, '{\cmsltt{} Datei\/}', 1024, FALSE);
\\Assert(f.res=done, ADR('Lookup misslungen!');
\\LOOP
\\ReadChar(f, ch);
\\IF f.eof OR (f.res<>done) THEN
\\EXIT
\\END;
\\Bearbeite(ch)
\\END;
\\(* Close auf jeden Fall aufrufen *)
\\Close(f)
\\END
\\\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{ttscript14020}%
\begin{ttscript}{ReadByteBlock}
\item[ReadBytes]
  Da {\tt ReadBytes} die Anzahl der gelesenen Byte immer
  angibt, k\"{o}nnen beim Dateiende zwei F\"{a}lle auftreten:
  \begin{enumerate}
  \item
    In der Datei sind zwischen einem und Blockgr\"{o}sse
    Byte bis zum Dateiende vorhanden. Diese werden in den
    Block eingelesen und die aktuelle L\"{a}nge wird entsprechend gesetzt.
    \begin{quote} \tt     eof = FALSE \\
    res = done
    \end{quote}
  \item
    Die Datei wurde bereits vollst\"{a}ndig gelesen. Das Dateiende
    ist erreicht, {\tt eof} ist wahr und der Lesezugriff ist
    erfolgreich.
    \begin{quote} \tt     eof = TRUE \\
    res = done
    \end{quote}
  \end{enumerate}
\item[ReadByteBlock]
  Die Prozedur {\tt ReadByteBlock} kennt keine M\"{o}glichkeit, unvollst\"{a}ndige
  Bl\"{o}cke anzuzeigen. Dadurch ergibt sich ein von {\tt ReadBytes}
  unterschiedliches Verhalten:
  \begin{enumerate}
  \item
    In der Datei sind zwischen einem und Blockgr\"{o}sse-1 Byte
    bis zum Dateiende vorhanden. Ein unvollst\"{a}ndiger
    Block ist jedoch kein g\"{u}ltiges Resultat dieser
    Operation, der Inhalt des Blocks ist undefiniert.
    \begin{quote} \tt     eof = FALSE \\
    res = notdone
    \end{quote}
  \item
    Das Dateiende wurde bereits vollst\"{a}ndig gelesen. Das Dateiende
    ist erreicht, {\tt eof} ist wahr und der Lesezugriff ist erfolgreich.
    \begin{quote} \tt     eof = TRUE \\
    res = done
    \end{quote}
  \end{enumerate}
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{section}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{warning14116}%
\begin{warning}
Greifen Sie nie auf einen Zeiger zu, dessen Speicherbereich nicht
alloziert oder bereits dealloziert wurde! Ein Absturz ist damit
garantiert! Verwenden Sie {\tt Storage} (Seite \pageref{Storage})
anstelle von {\tt Heap},
wenn Sie keine Ausnahmebehandlungen vorsehen wollen.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note14121}%
\begin{note}
Aus Gr\"{u}nden der Portabilit\"{a}t sollte --- wenn m\"{o}glich --- {\tt Allocate}
der Prozedur {\tt AllocMem} vorgezogen werden.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline14691}%
$\le$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note14171}%
\begin{note}
Solange Ein- und Ausgabe nicht explizit umgelenkt wurde --- durch
einen Aufruf
von {\tt OpenInput} oder {\tt OpenOutput} --- wird diese \"{u}ber
das Modul {\tt Terminal} abgewickelt. F\"{u}r Informationen
\"{u}ber die im Modul {\tt Terminal} verwendeten Ein- und Ausgabekan\"{a}le
muss im Abschnitt Terminal, Seite \pageref{Terminal},
nachgeschlagen werden.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note14178}%
\begin{note}
W\"{a}hrend Sie {\tt INTEGER}-Werte durch die gleiche
Prozedur wie {\tt LONGINT}-Werte schreiben
k\"{o}nnen, wird f\"{u}r deren Eingabe eine eigene Prozedur
ben\"{o}tigt. Dies kommt daher, dass bei Variablen-Parameter
die formalen und die aktuellen Parameter typenkompatibel
sein m\"{u}ssen. {\tt INTEGER} und {\tt LONGINT}
sind jedoch nur zuweisungskompatibel.
Die analoge Einschr\"{a}nkung gilt auch f\"{u}r die Typen
{\tt CARDINAL} und {\tt LONGCARD}.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note14186}%
\begin{note}
Um die Wahl zwischen Ausgabe auf den Bildschirm oder auf Datei
w\"{a}hlbar zu halten, sollte nach dem Aufruf von {\tt OpenOutput}
unbedingt die Variable {\tt termCh} abgefragt werden. Enth\"{a}lt
die Variable {\tt termCh} das Nullzeichen ({\tt0C}), wurde ein
leerer Name eingegeben. Das Programm sollte dann normal fortgesetzt
werden.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example14199}%
\begin{example}
Beispiel: Es soll ein Code erzeugt werden
mit Menu-Nummer 3 und der MenuItem-Nummer 4.
Die SubItem-Nummer wird nicht gebraucht und soll 0 sein.
\par\begin{quote}\tt code:=ShiftMenu(3)+ShiftItem(4);
\end{quote}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{section}
\stepcounter{section}
{\newpage\clearpage
\lthtmldisplayA{displaymath14693}%
\begin{displaymath} 1 rad = \frac{180^{\circ}}{\pi} \end{displaymath}%
\lthtmldisplayZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline14695}%
$e$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning14243}%
\begin{warning}
Funktionsaufrufe mit Argumenten, deren Resulatswert nicht definiert
ist --- beispielsweise Quadratwurzeln oder Logarithmen negativer
Zahlen --- f\"{u}hren zum Abbruch des Programms.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example14245}%
\begin{example}
Beispiele f\"{u}r aufbauende Funktionen:
\begin{verbatim}

PROCEDURE tan(x:REAL):REAL;
BEGIN
 RETURN sin(x)/cos(x)
END tan;

PROCEDURE log(x:REAL):REAL;
BEGIN
 RETURN ln(x)/ln(10)
END log;

PROCEDURE Rad2Angle(rad:REAL):REAL;
BEGIN
 RETURN rad*180.0/pi
END Rad2Angle;

PROCEDURE Angle2Rad(angle:REAL):REAL;
BEGIN
 RETURN angle*pi/180.0
END Angle2Rad;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example14265}%
\begin{example}
Beispiel f\"{u}r einen Modulaufbau einer m\"{o}glichst
portablen Applikation:
\begin{alltt}
\relax{} MODULE mlffp;
\\
\\FROM MathLibFFP IMPORT  (* !! *)
\\e, pi,
\\sqrt, exp, ln, sin, cos, arctan;
\\
\\TYPE REAL = FFP;         (* !! *)
\\
\\VAR
\\r1, r2: REAL;
\\
\\BEGIN
\\{\rm\ldots}
\\\relax \end{alltt}
Im obigen Beispiel m\"{u}ssen nur die beiden mit
{\tt (* !! *)} markierten Zeilen ge\"{a}ndert werden,
falls der Typ {\tt FFP} nicht vorhanden ist.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{warning14281}%
\begin{warning}
Funktionsaufrufe mit Argumenten, deren Resulatswert nicht definiert
oder zu gross sind --- beispielsweise {\tt sqrt(-1.0)} oder
{\tt exp(720.0)} --- f\"{u}hren {\em nicht\/} zum Programmabbruch.
Es wird mit falschen Werten weitergerechnet.
\par Ein Abbruch in diesen F\"{a}llen ist nur m\"{o}glich,
wenn Sie einen 6888x-Coprozessor haben.
Dann gen\"{u}gt ein blosser Import des Moduls {\tt FPUExc}
(Seite \pageref{FPUExc}).
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline23259}%
$ lassen.<tex2html_comment_mark>222$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\setcounter{footnote}{4}
{\newpage\clearpage
\lthtmlfigureA{note14288}%
\begin{note}
% latex2html id marker 14288

Falls sie eine FPU (6888x-Coprozessor) besitzen, k\"{o}nnen sie
obenstehende Funktionen auch direkt durch diese ausf\"{u}hren lassen.%%
\footnotemark 
Verwenden Sie dabei die entsprechenden Funktionen aus dem
Pseudomodul {\ttSYSTEM}, beschrieben im Abschnit \ref{SysMod},
Seite \pageref{SysMod}.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example14310}%
\begin{example}
\noindent
Einige Beispiele:
\begin{verbatim}

  IMPORT R;

  SYSTEM.SETREG(R.D1,longintval)
  longintval:=SYSTEM.REG(R.D5)
  SYSTEM.SAVEREGS({R.D0,R.D1,R.A0,R.A1});

  PROCEDURE float(longr{R.FP3}:LONGREAL;
                  VAR val{R.A0}:SHORTINT);

  VAR bool{R.D7}:BOOLEAN;\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example14321}%
\begin{example} \tt wurf:=1+RND(6);
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
\stepcounter{section}
\stepcounter{section}
\stepcounter{section}
\stepcounter{section}
\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{example14392}%
\begin{example}
\begin{alltt}
\relax{} CONST
\\halloWelt = Hallo Welt;
\\(*
\\Nun gilt folgende Gleichung:
\\Length(halloWelt) = SIZE(halloWelt)
\\*)
\\\relax \end{alltt}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmldisplayA{displaymath14709}%
\begin{displaymath} 0 \le {\tt Length(\cmsltt string\/\tt )} \le
{\tt HIGH(\cmsltt string\/\tt )} + 1 \end{displaymath}%
\lthtmldisplayZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note14426}%
\begin{note}
Da auch f\"{u}r Werteparameter {\em keine\/} lokalen Kopien erstellt
werden, sind Kopien innerhalb einer Zeichenkette problematisch:
\par\begin{example}
\begin{alltt}
\relax{} MODULE showString;
\\
\\IMPORT Terminal,String;
\\
\\VAR s1,s2,s3: ARRAY [0..15] OF CHAR;
\\
\\BEGIN
\\s1:=012345; s2:=abcdef; s3:=ABCDEF;
\\String.Copy(s1,s1);
\\String.CopyPos(s2,s2,3);
\\String.Concat(s3,s3);
\\Terminal.WriteString(s1);
\\Terminal.WriteLn;
\\Terminal.WriteString(s2);
\\Terminal.WriteLn;
\\Terminal.WriteString(s3);
\\Terminal.WriteLn;
\\END showString.
\\
\\\relax \end{alltt}
\par Obiges Programm ergibt folgende Ausgabe:
\begin{alltt}
\relax{} 012345
\\abcabcabcabcabc
\\ABCABCABCABCABC
\\\relax \end{alltt}
\par Die Prozeduren {\tt CopyPos} und {\tt Concat} kopieren die Zeichenkette
solange weiter, bis in der Zielzeichenkette der vorhandene Platz
aufgebraucht ist. Dies kommt daher, dass das abschliessende Nullzeichen
der Ursprungskette gleichzeitig das Abschlusszeichen der Zielkette ist;
letzteres wird aber mit der ersten Kopieraktion \"{u}berschrieben.
\end{example}
\par\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlfigureA{warning14519}%
\begin{warning}
Durch die Pufferung ergibt sich ein Problem: Sollen Zeichen auf dem
Bildschirm ausgegeben werden ---  ohne dass die aktuelle
Zeile beendet wird ---,
die der Bediener sofort sehen soll, so muss danach ein Aufruf an die Funktion
\begin{quote} \tt Flush \end{quote}
erfolgen, damit der Pufferinhalt ausgegeben wird.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline14711}%
$\backslash$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{ttscript14572}%
\begin{ttscript}{x}
\item[d] stellt den Wert als Dezimalzahl dar.
\item[x] stellt den Wert als Hexadezimalzahl dar.
\item[c] stellt den Wert als einzelnes Zeichen dar. Hier muss der Wert
\   aber immer in einem Wort oder Langwort stehen!
\item[s] nimmt den Wert als Adresse einer mit 0C abgeschlossenen
\   Zeichenkette.
Hier spielt die Angabe ,,l`` keine Rolle.
\item[\%\%] ergibt das Prozentzeichen.
\end{ttscript}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example14575}%
\begin{example}
\noindent
Ein Beispiel:
\begin{verbatim}

  Rec.longint:=10;
  Rec.integer:=51;
  Rec.cardinal:=ORD("y");
  Rec.stringadr:=ADR("LMNOPQRST");
  Rec.longcard:=123;
  Format("ABC%03lx,%-3d%%,%2c,%3.3s%ldEnde\n",ADR(Rec));
  -->  "ABC00A,51 % , y,LMN123Ende"
       mit anschliessendem Zeilenvorschub.\end{verbatim}
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{subsection}
{\newpage\clearpage
\lthtmlfigureA{example14599}%
\begin{example}
\begin{verbatim}

PROCEDURE Ja(text: ARRAY OF CHAR):BOOLEAN;
VAR ch:CHAR;
BEGIN
  WriteString(text);
  Read(ch);
  RETURN CAP(ch)="J"
END Ja;\end{verbatim}
\noindent In diesem Beispiel bleiben einige Zeichen im Eingabestrom
zur\"{u}ck, mindestens das Zeilenendezeichen ({\tt ASCII.eol}), die beim
n\"{a}chsten Lesen zur\"{u}ckgeliefert werden. Eine
bessere (weil sicherere) Variante dieser Funktion s\"{a}he folgendermassen
aus:
\begin{verbatim}

PROCEDURE Ja(text: ARRAY OF CHAR):BOOLEAN;
VAR
  l: INTEGER;
  str: ARRAY[0..3] OF CHAR;
BEGIN
  WriteString(text);
  ReadLn(str,l);
  RETURN CAP(str[0])="J"
END Ja;\end{verbatim}
\noindent
Diese Funktion liest eine ganze Zeile ein. Der Benutzer kann mit einem
einfachen \keyret{} die Frage verneinen, oder mit \key{j}\keyret{} die
Frage bejahen. Jede Zeichenkette, die mit ,,j`` oder ,,J`` beginnt
gilt als Zustimmung. ,,Jein`` w\"{u}rde somit als ,,Ja`` interpretiert.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline23281}%
$ Neuerung.<tex2html_comment_mark>233$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

\setcounter{footnote}{6}
{\newpage\clearpage
\lthtmlfigureA{note14615}%
\begin{note}
Der Name des Fensters muss mit angegeben werden! Dies ist
gegen\"{u}ber alten Versionen eine Neuerung.%%
\footnotemark 
Hierdurch ist es aber auch m\"{o}glich, den gew\"{u}nschten Screen
unter Kickstart 2.0 in der Fensterbeschreibung mit anzugeben
also beispielsweise
\begin{quote}\tt
WINDOW=CON:0/0/640/150/Prog/AUTO/CLOSE/SCREENPubScr
\end{quote}
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{example14620}%
\begin{example}
\noindent
Zum Beispiel findet ein Programm ,,Demo`` in der Ikone den Eintrag
\begin{verbatim}

  WINDOW=CON:0/0/640/200/Demo-Window\end{verbatim}
\noindent
dann wird dadurch das Fenster
\begin{verbatim}

  CON:0/0/640/200/Demo-Window\end{verbatim}
\noindent
ge\"{o}ffnet.
\end{example}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note14626}%
\begin{note}
F\"{u}r besondere Anwendungen ist es auch m\"{o}glich, andere Ein- und Ausgabekan\"{a}le
zu verwenden. Dabei ist zu beachten, dass Ein- und Ausgabe \"{u}ber den gleichen
Kanal abgewickelt werden.
\begin{example}
\begin{verbatim}

   WINDOW=AUX:
   WINDOW=SER:\end{verbatim}
\  usw.
\end{example}
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{warning14634}%
\begin{warning}
Diese Implementation des Moduls Terminal ist f\"{u}r die Verwendung von
Konsolenfenstern und sequentiellen Dateien bei Ein- und Ausgabeumlenkung
konzipiert. Darum ist es m\"{o}glich, dass unter bestimmten Umst\"{a}nden
(z.B. RAW: als Ein- Ausgabekanal) nicht alle Funktionen exakt der
Beschreibung folgen.
\end{warning}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{section}
{\newpage\clearpage
\lthtmlinlinemathA{tex2html_wrap_inline14715}%
$=$%
\lthtmlinlinemathZ
\lthtmlcheckvsize\clearpage}

{\newpage\clearpage
\lthtmlfigureA{note14682}%
\begin{note}
Das er\"{o}ffnete Fenster hat keine IDCMPFlags und somit
auch keinen Reply-Port. Mit der Prozedur
{\tt IntuitionL.ModifyIDCMP} kann dem Fenster ein Port zugewiesen
werden.
\end{note}%
\lthtmlfigureZ
\lthtmlcheckvsize\clearpage}

\stepcounter{chapter}
\stepcounter{section}
\stepcounter{section}
\stepcounter{subsection}
\stepcounter{subsection}
\stepcounter{subsection}

\end{document}
