GASP commands have a straightforward syntax that fits in well with assembly conventions. In general, a command extends for a line, and may have up to three fields: an optional label, the command itself, and optional arguments to the command. You can write commands in upper or lower case, though this manual shows them in upper case. See section Details of the GASP syntax, for more information.
The conditional-assembly directives allow you to include or exclude portions of an assembly depending on how a pair of expressions, or a pair of strings, compare.
The overall structure of conditionals is familiar from many other
contexts. .AIF marks the start of a conditional, and precedes
assembly for the case when the condition is true. An optional
.AELSE precedes assembly for the converse case, and an
.AENDI marks the end of the condition.
You may nest conditionals up to a depth of 100; GASP rejects nesting beyond that, because it may indicate a bug in your macro structure.
Conditionals are primarily useful inside macro definitions, where you often need different effects depending on argument values. See section Defining your own directives, for details about defining macros.
.AIF expra cmp exprb
.AIF "stra" cmp "strb"
.AIF
preprocessor command. You may compare either two strings, or two
expressions.
When you compare strings, only two conditional cmp comparison
operators are available: `EQ' (true if stra and strb
are identical), and `NE' (the opposite).
When you compare two expressions, both expressions must be
absolute (see section Arithmetic expressions in GASP). You
can use these cmp comparison operators with expressions:
EQ
NE
LT
LE
GT
GE
.AELSE
.AIF and
.AENDI).
.AENDI
Two preprocessor directives allow you to repeatedly issue copies of the same block of assembly code.
.AREPEAT aexp
.AENDR
.AREPEAT and .AENDR. Specify the number of
copies as aexp (which must be an absolute expression). For
example, this repeats two assembly statements three times in succession:
.AREPEAT 3
rotcl r2
div1 r0,r1
.AENDR
.AWHILE expra cmp exprb
.AENDW
.AWHILE stra cmp strb
.AENDW
.AWHILE.
.AENDW marks the end of the repeated block. The conditional
comparison works exactly the same way as for .AIF, with the same
comparison operators (see section Conditional assembly).
Since the terms of the comparison must be absolute expression,
.AWHILE is primarily useful within macros. See section Defining your own directives.
You can use the .EXITM preprocessor directive to break out of
loops early (as well as to break out of macros). See section Defining your own directives.
You can use variables in GASP to represent strings, registers, or the results of expressions.
You must distinguish two kinds of variables:
.EQU or .ASSIGN. To evaluate this
kind of variable in your assembly output, simply mention its name. For
example, these two lines define and use a variable `eg':
eg .EQU FLIP-64
...
mov.l eg,r0
Do not use this kind of variable in conditional expressions or
while loops; GASP only evaluates these variables when writing
assembly output.
.ASSIGNC or .ASSIGNA. To evaluate this
kind of variable, write `\&' before the variable name; for example,
opcit .ASSIGNA 47
...
.AWHILE \&opcit GT 0
...
.AENDW
GASP treats macro arguments almost the same way, but to evaluate
them you use the prefix `\' rather than `\&'.
See section Defining your own directives.
pvar .EQU expr
pvar .ASSIGN expr
.EQU, save that you may not redefine
pvar using .ASSIGN once it has a value.
pvar .ASSIGNA aexpr
.ASSIGNA at any time.
pvar .ASSIGNC "str"
.ASSIGNC at any time.
pvar .REG (register)
.REG to define a variable that represents a register. In
particular, register is not evaluated as an expression.
You may use .REG at will to redefine register variables.
All these directives accept the variable name in the "label" position, that is at the left margin. You may specify a colon after the variable name if you wish; the first example above could have started `eg:' with the same effect.
The commands .MACRO and .ENDM allow you to define macros
that generate assembly output. You can use these macros with a syntax
similar to built-in GASP or assembler directives. For example,
this definition specifies a macro SUM that adds together a range of
consecutive registers:
.MACRO SUM FROM=0, TO=9
! \FROM \TO
mov r\FROM,r10
COUNT .ASSIGNA \FROM+1
.AWHILE \&COUNT LE \TO
add r\&COUNT,r10
COUNT .ASSIGNA \&COUNT+1
.AENDW
.ENDM
With that definition, `SUM 0,5' generates this assembly output:
! 0 5
mov r0,r10
add r1,r10
add r2,r10
add r3,r10
add r4,r10
add r5,r10
.MACRO macname
.MACRO macname macargs ...
.MACRO statements:
.MACRO COMM
COMM, which takes no
arguments.
.MACRO PLUS1 P, P1
.MACRO PLUS1 P P1
PLUS1,
which takes two arguments; within the macro definition, write
`\P' or `\P1' to evaluate the arguments.
.MACRO RESERVE_STR P1=0 P2
RESERVE_STR, with two
arguments. The first argument has a default value, but not the second.
After the definition is complete, you can call the macro either as
`RESERVE_STR a,b' (with `\P1' evaluating to
a and `\P2' evaluating to b), or as `RESERVE_STR
,b' (with `\P1' evaluating as the default, in this case
`0', and `\P2' evaluating to b).
name .MACRO
name .MACRO ( macargs ... )
.ENDM
.EXITM
.AREPEAT loop, or
.AWHILE loop.
\@
LOCAL name [ , ... ]
LOCAL is only available if you select "alternate
macro syntax" with `-a' or `--alternate'. See section Alternate macro syntax.
Generate a string replacement for each of the name arguments, and
replace any instances of name in each macro expansion. The
replacement string is unique in the assembly, and different for each
separate macro expansion. LOCAL allows you to write macros that
define symbols, without fear of conflict between separate macro expansions.
In assembly code, you often need to specify working areas of memory; depending on the application, you may want to initialize such memory or not. GASP provides preprocessor directives to help you avoid repetitive coding for both purposes.
You can use labels as usual to mark the data areas.
These are the GASP directives for initialized data, and the standard GNU assembler directives they expand to:
.DATA expr, expr, ...
.DATA.B expr, expr, ...
.DATA.W expr, expr, ...
.DATA.L expr, expr, ...
as directive (labelled with lab). The unqualified
.DATA emits `.long'; .DATA.B emits `.byte';
.DATA.W emits `.short'; and .DATA.L emits
`.long'.
For example, `foo .DATA 1,2,3' emits `foo: .long 1,2,3'.
.DATAB repeat, expr
.DATAB.B repeat, expr
.DATAB.W repeat, expr
.DATAB.L repeat, expr
as emit repeat copies of the value of the expression
expr (using the as directive .fill).
`.DATAB.B' repeats one-byte values; `.DATAB.W' repeats
two-byte values; and `.DATAB.L' repeats four-byte values.
`.DATAB' without a suffix repeats four-byte values, just like
`.DATAB.L'.
repeat must be an absolute expression with a positive value.
.SDATA "str" ...
.SDATA concatenates multiple
arguments, making it easy to switch between string representations. You
can use commas to separate the individual arguments for clarity, if you
choose.
.SDATAB repeat, "str" ...
.SDATA.
.SDATAZ "str" ...
.SDATA, except that
.SDATAZ writes a zero byte at the end of the string.
.SDATAC "str" ...
.SDATA, except that
GASP precedes the string with a leading one-byte count. For
example, `.SDATAC "HI"' generates `.byte 2,72,73'. Since the
count field is only one byte, you can only use .SDATAC for
strings less than 256 bytes in length.
Use the .RES, .SRES, .SRESC, and .SRESZ
directives to reserve memory and leave it uninitialized. GASP
resolves these directives to appropriate calls of the GNU
as .space directive.
.RES count
.RES.B count
.RES.W count
.RES.L count
.RES.B reserves
count bytes, .RES.W reserves count pairs of bytes,
and .RES.L reserves count quartets. .RES without a
suffix is equivalent to .RES.L.
.SRES count
.SRES.B count
.SRES.W count
.SRES.L count
.SRES is a synonym for `.RES'.
.SRESC count
.SRESC.B count
.SRESC.W count
.SRESC.L count
.SRES, but reserves space for count+1 elements.
.SRESZ count
.SRESZ.B count
.SRESZ.W count
.SRESZ.L count
.SRES, but reserves space for count+1 elements.
The GASP listing-control directives correspond to
related GNU as directives.
.PRINT LIST
.PRINT NOLIST
as directive
.list or .nolist, according to its argument. See section `.list' in Using as, for details on how these directives
interact.
.FORM LIN=ln
.FORM COL=cols
.FORM LIN=ln COL=cols
.FORM
do not carry over as defaults.) Emits the .psize
assembler directive.
.HEADING string
.PAGE
.ALTERNATE
.ORG
.ORG.
.RADIX s
.RADIX B
.RADIX Q
.RADIX D
.RADIX H
.EXPORT name
.GLOBAL name
.PROGRAM
.END
.INCLUDE "str"
.INCLUDE directive does. GASP imposes a maximum
limit of 30 stacked include files, as a sanity check.
.ALIGN size
Since GASP is meant to work with assembly code, its statement syntax has no surprises for the assembly programmer.
Whitespace (blanks or tabs; not newline) is partially significant, in that it delimits up to three fields in a line. The amount of whitespace does not matter; you may line up fields in separate lines if you wish, but GASP does not require that.
The first field, an optional label, must be flush left in a line (with no leading whitespace) if it appears at all. You may use a colon after the label if you wish; GASP neither requires the colon nor objects to it (but will not include it as part of the label name).
The second field, which must appear after some whitespace, contains a GASP or assembly directive.
Any further fields on a line are arguments to the directive; you can separate them from one another using either commas or whitespace.
GASP recognizes a few special markers: to delimit comments, to continue a statement on the next line, to separate symbols from other characters, and to copy text to the output literally. (One other special marker, `\@', works only within macro definitions; see section Defining your own directives.)
The trailing part of any GASP source line may be a comment. A comment begins with the first unquoted comment character (`!' by default), or an escaped or doubled comment character (`\!' or `!!' by default), and extends to the end of a line. You can specify what comment character to use with the `-c' option (see section Command Line Options). The two kinds of comment markers lead to slightly different treatment:
!
.ASSIGNA or
.ASSIGNC) present. For example, a macro that begins like this
.MACRO SUM FROM=0, TO=9
! \FROM \TO
issues as the first line of output a comment that records the
values you used to call the macro.
\!
!!
To continue a statement on the next line of the file, begin the second line with the character `+'.
Occasionally you may want to prevent GASP from preprocessing some particular bit of text. To copy literally from the GASP source to its output, place `\(' before the string to copy, and `)' at the end. For example, write `\(\!)' if you need the characters `\!' in your assembly output.
To separate a preprocessor variable from text to appear
immediately after its value, write a single quote ('). For
example, `.SDATA "\P'1"' writes a string built by concatenating the
value of P and the digit `1'. (You cannot achieve this by
writing just `\P1', since `P1' is itself a valid name for a
preprocessor variable.)
There are two ways of writing string constants in GASP: as
literal text, and by numeric byte value. Specify a string literal
between double quotes ("str"). Specify an individual
numeric byte value as an absolute expression between angle brackets
(<expr>. Directives that output strings allow you to
specify any number of either kind of value, in whatever order is
convenient, and concatenate the result. (Alternate syntax mode
introduces a number of alternative string notations; see section Alternate macro syntax.)
You can write numeric constants either in a specific base, or in
whatever base is currently selected (either 10, or selected by the most
recent .RADIX).
To write a number in a specific base, use the pattern
s'ddd: a base specifier character s, followed
by a single quote followed by digits ddd. The base specifier
character matches those you can specify with .RADIX: `B' for
base 2, `Q' for base 8, `D' for base 10, and `H' for base
16. (You can write this character in lower case if you prefer.)
GASP recognizes symbol names that start with any alphabetic character, `_', or `$', and continue with any of the same characters or with digits. Label names follow the same rules.
There are two kinds of expressions, depending on their result: absolute expressions, which resolve to a constant (that is, they do not involve any values unknown to GASP), and relocatable expressions, which must reduce to the form
addsym+const-subsym
where addsym and subsym are assembly symbols of unknown value, and const is a constant.
Arithmetic for GASP expressions follows very similar rules to C. You can use parentheses to change precedence; otherwise, arithmetic primitives have decreasing precedence in the order of the following list.
+ (identity), - (arithmetic opposite), or
~ (bitwise negation). The argument must be an absolute
expression.
* (multiplication) and / (division). Both arguments
must be absolute expressions.
+ (addition) and - (subtraction). At least one argument
must be absolute.
& (bitwise and). Both arguments must be absolute.
| (bitwise or) and ~ (bitwise exclusive or; ^ in
C). Both arguments must be absolute.
You can use these primitives to manipulate strings (in the argument field of GASP statements):
.LEN("str")
"str", as an absolute
expression. For example, `.RES.B .LEN("sample")' reserves six
bytes of memory.
.INSTR("string", "seg", ix)
2.
The result is -1 if seg does not occur in string
after position ix.
.SUBSTR("string",start,len)
If you specify `-a' or `--alternate' on the GASP command
line, the preprocessor uses somewhat different syntax. This syntax is
reminiscent of the syntax of Phar Lap macro assembler, but it
is not meant to be a full emulation of Phar Lap or similar
assemblers. In particular, GASP does not support directives such
as DB and IRP, even in alternate syntax mode.
In particular, `-a' (or `--alternate') elicits these differences:
LOCAL, is available. See section Defining your own directives, for an explanation of how to use
LOCAL.
"string":
'string'
<string>
Go to the first, previous, next, last section, table of contents.