.ds [ \s+1\z[\h'1p'\z[\h'-1p'\s-1\0
.ds ] \s+1\z]\h'-1p'\z]\s-1\0
.ds Z \s+1\z]\h'-1p'\z]\h'3p'\z*\s-1\0
.TL
\s+6Macross 68000\s-6
\"Macross
.AU
an assembler for people who hate assembly language
by
Chip Morningstar
.AI
Lucasfilm Ltd. Games Division
\\*(DY
.ds LH Macross
.ds CH \\*(DY
.ds RH 68000 Version
.ds LF Lucasfilm Ltd. Proprietary Information
.ds CF - % -
.ds RF CONFIDENTIAL
.AB
This document describes the 68000 version of \fIMacross\fR, a super-duper
cross-assembler that has but to be used!
.AE
.SH
\s+3Introduction\s-3
\"Introduction
.PP
\fIMacross\fR is a generic cross assembler for a variety of different
microprocessors.  This document describes the 68000 version of \fIMacross\fR.
\fIMacross\fR differs from many macro assemblers in that it provides a number
of ``higher level'' constructs not traditionally found in assembly language.
These include block-structured flow-of-control statements (\fBif\fR,
\fBwhile\fR, etc.) and the ability to define record-oriented data structures
(\fBstruct\fR).  In addition, it contains a powerful macro capability that is
based on syntactic structural manipulations rather than simple text
substitution.  \fIMacross\fR is, in fact, a complete block-structured
programming language in its own right which is interpreted at assembly time.
.SH
\s+3General Form of \fIMacross\fP Statements\s-3
\"General Form of \fIMacross\fP Statements
.PP
Stylistically, much of \fIMacross\fR is patterned after \fBC\fR.  In
particular, the form of many keywords and of block structured entities is
derived from \fBC\fR.  Unlike \fBC\fR however, \fIMacross\fR follows the
convention of more traditional assemblers that statements are delimited by
line boundaries (i.e., one statement per line, with the end of a line ending a
statement).
.PP
In general, spaces and tabs are treated as whitespace characters and are
ignored.  Therefore, such characters may be used as the assembly language
programmer desires to format his or her program according to personal taste.
For the convenience of the programmer, \fIMacross\fR relaxes the syntax rule
that newlines always end a statement: newlines may also be treated as
whitespace characters (again, for purposes of formatting) in places where it
would be syntactically unambiguous to do so (i.e., where a statement obviously
cannot terminate, such as after a comma).  For example:
.nf

	\fBbyte	1, 2, 3, 4,
		5, 6, 7, 8\fR

.fi
is allowed and is equivalent to
.nf

	\fBbyte	1, 2, 3, 4, 5, 6, 7, 8

.fi
.PP
Comments begin with a semicolon (``\fB;\fR'') and continue to the end of the
line, as is common in many assemblers.  In addition, \fIMacross\fR supports
\fBC\fR style comments bracketed by ``\fB/*\fR'' and ``\fB*/\fR''.
.PP
As with most assemblers, \fIMacross\fR statements are allowed to begin with a
label (or several labels, if you like).  A label is denoted by an identifier
followed by a colon (``\fB:\fR'').  There is no requirement that the label
start in column 1, or anything like that.  Labels, if present, merely must
precede anything else in a statement.
.PP
An identifier is just what you'd expect from all your years of programming
experience: a string of letters and digits that must begin with a letter.  As
is traditional in Unix*
.FS *
Unix is a footnote of Bell Laboratories.
.FE
land, the underscore character (``\fB_\fR'') is considered to be a letter
(smacks of hubris that, but tradition is tradition).  Departing from Unix
tradition, upper- and lower-case characters are not distinct from each other
for purposes of distinguishing identifiers.  If you use mixed case for
stylistic reasons, \fIMacross\fR will remember the case of the letters in an
identifier when it was first defined, so that symbol table dumps and
cross-reference listings will retain whatever case usage style you've adopted.
There is, in principle, no restriction imposed upon the length of identifiers.
.SH
\s+3The Language\s-3
.PP
In what follows, things in \fBboldface\fR are keywords and characters that are
used literally.  Things in \fIitalics\fR are other kinds of syntactic
entities.  Double brackets (``\*['' and ``\*]'') enclose things that are
optional, while brackets followed by an asterisk (``*'') enclose things that
may be optionally repeated zero or more times.
.NH 1
The Instruction Statement
.PP
The most elementary \fIMacross\fR statement is the instruction statement,
wherein the programmer specifies a machine instruction to be assembled.  The
instruction statement is
.nf

\*[ \fIlabel\fR \*Z	\fIopcode\fR \*[ \fIoperand\fR \*[ \fB,\fR \fIoperand\fR \*Z \*]

.fi
just like every assembler ever made (except \fBa65\fR, of course).
\fIOpcode\fR is an identifier which is either a machine instruction mnemonic
(a list of which mnemonics are accepted by \fIMacross\fR is given in
\fBAppendix B\fR at the end of this document) or a macro name.  For example:
.nf

	\fBandb			foobar, d3\fR
	\fBsomeMacro	foo, bar, baz, bletch\fR

.fi
.PP
The operands of an instruction may be any of the various types of operands
allowed by the various address modes of the target processor.  In the case
of the 68000, these are:
.NH 2
\fRRegister mode
.PP
Register operands take one of the forms
.nf

		\fBd\fIn\fR
		\fBa\fIn\fR
		\fBsp\fR

.fi
where \fIn\fR is a digit from \fB0\fR to \fB7\fR.  \fBd\fIn\fR of course
represents a data register and \fBa\fIn\fR represents an address register.
\fBsp\fR is equivalent to \fBa7\fR.
.NH 2
\fRRegister indirect mode
.PP
Register indirect mode operands take the form
.nf

		\fB\s-1[\s+1\fBa\fIn\fB\s-1]\s+1\fR

.fi
where \fBa\fIn\fR is some address register.
.NH 2
\fRPostincrement mode
.PP
Postincrement mode operands take the form
.nf

		\fB\s-1[\s+1\fBa\fIn\fB\s-1]\s+1+\fR

.fi
where \fBa\fIn\fR is some address register.
.NH 2
\fRPredecrement mode
.PP
Predecrement mode operands take the form
.nf

		\fB-\s-1[\s+1\fBa\fIn\fB\s-1]\s+1\fR

.fi
where \fBa\fIn\fR is some address register.
.NH 2
\fRNormal mode
.PP
Normal mode addresses take the form
.nf

		\fIexpression\fR

.fi
and are used in a couple of different ways.  First, normal mode addresses are
used by instructions that require relative addresses (such as branch
instructions; the offset is computed automatically by \fIMacross\fR).  Second,
the normal mode form of addresses is a shorthand way of refering to locations
for which \fIMacross\fR selects an appropriate address mode to use (PC
relative if it can, otherwise absolute).
.NH 2
\fRAbsolute mode
.PP
Absolute addresses take one of these two forms
.nf

		\fIexpression\fB . w\fR
		\fIexpression\fB . l\fR

.fi
with the \fBw\fR or \fBl\fR indicating whether to generate a short (16 bit) or
a long (32 bit) address.
.NH 2
\fRImmediate mode
.PP
Immediate mode operands take the form
.nf

		\fB#\fR \fIexpression\fR

.fi
Generally speaking, in the 68000 immediate mode operands are restricted to
sixteen bit quantities.  Depending upon the particular instruction involved,
the size may be even more restricted.  \fIMacross\fR will give an error
message if the operand value is larger than allowed.
.NH 2
\fRDisplacement mode
.PP
Displacement mode operands take the form
.nf

		\fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB\s-1]\s+1\fR

.fi
where \fIexpression\fR is an offset off of the address register \fBa\fIn\fR.
These displacement values are limited to 16 bit quantities in the 68000.
.PP
An alternate form of displacment mode addressing which is supported by
\fIMacross\fR allows the symbolic selection of a field of a \fBstruct\fR
pointed to by an address register
.nf

		\fBa\fIn\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z

.fi
This is explained in greater detail in the sections on \fBstruct\fRs and
expressions below.
.NH 2
\fRIndexed mode
.PP
Indexed mode addressing is specified by operands of the form
.nf

		\fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB. w \s-1]\s+1\fR
		\fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB. l \s-1]\s+1\fR
		\fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB\s-1]\s+1\fR

.fi
where \fIexpression\fR is an offset off of address register \fBa\fIn\fR and
another register \fIrn\fR which may be any data or address register.  The
Offset is restricted to an 8-bit quantity.  The \fBw\fR or \fBl\fR indicates
whether the offset value in \fIrn\fR is to be taken as a word (16 bit) value
or as a long (32 bit) value (if omitted it defaults to long).
.PP
As with ordinary displacment addressing, there is a form of indexed addressing
which uses \fBstruct\fR fields
.nf

		\fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB. w \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z
		\fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB. l \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z
		\fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z

.fi
.NH 2
\fRProgram counter displacement mode
.PP
Program counter displacement mode operands take the form
.nf

		\fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB\s-1]\s+1\fR

.fi
where \fIexpression\fR is an offset off of the program counter.  These
displacement values are limited to 16 bit quantities in the 68000.
.NH 2
\fRProgram counter indexed mode
.PP
Program counter indexed mode addressing is specified by operands of the form
.nf

		\fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB. w \s-1]\s+1\fR
		\fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB. l \s-1]\s+1\fR
		\fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB\s-1]\s+1\fR

.fi
where \fIexpression\fR is an offset off of the program counter and another
register \fIrn\fR which may be any data or address register.  The Offset is
restricted to an 8-bit quantity.  The \fBw\fR or \fBl\fR indicates whether the
offset value in \fIrn\fR is to be taken as a word (16 bit) value or as a long
(32 bit) value (if omitted it defaults to long).
.NH 2
\fRControl register mode
.PP
The various control register of the 68000 are sometimes used as operands
.nf

		\fBccr\fR
		\fBsr\fR
		\fBusp\fR
		\fBsfc\fR
		\fBdfc\fR
		\fBvbr\fR

.fi
where \fBccr\fR represents the condition code register, \fBsr\fR represents
the status register, \fBusp\fR represents the user stack pointer, \fBsfc\fR
represents the source function code register, \fBdfc\fR represents the
destination function code register, and \fBvbr\fR represents the vector base
register.
.NH 2
\fRText operands
.PP
For the sake of macros, text strings may also be used as operands
.nf

		\fB"\fIany string you like\fB"\fR

.fi
The same conventions regarding escaped characters (using ``\fB\\\fR'') that
are followed by \fBC\fR are followed by \fIMacross\fR.  These are documented
in \fBAppendix F\fR.  Note that on many target machines the codes that these
escape sequences stand for are meaningless.  They are provided primarily as a
convenience for writing calls to \fBprintf()\fR.
.NH 1
The Flow of Control Statements
.PP
\fIMacross\fR provides a number of statements which allow program flow of
control to be specified in a \fBC\fR-like block structured fashion.  This
include a conditional execution statement (\fBif\fR) and three conditional
loop statements (\fBwhile\fR, \fBdo-while\fR and \fBdo-until\fR).  These
statements assemble into the appropriate conditional branches and jumps to
realize the desired construct.
.NH 2
If\fR statement
.PP
The \fBif\fR statement has the following form
.nf

\*[ \fIlabel\fR \*Z	\fBif\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR \*[ \fBelseif\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR \*Z \*[ \fBelse\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR \*]

.fi
\fIcondition\fR is either the name of one of the target processor's hardware
condition codes such as can be tested for in a conditional branch instruction
(e.g., \fBcarry\fR, \fBoverflow\fR, etc.\*- the complete list is in
\fBAppendix C\fR) or one either of these negated using the ``logical not''
operator (``\fB!\fR'').  The condition is used to determine the appropriate
type of branch instruction to use.  For example,
.nf

		\fBif (overflow) {\fR
			\fIstatements-1\fR
		\fB} elseif (carry) {\fR
			\fIstatements-2\fR
		\fB} else {\fR
			\fIstatements-3\fR
		\fB}\fR

.fi
expands into this (the labels are made up for illustrative purposes only):
.nf

		\fBbvc	temp1
		\fIstatements-1
		\fBjmp	temp3	
temp1:	bcc	temp2
		\fIstatements-3
		\fBjmp	temp3
temp2:	\fIstatements-3
\fBtemp3:	\fIwhatever follows\fR

.fi
The keyword \fBelseif\fR may be used as shown, or specified as two separate
keywords, \fBelse if\fR, depending on the programmer's whim.
.NH 2
While\fR statement
.PP
The \fBwhile\fR statement has the following form
.nf

\*[ \fIlabel\fR \*Z	\fBwhile\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR

.fi
\fIcondition\fR is as described above for the \fBif\fR statement.  An example
of the \fBwhile\fR statement would be
.nf

		\fBwhile (!carry) {\fR
			\fIstatements\fR
		\fB}\fR

.fi
which would turn into
.nf

\fBtemp2:	bcs	temp1
		\fIstatements
		\fBjmp	temp2
temp1:	\fIwhatever follows\fR

.fi
.NH 2
Do-while\fR statement
.PP
The \fBdo-while\fR statement is similar to the \fBwhile\fR statement except
that the condition is tested at the bottom of the loop.  It has the form
.nf

\*[ \fIlabel\fR \*Z	\fBdo\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR \fBwhile\fR \fB(\fR \fIcondition\fR \fB)\fR

.fi
For example
.nf

		\fBdo {\fR
			\fIstatements\fR
		\fB} while (equal)\fR

.fi
which is equivalent to
.nf

\fBtemp:	\fIstatements
		\fBbeq temp\fR

.fi
.NH 2
Do-until\fR statement
.PP
The \fBdo-until\fR statement is the same as the \fBdo-while\fR statement
except that the sense of the condition is negated.  It has the form
.nf

\*[ \fIlabel\fR \*Z	\fBdo\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR \fBuntil\fR \fB(\fR \fIcondition\fR \fB)\fR

.fi
For example
.nf

		\fBdo {\fR
			\fIstatements\fR
		\fB} until (equal)\fR

.fi
which is equivalent to
.nf

\fBtemp:	\fIstatements
		\fBbne temp\fR

.fi
.NH 1
The Data Statements
.PP
The data statements allow the allocation of memory space and the storage of
constant data.  These statements are like the ones found in most assemblers.
There are several different forms, each for a different type of data.
.NH 2
Block\fR statement
.PP
The \fBblock\fR statement allocates blocks of memory without initializing the
bytes to any particular value (actually, the loader will in all likelihood
initialize these to 0, but it is probably not really wise to rely on this).
It has the form
.nf

\*[ \fIlabel\fR \*Z	\fBblock\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z

.fi
The \fIexpression\fRs are the sizes of the blocks to reserve, expressed in
bytes.
.NH 2
Align\fR statement
.PP
The \fBalign\fR statement aligns the current location counter to an integer
multiple of some value (e.g., to align with a word boundary).  It has the form
.nf

\*[ \fIlabel\fR \*Z	\fBalign\fR \fIexpression\fR

.fi
The \fIexpression\fR is the multiple to which the current location counter is
to be aligned.  For example,
.nf

		\fBalign		2\fR

.fi
would align the current location to a word boundary, while
.nf

		\fBalign		0x100\fR

.fi
would align to a page boundary.
.NH 2
Constrain\fR statement
.PP
The \fBconstrain\fR statement provides a means of constraining a portion of
code or data to be located within a region of memory bounded by addresses of
integer multiples of some value (e.g., within a page).  Its form is
.nf

		\fBconstrain\fR \fB(\fR \fIboundary\fR \fB)\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR

.fi
\fIBoundary\fR may be any expression which evaluates to a number.  The
\fIstatement\fRs are assembled normally.  If assembling in absolute mode, an
error message is issued if the current location counter crosses an integer
multiple of \fIboundary\fR.  If assembling in relocatable mode, information
about the constraint will be output in the object file and the contents of the
constrained block will be relocated as needed to satisfy the constraint (note
that this means that it is unsafe to assume that the things in the assembly
source immediately before the \fBconstrain\fR statement, the contents of the
constrain block itself, and the things in the assembly source immediately
after the \fBconstrain\fR statement will be located in contiguous locations in
the eventual target machine address space).  For example,
.nf

		\fBconstrain (0x100) {\fR
			\fIstatements\fR
		\fB}\fR

.fi
constrains the given statements to all fit within a page.
.NH 2
Word\fR statement
.PP
The \fBword\fR statement allocates words, i.e., two byte chunks, of memory.
It takes the form
.nf

\*[ \fIlabel\fR \*Z	\fBword\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z

.fi
The \fIexpression\fRs must evaluate to quantities that can be contained in 16
bits, of course.  For example,
.nf

		\fBword		0x1234, foobar\fR

.fi
would allocate two words, the first of which would be initialized to the
hexadecimal value 0x1234 and the second to whatever the value of \fBfoobar\fR
is.
.NH 2
Dbyte\fR statement
.PP
The \fBdbyte\fR statement is just like the \fBword\fR statement, except that
the word is byte-swapped in memory.  Its form is
.nf

\*[ \fIlabel\fR \*Z	\fBdbyte\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z
.fi
.NH 2
Long\fR statement
.PP
The \fBlong\fR statement allocates longwords, i.e., four byte chunks, of
memory.  It takes the form
.nf

\*[ \fIlabel\fR \*Z	\fBlong\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z

.fi
The \fIexpression\fRs must evaluate to quantities that can be contained in 32
bits, of course.  For example,
.nf

		\fBword		0x12345678, foobar\fR

.fi
would allocate two longwords, the first of which would be initialized to the
hexadecimal value 0x12345678 and the second to whatever the value of
\fBfoobar\fR is.
.NH 2
Byte\fR statement
.PP
The \fBbyte\fR statement is similar to the \fBword\fR and \fBdbyte\fR
statements, except that it allocates single byte chunks.  Its form is
.nf

\*[ \fIlabel\fR \*Z	\fBbyte\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z

.fi
An \fIexpression\fR, in this case, is either an ordinary expression (see
\fBExpressions\fR, below) which must evaluate to an 8-bit quantity, indicating
the value for a single byte to be reserved, or a string (see above, under the
discussion of text operands), indicating that the characters in the string
should be placed in memory at the current location.
.NH 2
String\fR statement
.PP
The \fBstring\fR statement is much like the \fBbyte\fR statement, except that
the values indicated are followed in memory by a zero byte.  This enables the
convenient declaration and allocation of NULL terminated character strings.
This feature is of little use in the 68000 version of \fIMacross\fR but is
provided for compatability with future versions targeted at more sophisticated
processors.  The form of the \fBstring\fR statement is
.nf

\*[ \fIlabel\fR \*Z	\fBstring\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z
.fi
.NH 2
Struct\fR statement
.PP
The \fBstruct\fR statement enables the declaration and allocation of
record-oriented data structures.  There are two forms of the \fBstruct\fR
statement, the first of which declares a \fBstruct\fR record type, and the
second of which causes space to be set aside in memory for a \fBstruct\fR that
has already been declared.  The form of the first type of \fBstruct\fR
statement is
.nf

\*[ \fIlabel\fR \*Z	\fBstruct\fR \fB{\fR
			\*[ \fIdataStatement\fR \*Z
		\fB}\fR \fIname\fR

.fi
\fIdataStatement\fRs are any of the data statements described in this section
(section 3).  \fIName\fR becomes the name of the \fBstruct\fR.  Any labels
inside the \fBstruct\fR become \fIfields\fR of the data structure which may be
referred to later in expressions using the ``\fB.\fR'' operator, as in
\fBC\fR.  A more complete description of the semantics of \fBstruct\fRs is
given in the section below on expressions.
.PP
The first form of the \fBstruct\fR statement, called a ``\fBstruct\fR
definition'', lays out the constituent parts of a data structure and gives
those names to those parts. The second form of the \fBstruct\fR statement,
called a ``\fBstruct\fR instantiation'',
.nf

\*[ \fIlabel\fR \*Z	\fBstruct\fR \fIname\fR

.fi
causes storage for the \fBstruct\fR named by \fIname\fR to be allocated.  A
\fBstruct\fR definition \fImay not\fR contain another \fBstruct\fR definition,
but it \fImay\fR contain a \fBstruct\fR instantiation.  For example,
.nf

		\fBstruct {
			pointer:	block 2
			class:	block 1
		} fooThing\fR

.fi
would create a \fBstruct\fR called \fBfooThing\fR.  Then,
.nf

\fBfooLabel:	struct	fooThing\fR

.fi
would allocate one at the current location at the address labeled
\fBfooLabel\fR.  This could then be used as follows:
.nf

		\fBandb		fooLabel.class, d0
		jmp		fooLabel.pointer\fR

.fi
which would AND \fBd0\fR with the \fBclass\fR field of the \fBstruct\fR and
then jump to wherever the \fBpointer\fR field pointed to.  If the \fBx\fR
address register \fBa4\fR already contained the address of this \fBstruct\fR,
then one could say
.nf

		\fBandb		a4.class, d0\fR

.fi
.NH 1
The Symbol Definition Statements
.PP
The various symbol definition statements allow the declaration of symbolic
variables and values and the definition of macros and functions.
.NH 2
Define\fR statement
.PP
The \fBdefine\fR statement enables the programmer to create symbolic names for
values.  It has two forms.  The first
.nf

		\fBdefine\fR \fIsymbolname\fR

.fi
creates a new symbol, \fIsymbolname\fR (an identifier), and gives it the
special value \fBunassigned\fR.  Any attempt to take the value of an
unassigned symbol will cause an error message from the assembler.  The symbol
will, however, cause the \fBisDefined()\fR built-in function (see
\fBExpressions\fR, below) to return \fBTRUE\fR if passed as an argument.  It
is also an error to \fBdefine\fR a symbol that has already been \fBdefine\fRd.
.PP
The second form of the \fBdefine\fR statement
.nf

		\fBdefine\fR \fIsymbolname\fR \fB=\fR \fIexpression\fR

.fi
creates the symbol and gives it the value obtained by evaluating
\fIexpression\fR (see \fBExpressions\fR, below).  Actually, what \fBdefine\fR
does is create a symbolic name for \fIexpression\fR and the save this
expression away in a secret place.  This means that symbols in
\fIexpression\fR may be forward references, e.g., labels that haven't been
encountered yet.  It is also possible to forward reference to symbols that are
defined by future \fBdefine\fR statements, for example:
.nf

		\fBdefine foo = bar + 2
		define bar = 47\fR

.fi
effectively defines \fBfoo\fR to be \fB49\fR.  Beware, however, as there is no
way for the assembler to detect mutually recursive references of this sort, so
that
.nf

		\fBdefine foo = bar + 2
		define bar = foo + 2\fR

.fi
will be happily swallowed without complaint, until you actually try to use
\fBfoo\fR or \fBbar\fR in an instruction, whereupon \fIMacross\fR's expression
evaluator will go into infinite recursion until it runs out of stack space and
crashes the assembler (it looks to see what \fBfoo\fR is and sees that it's
\fBbar + 2\fR, so it looks to see what \fBbar\fR and see that it's \fBfoo +
2\fR, so it looks to see what \fBfoo\fR is...  To have the assembler detect
and signal this error would, in the general case, add much complication and
inefficiency (read: make your programs assemble a lot more slowly) for little
return).
.PP
The scope of symbols defined in either of these two ways extends in time from
the definition itself to the end of the assembly.
.NH 2
Variable\fR statement
.PP
The \fBvariable\fR statement enables the programmer to declare symbolic
variables for future use.  Similar to the \fBdefine\fR statement, it has two
forms.  The first
.nf

		\fBvariable\fR \fIsymbolname\fR

.fi
creates a variable named \fIsymbolname\fR and gives it the special value
\fBunassigned\fR, just like the analogous \fBdefine\fR statement.
.PP
The second form of the \fBvariable\fR statement
.nf

		\fBvariable\fR \fIsymbolname\fR \fB=\fR \fIexpression\fR

.fi
creates the variable and gives it the value obtained by evaluating
\fIexpression\fR.  The scope of variables defined in either of these two ways
extends from the \fBvariable\fR statement itself to the end of the assembly
(i.e., the variable is global).
.PP
The difference between the \fBdefine\fR statement and the \fBvariable\fR
statement is that the \fBdefine\fR statement creates what is in essence a
constant whereas the \fBvariable\fR statement creates a true variable.  The
value of a variable may change (e.g., it may be assigned to) during the course
of assembly.  In addition, the expression which establishes a symbol's value
in a \fBdefine\fR statement may contain forward references (i.e., labels whose
values are unknown because they haven't been encountered yet) whereas the
expression assigning an initial value to a variable must be made up of terms
all of whose values are known at the time the \fBvariable\fR statement is
encountered in the assembly.
.NH 2
Macro\fR statement
.PP
The \fBmacro\fR statement is used to define macros (surprise!).  Its syntax is
.nf

		\fBmacro\fR \fImacroname\fR \*[ \fIargumentname\fR \*[ \fB,\fR \fIargumentname\fR \*Z \*] \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR

.fi
where \fImacroname\fR is just that and the \fIargumentname\fRs are identifiers
corresponding to the formal parameters of the macro (in the classical
fashion).  When the macro is called, the call arguments are bound to these
symbols and then \fIMacross\fR assembles the \fIstatement\fRs which form the
macro body.  The scope of these symbols is limited to the inside of the macro
body and their values go away when the macro expansion is completed.  The
\fIstatement\fRs may be any valid \fIMacross\fR statements except for
\fBmacro\fR statements and \fBfunction\fR statements (i.e., macro and function
definitions may not be nested).
.PP
Statement labels used inside macros can be made local to the macro by
preceding the label identifier with a dollar sign (``\fB$\fR'').  For
example,
.nf

		\fBmacro	fooMac	arg {
				jmp		$foo
				word	arg
		$foo:		nop
		}\fR

.fi
defines a macro named \fBfooMac\fR that emits a word of data that gets jumped
over.  The label \fB$foo\fR is local to the macro: both the reference to it
in the first line of the macro and its definition on the third will only be
seen inside the macro.  Each time the macro is called, the \fBjmp\fR will
refer to the location two instructions ahead, and any other macros that might
contain \fB$foo\fR will not affect this nor will they be affected by this.
.NH 2
Function\fR statement
.PP
The \fBfunction\fR statement is used to define functions.  Its syntax is
.nf

		\fBfunction\fR \fIfuncname\fR \fB(\fR \*[ \fIargumentname\fR \*[ \fB,\fR \fIargumentname\fR \*Z \*] \fB)\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR

.fi
where \fIfuncname\fR is the name of the function and the \fIargumentname\fRs
are identifiers corresponding to the formal parameters of the function.  When
the function is called, the call arguments are evaluated and then bound to
these symbols and then \fIMacross\fR assembles the \fIstatement\fRs which form
the function body.  The scope of these symbols is limited to the inside of the
function body and their values go away when the function evaluation is
completed.  As with macro definitions, the \fIstatement\fRs may be any valid
\fIMacross\fR statements except for the \fBmacro\fR and \fBfunction\fR
statements.  A function may return a value using the \fBfreturn\fR statement,
which is described below.
.NH 2
Undefine\fR statement
.PP
The \fBundefine\fR statement allows symbol and macro definitions to be removed
from \fIMacross\fR' symbol table.  It takes the form
.nf

		\fBundefine\fR \fIsymbolname\fR \*[ \fB,\fR \fIsymbolname\fR \*Z

.fi
The named symbols go away as if they never were \*- they are free to be
defined again and the \fBisDefined()\fR built-in function will return
\fBFALSE\fR if passed one of them as an argument.
.NH 1
Macro Body Statements
.PP
\fIMacross\fR provides several statements which are primarily intended to
manage the flow of control (or, rather, the ``flow of assembly'') within a
macro or function definition.  Some of these statements are analogs to the
flow of control statements described above in section 2.  However, one should
keep in mind that these statements are executed interpretively at assembly
time, whereas the previously described statements result in machine code in
the target-processor-executable output of the assembly process.
.PP
Although these statements are intended primarily for use within macros and
functions, their use is not restricted and they may be used at any point in a
program.  In particular, the \fBmif\fR statement (to be described shortly) is
the means by which conditional assembly may be realized.
.NH 2
\fRBlocks
.PP
The construct
.nf

		\fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR

.fi
is called a \fIblock\fR and is in fact a valid \fIMacross\fR statement type in
its own right.  Blocks are used extensively in \fIMacross\fR to form the
bodies of flow-of-control statements, flow-of-assembly statements and macros.
.NH 2
Mdefine\fR statement
.PP
The \fBmdefine\fR statement
.nf

		\fBmdefine\fR \fIsymbolname\fR
or
		\fBmdefine\fR \fIsymbolname\fR \fB=\fR \fIexpression\fR

.fi
operates like (and is syntactically congruent with) the \fBdefine\fR
statement, except that the scope of the symbol definition is restricted to the
body block of the macro or function in which the \fBmdefine\fR appears.  The
symbol definition is invisible outside that block, though it \fIis\fR visible
inside any blocks that may themselves be contained within the macro or
function.
.NH 2
Mvariable\fR statement
.PP
The \fBmvariable\fR statement
.nf

		\fBmvariable\fR \fIsymbolname\fR
or
		\fBmvariable\fR \fIsymbolname\fR \fB=\fR \fIexpression\fR

.fi
bears exactly the same relationship to the \fBvariable\fR statement that the
\fBmdefine\fR statement does to the \fBdefine\fR statement.  It declares a
variable whose scope is limited to the function or macro in whose definition
it appears.
.NH 2
Mif\fR statement
.PP
The \fBmif\fR statement conditionally assembles the statements contained in
the block following it:
.nf

		\fBmif\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR \*[ \fBmelseif\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR \*Z \*[ \fBmelse\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR \*]

.fi
unlike the \fBif\fR statement, the \fIcondition\fR may be any expression
whatsoever.  \fIMacross\fR follows the \fBC\fR convention that the value 0
represents \fBFALSE\fR and any other value represents \fBTRUE\fR (in fact, the
symbols \fBTRUE\fR and \fBFALSE\fR are ``predefined'' by the assembler to
have the values 1 and 0 respectively).  The meaning of the \fBmif\fR construct
is the obvious one, but keep in mind that it is interpreted at assembly time
and has no direct bearing on the execution of the resulting assembled program.
.NH 2
Mwhile\fR statement
.PP
The \fBmwhile\fR statement repetitively assembles a block of statements so
long as a given condition remains true.  Its form is
.nf

		\fBmwhile\fR \fB(\fR \fIcondition\fR \fB)\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR

.fi
As with \fBmif\fR, the \fIcondition\fR may be any valid \fIMacross\fR
expression and the interpretation is what it seems.
.NH 2
Mdo-while\fR statement
.PP
The \fBmdo-while\fR statement provides an alternative to the \fBmwhile\fR
statement by testing at the bottom of the loop instead of at the top.  Its
form is
.nf

		\fBmdo\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR \fBwhile\fR \fB(\fR \fIcondition\fR \fB)\fR
.fi
.NH 2
Mdo-until\fR statement
.PP
The \fBmdo-until\fR statement is the same as the \fBmdo-while\fR statement
except that the sense of the condition is negated.  It has the form
.nf

		\fBmdo\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR \fBuntil\fR \fB(\fR \fIcondition\fR \fB)\fR
.fi
.NH 2
Mfor\fR statement
.PP
The \fBmfor\fR statement provides a more general looping construct analogous
to the \fBC\fR \fBfor\fR loop.  Its form is
.nf

		\fBmfor\fR \fB(\fR \fIexpression-1\fR \fB,\fR \fIexpression-2\fR \fB,\fR \fIexpression-3\fR \fB)\fR \fB{\fR
			\*[ \fIstatement\fR \*Z
		\fB}\fR

.fi
where \fIexpression-1\fR is an initialization expression, \fIexpression-2\fR
is a test to see if looping should continue, and \fIexpression-3\fR is
executed at the bottom of the loop to set up for the next time around, just as
in \fBC\fR.  Note that, unlike \fBC\fR, the \fIexpression\fRs are separated by
commas, not semicolons.  This is because semicolons are used to delimit line
comments.
.PP
The \fBmfor\fR statement is equivalent to
.nf

		\fIexpression-1\fR
		\fBmwhile (\fIexpression-2\fB ) {\fR
			\fIstatements\fR
			\fIexpression-3\fR
		\fB}\fR
.fi
.NH 2
Mswitch\fR statement
.PP
The \fBmswitch\fR statement provides a means of selecting one of a number of
blocks of code for assembly depending upon the value of some expression.  Its
form is:
.nf

		\fBmswitch ( \fIselectionExpression \fB) {\fR
			\*[ \fBmcase ( \fIexpression\fR \*[ \fB,\fI expression\fR \*Z \fB) {\fR
				\*[ \fIstatement\fR \*Z
			\fB}\fR \*Z
			\*[ \fBmdefault {\fR
				\*[ \fIstatement\fR \*Z
			\fB}\fR \*]
		\fB}\fR

.fi
The way this works is as follows (it's actually easier to use than to
explain): \fIselectionExpression\fR is evaluated.  Each of the
\fIexpression\fRs associated with the various \fBmcase\fR clauses (if any) is
then evaluated in turn and the resulting value compared to that of
\fIselectionExpression\fR.  When and if one of these values ``matches'' the
value of \fIselectionExpression\fR the block of \fIstatement\fRs associated
with the corresponding \fBmcase\fR clause is immediately assembled and
execution of the \fBmswitch\fR statement is complete.  If no such value
matches and there is an \fBmdefault\fR clause, the block of \fIstatement\fRs
associated with the \fBmdefault\fR clause is assembled.  If no value matches
and there is no \fBmdefault\fR clause then nothing is assembled as a result of
the \fBmswitch\fR.  When we say the values ``match'', we mean that either
the expressions evaluate to the same number or to strings which are identical
except for the case of alphabetic characters.  For example:
.nf

		\fBmswitch (foo) {
			mcase ("hello", "fnord") {
				\fIstatements-1\fB
			}
			mcase ("ZAP!") {
				\fIstatements-2\fB
			}
			mdefault {
				\fIstatements-3\fR
			}
		}\fR

.fi
would switch on the value of the symbol \fBfoo\fR.  If the value of \fBfoo\fR
was \fB"hello"\fR, \fIstatements-1\fR would be assembled.  If the value of
\fBfoo\fR was \fB"zap!"\fR, \fIstatements-2\fR would be assembled (since the
string comparison is done independent of case).  If the value of \fBfoo\fR was
\fB"cromfelter"\fR or \fB47\fR, then \fIstatements-3\fR would be assembled by
default.
.NH 2
Freturn\fR statement
.PP
A \fIMacross\fR function may (and probably will) be called from an expression
in the traditional manner of functions throughout the annals of computer
science.  In such a situation, the programmer may wish to have a function
return a value.  The \fBfreturn\fR statement enables this.  Its form is
.nf

		\fBfreturn\fR \*[ \fIexpression\fR \*]

.fi
where \fIexpression\fR is any permissible \fIMacross\fR expression as
described below under \fBExpressions\fR.  If no \fIexpression\fR is given, the
macro simply returns without having a value as its result.  Any attempt to use
the (non-existent) value returned by a call to function which doesn't return a
value will result in an error message from the assembler.  Function calls will
automatically return without a value upon reaching the end of the block that
forms the body of the function.
.NH 1
Miscellaneous Statements
.PP
Various useful statements don't fall into any of the above categories.
.NH 2
Include\fR statement
.PP
The \fBinclude\fR statement allows the text in other files to be included in
the source program being assembled, in the time-honored fashion.  Its form is
.nf

		\fBinclude\fR \fIfilename\fR

.fi
where \fIfilename\fR is a string value giving the name of the file to be
included.  \fBInclude\fRd files may themselves contain \fBinclude\fR
statements to any number of levels of recursion (within reason).
.NH 2
Extern\fR statement
.PP
The \fBextern\fR statement allows you to declare symbols to be visible to the
linker outside of the file in which they are found.  Its use:
.nf

		\fBextern\fR \fIsymbol\fR \*[ \fB,\fR \fIsymbol\fR \*Z
.fi
.NH 2
Start\fR statement
.PP
The \fBstart\fR statement declares the starting address of a program.
.nf

		\fBstart\fR \fIexpression\fR

.fi
where the \fIexpression\fR indicates the start address.  There should be no
more than one \fBstart\fR statement in a program.  If no start address is
specified, the object file will be produced without a start address entry.
.NH 2
Assert\fR statement
.PP
The \fBassert\fR statement provides a means of testing assembly time
conditions and generating programmer specified error messages if those
conditions are not satisfied.  Its syntax is:
.nf

		\fBassert (\fIcondition\fB)\fR \*[ \fItextString\fR \*]

.fi
where \fIcondition\fR is an expression such as those used in the \fBmif\fR
statement.  This condition is evaluated and if \fBFALSE\fR then the message
\fItextString\fR, if given, is written to the standard output.  The message is
written in the form of a conventional \fIMacross\fR error message, giving the
file and line number on which the failed assertion occured.  If
\fItextString\fR is omitted then a simple error message to the effect that the
assert failed will be output.  For example,
.nf

		\fBassert (foo == 1) "Hey!  You blew it."\fR

.fi
would check to see that the value of the symbol \fBfoo\fR is \fB1\fR, and if
it isn't would issue an error message containing the string \fB"Hey!  You blew
it."\fR.
.NH 2
Org\fR statement
.PP
The \fBorg\fR statement adjusts the current location counter and tells the
assembler to start locating instructions and data in absolute memory
locations.
.nf

		\fBorg\fR \fIexpression\fR

.fi
The \fIexpression\fR indicates the new current location.  If this is an
absolute address, \fIMacross\fR starts assembling at the specified
absolute memory location.  If, on the other hand, it is relative to a
relocatable address or to the current location counter, the current location
counter is simply adjusting accordingly.
.NH 2
Rel\fR statement
.PP
The \fBrel\fR statement restores \fIMacross\fR to assembling code in a
relocatable fashion, if it was not already doing so.  The relocatable location
resumes from wherever it was left the last time an absolute \fBorg\fR stopped
relocatable code assembly.  \fI((explain this better))\fR
.NH 2
Target\fR statement
.PP
The \fBtarget\fR statement
.nf

		\fBtarget\fR \fIexpression\fR

.fi
tells the assembler to assemble as if it had been \fBorg\fRed to a particular
address without actually performing the \fBorg\fR.  The \fIexpression\fR
indicates the location to start assembling from.  This must be an absolute
address (and the \fBtarget\fR statement may only be used when assembling in
absolute mode).
.PP
The result of the \fBtarget\fR statement is that assembly proceeds from the
current location but labels will be defined as if it was proceeding from the
location specified by \fIexpression\fR and references to the current location
counter will be offset by the difference between the actual current location
counter value and the value of \fIexpression\fR.  This effect will persist until the next \fBorg\fR or \fBtarget\fR statement.  For example
.nf

		\fBorg		0x1000
		target	0x0800
foo:		rts
bar:		word	0x1234
		word	here
		org		someplaceElse\fR

.fi
would first set the current location counter to \fB0x1000\fR.  At location
\fB0x1000\fR it would assemble an \fBrts\fR instruction while giving the label
\fBfoo\fR the value \fB0x800\fR.  Then, at location \fB0x1002\fR it would
deposit the word value \fB0x1234\fR while giving the label \fBbar\fR the
value \fB0x802\fR.  At location \fB0x1004\fR it would deposit the word value
\fB0x804\fR.  Finally, the second \fBorg\fR would set the current location
counter to \fBsomeplaceElse\fR and the effects of the \fBtarget\fR statement
would cease.
.SH
\s+3Expressions\s-3
.PP
The expression syntax of \fIMacross\fR was chosen to be as close to that of
\fBC\fR as possible.  \fIMacross\fR recognizes the same set of operators as
\fBC\fR with few exceptions, and the operators have the same precedence with
respect to each other that everyone is used to.
.PP
Another important feature of expressions in \fIMacross\fR is that expressions
by themselves on a line are valid statements.  Assignment expressions, uses of
the post- and pre-increment and decrement operators (``\fB++\fR'' and
``\fB--\fR''), and calls to functions used like procedures are the most
useful applications of this.  For example
.nf

		\fBfoo = 5\fR
		\fBbar++\fR
		\fBprintf("Hello world\\n")\fR

.fi
are all valid statements.
.NH 0
\fRPrimitive expressions
.PP
The most primitive expressions are identifiers, numbers, characters, character
strings, and function calls.
.PP
Identifiers have already been described, in the section \fBGeneral Form of
\fIMacross\fB Statements\fR above.  The only thing to add here is that the
special identifier \fBhere\fR denotes the value of the current location
counter.
.PP
Numbers may be decimal, octal, hexadecimal, binary or quarters.  The form of
the first three of these is as in \fBC\fR: decimal numbers are denoted by a
sequence of decimal digits that does not begin with a ``\fB0\fR''; octal
numbers by a sequence of octal digits that \fIdoes\fR begin with a
``\fB0\fR''; and hexadecimal numbers by a sequence of hexadecimal digits
(the decimal digits plus the letters ``\fBa\fR'' through ``\fBf\fR'', in
either upper or lower case), preceded by ``\fB0x\fR'' or ``\fB0X\fR''.
Binary numbers and quarters are represented analogously.  Binary numbers are
represented by a sequence of ``\fB0\fR''s and ``\fB1\fR''s preceded by
``\fB0b\fR'' or ``\fB0B\fR''.  Quarters are base-four numbers (for two-bit
entities like Atari pixels) and are represented by the sequences of the digits
\fB0\fR through \fB3\fR preceded by ``\fB0q\fR'' or ``\fB0Q\fR'' (the
credit for this idea goes to Charlie Kellner).
.PP
Character constants are denoted the same as in \fBC\fR: by a single character
enclosed in apostrophes (``\fB'\fR'').  The same conventions about
characters escaped with a backslash (``\fB\\\fR'') also apply.  Strings may
be of varying lengths and are enclosed in quotation marks (``\fB"\fR''),
as discussed above in the explanation of instruction operands.
.PP
A function call, in \fIMacross\fR, is syntactically the same as in \fBC\fR:
the name of the function being called followed by a comma-separated argument
list in parenthesis.  The argument list, as in \fBC\fR, may be empty.  The
arguments themselves may be arbitrary instruction operands (described above in
section 1).  A number of built-in functions are provided by \fIMacross\fR to
perform a variety of useful operations.  These are discussed in \fBAppendix
D\fR.
.NH 1
\fROperators
.PP
Expressions may be constructed from the primitive elements described above and
from other expressions using a variety of unary and binary operators.  The
operator set is patterned after \fBC\fR's.  The only \fBC\fR operators not
supported are:
.IP
[1] ``\fB?:\fR'' (arithmetic if) \*- not supported for reasons of syntactic
confusion on both the part of the parser attempting to parse it and the
programmer attempting to use it.
.IP
[2] ``\fB,\fR'' (comma) \*- used in \fIMacross\fR as an important separator
and thus not available.
.IP
[3] unary ``\fB*\fR'' and ``\fB&\fR'', \fBsizeof\fR, casts and
``\fB->\fR'' \*- not relevant here.
.LP
All of the assignment operators (``\fB+=\fR'', ``\fB-=\fR'', etc.)
\fIare\fR supported by \fIMacross\fR.
.LP
\fIMacross\fR reinterprets the \fB.\fR operator in that ``\fIexpression\fB .
\fIstructfieldname\fR'' is interpreted as adding the offset value implied by
\fIstructfieldname\fR (i.e., the distance in bytes into a \fBstruct\fR to
reach the named field) to the address that is the value of \fIexpression\fR.
.LP
\fIMacross\fR adds to the operator set the following:
.IP
[1] ``\fB?\fR'' \*- as a unary operator, takes the high order byte of the
word value that is its argument.
.IP
[2] ``\fB/\fR'' \*- as a unary operator, takes the low order byte of the
word value that is its argument.
.IP
[3] ``\fB^^\fR'' \*- a binary operator, denotes logical exclusive-OR.  This
is simply an orthogonal extension for the sake of completeness.
.LP
Of course, parenthesis can be used at any point to override the normal
precedence of the various operators.  A full list of all the operators that
\fIMacross\fR understands is given in \fBAppendix E\fR.
.NH 1
\fRExpression evaluation
.PP
In order to make the most effective use of expressions in the \fIMacross\fR
environment, it is helpful (and at times necessary) to understand how and when
\fIMacross\fR evaluates them.
.PP
When \fIMacross\fR evaluates an expression, it may have one of three sorts of
results.  These are \fIsuccess\fR, \fIundefined\fR, and \fIfailure\fR.  A
\fIsuccess\fR result means that \fIMacross\fR encountered no problems
evaluating the expression, and whatever value it evaluated to is just used as
needed.  A \fIfailure\fR result indicates that there was a problem of some
sort.  Usually this is a result of some user error.  In any case, an
appropriate diagnostic message will be issued by the assembler and the
statement in which the expression was found will not be assembled.
.PP
An \fIundefined\fR result is where the complications, if any, arise.  An
expression will evaluate to an \fIundefined\fR result if one or more of the
terms of the expression are undefined symbols.  Usually these are labels which
simply haven't been encountered yet (i.e., they are forward references).  In
certain contexts, such as the operand of a machine instruction, this is a
legitimate thing to do, and in certain others, such as the condition of a
\fBmif\fR statement, this is not allowed at all.  In the latter case, an
\fIundefined\fR result is just like a \fIfailure\fR result.  In the former
case, the assembler is forced to get fancy in order to make it all work right.
.PP
What \fIMacross\fR does is squirrel away a copy of the expression along with a
pointer as to where in the object code the value of the expression is supposed
to go.  At the end of assembly, the undefined label will presumably now be
defined, and \fIMacross\fR evaluates the saved expression and pokes the result
into the appropriate location.  (If, at this point, the undefined label is
still undefined, an error message to that effect is issued).  Clearly, if an
expression has side effects (such as changing the value of some global
variable), this can result in some confusing behavior.  The \fIMacross\fR
assembler is smart enough to not let you do anything that has overt side
effects in an expression that is being saved away for future evaluation.  The
things which are disallowed in such a case are assignments and uses of the
post- and pre-increment and decrement operators (``\fB++\fR'' and
``\fB--\fR'').  Functions, however, may have side effects and \fIMacross\fR
does not try to prevent you from using function calls in expressions that get
saved for later evaluation. It can, and will, detect some, but not all, side
effects during the later evaluation and give a suitable error message.  This
is because it is perfectly legitimate to use a function call to a function
that doesn't have side effects in an expression containing forward references.
.PP
If you are now totally confused, the only thing you need remember is: \fBDon't
ever use a call to a function that has side effects in an expression
containing a forward reference.\fR
.bp
.CD
 \s+5\fBAppendix A \*- Macross 68000 Grammar\fR\s-5
\"\s+4\fBAppendix A \*- Macross 68000 Grammar\fR\s-4
.DE
.LP
.nf
\fR\fIprogram\fR:
		\*[ \fIstatement\fR Newline \*Z Endfile

\fIstatement\fR:
\*[ \fIlabel\fR \*Z	\fIopcode\fR \*[ \fIoperand\fR \*[ \fB,\fR \fIoperand\fR \*Z \*]
\*[ \fIlabel\fR \*Z	\fBif\fR \fB(\fR \fIcondition\fR \fB)\fR \fIblock\fR
			\*[ \fBelseif\fR \fB(\fR \fIcondition\fR \fB)\fR \fIblock\fR \*Z
			\*[ \fBelse\fR \fIblock\fR \*]
\*[ \fIlabel\fR \*Z	\fBwhile\fR \fB(\fR \fIcondition\fR \fB)\fR \fIblock\fR
\*[ \fIlabel\fR \*Z	\fBdo\fR \fIblock\fR \fBwhile\fR \fB(\fR \fIcondition\fR \fB)\fR
\*[ \fIlabel\fR \*Z	\fBdo\fR \fIblock\fR \fBuntil\fR \fB(\fR \fIcondition\fR \fB)\fR
		\fIdataStatement\fR
		\fBdefine\fR \fIidentifier\fR \*[ \fB=\fR \fIexpression\fR \*]
		\fBvariable\fR \fIidentifier\fR \*[ \fB=\fR \fIexpression\fR \*]
		\fBmacro\fR \fIidentifier\fR \*[ \fIidentifier\fR \*[ \fB,\fR \fIidentifier\fR \*Z \*] \fIblock\fR
		\fBfunction\fR \fIidentifier\fR \fB(\fR \*[ \fIidentifier\fR \*[ \fB,\fR \fIidentifier\fR \*Z \*]  \fB)\fR \fIblock\fR
		\fBundefine\fR \fIidentifier\fR \*[ \fB,\fR \fIidentifier\fR \*Z
\*[ \fIlabel\fR \*Z	\fIblock\fR
		\fBmdefine\fR \fIidentifier\fR \*[ \fB=\fR \fIexpression\fR \*]
		\fBmif\fR \fB(\fR \fIexpression\fR \fB)\fR \fIblock\fR
			\*[ \fBmelseif\fR \fB(\fR \fIexpression\fR \fB)\fR \fIblock\fR \*Z
			\*[ \fBmelse\fR \fIblock\fR \*]
		\fBmwhile\fR \fB(\fR \fIexpression\fR \fB)\fR \fIblock\fR
		\fBmdo\fR \fIblock\fR \fBwhile\fR \fB(\fR \fIexpression\fR \fB)\fR
		\fBmdo\fR \fIblock\fR \fBuntil\fR \fB(\fR \fIexpression\fR \fB)\fR
		\fBfreturn\fR \*[ \fIexpression\fR \*]
		\fBmfor\fR \fB(\fR \fIexpression\fR \fB,\fR \fIexpression\fR \fB,\fR \fIexpression\fR \fB)\fR \fIblock\fR
		\fBmswitch ( \fIselectionExpression \fB) {\fR
			\*[ \fBmcase ( \fIexpression\fR \*[ \fB,\fI expression\fR \*Z \fB)\fI block\fR \*Z
			\*[ \fBmdefault\fI block\fR \*]
		\fB}\fR
		\fBconstrain\fR \fB(\fR \fIexpression\fR \fB)\fR \fIblock\fR
		\fBassert\fR \fB(\fR \fIexpression\fR \fB)\fR \*[ \fIexpression\fR \*]
		\fBinclude\fR \fItextString\fR
		\fBextern\fR \fIidentifier\fR \*[ \fB,\fR \fIidentifier\fR \*Z
		\fBstart\fR \fIexpression\fR
		\fBorg\fR \fIexpression\fR
		\fBtarget\fR \fIexpression\fR
		\fIexpression\fR

\fIdataStatement\fR:
\*[ \fIlabel\fR \*Z	\fBblock\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z
\*[ \fIlabel\fR \*Z	\fBalign\fR \fIexpression\fR
\*[ \fIlabel\fR \*Z	\fBword\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z
\*[ \fIlabel\fR \*Z	\fBlong\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z
\*[ \fIlabel\fR \*Z	\fBdbyte\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z
\*[ \fIlabel\fR \*Z	\fBbyte\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z
\*[ \fIlabel\fR \*Z	\fBstring\fR \fIexpression\fR \*[ \fB,\fR \fIexpression\fR \*Z
\*[ \fIlabel\fR \*Z	\fBstruct\fR \fB{\fR \*[ \fIdataStatement\fR \*Z \fB}\fR \fIidentifier\fR
\*[ \fIlabel\fR \*Z	\fBstruct\fR \fIidentifier\fR

\fIlabel\fR:		\fIidentifier\fR \fB:\fR

\fIoperand\fR:
		\fBd\fIn\fR
		\fBa\fIn\fR
		\fBsp\fR
		\fB\s-1[\s+1\fR \fBa\fIn\fR \fB\s-1]\s+1\fR
		\fB\s-1[\s+1\fR \fBa\fIn\fR \fB\s-1]\s+1+\fR
		\fB-\s-1[\s+1\fR \fBa\fIn\fR \fB\s-1]\s+1\fR
		\fIexpression\fR
		\fIexpression\fB . w\fR
		\fIexpression\fB . l\fR
		\fB#\fR \fIexpression\fR
		\fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB\s-1]\s+1\fR
		\fBa\fIn\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z
		\fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB. w \s-1]\s+1\fR
		\fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB. l \s-1]\s+1\fR
		\fIexpression\fR \fB\s-1[\s+1\fR \fBa\fIn\fR \fB,\fR \fIrn\fR \fB\s-1]\s+1\fR
		\fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB. w \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z
		\fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB. l \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z
		\fBa\fIn\fR \fB\s-1[\s+1\fR \fIrn\fR \fB\s-1]\s+1\fR \fB.\fR \fIidentifier\fR \*[ \fB.\fR \fIidentifier\fR \*Z
		\fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB\s-1]\s+1\fR
		\fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB. w \s-1]\s+1\fR
		\fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB. l \s-1]\s+1\fR
		\fIexpression\fR \fB\s-1[\s+1\fR \fBpc\fR \fB,\fR \fIrn\fR \fB\s-1]\s+1\fR
		\fBccr\fR
		\fBsr\fR
		\fBusp\fR
		\fBsfc\fR
		\fBdfc\fR
		\fBvbr\fR
		\fItextString\fR

\fIblock\fR:		\fB{\fR \*[ \fIstatement\fR Newline \*Z \fB}\fR

\fItextString\fR:
		\fB" \fIany string you like \fB"\fR

\fIcondition\fR:
		\fIconditionCode\fR
		\fB!\fR \fIconditionCode\fR

\fIexpression\fR:
		\fIidentifier\fR
		\fIidentifier\fR \fB(\fR \*[ \fIoperand\fR \*[ \fB,\fR \fIoperand\fR \*Z \*] \fB)\fR
		\fInumber\fR
		\fBhere\fR
		\fItextString\fR
		\fB(\fR \fIexpression\fR \fB)\fR
		\fB-\fR \fIexpression\fR
		\fB!\fR \fIexpression\fR
		\fB~\fR \fIexpression\fR
		\fB?\fR \fIexpression\fR
		\fB/\fR \fIexpression\fR
		\fIexpression\fR \fB*\fR \fIexpression\fR
		\fIexpression\fR \fB/\fR \fIexpression\fR
		\fIexpression\fR \fB%\fR \fIexpression\fR
		\fIexpression\fR \fB-\fR \fIexpression\fR
		\fIexpression\fR \fB+\fR \fIexpression\fR
		\fIexpression\fR \fB<<\fR \fIexpression\fR
		\fIexpression\fR \fB>>\fR \fIexpression\fR
		\fIexpression\fR \fB<\fR \fIexpression\fR
		\fIexpression\fR \fB>\fR \fIexpression\fR
		\fIexpression\fR \fB<=\fR \fIexpression\fR
		\fIexpression\fR \fB>=\fR \fIexpression\fR
		\fIexpression\fR \fB==\fR \fIexpression\fR
		\fIexpression\fR \fB!=\fR \fIexpression\fR
		\fIexpression\fR \fB&\fR \fIexpression\fR
		\fIexpression\fR \fB|\fR \fIexpression\fR
		\fIexpression\fR \fB^\fR \fIexpression\fR
		\fIexpression\fR \fB&&\fR \fIexpression\fR
		\fIexpression\fR \fB||\fR \fIexpression\fR
		\fIexpression\fR \fB^^\fR \fIexpression\fR
		\fIexpression\fR \fB.\fR \fIidentifier\fR
		\fIidentifier\fR \fB=\fR \fIexpression\fR
		\fIidentifier\fR \fB+=\fR \fIexpression\fR
		\fIidentifier\fR \fB-=\fR \fIexpression\fR
		\fIidentifier\fR \fB*=\fR \fIexpression\fR
		\fIidentifier\fR \fB/=\fR \fIexpression\fR
		\fIidentifier\fR \fB%=\fR \fIexpression\fR
		\fIidentifier\fR \fB&=\fR \fIexpression\fR
		\fIidentifier\fR \fB|=\fR \fIexpression\fR
		\fIidentifier\fR \fB^=\fR \fIexpression\fR
		\fIidentifier\fR \fB<<=\fR \fIexpression\fR
		\fIidentifier\fR \fB>>=\fR \fIexpression\fR
		\fIidentifier\fR \fB++\fR
		\fIidentifier\fR \fB--\fR
		\fB++\fR \fIidentifier\fR
		\fB--\fR \fIidentifier\fR

\fIidentifier\fR:
		\*[\fBa\fR-\fBzA\fR-\fBZ_\fR\*]\*[\fBa\fR-\fBzA\fR-\fBZ_0\fR-\fB9\fR\*Z

\fInumber\fR:
		\fIdecimalNumber\fR
		\fIoctalNumber\fR
		\fIbinaryNumber\fR
		\fIhexadecimalNumber\fR
		\fIquarter\fR

\fIdecimalNumber\fR:
		\*[\fB1\fR-\fB9\fR\*]\*[\fB0\fR-\fB9\fR\*Z

\fIoctalNumber\fR:
		\fB0\fR\*[\fB0\fR-\fB7\fR\*Z

\fIbinaryNumber\fR:
		\fB0b\fR\*[\fB01\fR\*]\*[\fB01\fR\*Z

\fIhexadecimalNumber\fR:
		\fB0x\fR\*[\fB0\fR-\fB9a\fR-\fBf\fR\*]\*[\fB0\fR-\fB9a\fR-\fBf\fR\*Z

\fIquarter\fR:
		\fB0q\fR\*[\fB0\fR-\fB3\fR\*]\*[\fB0\fR-\fB3\fR\*Z

.fi
.bp
.CD
\s+5\fBAppendix B \*- Recognized Opcode Mnemonics\fR\s-5
\"\s+4\fBAppendix B \*- Recognized Opcode Mnemonics\fR\s-4
.sp 1
\s+3\fB(68000 version)\fR\s-3
.DE
.PP
These are the 68000 opcode mnemonics recognized by \fIMacross\fR:
.2C
.nf
\fBabcd
addb
addl
addqb
addql
addqw
addw
addxb
addxl
addxw
andb
andl
andw
aslb
asll
aslw
asrb
asrl
asrw
bcc
bchg
bclr
bcs
beq
bge
bgt
bhi
ble
bls
blt
bmi
bne
bpl
bra
bset
bsr
btst
bvc
bvs
chk
clrb
clrl
clrw
cmpb
cmpl
cmpmb
cmpml
cmpmw
cmpw
dbcc
dbcs
dbeq
dbf
dbge
dbgt
dbhi
dble
dbls
dblt
dbmi
dbne
dbpl
dbra
dbt
dbvc
dbvs
divs
divu
eorb
eorl
eorw
exg
extl
extw
illegal
jmp
jsr
lea
link
lslb
lsll
lslw
lsrb
lsrl
lsrw
movb
moveb
movel
moveml
movemw
movepl
movepw
moveq
movesb
movesl
movesw
movew
movl
movml
movmw
movpl
movpw
movq
movsb
movsl
movsw
movw
muls
mulu
nbcd
negb
negl
negw
negxb
negxl
negxw
nop
notb
notl
notw
orb
orl
orw
pea
reset
rolb
roll
rolw
rorb
rorl
rorw
roxlb
roxll
roxlw
roxrb
roxrl
roxrw
rtd
rte
rtr
rts
sbcd
scc
scs
seq
sf
sge
sgt
shi
sle
sls
slt
smi
sne
spl
st
stop
subb
subl
subqb
subql
subqw
subw
subxb
subxl
subxw
svc
svs
swap
tas
trap
trapv
tstb
tstl
tstw
unlk
.fi
.1C
.CD
\s+5\fBAppendix C \*- Condition Codes\fR\s-5
\"\s+4\fBAppendix C \*- Condition Codes\fR\s-4
.sp 1
\s+3\fB(68000 version)\fR\s-3
.DE
.PP
The \fIMacross\fR \fBif\fR, \fBwhile\fR, \fBdo-while\fR and \fBdo-until\fR
statements make use of symbols denoting the hardware condition codes of the
target processor which may be used as the conditions upon which conditional
branches are base.  In the 68000 version of \fIMacross\fR, these are the
recognized condition code symbols:
.LP
.nf
	\fBcarry\fR
	\fBequal\fR
	\fBgeq\fR
	\fBgreater\fR
	\fBgt\fR
	\fBhigh\fR
	\fBhigh_same\fR
	\fBhs\fR
	\fBless\fR
	\fBleq\fR
	\fBlow\fR
	\fBlow_same\fR
	\fBls\fR
	\fBlt\fR
	\fBminus\fR
	\fBnegative\fR
	\fBneq\fR
	\fBoverflow\fR
	\fBplus\fR
	\fBpositive\fR
	\fBzero\fR

.fi
.bp
.CD
\s+5\fBAppendix D \*- Built-In Functions\fR\s-5
\"\s+4\fBAppendix D \*- Built-In Functions\fR\s-4
.DE
.PP
Certain predefined built-in functions are supported by \fIMacross\fR for
reasons of convenience or syntactic or semantic irregularity.  They are:
.nf

\fBaddressMode(\fIoperand\fB)\fR
.fi
.RS
Returns a number whose value indicates which addressing mode \fIoperand\fR
represents \fI((define these values))\fR.
.RE
.nf

\fBapply(\fImacname\fR \*[ \fB, \fIarg\fR \*Z \fB)\fR
.fi
.RS
Assembles the macro whose name is specified by the \fBstring\fR \fImacname\fR
with the macro arguments (if any) given by the \fIarg\fRs.
.RE
.nf

\fBgetAddressRegister(\fIoperand\fB)\fR
.fi
.RS
Returns a number from 0 to 7 indicating which address register is used in
\fIoperand\fR (assuming that the address mode of \fIoperand\fR is address
register, register indirect, postincrement, predecrement, displacement or
indexed).
.RE
.nf

\fBgetDataRegister(\fIoperand\fB)\fR
.fi
.RS
Returns a number from 0 to 7 indicating which data register is used in
\fIoperand\fR (assuming that the address mode of \fIoperand\fR is data
register).
.RE
.nf

\fBgetIndexRegister(\fIoperand\fB)\fR
.fi
.RS
Returns a number from 0 to 15 indicating which register is used as the index
register in \fIoperand\fR (assuming that the address mode of operand is
indexed or program counter indexed).  The values 0 through 7 indicate the
address registers \fBa0\fR through \fBa7\fR and the values 8 through 15
indicate the data registers \fBd0\fR through \fBd7\fR.
.RE
.nf

\fBgetRegister(\fIoperand\fB)\fR
.fi
.RS
Returns a number from 0 to 15 indicating which register is used in
\fIoperand\fR.  The values 0 through 7 indicate the address registers \fBa0\fR
through \fBa7\fR and the values 8 through 15 indicate the data registers
\fBd0\fR through \fBd7\fR.
.RE
.nf

\fBgetWL(\fIoperand\fB)\fR
.fi
.RS
Returns a number 0 or 1 indicatng whether \fIoperand\fR is a word operand or a
long operand (assuming that the address mode of \fIoperand\fR is absolute,
indexed or program counter indexed).
.RE
.nf

\fBisAbsoluteLongMode(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is
absolute long, otherwise \fBFALSE\fR.
.RE
.nf

\fBisAbsoluteMode(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is
absolute (short or long), otherwise \fBFALSE\fR.
.RE
.nf

\fBisAbsoluteShortMode(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is
absolute short, otherwise \fBFALSE\fR.
.RE
.nf

\fBisAbsoluteValue(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is an absolute (i.e.,
non-relocatable) value, otherwise \fBFALSE\fR.
.RE
.bp
.nf
\fBisARegister(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is an address register,
otherwise \fBFALSE\fR.
.RE
.nf

\fBisBlock(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is a block, otherwise
\fBFALSE\fR.
.RE
.nf

\fBisBuiltInFunction(\fIsymbol\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIsymbol\fR is a built-in function,
otherwise \fBFALSE\fR.
.RE
.nf

\fBisCCRegister(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is the condition code
register, otherwise \fBFALSE\fR.
.RE
.nf

\fBisConditionCode(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is a condition code,
otherwise \fBFALSE\fR.
.RE
.nf

\fBisControlRegister(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is a control register
(\fBusp\fR, \fBdfc\fR, \fBsfc\fR, or \fBvbr\fR), otherwise \fBFALSE\fR.
.RE
.nf

\fBisDefined(\fIsymbol\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIsymbol\fR has been defined, otherwise
\fBFALSE\fR.
.RE
.nf

\fBisDFCRegister(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is the destination function
code register, otherwise \fBFALSE\fR.
.RE
.nf

\fBisDRegister(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is a data register, otherwise
\fBFALSE\fR.
.RE
.nf

\fBisDisplacementMode(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR
displacment, otherwise \fBFALSE\fR.
.RE
.nf

\fBisExternal(\fIsymbol\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIsymbol\fR is external (i.e., visible
outside the file in which it is defined), otherwise \fBFALSE\fR.
.RE
.nf

\fBisField(\fIsymbol\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIsymbol\fR is a field of a struct,
otherwise \fBFALSE\fR.
.RE
.nf

\fBisFunction(\fIsymbol\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIsymbol\fR is a user defined function,
otherwise \fBFALSE\fR.
.RE
.nf

\fBisImmediateMode(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is
\fIimmediate\fR, otherwise \fBFALSE\fR.
.RE
.nf

\fBisIndexedMode(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is an
indexed mode, otherwise \fBFALSE\fR.
.RE
.nf

\fBisPostincrementMode(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is
postincrement, otherwise \fBFALSE\fR.
.RE
.nf

\fBisPredecrementMode(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if the address mode of \fIoperand\fR is
predecrement, otherwise \fBFALSE\fR.
.RE
.nf

\fBisRelocatableValue(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is a relocatable value,
otherwise \fBFALSE\fR.
.RE
.nf

\fBisSFCRegister(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is the source function code
register, otherwise \fBFALSE\fR.
.RE
.nf

\fBisStatusRegister(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is the status register,
otherwise \fBFALSE\fR.
.RE
.nf

\fBisString(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is a string, otherwise
\fBFALSE\fR.
.RE
.nf

\fBisStruct(\fIsymbol\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIsymbol\fR is the name of a struct,
otherwise \fBFALSE\fR.
.RE
.nf

\fBisSymbol(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is a symbol (as opposed to an
expression or a number, for example), otherwise \fBFALSE\fR.
.RE
.nf

\fBisUSP(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is the user stack pointer,
otherwise \fBFALSE\fR.
.RE
.nf

\fBisVBRegister(\fIoperand\fB)\fR
.fi
.RS
Returns \fBTRUE\fR if and only if \fIoperand\fR is the vector base register,
otherwise \fBFALSE\fR.
.RE
.nf

\fBlistingOff()\fR
.fi
.RS
If assembly listing has been enabled using the \fB-l\fR command line flag,
turn listing off temporarily.  Otherwise, no effect.
.RE
.nf

\fBlistingOn()\fR
.fi
.RS
If assembly listing was turned off using the \fBlistingOff()\fR function, turn
it back on again.  If listings have been globally disabled by not specifying
the \fB-l\fR command line flag, this function has no effect.  The
\fBlistingOff()\fR and \fBlistingOn()\fR functions are intended to be used to
together to control assembly listings of large programs.  They can be used to
suppress listing of large and uninteresting sections such as header files full
of definitions of global values.  These functions may nest: in effect
\fBlistingOff()\fR increments a counter and \fBlistingOn()\fR decrements it.
Only when the counter is zero (i.e., the number of \fBlistingOn()\fRs matches
the number of \fBlistingOff()\fRs) does listing actually occur.
.RE
.nf

\fBprintf(\fIformat\fR \*[ \fB, \fIarg\fR \*Z \fB)\fR
.fi
.RS
A formatted print routine just like the Unix system subroutine of the same
name.
.RE
.nf

\fBstrcat(\fIstring1\fB, \fIstring2\fB)\fR
.fi
.RS
Returns a string which is the concatenation of the two operands, which must
themselves be strings.
.RE
.nf

\fBstrcmp(\fIstring1\fB, \fIstring2\fB)\fR
.fi
.RS
Returns a number which is less than, equal to, or greater than 0 depending
upon whether \fIstring1\fR is lexically less than, equal to, or greater than
\fIstring2\fR.  The ASCII character set is used.  The two operands, of course,
must be strings.
.RE
.nf

\fBstrcmplc(\fIstring1\fB, \fIstring2\fB)\fR
.fi
.RS
Essentially the same as \fBstrcmp()\fR except that alphabetic characters are
converted to lower case before being compared.  The result is a
case-independent string comparison.  This is useful for comparing two
identifier name strings to see if they represent the same symbols.
.RE
.nf

\fBstrlen(\fIstring\fB)\fR
.fi
.RS
Returns a number which is the length, in characters, of \fIstring\fR.
.RE
.nf

\fBsubstr(\fIstring\fB, \fIstartPos\fR \*[\fB , \fIlength\fR \*] \fB)\fR
.fi
.RS
Returns a substring of the string \fIstring\fR starting from the character at
start position \fIstartPos\fR (counting the first character from 0) and
continuing for \fIlength\fR characters.  If \fIstartPos\fR is negative, the
start position is counted from right to left (with the rightmost character
position being indicated by -1) instead of the more usual left to right.  If
\fIlength\fR is negative, \fIstartPos\fR in essence denotes the end of the
desired substring and \fIlength\fR characters up to that position are
returned.  If \fIlength\fR is omitted, the substring from \fIstartPos\fR to
the end of the string is returned, if \fIstartPos\fR is positive, or to the
beginning of the string, if \fIstartPos\fR is negative.  If any of the indices
cause the substring bounds to go off the end of \fIstring\fR an error results.
For example,
.nf
	\fBsubstr("hello there", 6, 3)\fR	yields \fB"the"\fR
	\fBsubstr("hello there", -8, 2)\fR	yields \fB"lo"\fR
	\fBsubstr("hello there", 6, -3)\fR	yields \fB"o t"\fR
	\fBsubstr("hello there", -8, -4)\fR	yields \fB"hell"\fR
	\fBsubstr("hello there", 6)\fR		yields \fB"there"\fR
	\fBsubstr("hello there", -7)\fR		yields \fB"hello"\fR
.fi
.RE
.nf

\fBsymbolLookup(\fIstring\fB)\fR
.fi
.RS
A call to this function with a string operand is equivalent to a reference to
the symbol that the string represents.  For example, 
.nf
	\fBand	symbolLookup("foo")\fR
.fi
is equivalent to
.nf
	\fBand	foo\fR
.fi
.RE
.nf

\fBsymbolName(\fIsymbol\fB)\fR
.fi
.RS
Returns a string which is the name of the symbol \fIsymbol\fR.  For example,
\fBsymbolName(foo)\fR would return \fB"foo"\fR.  This can be used in
conjunction with the \fBsymbolLookup\fR function so that the following:
.nf
	\fBand	symbolLookup(strcat(symbolName(foo), "bar"))\fR
.fi
is equivalent to
.nf
	\fBand	foobar\fR
.fi
.RE
.nf

\fBsymbolUsage(\fIsymbol\fB)\fR
.fi
.RS
Returns a number whose value indicates what sort of symbol \fIsymbol\fR is
(i.e., label, function, struct field, etc.).  \fI((define these values))\fR
.RE
.nf

\fBvalueType(\fIthing\fB)\fR
.fi
.RS
Returns a number whose value indicates the type of \fIthing\fR (i.e., symbol,
condition code, number, block, etc.).  \fI((define these values))\fR
.RE

.fi
.bp
.CD
\s+5\fBAppendix E \*- Operator Set\fR\s-5
\"\s+4\fBAppendix E \*- Operator Set\fR\s-4
.DE
.PP
This appendix describes the (\fBC\fR derived) operators supported by
\fIMacross\fR.
.nf

	\fB-\fR \fIexpression\fR				integer negation
	\fB!\fR \fIexpression\fR				logical negation (0 goes to 1, all other values go to 0)
	\fB~\fR \fIexpression\fR				bitwise negation (ones complement)
	\fB?\fR \fIexpression\fR				high byte
	\fB/\fR \fIexpression\fR				low byte
	\fIexpression\fR \fB*\fR \fIexpression\fR		integer multiplication
	\fIexpression\fR \fB/\fR \fIexpression\fR		integer division
	\fIexpression\fR \fB%\fR \fIexpression\fR		integer modulus (remainder)
	\fIexpression\fR \fB-\fR \fIexpression\fR		integer subtraction
	\fIexpression\fR \fB+\fR \fIexpression\fR		integer addition
	\fIexpression\fR \fB<<\fR \fIexpression\fR		left shift
	\fIexpression\fR \fB>>\fR \fIexpression\fR		right shift
	\fIexpression\fR \fB<\fR \fIexpression\fR		less than
	\fIexpression\fR \fB>\fR \fIexpression\fR		greater than
	\fIexpression\fR \fB<=\fR \fIexpression\fR		less than or equal to
	\fIexpression\fR \fB>=\fR \fIexpression\fR		greater than or equal to
	\fIexpression\fR \fB==\fR \fIexpression\fR		equal to
	\fIexpression\fR \fB!=\fR \fIexpression\fR		not equal to
	\fIexpression\fR \fB&\fR \fIexpression\fR		bitwise AND
	\fIexpression\fR \fB|\fR \fIexpression\fR			bitwise OR
	\fIexpression\fR \fB^\fR \fIexpression\fR		bitwise XOR
	\fIexpression\fR \fB&&\fR \fIexpression\fR		logical AND
	\fIexpression\fR \fB||\fR \fIexpression\fR		logical OR
	\fIexpression\fR \fB^^\fR \fIexpression\fR		logical XOR
	\fIexpression\fR \fB.\fR \fIidentifier\fR			struct field selection
	\fIidentifier\fR \fB=\fR \fIexpression\fR		assignment
	\fIidentifier\fR \fB+=\fR \fIexpression\fR		assignment with addition
	\fIidentifier\fR \fB-=\fR \fIexpression\fR		assignment with subtraction
	\fIidentifier\fR \fB*=\fR \fIexpression\fR		assignment with multiplication
	\fIidentifier\fR \fB/=\fR \fIexpression\fR		assignment with division
	\fIidentifier\fR \fB%=\fR \fIexpression\fR		assignment with modulus
	\fIidentifier\fR \fB&=\fR \fIexpression\fR		assignment with AND
	\fIidentifier\fR \fB|=\fR \fIexpression\fR		assignment with OR
	\fIidentifier\fR \fB^=\fR \fIexpression\fR		assignment with XOR
	\fIidentifier\fR \fB<<=\fR \fIexpression\fR		assignment with left shift
	\fIidentifier\fR \fB>>=\fR \fIexpression\fR		assignment with right shift
	\fIidentifier\fR \fB++\fR				post-increment
	\fIidentifier\fR \fB--\fR				post-decrement
	\fB++\fR \fIidentifier\fR				pre-increment
	\fB--\fR \fIidentifier\fR				pre-decrement

.fi
.bp
.CD
\s+5\fB Appendix F \*- Character Escape Codes\fR\s-5
\"\s+4\fB Appendix F \*- Character Escape Codes\fR\s-4
.DE
.PP
Like \fBC\fR, \fIMacross\fR enables you to use the ``\fB\\\fR'' character as
an escape to embed quotation marks, formatting characters (such as newline)
and other non-printing characters in character strings and character
constants.  The recognized codes are:
.nf

	\fB\\n\fR		newline
	\fB\\t\fR		horizontal tab
	\fB\\b\fR		backspace
	\fB\\r\fR		carriage return
	\fB\\f\fR		form feed
	\fB\\e\fR		escape
	\fB\\\\\fR		backslash
	\fB\\'\fR		apostrophe
	\fB\\"\fR		quote
	\fB\\^\fIc\fR		CONTROL-\fIc\fR (where \fIc\fR is any character).
	\fB\\\fIddd\fR		arbitrary byte (where \fIddd\fR is one, two or three octal digits).
.fi