64tass v1.53 r1515 reference manual This is the manual for 64tass, the multi pass optimizing macro assembler for the 65xx series of processors. Key features: * Open source portable C with minimal dependencies * Familiar syntax to Omicron TASS and TASM * Supports 6502, 65C02, R65C02, W65C02, 65CE02, 65816, DTV, 65EL02, 4510 * Arbitrary-precision integers and bit strings, double precision floating point numbers * Character and byte strings, array arithmetic * Handles UTF-8, UTF-16 and 8 bit RAW encoded source files, Unicode character strings * Supports Unicode identifiers with compatibility normalization and optional case insensitivity * Built-in `linker' with section support * Various memory models, binary targets and text output formats (also Hex/ S-record) * Assembly and label listings available for debugging or exporting * Conditional compilation, macros, structures, unions, scopes Contrary how the length of this document suggests 64tass can be used with just basic 6502 assembly knowledge in simple ways like any other assembler. If some advanced functionality is needed then this document can serve as a reference. This is a development version. Features or syntax may change as a result of corrections in non-backwards compatible ways in some rare cases. It's difficult to get everything `right' first time. Project page: http://sourceforge.net/projects/tass64/ The page hosts the latest and older versions with sources and a bug and a feature request tracker. ------------------------------------------------------------------------------- Table of Contents * Table of Contents * Usage tips * Expressions and data types + Integer constants + Bit string constants + Floating point constants + Character string constants + Byte string constants + Lists and tuples + Dictionaries + Code + Addressing modes + Uninitialized memory + Booleans + Types + Symbols o Regular symbols o Local symbols o Anonymous symbols o Constant and re-definable symbols o The star label + Built-in functions o Mathematical functions o Other functions + Expressions o Operators o Comparison operators o Bit string extraction operators o Conditional operators o Address length forcing o Compound assignment o Slicing and indexing * Compiler directives + Controlling the compile offset and program counter + Dumping data o Storing numeric values o Storing string values + Text encoding + Structured data o Structure o Union o Combined use of structures and unions + Macros o Parameter references o Text references + Custom functions + Conditional assembly o If, else if, else o Switch, case, default + Repetitions + Including files + Scopes + Sections + 65816 related + Controlling errors + Target + Misc + Printer control * Pseudo instructions + Aliases + Always taken branches + Long branches * Original turbo assembler compatibility + How to convert source code for use with 64tass + Differences to the original turbo ass macro on the C64 + Labels + Expression evaluation + Macros + Bugs * Command line options + Output options + Operation options + Diagnostic options + Target selection on command line + Symbol listing + Assembly listing + Other options * Messages + Warnings + Errors + Fatal errors * Credits * Default translation and escape sequences + Raw 8-bit source o The none encoding for raw 8-bit o The screen encoding for raw 8-bit + Unicode and ASCII source o The none encoding for Unicode o The screen encoding for Unicode * Opcodes + Standard 6502 opcodes + 6502 illegal opcodes + 65DTV02 opcodes + Standard 65C02 opcodes + R65C02 opcodes + W65C02 opcodes + W65816 opcodes + 65EL02 opcodes + 65CE02 opcodes + CSG 4510 opcodes * Appendix + Assembler directives + Built-in functions + Built-in types ------------------------------------------------------------------------------- Usage tips 64tass is a command line assembler, the source can be written in any text editor. As a minimum the source filename must be given on the command line. The `-a' command line option is highly recommended if the source is Unicode or ASCII. 64tass -a src.asm There are also some useful parameters which are described later. For comfortable compiling I use such `Makefile's (for make): demo.prg: source.asm macros.asm pic.drp music.bin 64tass -C -a -B -i source.asm -o demo.tmp pucrunch -ffast -x 2048 demo.tmp >demo.prg This way `demo.prg' is recreated by compiling `source.asm' whenever `source.asm', `macros.asm', `pic.drp' or `music.bin' had changed. Of course it's not much harder to create something similar for win32 (make.bat), however this will always compile and compress: 64tass.exe -C -a -B -i source.asm -o demo.tmp pucrunch.exe -ffast -x 2048 demo.tmp >demo.prg Here's a slightly more advanced Makefile example with default action as testing in VICE, clean target for removal of temporary files and compressing using an intermediate temporary file: all: demo.prg x64 -autostartprgmode 1 -autostart-warp +truedrive +cart $< demo.prg: demo.tmp pucrunch -ffast -x 2048 $< >$@ demo.tmp: source.asm macros.asm pic.drp music.bin 64tass -C -a -B -i $< -o $@ .INTERMEDIATE: demo.tmp .PHONY: all clean clean: $(RM) demo.prg demo.tmp It's useful to add a basic header to your source files like the one below, so that the resulting file is directly runnable without additional compression: * = $0801 .word (+), 2005 ;pointer, line number .null $9e, format("%d", start);will be sys 4096 + .word 0 ;basic line end * = $1000 start rts A frequently coming up question is, how to automatically allocate memory, without hacks like *=*+1? Sure there's .byte and friends for variables with initial values but what about zero page, or RAM outside of program area? The solution is to not use an initial value by using `?' or not giving a fill byte value to .fill. * = $02 p1 .word ? ;a zero page pointer temp .fill 10 ;a 10 byte temporary area Space allocated this way is not saved in the output as there's no data to save at those addresses. What about some code running on zero page for speed? It needs to be relocated, and the length must be known to copy it there. Here's an example: ldx #size(zpcode)-1;calculate length - lda zpcode,x sta wrbyte,x dex ;install to zero page bpl - jsr wrbyte rts ;code continues here but is compiled to run from $02 zpcode .logical $02 wrbyte sta $ffff ;quick byte writer at $02 inc wrbyte+1 bne + inc wrbyte+2 + rts .here The assembler supports lists and tuples, which does not seems interesting at first as it sound like something which is only useful when heavy scripting is involved. But as normal arithmetic operations also apply on all their elements at once, this could spare quite some typing and repetition. Let's take a simple example of a low/high byte jump table of return addresses, this usually involves some unnecessary copy/pasting to create a pair of tables with constructs like >(label-1). jumpcmd lda hibytes,x ; selected routine in X register pha lda lobytes,x ; push address to stack pha rts ; jump, rts will increase pc by one! ; Build an anonymous list of jump addresses minus 1 - = (cmd_p, cmd_c, cmd_m, cmd_s, cmd_r, cmd_l, cmd_e)-1 lobytes .byte <(-) ; low bytes of jump addresses hibytes .byte >(-) ; high bytes There are some other tips below in the descriptions. ------------------------------------------------------------------------------- Expressions and data types Integer constants Integer constants can be entered as decimal digits of arbitrary length. An underscore can be used between digits as a separator for better readability of long numbers. The following operations are accepted: Integer operators and functions x + y add x to y 2 + 2 is 4 x - y subtract y from x 4 - 1 is 3 x * y multiply x with y 2 * 3 is 6 x / y integer divide x by y 7 / 2 is 3 x % y integer modulo of x divided by y 5 % 2 is 1 x ** y x raised to power of y 2 ** 4 is 16 -x negated value -2 is -2 +x unchanged +2 is 2 ~x -x - 1 ~3 is -4 x | y bitwise or 2 | 6 is 6 x ^ y bitwise xor 2 ^ 6 is 4 x & y bitwise and 2 & 6 is 2 x << y logical shift left 1 << 3 is 8 x >> y arithmetic shift right -8 >> 3 is -1 Integers are automatically promoted to float as necessary in expressions. Other types can be converted to integer using the integer type int. .byte 23 ; decimal lda #((bitmap >> 10) & $0f) | ((screen >> 6) & $f0) sta $d018 Bit string constants Bit string constants can be entered in hexadecimal form with a leading dollar sign or in binary with a leading percent sign. An underscore can be used between digits as a separator for better readability of long numbers. The following operations are accepted: Bit string operators and functions ~x invert bits ~%101 is ~%101 y .. x concatenate bits $a .. $b is $ab y x n repeat %101 x 3 is %101101101 x[n] extract bit(s) $a[1] is %1 x[s] slice bits $1234[4:8] is $3 x | y bitwise or ~$2 | $6 is ~$0 x ^ y bitwise xor ~$2 ^ $6 is ~$4 x & y bitwise and ~$2 & $6 is $4 x << y bitwise shift left $0f << 4 is $0f0 x >> y bitwise shift right ~$f4 >> 4 is ~$f Length of bit string constants are defined in bits and is calculated from the number of bit digits used including leading zeros. Bit strings are automatically promoted to integer or floating point as necessary in expressions. The higher bits are extended with zeros or ones as needed. Bit strings support indexing and slicing. This is explained in detail in section `Slicing and indexing'. Other types can be converted to bit string using the bit string type bits. .byte $33 ; hex .byte %00011111 ; binary .text $1234 ; $34, $12 lda $01 and #~$07 ora #$05 sta $01 lda $d015 and #~%00100000 ;clear a bit sta $d015 Floating point constants Floating point constants have a radix point in them and optionally an exponent. A decimal exponent is `e' while a binary one is `p'. An underscore can be used between digits as a separator for better readability. The following operations can be used: Floating point operators and functions x + y add x to y 2.2 + 2.2 is 4.4 x - y subtract y from x 4.1 - 1.1 is 3.0 x * y multiply x with y 1.5 * 3 is 4.5 x / y integer divide x by y 7.0 / 2.0 is 3.5 x % y integer modulo of x divided by y 5.0 % 2.0 is 1.0 x ** y x raised t power of y 2.0 ** -1 is 0.5 -x negated value -2.0 is -2.0 +x unchanged +2.0 is 2.0 x | y bitwise or 2.5 | 6.5 is 6.5 x ^ y bitwise xor 2.5 ^ 6.5 is 4.0 x & y bitwise and 2.5 & 6.5 is 2.5 x << y logical shift left 1.0 << 3.0 is 8.0 x >> y arithmetic shift right -8.0 >> 4 is -0.5 ~x almost -x ~2.1 is almost -2.1 As usual comparing floating point numbers for (non) equality is a bad idea due to rounding errors. The only predefined constant is pi. Floating point numbers are automatically truncated to integer as necessary. Other types can be converted to floating point by using the type float. Fixed point conversion can be done by using the shift operators. For example a 8.16 fixed point number can be calculated as (3.14 << 16) & $ffffff. The binary operators operate like if the floating point number would be a fixed point one. This is the reason for the strange definition of inversion. .byte 3.66e1 ; 36.6, truncated to 36 .byte $1.8p4 ; 4:4 fixed point number (1.5) .sint 12.2p8 ; 8:8 fixed point number (12.2) Character string constants Character strings are enclosed in single or double quotes and can hold any Unicode character. Operations like indexing or slicing are always done on the original representation. The current encoding is only applied when it's used in expressions as numeric constants or in context of text data directives. Doubling the quotes inside string literals escapes them and results in a single quote. Character string operators and functions y .. x concatenate strings "a" .. "b" is "ab" y in x is substring of "b" in "abc" is true a x n repeat "ab" x 3 is "ababab" a[i] character from start "abc"[1] is "b" a[i] character from end "abc"[-1] is "c" a[s] no change "abc"[:] is "abc" a[s] cut off start "abc"[1:] is "bc" a[s] cut off end "abc"[:-1] is "ab" a[s] reverse "abc"[::-1] is "cba" Character strings are converted to integers, byte and bit strings as necessary using the current encoding and escape rules. For example when using a sane encoding "z"-"a" is 25. Other types can be converted to character strings by using the type str or by using the repr and format functions. Character strings support indexing and slicing. This is explained in detail in section `Slicing and indexing'. mystr = "oeU" ; text .text 'it''s' ; text: it's .word "ab"+1 ; character, results in "bb" usually .text "text"[:2] ; "te" .text "text"[2:] ; "xt" .text "text"[:-1] ; "tex" .text "reverse"[::-1]; "esrever" Byte string constants Byte strings are like character strings, but hold bytes instead of characters. Quoted character strings prefixing by `b', `l', `n', `p' or `s' characters can be used to create byte strings. The resulting byte string contains what .text, .shiftl, .null, .ptext and .shift would create. Byte string operators and functions y .. x concatenate strings b"a" .. b"b" is b"ab" y in x is substring of b"b" in b"abc" is true a x n repeat b"ab" x 3 is b"ababab" a[i] byte from start b"abc"[1] is b"b" a[i] byte from end b"abc"[-1] is b"c" a[s] no change b"abc"[:] is b"abc" a[s] cut off start b"abc"[1:] is b"bc" a[s] cut off end b"abc"[:-1] is b"ab" a[s] reverse b"abc"[::-1] is b"cba" Byte strings support indexing and slicing. This is explained in detail in section `Slicing and indexing'. Other types can be converted to byte strings by using the type bytes. .enc "screen" ;use screen encoding mystr = b"oeU" ;convert text to bytes, like .text .enc "none" ;normal encoding .text mystr ;text as originally encoded .text s"p1" ;convert to bytes like .shift .text l"p2" ;convert to bytes like .shiftl .text n"p3" ;convert to bytes like .null .text p"p4" ;convert to bytes like .ptext Lists and tuples Lists and tuples can hold a collection of values. Lists are defined from values separated by comma between square brackets [1, 2, 3], an empty list is []. Tuples are similar but are enclosed in parentheses instead. An empty tuple is (), a single element tuple is (4,) to differentiate from normal numeric expression parentheses. When nested they function similar to an array. Currently both types are immutable. List and tuple operators and functions y .. x concatenate lists [1] .. [2] is [1, 2] y in x is member of list 2 in [1, 2, 3] is true a x n repeat [1, 2] x 2 is [1, 2, 1, 2] a[i] element from start ("1", 2)[1] is 2 a[i] element from end ("1", 2, 3)[-1] is 3 a[s] no change (1, 2, 3)[:] is (1, 2, 3) a[s] cut off start (1, 2, 3)[1:] is (2, 3) a[s] cut off end (1, 2.0, 3)[:-1] is (1, 2.0) a[s] reverse (1, 2, 3)[::-1] is (3, 2, 1) *a convert to arguments format("%d: %s", *mylist) Arithmetic operations are applied on the all elements recursively, therefore [1, 2] + 1 is [2, 3], and abs([1, -1]) is [1, 1]. Arithmetic operations between lists are applied one by one on their elements, so [1, 2] + [3, 4] is [4, 6]. When lists form an array and columns/rows are missing the smaller array is stretched to fill in the gaps if possible, so [[1], [2]] * [3, 4] is [[3, 4], [6, 8]]. Lists and tuples support indexing and slicing. This is explained in detail in section `Slicing and indexing'. mylist = [1, 2, "whatever"] mytuple = (cmd_e, cmd_g) mylist = ("e", cmd_e, "g", cmd_g, "i", cmd_i) keys .text mylist[::2] ; keys ("e", "g", "i") call_l .byte mylist[1::2]-1; routines (>cmd_e-1, >cmd_g-1, >cmd_i-1) The range(start, end, step) built-in function can be used to create lists of integers in a range with a given step value. At least the end must be given, the start defaults to 0 and the step to 1. Sounds not very useful, so here are a few examples: ;Bitmask table, 8 bits from left to right .byte %10000000 >> range(8) ;Classic 256 byte single period sinus table with values of 0-255. .byte 128.5 + 127 * sin(range(256) * rad(360.0/256)) ;Screen row address tables - = $400 + range(0, 1000, 40) scrlo .byte <(-) scrhi .byte >(-) Dictionaries Dictionaries are unsorted lists holding key and value pairs. Definition is done by collecting key:value pairs separated by comma between braces {1:"value", "key":1, :"optional default value"}. Looking up a non existing key is normally an error unless a default value is given. An empty dictionary is {}. Currently this type is immutable. Numeric and string keys are accepted, the value can be anything. Dictionary operators and functions x[i] value lookup {"1":2}["1"] is 2 y in x is a key 1 in {1:2} is true ; Simple lookup .text {1:"one", 2:"two"}[2]; "two" ; 16 element "fader" table 1->15->12->11->0 .byte {1:15, 15:12, 12:11, :0}[range(16)] Code Code holds the result of compilation in binary and other enclosed objects. In an arithmetic operation it's used as the numeric address of the memory where it starts. The compiled content remains static even if later parts of the source overwrite the same memory area. Indexing and slicing of code to access the compiled content might be implemented differently in future releases. Use this feature at your own risk for now, you might need to update your code later. Label operators and functions a.b member label.locallabel a[i] element from start label[1] a[i] element from end label[-1] a[s] copy as tuple label[:] a[s] cut off start, as tuple label[1:] a[s] cut off end, as tuple label[:-1] a[s] reverse, as tuple label[::-1] mydata .word 1, 4, 3 mycode .block local lda #0 .bend ldx #size(mydata) ;6 bytes (3*2) ldx #len(mydata) ;3 elements ldx #mycode[0] ;lda instruction, $a9 ldx #mydata[1] ;2nd element, 4 jmp mycode.local ;address of local label Addressing modes Addressing modes are used for determining addressing modes of instructions. For indexing there must be no white space between the comma and the register letter, otherwise the indexing operator is not recognized. On the other hand put a space between the comma and a single letter symbol in a list to avoid it being recognized as an operator. Addressing mode operators # immediate #+ signed immediate #- signed immediate ( indirect [ long indirect ,b data bank indexed ,d direct page indexed ,k program bank indexed ,r data stack pointer indexed ,s stack pointer indexed ,x x register indexed ,y y register indexed ,z z register indexed Parentheses are used for indirection and square brackets for long indirection. These operations are only available after instructions and functions to not interfere with their normal use in expressions. Several addressing mode operators can be combined together. Currently the complexity is limited to 4 operators. This is enough to describe all addressing modes of the supported CPUs. Valid addressing mode operator combinations # immediate lda #$12 #+ signed immediate lda #+127 #- signed immediate lda #-128 #addr,#addr move mvp #5,#6 addr direct or relative lda $12 lda $1234 bne $1234 addr,addr direct page bit rmb 5,$12 addr,addr,addr direct page bit relative jump bbs 5,$12,$1234 (addr) indirect lda ($12) jmp ($1234) (addr),y indirect y indexed lda ($12),y (addr),z indirect z indexed lda ($12),z (addr,x) x indexed indirect lda ($12,x) jmp ($1234,x) [addr] long indirect lda [$12] jmp [$1234] [addr],y long indirect y indexed lda [$12],y #addr,b data bank indexed lda #0,b #addr,b,x data bank x indexed lda #0,b,x #addr,b,y data bank y indexed lda #0,b,y #addr,d direct page indexed lda #0,d #addr,d,x direct page x indexed lda #0,d,x #addr,d,y direct page y indexed ldx #0,d,y (#addr,d) direct page indirect lda (#$12,d) (#addr,d,x) direct page x indexed indirect lda (#$12,d,x) (#addr,d),y direct page indirect y indexed lda (#$12,d),y (#addr,d),z direct page indirect z indexed lda (#$12,d),z [#addr,d] direct page long indirect lda [#$12,d] [#addr,d],y direct page long indirect y indexed lda [#$12,d],y #addr,k program bank indexed jsr #0,k (#addr,k,x) program bank x indexed indirect jmp (#$1234,k,x) #addr,r data stack indexed lda #1,r (#addr,r),y data stack indexed indirect y lda #($12,r),y indexed #addr,s stack indexed lda #1,s (#addr,s),y stack indexed indirect y indexed lda (#$12,s),y addr,x x indexed lda $12,x addr,y y indexed lda $12,y Direct page, data bank, program bank indexed and long addressing modes of instructions are intelligently chosen based on the instruction type, the address ranges set up by .dpage, .databank and the current program counter address. Therefore the `,d', `,b' and `,k' indexing is only used in very special cases. The immediate direct page indexed `#0,d' addressing mode is usable for direct page access. The 8 bit constant is a direct offset from the start of actual direct page. The immediate data bank indexed `#0,b' addressing mode is usable for data bank access. The 16 bit constant is a direct offset from the start of actual data bank. The immediate program bank indexed `#0,k' addressing mode is usable for program bank jumps, braches and calls. The 16 bit constant is a direct offset from the start of actual program bank. The immediate stack indexed `#0,s' and data stack indexed `#0,r' accept 8 bit constants as an offset from the start of (data) stack. These are sometimes written without the immediate notation, but this makes it more clear what's going on. For the same reason the move instructions are written with an immediate addressing mode `#0,#0' as well. The immediate (#) addressing mode expects unsigned values of byte or word size. Therefore it only accepts constants of 1 byte or in range 0-255 or 2 bytes or in range 0-65535. The signed immediate (#+ and #-) addressing mode is to allow signed numbers to be used as immediate constants. It accepts a single byte or an integer in range -128-127, or two bytes or an integer of -32768-32767. The use of signed immediate (like #-3) is seamless, but it needs to be explicitly written out for variables or expressions (#+variable). In case the unsigned variant is needed but the expression starts with a negation then it needs to be put into parentheses (#(-variable)) or else it'll change the address mode to signed. Normally addressing mode operators are used in expressions right after instructions. They can also be used for defining stack variable symbols when using a 65816, or to force a specific addressing mode. param = #1,s ;define a stack variable const = #1 ;immediate constant lda #0,b ;always "absolute" lda $0000 lda param ;results in lda #$01,s lda param+1 ;results in lda #$02,s lda (param),y ;results in lda (#$01,s),y ldx const ;results in ldx #$01 lda #-2 ;negative constant, $fe Uninitialized memory There's a special value for uninitialized memory, it's represented by a question mark. Whenever it's used to generate data it creates a `hole' where the previous content of memory is visible. Uninitialized memory holes without previous content are not saved unless it's really necessary for the output format, in that case it's replaced with zeros. It's not just data generation statements (e.g. .byte) that can create uninitialized memory, but .fill, .align, .offs or address manipulation as well. * = $200 ;bytes as necessary .word ? ;2 bytes .fill 10 ;10 bytes .align 64 ;bytes as necessary .offs 16 ;16 bytes Booleans There are two predefined boolean constant variables, true and false. Booleans are created by comparison operators (<, <=, !=, ==, >=, >), logical operators (&&, ||, ^^, !), the membership operator (in) and the all and any functions. Normally in numeric expressions true is 1 and false is 0, unless the ` -Wstrict-bool' command line option was used. Other types can be converted to boolean by using the type bool. Boolean values of various types bits At least one non-zero bit bool When true bytes At least one non-zero byte code Address is non-zero float Not 0.0 int Not zero str At least one non-zero byte after translation Types The various types mentioned earlier have predefined names. These can used for conversions or type checks. Built-in type names address Address type bits Bit string type bool Boolean type bytes Byte string type code Code type dict Dictionary type float Floating point type gap Uninitialized memory type int Integer type list List type str Character string type tuple Tuple type type Type type .cerror type(var) != str, "Not a string!" .text str(year) ; convert to string Symbols Symbols are used to reference objects. Regularly named, anonymous and local symbols are supported. These can be constant or re-definable. Scopes are where symbols are stored and looked up. The global scope is always defined and it can contain any number of nested scopes. Symbols must be uniquely named in a scope, therefore in big programs it's hard to come up with useful and easy to type names. That's why local and anonymous symbols exists. And grouping certain related symbols into a scope makes sense sometimes too. Scopes are usually created by .proc and .block directives, but there are a few other ways. Symbols in a scope can be accessed by using the dot operator, which is applied between the name of the scope and the symbol (e.g. myconsts.math.pi). Regular symbols Regular symbol names are starting with a letter and containing letters, numbers and underscores. Unicode letters are allowed if the `-a' command line option was used. There's no restriction on the length of symbol names. Care must be taken to not use duplicate names in the same scope when the symbol is used as a constant. Case sensitivity can be enabled with the `-C' command line option, otherwise all symbols are matched case insensitive. Duplicate names in parent scopes are never a problem, they'll just be `shadowed'. This could be either good by reducing collisions and gives the ability to override `defaults' defined in lower scopes. On the other hand it's possible to mix-up the new symbol with a old one by mistake, which is hard to notice. A regular symbol is looked up first in the current scope, then in lower scopes until the global scope is reached. f .block g .block n nop ;jump here .bend .bend jsr f.g.n ;reference from a scope f.x = 3 ;create x in scope f with value 3 Local symbols Local symbols have their own scope between two regularly named code symbols and are assigned to the code symbol above them. Therefore they're easy to reuse without explicit scope declaration directives. Not all regularly named symbols can be scope boundaries just plain code symbol ones without anything or an opcode after them (no macros!). Symbols defined as procedures, blocks, macros, functions, structures and unions are ignored. Also symbols defined by .var, := or = don't apply, and there are a few more exceptions, so stick to using plain code labels. The name must start with an underscore (_), otherwise the same character restrictions apply as for regular symbols. There's no restriction on the length of the name. Care must be taken to not use the duplicate names in the same scope when the symbol is used as a constant. A local symbol is only looked up in it's own scope and nowhere else. incr inc ac bne _skip inc ac+1 _skip rts decr lda ac bne _skip dec ac+1 _skip dec ac ;symbol reused here jmp incr._skip ;this works too, but is not advised Anonymous symbols Anonymous symbols don't have a unique name and are always called as a single plus or minus sign. They are also called as forward (+) and backward (-) references. When referencing them `-' means the first backward, `--' means the second backwards and so on. It's the same for forward, but with `+'. In expressions it may be necessary to put them into brackets. ldy #4 - ldx #0 - txa cmp #3 bcc + adc #44 + sta $400,x inx bne - dey bne -- Excessive nesting or long distance references create poorly readable code. It's also very easy to copy-paste a few lines of code with these references into a code fragment already containing similar references. The result is usually a long debugging session to find out what went wrong. These references are also useful in segments, but this can create a nice trap when segments are copied into the code with their internal references. bne + #somemakro ;let's hope that this segment does + nop ;not contain forward references... A anonymous symbols are looked up first in the current scope, then in lower scopes until the global scope is reached. Constant and re-definable symbols Constant symbols can be created with the equal sign. These are not re-definable. Forward referencing of them is allowed as they retain the objects over compilation passes. Symbols in front of code or certain assembler directives are created as constant symbols too. They are bound to the object following them. Re-definable symbols can be created by the .var directive or := construct. These are also called as variables as they don't carry their content over from the previous pass. Therefore it's not possible to use them before their definition. border = $d020 ;a constant inc border ;inc $d020 variabl .var 1 ;a variable var2 := 1 ;another variable .rept 10 .byte variabl variabl .var variabl+1 ;increment it .next The star label The `*' symbol denotes the current program counter value. When accessed it's value is the program counter at the beginning of the line. Assigning to it changes the program counter and the compiling offset. Built-in functions Built-in functions are pre-assigned to the symbols listed below. If you reuse these symbols in a scope for other purposes then they become inaccessible, or can perform a different function. Built-in functions can be assigned to symbols (e.g. sinus = sin), and the new name can be used as the original function. They can even be passed as parameters to functions. Mathematical functions floor() Round down. E.g. floor(-4.8) is -5.0 round() Round to nearest away from zero. E.g. round(4.8) is 5.0 ceil() Round up. E.g. ceil(1.1) is 2.0 trunc() Round down towards zero. E.g. trunc(-1.9) is -1 frac() Fractional part. E.g. frac(1.1) is 0.1 sqrt() Square root. E.g. sqrt(16.0) is 4.0 cbrt() Cube root. E.g. cbrt(27.0) is 3.0 log10() Common logarithm. E.g. log10(100.0) is 2.0 log() Natural logarithm. E.g. log(1) is 0.0 exp() Exponential. E.g. exp(0) is 1.0 pow(, ) A raised to power of B. E.g. pow(2.0, 3.0) is 8.0 sin() Sine. E.g. sin(0.0) is 0.0 asin() Arc sine. E.g. asin(0.0) is 0.0 sinh() Hyperbolic sine. E.g. sinh(0.0) is 0.0 cos() Cosine. E.g. cos(0.0) is 1.0 acos() Arc cosine. E.g. acos(1.0) is 0.0 cosh() Hyperbolic cosine. E.g. cosh(0.0) is 1.0 tan() Tangent. E.g. tan(0.0) is 0.0 atan() Arc tangent. E.g. atan(0.0) is 0.0 tanh() Hyperbolic tangent. E.g. tanh(0.0) is 0.0 rad() Degrees to radian. E.g. rad(0.0) is 0.0 deg() Radian to degrees. E.g. deg(0.0) is 0.0 hypot(, ) Polar distance. E.g. hypot(4.0, 3.0) is 5.0 atan2(, ) Polar angle in -pi to +pi range. E.g. atan2(0.0, 3.0) is 0.0 abs() Absolute value. E.g. abs(-1) is 1 sign() Returns the sign of value as -1, 0 or 1 for negative, zero and positive. E.g. sign(-5) is -1 Other functions all() Return truth for various definitions of `all'. All function all bits set or no bits at all all($f) is true all characters non-zero or empty all("c") is true string all bytes non-zero or no bytes all(b"c") is true all elements true or empty list all([true, true, false]) is false Only booleans in a list are accepted with the `-Wstrict-bool' command line option. any() Return truth for various definitions of `any'. Any function at least one bit set any(~$f) is false at least one non-zero character any("c") is true at least one non-zero byte any(b"c") is true at least one true element any([true, true, false]) is true Only booleans in a list are accepted with the `-Wstrict-bool' command line option. format([, , ...]) Create string from values according to a format string. The format function converts a list of values into a character string. The converted values are inserted in place of the % sign. Optional conversion flags and minimum field length may follow, before the conversion type character. These flags can be used: Formatting flags # alternate form ($a, %10, 10.) * width/precision from list . precision 0 pad with zeros - left adjusted (default right) blank when positive or minus sign + sign even if positive The following conversion types are implemented: Formatting conversion types a A hexadecimal floating point (uppercase) b binary c Unicode character d decimal e E exponential float (uppercase) f F floating point (uppercase) g G exponential/floating point s string r representation x X hexadecimal (uppercase) % percent sign .text format("%#04x bytes left", 1000); $03e8 bytes left len() Returns the number of elements. Length of various types bit string length in bits len($034) is 12 character string number of characters len("abc") is 3 byte string number of bytes len(b"abc") is 3 tuple, list number of elements len([1, 2, 3]) is 3 dictionary number of elements len({1:2, 3:4]) is 2 code number of elements len(label) random([, ...]) Returns a pseudo random number. The sequence does not change across compilations and is the same every time. Different sequences can be generated by seeding with .seed. Random function invocation types floating point number 0.0 <= x < 1.0 random() integer in range of 0 <= x < e random(e) integer in range of s <= x < e random(s, a) integer in range of s <= x < e, step t random(s, a, t) .seed 1234 ; default is boring, seed the generator .byte random(256); a pseudo random byte (0..255) .byte random([16] x 8); 8 pseudo random bytes (0..15) range([, , ...]) Returns a list of integers in a range, with optional stepping. Range function invocation types integers from 0 to e-1 range(e) integers from s to e-1 range(s, a) integers from s to e (not including e), step t range(s, a, t) .byte range(16) ; 0, 1, ..., 14, 15 .char range(-5, 6); -5, -4, ..., 4, 5 mylist = range(10, 0, -2); [10, 8, 6, 4, 2] repr() Returns a string representation of value. .warn repr(var) ; pretty print value, for debugging size() Returns the size of code, structure or union in bytes. ldx #size(var) ; size to x sort() Returns a sorted list or tuple. If the original list contains further lists then these must be all of the same length. In this case the order of lists is determined by comparing their elements from the start until a difference is found. The sort is stable. ; sort IRQ routines by their raster lines sorted = sort([(60, irq1), (50, irq2)]) lines .byte sorted[:, 0] ; 50, 60 irqs .addr sorted[:, 1] ; irq2, irq1 Expressions Operators The following operators are available. Not all are defined for all types of arguments and their meaning might slightly vary depending on the type. Unary operators - negative + positive ! not ~ invert * convert to arguments ^ decimal string The `^' decimal string operator will be changed to mean the bank byte soon. Please update your sources to use format("%d", xxx) instead! This is done to be in line with it's use in most other assemblers. Binary operators + add - subtract * multiply / divide % modulo ** raise to power | binary or ^ binary xor & binary and << shift left >> shift right . member .. concat x repeat in contains There's a ternary operator (? :) which gives the second value if the first is true or the third if the first is false. Parenthesis (( )) can be used to override operator precedence. Don't forget that they also denote indirect addressing mode for certain opcodes. lda #(4+2)*3 Comparison operators Traditional comparison operators give false or true depending on the result. The compare operator (<=>) gives -1 for less, 0 for equal and 1 for more. Comparison operators <=> compare == equals != not equal < less than >= more than or equals > more than <= less than or equals Bit string extraction operators These unary operators extract 8 or 16 bits as a bit string from various types of operands. Bit string extraction operators < lower byte > higher byte <> lower word >` higher word >< lower byte swapped word ` bank byte lda #