.SH
2.3 Keywords
.SH
-\f5asm\fP
+\f(CWasm\fP
.PP
-The keyword \f5asm\fP
+The keyword \f(CWasm\fP
is recognized.
However, the statement
.DS
-.ft 5
+.ft CW
asm(string);
.ft R
.DE
is skipped, while a warning is given.
.SH
-\f5enum\fP
+\f(CWenum\fP
.PP
-The \f5enum\fP keyword is recognized and interpreted.
+The \f(CWenum\fP keyword is recognized and interpreted.
.SH
-\f5entry\fP, \f5fortran\fP
+\f(CWentry\fP, \f(CWfortran\fP
.PP
-The words \f5entry\fP and \f5fortran\fP
+The words \f(CWentry\fP and \f(CWfortran\fP
are reserved under the restricted option.
The words are not interpreted by the compiler.
.SH
2.4.1 Integer Constants
.PP
The type of an integer constant is the first of the corresponding list
-in which its value can be represented. Decimal: \f5int, long, unsigned long\fP;
-octal or hexadecimal: \f5int, unsigned, long, unsigned long\fP; suffixed by
-the letter L or l: \f5long, unsigned long\fP.
+in which its value can be represented. Decimal: \f(CWint, long, unsigned long\fP;
+octal or hexadecimal: \f(CWint, unsigned, long, unsigned long\fP; suffixed by
+the letter L or l: \f(CWlong, unsigned long\fP.
.SH
2.4.3 Character Constants
.PP
-A character constant is a sequence of 1 up to \f5sizeof(int)\fP characters
+A character constant is a sequence of 1 up to \f(CWsizeof(int)\fP characters
enclosed in single quotes.
The value of a character constant '$c sub 1 c sub 2 ... c sub n$'
is $d sub n + M \(mu d sub {n - 1} + ... + M sup {n - 1} \(mu d sub 2 + M sup n \(mu d sub 1$,
-where M is 1 + maximum unsigned number representable in an \f5unsigned char\fP,
+where M is 1 + maximum unsigned number representable in an \f(CWunsigned char\fP,
and $d sub i$ is the signed value (ASCII)
of character $c sub i$.
.SH
The compiler is capable of producing EM code for machines with the following
properties
.IP \(bu
-a \f5char\fP is 8 bits
+a \f(CWchar\fP is 8 bits
.IP \(bu
-the size of \f5int\fP is equal to the word size
+the size of \f(CWint\fP is equal to the word size
.IP \(bu
-the size of \f5short\fP may not exceed the size of \f5int\fP
+the size of \f(CWshort\fP may not exceed the size of \f(CWint\fP
.IP \(bu
-the size of \f5int\fP may not exceed the size of \f5long\fP
+the size of \f(CWint\fP may not exceed the size of \f(CWlong\fP
.IP \(bu
-the size of pointers is equal to the size of either \f5short\fP, \f5int\fP
-or \f5long\fP
+the size of pointers is equal to the size of either \f(CWshort\fP, \f(CWint\fP
+or \f(CWlong\fP
.LP
.SH
4 What's in a name?
.SH
-\f5char\fP
+\f(CWchar\fP
.PP
-Objects of type \f5char\fP are taken to be signed.
-The combination \f5unsigned char\fP is legal.
+Objects of type \f(CWchar\fP are taken to be signed.
+The combination \f(CWunsigned char\fP is legal.
.SH
-\f5unsigned\fP
+\f(CWunsigned\fP
.PP
-The type combinations \f5unsigned char\fP, \f5unsigned short\fP and
-\f5unsigned long\fP are supported.
+The type combinations \f(CWunsigned char\fP, \f(CWunsigned short\fP and
+\f(CWunsigned long\fP are supported.
.SH
-\f5enum\fP
+\f(CWenum\fP
.PP
-The data type \f5enum\fP is implemented as described
+The data type \f(CWenum\fP is implemented as described
in \fIRecent Changes to C\fP (see appendix A).
.I Cem
-treats enumeration variables as if they were \f5int\fP.
+treats enumeration variables as if they were \f(CWint\fP.
.SH
-\f5void\fP
+\f(CWvoid\fP
.PP
-Type \f5void\fP is implemented.
+Type \f(CWvoid\fP is implemented.
The type specifies an empty set of values, which takes no storage space.
.SH
\fRFundamental types\fP
.PP
The names of the fundamental types can be redefined by the user, using
-\f5typedef\fP.
+\f(CWtypedef\fP.
.SH
7 Expressions
.PP
.SH
7.2 Unary operators
.PP
-The type of a \f5sizeof\fP expression is \f5unsigned int\fP.
+The type of a \f(CWsizeof\fP expression is \f(CWunsigned int\fP.
.SH
7.13 Conditional operator
.PP
.SH
8.2 Type specifiers
.PP
-The combinations \f5unsigned char\fP, \f5unsigned short\fP
-and \f5unsigned long\fP are implemented.
+The combinations \f(CWunsigned char\fP, \f(CWunsigned short\fP
+and \f(CWunsigned long\fP are implemented.
.SH
8.5 Structure and union declarations
.PP
.PP
Fields are left adjusted by default; the first field is put into the left
part of a word, the next one on the right side of the first one, etc.
-The \f5-Vr\fP option in the call of the compiler
+The \f(CW-Vr\fP option in the call of the compiler
causes fields to be right adjusted within a machine word.
.PP
The tags of structs and unions occupy a different name space from that of
.PP
The type of \fIexpression\fP in
.DS
-.ft 5
-\f5switch (\fP\fIexpression\fP\f5)\fP \fIstatement\fP
+.ft CW
+\f(CWswitch (\fP\fIexpression\fP\f(CW)\fP \fIstatement\fP
.ft
.DE
must be integral.
-A warning is given under the restricted option if the type is \f5long\fP.
+A warning is given under the restricted option if the type is \f(CWlong\fP.
.SH
10 External definitions
.PP
.SH
12 Compiler control lines
.PP
-Lines which do not occur within comment, and with \f5#\fP as first
+Lines which do not occur within comment, and with \f(CW#\fP as first
character, are interpreted as compiler control line.
There may be an arbitrary number of spaces, tabs and comments (collectively
-referred as \fIwhite space\fP) following the \f5#\fP.
+referred as \fIwhite space\fP) following the \f(CW#\fP.
Comments may contain newline characters.
-Control lines with only white space between the \f5#\fP and the line separator
+Control lines with only white space between the \f(CW#\fP and the line separator
are skipped.
.PP
-The #\f5include\fP, #\f5ifdef\fP, #\f5ifndef\fP, #\f5undef\fP, #\f5else\fP and
-#\f5endif\fP control lines and line directives consist of a fixed number of
+The #\f(CWinclude\fP, #\f(CWifdef\fP, #\f(CWifndef\fP, #\f(CWundef\fP, #\f(CWelse\fP and
+#\f(CWendif\fP control lines and line directives consist of a fixed number of
arguments.
The list of arguments may be followed an arbitrary sequence of characters,
in which comment is interpreted as such.
-(I.e., the text between \f5/*\fP and \f5*/\fP is skipped, regardless of
-newlines; note that commented-out lines beginning with \f5#\fP are not
+(I.e., the text between \f(CW/*\fP and \f(CW*/\fP is skipped, regardless of
+newlines; note that commented-out lines beginning with \f(CW#\fP are not
considered to be control lines.)
.SH
12.1 Token replacement
text are replaced by a space character.
.PP
The actual parameters of a macro are considered tokens and are
-balanced with regard to \f5()\fP, \f5{}\fP and \f5[]\fP.
+balanced with regard to \f(CW()\fP, \f(CW{}\fP and \f(CW[]\fP.
This prevents the use of macros like
.DS
-.ft 5
+.ft CW
CTL([)
.ft
.DE
list of that macro.
.PP
A message is given at the definition of a macro if the macro has
-already been #\f5defined\fP, while the number of formal parameters differ or
+already been #\f(CWdefined\fP, while the number of formal parameters differ or
the replacement texts are not equal (apart from leading and trailing
white space).
.PP
Recursive use of macros is detected by the compiler.
.PP
-Standard #\f5defined\fP macros are
+Standard #\f(CWdefined\fP macros are
.DS
-\f5__FILE__\fP name of current input file as string constant
-\f5__DATE__\fP curent date as string constant; e.g. \f5"Tue Wed 2 14:45:23 1986"\fP
-\f5__LINE__\fP current line number as an integer
+\f(CW__FILE__\fP name of current input file as string constant
+\f(CW__DATE__\fP curent date as string constant; e.g. \f(CW"Tue Wed 2 14:45:23 1986"\fP
+\f(CW__LINE__\fP current line number as an integer
.DE
.PP
No message is given if \fIidentifier\fP is not known in
.DS
-.ft 5
+.ft CW
#undef \fIidentifier\fP
.ft
.DE
.SH
12.3 Conditional compilation
.PP
-The #\f5if\fP, #\f5ifdef\fP and #\f5ifndef\fP control lines may be followed
+The #\f(CWif\fP, #\f(CWifdef\fP and #\f(CWifndef\fP control lines may be followed
by an arbitrary number of
.DS
-.ft 5
+.ft CW
#elif \fIconstant-expression\fP
.ft
.DE
-control lines, before the corresponding #\f5else\fP or #\f5endif\fP
+control lines, before the corresponding #\f(CWelse\fP or #\f(CWendif\fP
is encountered.
The construct
.DS
-.ft 5
+.ft CW
#elif \fIconstant-expression\fP
some text
#endif /* corresponding to #elif */
.DE
is equivalent to
.DS
-.ft 5
+.ft CW
#else
#if \fIconstant-expression\fP
some text
.ft
.DE
.PP
-The \fIconstant-expression\fP in #\f5if\fP and #\f5elif\fP control lines
+The \fIconstant-expression\fP in #\f(CWif\fP and #\f(CWelif\fP control lines
may contain the construction
.DS
-.ft 5
+.ft CW
defined(\fIidentifier\fP)
.ft
.DE
-which is replaced by \f51\fP, if \fIidentifier\fP has been #\f5defined\fP,
-and by \f50\fP, if not.
+which is replaced by \f(CW1\fP, if \fIidentifier\fP has been #\f(CWdefined\fP,
+and by \f(CW0\fP, if not.
.PP
Comments in skipped lines are interpreted as such.
.SH
.PP
Line directives may occur in the following forms:
.DS
-.ft 5
+.ft CW
#line \fIconstant\fP
#line \fIconstant\fP "\fIfilename\fP"
#\fIconstant\fP
.IP \(bu
enum-value specifier
.IP \(bu
-truth value in \f5#if\fP control line
+truth value in \f(CW#if\fP control line
.LP
.PP
Constant integral expressions are compile-time evaluated while an effort
To put the directories "include", "sys/h" and "util/h" into the
include directory list in that order, the user has to specify
.DS
-.ft 5
+.ft CW
-Iinclude -Isys/h -Iutil/h
.ft R
.DE
An empty \fIpath\fP causes the standard include
-directory (usually \f5/usr/include\fP) to be forgotten.
+directory (usually \f(CW/usr/include\fP) to be forgotten.
.IP \fB\-M\fP\fIn\fP
.br
Set maximum significant identifier length to \fIn\fP.
Get rid of the compiler-predefined macro \fIname\fP, i.e.,
consider
.DS
-.ft 5
+.ft CW
#undef \fIname\fP
.ft R
.DE
Generate a dependency graph, reflecting the calling structure of functions.
Lines of the form
.DS
-.ft 5
+.ft CW
DFA: \fIcalling-function\fP: \fIcalled-function\fP
.ft
.DE
.RS
.I enum-specifier :
.RS
-\&\f5enum\fP { \fIenum-list\fP }
+\&\f(CWenum\fP { \fIenum-list\fP }
.br
-\&\f5enum\fP \fIidentifier\fP { \fIenum-list\fP }
+\&\f(CWenum\fP \fIidentifier\fP { \fIenum-list\fP }
.br
-\&\f5enum\fP \fIidentifier\fP
+\&\f(CWenum\fP \fIidentifier\fP
.RE
.sp
\&\fIenum-list\fP :
.NH 2
Vocabulary and Representation (section 3)
.PP
-The input "\f510..\fP" is parsed as two tokens: "\f510\fP" and "\f5..\fP".
+The input "\f(CW10..\fP" is parsed as two tokens: "\f(CW10\fP" and "\f(CW..\fP".
.PP
-The empty string \f5""\fP has type
+The empty string \f(CW""\fP has type
.DS
-.ft 5
+.ft CW
ARRAY [0 .. 0] OF CHAR
.ft P
.DE
-and contains one character: \f50C\fP.
+and contains one character: \f(CW0C\fP.
.PP
-When the text of a comment starts with a '\f5$\fP', it may be a pragma.
+When the text of a comment starts with a '\f(CW$\fP', it may be a pragma.
Currently, the following pragmas exist:
.DS
-.ft 5
+.ft CW
(*$F (F stands for Foreign) *)
(*$R[+|-] (Runtime checks, on or off, default on) *)
(*$A[+|-] (Array bound checks, on or off, default off) *)
(*$U (Allow for underscores within identifiers) *)
.ft P
.DE
-The Foreign pragma is only meaningful in a \f5DEFINITION MODULE\fP,
+The Foreign pragma is only meaningful in a \f(CWDEFINITION MODULE\fP,
and indicates that this
-\f5DEFINITION MODULE\fP describes an interface to a module written in another
+\f(CWDEFINITION MODULE\fP describes an interface to a module written in another
language (for instance C, Pascal, or EM).
Runtime checks that can be disabled are:
range checks,
-\f5CARDINAL\fP overflow checks,
-checks when assigning a \f5CARDINAL\fP to an \f5INTEGER\fP and vice versa,
-and checks that \f5FOR\fP-loop control-variables are not changed
+\f(CWCARDINAL\fP overflow checks,
+checks when assigning a \f(CWCARDINAL\fP to an \f(CWINTEGER\fP and vice versa,
+and checks that \f(CWFOR\fP-loop control-variables are not changed
in the body of the loop.
Array bound checks can be enabled, because many EM implementations do not
implement the array bound checking of the EM array instructions.
EM array instruction.
Even when underscores are enabled, they still may not start an identifier.
.PP
-Constants of type \f5LONGINT\fP are integers with a suffix letter \f5D\fP
-(for instance \f51987D\fP).
-Constants of type \f5LONGREAL\fP have suffix \f5D\fP if a scale factor is missing,
-or have \f5D\fP in place of \f5E\fP in the scale factor (f.i. \f51.0D\fP,
-\f50.314D1\fP).
+Constants of type \f(CWLONGINT\fP are integers with a suffix letter \f(CWD\fP
+(for instance \f(CW1987D\fP).
+Constants of type \f(CWLONGREAL\fP have suffix \f(CWD\fP if a scale factor is missing,
+or have \f(CWD\fP in place of \f(CWE\fP in the scale factor (f.i. \f(CW1.0D\fP,
+\f(CW0.314D1\fP).
This addition was made, because there was no way to indicate long constants,
and also because the addition was made in Wirth's newest Modula-2 compiler.
.NH 2
a string, a number, a set, an enumeration literal, a qualifier denoting a
constant expression, a typetransfer with a constant argument, or
one of the standard procedures
-\f5ABS\fP, \f5CAP\fP, \f5CHR\fP, \f5LONG\fP, \f5MAX\fP, \f5MIN\fP,
-\f5ODD\fP, \f5ORD\fP,
-\f5SIZE\fP, \f5SHORT\fP, \f5TSIZE\fP, or \f5VAL\fP, with constant argument(s);
-\f5TSIZE\fP and \f5SIZE\fP may also have a variable as argument.
+\f(CWABS\fP, \f(CWCAP\fP, \f(CWCHR\fP, \f(CWLONG\fP, \f(CWMAX\fP, \f(CWMIN\fP,
+\f(CWODD\fP, \f(CWORD\fP,
+\f(CWSIZE\fP, \f(CWSHORT\fP, \f(CWTSIZE\fP, or \f(CWVAL\fP, with constant argument(s);
+\f(CWTSIZE\fP and \f(CWSIZE\fP may also have a variable as argument.
.PP
Floating point expressions are never evaluated compile time, because
the compiler basically functions as a cross-compiler, and thus cannot
use the floating point instructions of the machine on which it runs.
-Also, \f5MAX(REAL)\fP and \f5MIN(REAL)\fP are not allowed.
+Also, \f(CWMAX(REAL)\fP and \f(CWMIN(REAL)\fP are not allowed.
.NH 2
Type declarations (section 6)
.NH 3
Basic types (section 6.1)
.PP
-The type \f5CHAR\fP includes the ASCII character set as a subset.
+The type \f(CWCHAR\fP includes the ASCII character set as a subset.
Values range from
-\f50C\fP to \f5377C\fP, not from \f50C\fP to \f5177C\fP.
+\f(CW0C\fP to \f(CW377C\fP, not from \f(CW0C\fP to \f(CW177C\fP.
.NH 3
Enumerations (section 6.2)
.PP
The maximum number of enumeration literals in any one enumeration type
-is \f5MAX(INTEGER)\fP.
+is \f(CWMAX(INTEGER)\fP.
.NH 3
Record types (section 6.5)
.PP
Set types (section 6.6)
.PP
The only limitation imposed by the compiler is that the base type of the
-set must be a subrange type, an enumeration type, \f5CHAR\fP, or
-\f5BOOLEAN\fP.
+set must be a subrange type, an enumeration type, \f(CWCHAR\fP, or
+\f(CWBOOLEAN\fP.
So, the lower bound may be negative.
However, if a negative lower bound is used,
the compiler gives a warning of the \fIrestricted\fP class (see the manual
page of the compiler).
.PP
-The standard type \f5BITSET\fP is defined as
+The standard type \f(CWBITSET\fP is defined as
.DS
-.ft 5
+.ft CW
TYPE BITSET = SET OF [0 .. 8*SIZE(INTEGER)-1];
.ft P
.DE
Arithmetic operators (section 8.2.1)
.PP
The Report does not specify the priority of the unary
-operators \f5+\fP or \f5-\fP:
+operators \f(CW+\fP or \f(CW-\fP:
It does not specify whether
.DS
-.ft 5
+.ft CW
- 1 + 1
.ft P
.DE
means
.DS
-.ft 5
+.ft CW
- (1 + 1)
.ft P
.DE
or
.DS
-.ft 5
+.ft CW
(-1) + 1
.ft P
.DE
left undefined. Therefore, programs that depend on it, may cease to
work later.
.PP
-The types \f5INTEGER\fP and \f5CARDINAL\fP are assignment-compatible with
-\f5LONGINT\fP, and \f5REAL\fP is assignment-compatible with \f5LONGREAL\fP.
+The types \f(CWINTEGER\fP and \f(CWCARDINAL\fP are assignment-compatible with
+\f(CWLONGINT\fP, and \f(CWREAL\fP is assignment-compatible with \f(CWLONGREAL\fP.
.NH 3
Case statements (section 9.5)
.PP
the word-size.
.PP
The Report does not specify what happens if the value of the case-expression
-does not occur as a label of any case, and there is no \f5ELSE\fP-part.
+does not occur as a label of any case, and there is no \f(CWELSE\fP-part.
In our implementation, this results in a runtime error.
.NH 3
For statements (section 9.8)
.PP
The Report does not specify the legal types for a control variable.
-Our implementation allows the basic types (except \f5REAL\fP),
+Our implementation allows the basic types (except \f(CWREAL\fP),
enumeration types, and subranges.
A runtime warning is generated when the value of the control variable
is changed by the statement sequence that forms the body of the loop,
.NH 3
Standard procedures (section 10.2)
.PP
-Our implementation supports \f5NEW\fP and \f5DISPOSE\fP
+Our implementation supports \f(CWNEW\fP and \f(CWDISPOSE\fP
for backwards compatibility,
but issues warnings for their use. However, see section 3.
.PP
Also, some new standard procedures were added, similar to the new standard
procedures in Wirth's newest compiler:
.IP \-
-\f5LONG\fP converts an argument of type \f5INTEGER\fP or \f5REAL\fP to the
-types \f5LONGINT\fP or \f5LONGREAL\fP.
+\f(CWLONG\fP converts an argument of type \f(CWINTEGER\fP or \f(CWREAL\fP to the
+types \f(CWLONGINT\fP or \f(CWLONGREAL\fP.
.IP \-
-\f5SHORT\fP performs the inverse transformation, without range checks.
+\f(CWSHORT\fP performs the inverse transformation, without range checks.
.IP \-
-\f5FLOATD\fP is analogous to \f5FLOAT\fP, but yields a result of type
-\f5LONGREAL\fP.
+\f(CWFLOATD\fP is analogous to \f(CWFLOAT\fP, but yields a result of type
+\f(CWLONGREAL\fP.
.IP \-
-\f5TRUNCD\fP is analogous to \f5TRUNC\fP, but yields a result of type
-\f5LONGINT\fP.
+\f(CWTRUNCD\fP is analogous to \f(CWTRUNC\fP, but yields a result of type
+\f(CWLONGINT\fP.
.NH 2
System-dependent facilities (section 12)
.PP
-The type \f5BYTE\fP is added to the \f5SYSTEM\fP module.
+The type \f(CWBYTE\fP is added to the \f(CWSYSTEM\fP module.
It occupies a storage unit of 8 bits.
-\f5ARRAY OF BYTE\fP has a similar effect to \f5ARRAY OF WORD\fP, but is
-safer. In some obscure cases the \f5ARRAY OF WORD\fP mechanism does not quite
+\f(CWARRAY OF BYTE\fP has a similar effect to \f(CWARRAY OF WORD\fP, but is
+safer. In some obscure cases the \f(CWARRAY OF WORD\fP mechanism does not quite
work properly.
.PP
-The procedure \f5IOTRANSFER\fP is not implemented.
+The procedure \f(CWIOTRANSFER\fP is not implemented.
.NH 1
Backwards compatibility
.PP