Aby skompilować źródło MADS-a, można użyć kompilatora z Delphi, jeśli ktoś ma akurat zainstalowane środowisko Delphi 7.0 lub Delphi 2005.

RÓŻNICE I PODOBIEŃSTWA POMIĘDZY XASM I MADS

  lda #' '
  lda #" "

MADS będzie rozróżniał apostrof pojedyńczy (kod ATASCII) i apostrof podwójny (kod INTERNAL), XASM oba rodzaje apostrofów potraktuje jednakowo (kod ATASCII). Oczywiście dla danych DTA apostrofy nie są rozróżniane przez MADS.

 lda $2000,x+    ->    lda $2000,x
                       inx

 lda $2000,x+2   ->    lda $2002,x

SPOSÓB UŻYCIA

Syntax: mads source [switches]

-b:address      Generate binary file at specific address
-c              Label case sensitivity
-d:label=value  Define a label
-f              CPU command at first column
-hc[:filename]  Header file for CC65
-hm[:filename]  Header file for MADS
-i:path         Additional include directories
-l[:filename]   Generate listing
-m:filename     File with macro definition
-o:filename     Set object file name
-p              Print fully qualified file names in listing
-s              Silent mode
-t[:filename]   List label table
-x              Exclude unreferenced procedures

Domyślne nazwy plików to:

Jeśli nie podamy rozszerzenia dla pliku source, wówczas MADS domyślnie przyjmie rozszerzenie .ASM.

mads -lptd:label=value -d:label2=value source.asm
mads -l  -p  -t  source
mads source.asm  -lpt
mads.exe  %1 -ltpi:"d:\!atari\macro\"
mads -i:"c:\atari\macros\" /c source.asm  -lpt

Wartość liczbowa, która występuje po :: oznacza numer wywołania makra.

Mad-Assembler v1.4.2beta by TeBe/Madteam
Label table:
00	0400	@STACK_ADDRESS
00	00FF	@STACK_POINTER
00	2000	MAIN
00	2019	LOOP
00	201C	LOOP::1
00	201C	LHEX
00	0080	LHEX.HLP
00	204C	LHEX.THEX
00	205C	HEX
00	205C	HEX.@GETPAR0.LOOP
00	2079	HEX.@GETPAR1.LOOP

Nie jestem pewien czy wszystko z tym plikiem jest OK, ale Eru chciał żeby coś takiego było więc jest :) Ma on być pomocny przy łączeniu ASM-a z CC65, czyli portem C dla małego Atari. Jego zawartość może wyglądać tak (przykładowy plik TEST.ASM):

#ifndef _TEST_ASM_H_
#define _TEST_ASM_H_

#define TEST_CPU65816 0x200F
#define TEST_CPU6502 0x2017
#define TEST_TEXT6502 0x201F
#define TEST_TEXT65816 0x2024

#endif

MAKRO ROZKAZY

REQ, RNE, RPL, RMI, RCC, RCS, RVC, RVS

W/w makro rozkazy swoimi nazwami nawiązują do odpowiednich mnemoników 6502, odpowiednio BEQ, BNE, BPL, BMI, BCC, BCS, BVC, BVS. Posiadają dodatkową właściwość jaką jest skok do poprzednio asemblowanej instrukcji, np.:

   lda:cmp:req 20           ->      lda 20
                            -> wait cmp 20
                            ->      beq wait

   ldx #0                   ->      ldx #0 
   mva:rne $500,x $600,x+   -> loop lda $500,x
                            ->      sta $600,x
                            ->      inx
                            ->      bne loop

SEQ, SNE, SPL, SMI, SCC, SCS, SVC, SVS

W/w makro rozkazy swoimi nazwami nawiązują do odpowiednich mnemoników 6502, odpowiednio BEQ, BNE, BPL, BMI, BCC, BCS, BVC, BVS. Posiadają dodatkową właściwość jaką jest skok do następnej asemblowanej instrukcji, np.:

   lda #40         ->       lda #40
   add:sta  $80    ->       clc
   scc:inc  $81    ->       adc $80
                   ->       sta $80
                   ->       bcc skip
                   ->       inc $81
                   ->  skip

JEQ, JNE, JPL, JMI, JCC, JCS, JVC, JVS

W/w makro rozkazy swoimi nazwami nawiązują do odpowiednich mnemoników 6502, odpowiednio BEQ, BNE, BPL, BMI, BCC, BCS, BVC, BVS. Posiadają dodatkową właściwość jaką jest skok warunkowy pod wskazany adres, z ich pomocą możemy skakać nie tylko w zakresie -128..+127 bajtów ale w całym zakresie 64kB np.:

 jne dest   ->  beq *+4
            ->  jmp dest

ADD, SUB

W/w makro rozkazy realizują odpowiednio zwiększenie/zmniejszenie bajtu pamięci bez zapisywania wyniku (wynik w akumulatorze CPU).

  ADD -> CLC         SUB -> SEC
      -> ADC ...         -> SBC ...

ADB, SBB

W/w makro rozkazy realizują odpowiednio zwiększenie/zmniejszenie bajtu pamięci z zapisaniem wyniku.

  ADB SRC #$40 -> LDA SRC       ADB A B C  -> LDA A
               -> CLC                      -> CLC
               -> ADC #$40                 -> ADC B
               -> STA SRC                  -> STA C

  SBB SRC #$80 -> LDA SRC       SBB A B C  -> LDA A
               -> SEC                      -> SEC
               -> SBC #$80                 -> SBC B
               -> STA SRC                  -> STA C

ADW, SBW

W/w makro rozkazy realizują odpowiednio zwiększenie/zmniejszenie słowa pamięci z zapisaniem wyniku.

  ADW SRC #$40 -> CLC             ADW A B C  -> CLC
               -> LDA SRC                    -> LDA A
               -> ADC #$40                   -> ADC B
               -> STA SRC                    -> STA C
               -> SCC                        -> LDA A+1
               -> INC SRC+1                  -> ADC B+1
                                             -> STA C+1

  ADW SRC #$40 SRC -> CLC
                   -> LDA SRC
                   -> ADC #$40
                   -> STA SRC
                   -> LDA SRC+1
                   -> ADC #$00
                   -> STA SRC+1
                                             
  SBW SRC #$4080 -> SEC           SBW A B C  -> SEC
                 -> LDA SRC                  -> LDA A
                 -> SBC <$4080               -> SBC B
                 -> STA SRC                  -> STA C
                 -> LDA SRC+1                -> LDA A+1
                 -> SBC >$4080               -> SBC B+1
                 -> STA SRC+1                -> STA C+1 

PHR, PLR

W/w makro rozkazy swoimi nazwami nawiązują do odpowiednich mnemoników 6502, odpowiednio PHA, PLA, realizują odkładanie na stosie i zdejmowanie ze stosu rejestrów A,X,Y.

  PHR  -> PHA         PLR  -> PLA
       -> TXA              -> TAY
       -> PHA              -> PLA
       -> TYA              -> TAX
       -> PHA              -> PLA

INW, INL, IND, DEW, DEL, DED

Makro rozkazy INW, INL, IND realizują zwiększenie odpowiednio słowa pamięci (.WORD), długiego słowa pamięci (.LONG), podwójnego słowa pamięci (.DWORD).

    inw dest  ->       inc dest    ->   inc dest
              ->       bne skip    ->   sne
              ->       inc dest+1  ->   inc dest+1
              ->  skip             ->

    dew dest  ->       lda dest    ->   lda dest
              ->       bne skip    ->   sne
              ->       dec dest+1  ->   dec dest+1
              ->  skip dec dest    ->   dec dest   

MVA, MVX, MVY

Makro rozkazy MVA, MVX, MVY służą do przenoszenia bajtów (.BYTE) pamięci przy pomocy rejestrów CPU odpowiednio A, X, Y. Użycie opcji OPT R+ pozwala na potencjalne skrócenie kodu wynikowego dla następujących po sobie makro rozkazów MVA, MVX, MVY.

    lda src    ->  mva src dst
    sta dst    ->

    ldy $10,x  ->  mvy $10,x $a0,x
    sty $a0,x  ->

    ldx #$10   ->  mvx #$10 dst
    stx dst    ->

MWA, MWX, MWY

Makro rozkazy MWA, MWX, MWY służą do przenoszenia słów (.WORD) pamięci przy pomocy rejestrów CPU odpowiednio A, X, Y. Użycie opcji OPT R+ pozwala na potencjalne skrócenie kodu wynikowego dla następujących po sobie makro rozkazów MWA, MWX, MWY.

    ldx <adr    ->  mwx #adr dst
    stx dst     ->
    ldx >adr    ->
    stx dst+1   ->

    mwa #0 $80  ->  lda #0           mwy #$3040 $80  ->  ldy <$3040
                ->  sta $80                          ->  sty $80
                ->  sta $81                          ->  ldy >$3040
                                                     ->  sty $81

    mwa ($80),y $a000,x  ->  lda ($80),y
                         ->  sta $a000,x
                         ->  iny
                         ->  lda ($80),y
                         ->  sta $a001,x

CPB, CPW, CPL, CPD

Makro rozkazy CPB, CPW, CPL, CPD realizują porównanie wartości odpowiednich typów, odpowiednio .BYTE, .WORD, .LONG, .DWORD.

PSEUDO ROZKAZY

BLK

 BLK N[one] X                    - blok bez nagłówków, licznik programu ustawiany na X

 BLK D[os] X                     - blok DOS-a z nagłówkiem $FFFF lub bez nagłówka gdy
                                   poprzedni taki sam, licznik programu ustawiany na X

 BLK S[parta] X                  - blok o stałych adresach ładowania z nagłówkiem $FFFA,
                                   licznik programu ustawiany na X

 BLK R[eloc] M[ain]|E[xtended]   - blok relokowalny umieszczany w pamięci MAIN lub EXTENDED

 BLK E[mpty] X M[ain]|E[xtended] - blok relokowalny rezerwujący X bajtów w pamięci MAIN lub EXTENDED
                                   UWAGA: licznik programu jest natychmiastowo zwiększany o X bajtów

 BLK U[pdate] S[ymbols]          - blok aktualizujący w poprzednich blokach SPARTA lub
                                   RELOC adresy symboli SDX

 BLK U[pdate] E[xternal]         - blok aktualizujący adresy etykiet external (nagłówek $FFEE)
                                   UWAGA: nie dotyczy Sparta DOS X, jest to rozszerzenie MADS-a

 BLK U[pdate] A[dress]           - blok aktualizacji adresów w blokach RELOC

 BLK U[pdate] N[ew] X 'string'   - blok deklarujący nowy symbol 'string' w bloku RELOC
                                   o adresie X. Gdy nazwa symbolu poprzedzona jest znakiem @,
                                   a adres jest z pamięci podstawowej to taki symbol może być
                                   wywoływany z command.com

Deklaracja etykiety jako symbolu SDX. Symbol może mieć maksymalnie długość 8-iu znaków. Dzięki temu po użyciu BLK UPDATE SYMBOLS asembler wygeneruje poprawny blok aktualizacji symboli. Np:

       pf  smb 'PRINTF'
           jsr pf
           ...

       cm  smb 'COMTAB'
       wp  equ cm-1       (błąd !)

           sta wp

       cm  smb 'COMTAB'

           sta cm-1       (ok !)

Uwaga: wszystkie deklaracje symboli należy użyć przed deklaracjami etykiet, jak i programem właściwym !

:repeat

Example: 
           :4 asl @
           :2 dta a(*)
           :256 dta #/8

.macro test
 :2 lsr @
.endm

.macro test
 :+2 lsr @
.endm

Teraz znak dwukropka ':' zostanie prawidłowo zinterpretowany jako :repeat

 b+  bank sensitive on
 b-  bank sensitive off                                               (default)
 c+  włącza obsługę CPU 65816 (16bit)
 c-  włącza obsługę CPU 6502 (8bit)                                   (default)
 f+  plik wynikowy w postaci jednego bloku (przydatne dla carta)
 f-  plik wynikowy w postaci blokowej                                 (default)
 h+  zapisuje nagłówek pliku dla DOS                                  (default)
 h-  nie zapisuje nagłówka pliku dla DOS
 l+  zapisuje listing do pliku (LST)
 l-  nie zapisuje listingu (LST)                                      (default)
 m+  zapisuje całe makra w listingu
 m-  zapisuje w listingu tylko tą część makra która zostaje wykonana  (default)
 o+  zapisuje wynik asemblacji do pliku wynikowego (OBX)              (default)
 o-  nie zapisuje wyniku asemblacji do pliku wynikowego (OBX)
 r+  optymalizacja długości kodu dla MVA, MVX, MVY, MWA, MWX, MWY
 r-  bez optymalizacji długości kodu dla MVA, MVX, MVY, MWA, MWX, MWY (default)
 s+  drukuje listing na ekranie
 s-  nie drukuje listingu na ekranie                                  (default)
 t+  track SEP REP on (CPU 65816)
 t-  track SEP REP off (CPU 65816)                                    (default)
 ?+  etykiety ze znakiem '?' na początku są lokalne (styl MAE)
 ?-  etykiety ze znakiem '?' na początku są tymczasowe                (default)

Example:
 
 OPT c+ c  - l  + s +
 OPT h-
 OPT o +

Wszystkie opcje OPT możemy używać w dowolnym miejscu listingu, czyli np. możemy włączyć zapis listingu w linii 12, a w linii 20 wyłączyć itd., wówczas plik z listingiem będzie zawierał tylko linie 12..20.

Jeśli używamy CodeGenie możemy użyć 'OPT S+', dzięki temu nie musimy przechodzić do pliku z listingiem, bo listing wydrukowany został w dolnym okienku (Output Bar).

 adr                 asembluj od adresu ADR, ustaw adres w nagłówku pliku na ADR
 adr,adr2            asembluj od adresu ADR, ustaw adres w nagłówku pliku na ADR2
 [b($ff,$fe)]        zmień nagłówek na $FFFE (zostaną wygenerowane 2 bajty)
 [$ff,$fe],adr       zmień nagłówek na $FFFE, ustaw adres w nagłówku pliku na ADR
 [$d0,$fe],adr,adr2  zmień nagłówek na $D0FE, asembluj od adresu ADR, ustaw adres w nagłówku pliku na ADR2
 [a($FFFA)],adr      nagłówek SpartaDOS $FAFF, ustaw adres w nagłówku pliku na ADR

Example:

 opt h-
 ORG [a($ffff),d'atari',c'ble',20,30,40],adr,adr2

Nawiasy kwadratowe [ ] służą określeniu nowego nagłówka, który może być dowolnej długości. Pozostałe wartości za zamykającym nawiasem kwadratowym ']', rozdzielone znakiem przecinka ',' oznaczają odpowiednio: adres asemblacji, adres w nagłówku pliku.

Example:

 opt h-f+
 ORG [a(start), a(over-1)],$2000

start
 nop
 .ds 128
 nop
over

   b   wartość typu BYTE
   a   wartość typu WORD
   v   wartość typu WORD, relokowalna
   l   młodszy bajt wartości (BYTE)
   h   starszy bajt wartości (BYTE)
   t   wartość typu LONG (24bit)
   e   wartość typu LONG (24bit)
   f   wartość typu DWORD (32bit)
   g   wartość typu DWORD (32bit) w odwróconej kolejności     
   c   ciąg znaków ATASCII ograniczony apostrofami '' lub "", znak * na końcu spowoduje
       invers wartości ciągu, np. dta c'abecadlo'*
   d   ciąg znaków INTERNAL ograniczony apostrofami '' lub "", znak * na końcu spowoduje
       invers wartości ciągu, np. dta d'abecadlo'*

Example:

  dta 1 , 2, 4
  dta a ($2320 ,$4444)
  dta d'sasasa', 4,a ( 200 ), h($4000)
  dta  c  'file' , $9b
  dta c'invers'*

where: 

centre     is a number which is added to every sine value 
amp        is the sine amplitude 
size       is the sine period 
first,last define range of values in the table. They are optional.
           Default are 0,size-1. 

Example: dta a(sin(0,1000,256,0,63))
         defines table of 64 words representing a quarter of sine with
         amplitude of 1000.

RND(min,max,length)

Example: dta b(rnd(0,33,256))

 IFT [.IF] expression
 ELS [.ELSE]
 ELI [.ELSEIF] expression
 EIF [.ENDIF]

W/w pseudo rozkazy i dyrektywy wpływają na przebieg asemblacji (można ich używać zamiennie).

DYREKTYWY

Dyrektywa .SYMBOL to odpowiednik pseudo rozkazu SMB z tą różnicą że nie trzeba podawać symbolu, symbolem jest etykieta label. Dyrektywę .SYMBOL można umieszczać w dowolnym miejscu bloku relokowalnego SDX (BLK RELOC) w przeciwieństwie do SMB.

Jeśli wystąpiła dyrektywa .SYMBOL zostanie wygenerowany odpowiedni blok aktualizacji:

BLK UPDATE NEW LABEL 'LABEL'

.REPT expression [,parameter1, parameter2, ...]

.PAGES [expression]

Example:

 org $4000
 
 .pages $40
  ...
  ...
 .endpg

.END

.VAR var1[=value1],var2[=value2]... (.BYTE|.WORD|.LONG|.DWORD)

Example:

 .var a,b , c, d  .word          ; 4 zmienne typu .WORD
 .var a,b,f  :256 .byte          ; 3 zmienne każda o wielkości 256 bajtów
 .var c=5,d=2,f=$123344 .dword   ; 3 zmienne .DWORD o wartościach 5, 2, $123344

  .proc name
  .var p1,p2,p3 .word
  .endp

 .local
  .var a,b,c .byte
  lda a
  ldx b
  ldy c
 .endl

.PRINT

Example:

 .print "End: ",*,'..','$8000-*

.DB

.DW

.DS expression

purpose: reserves space for data without initializing then space to any particular value(s).

usage: [label] .DS expression

Using ".DS expression" is exactly equivalent of using "ORG *+expression". That is, the label
(if it is given) is set equal to the current value of the location counter. Then then value
of the expression is added to then location counter.

Example: BUFFERLEN .DS 1 ;reserve a single byte
         BUFFER   .DS 256  ;reserve 256 bytes

.BY [+byte] bytes and/or ASCII

Example:
      .BY +$80 1 10 $10 'Hello' $9B

will generate:
        81 8A 90 C8 E5 EC EC EF 1B

.WO words

.HE hex bytes

.SB [+byte] bytes and/or ASCII

.FL floating point numbers

.EN

This is an optional pseudo-op to mark the end of assembly. It can be placed before the end of your source file to prevent a portion of it from being assembled.

.ADR label

 org $2000

.proc tb,$1000
tmp lda #0
.endp

 lda .adr tb.tmp  ; = $2000
 lda tb.tmp       ; = $1000

.LEN label

label .array [255] .dword
      .enda

      dta a(.len label)   ; = $400

.proc wait
 lda:cmp:req 20
 rts
.endp

 dta .len wait    ; = 7

.USING, [.USE]

Example:

.local move

tmp    lda #0
hlp    sta $a000

.local move2

tmp2   ldx #0
hlp2   stx $b000

.endl

.endl

.local main

.use move.move2

       lda tmp2
 
.use move

       lda tmp

.endl

.GET [index] 'filename'... [.BYTE, .WORD, .LONG, .DWORD]

Example:

 .get 'file'                    ; wczytanie pliku do tablicy MADS-a
 .get [5] 'file'                ; wczytanie pliku do tablicy MADS-a od indeksu = 5

 .get 'file',0,3                ; wczytanie do tablicy MADS-a 3-ech wartości

 lda #.get[7]                   ; odczytanie 7 bajtu z tablicy MADS-a
 adres = .get[2]+.get[3]<<8     ; 2 i 3 bajt w nagłówku pliku DOS zawiera informacje o adresie ładowania

.PUT [index] = value

Dopuszczalny zakres wartości dla INDEX = <0..65535>.

Example:

 .put [5] = 12       ; zapisanie wartosci 12 w talicy MADS-a na pozycji 5-ej

.SAV [index] ['filename',] length

Example:

 .sav ?length            ; dołączenie do asemblowanego pliku zawartości bufora [0..?length-1]
 .sav [200] 256          ; dołączenie do asemblowanego pliku zawartości bufora [200..200+256-1]
 .sav [6] 'filename',32  ; zapisanie do pliku FILENAME zawartości bufora [6..6+32-1]

.OR, .AND, .XOR, .NOT

.LO (expression), .HI (expression)

 .IF     [IFT] expression
 .ELSE   [ELS]
 .ELSEIF [ELI] expression
 .ENDIF  [EIF]

W/w dyrektywy i pseudo rozkazy wpływają na przebieg asemblacji (można ich używać zamiennie), np.:

Example:

 .IF .NOT .DEF label_name
   label_name = 1
 .ENDIF

 .IF [.NOT .DEF label_name] .AND [.NOT .DEF label_name2]
   label_name = 1
   label_name2 = 2
 .ENDIF

W w/w przykładzie nawiasy (kwadratowe lub okrągłe) są koniecznością, ich brak spowodowałby że dla pierwszej dyrektywy .DEF parametrem byłaby nazwa etykiety label_name.AND.NOT.DEFlabel_name2 (spacje są pomijane, a znak kropki akceptowany w nazwie etykiety).

DYREKTYWY GENERUJĄCE KOD 6502

#IF type expression [.OR type expression] [.AND type expression]

Dyrektywy #IF, #ELSE i #END pozwalają na wygenerowanie kodu maszynowego CPU 6502 instrukcji warunkowej IF dla wyznaczonego bloku programu, możliwe jest ich zagnieżdżanie. Dopuszczalne są wszystkie typy .BYTE, .WORD, .LONG, .DWORD, możliwe jest łączenie większej ilości warunków przy pomocy dyrektyw .OR i .AND, nie ma możliwości określenia kolejności wartościowania poprzez nawiasy.

Jeżeli wyrażenie ma wartość różną od zera (TRUE), to zostanie wykonywany blok programu występujący po dyrektywie #IF. Blok takiego programu automatycznie kończony jest instrukcją 'JMP' realizującą skok do następnej instrukcji programu za dyrektywą #END w przypadku występowania bloku #ELSE.

#if .byte label>#10 .or .byte label<#5
#end

#if .byte label>#100

#else

 #if .byte label<#200
 #end
 
#end

#if .byte label>#100 .and .byte label<#200 .or .word lab=temp
#end

#if .byte @
#end

#WHILE type expression [.OR type expression] [.AND type expression]

Dyrektywy #WHILE i #END pozwalają na wygenerowanie kodu maszynowego CPU 6502 pętli dla wyznaczonego bloku programu, możliwe jest ich zagnieżdżanie. Dopuszczalne są wszystkie typy .BYTE, .WORD, .LONG, .DWORD, możliwe jest łączenie większej ilości warunków przy pomocy dyrektyw .OR i .AND, nie ma możliwości określenia kolejności wartościowania poprzez nawiasy.

Sekwencja działań przy wykonywaniu dyrektywy #WHILE jest następująca:

• 1. Oblicz wartość wyrażenia i sprawdź, czy jest równe zeru (FALSE).
  • jeżeli tak, to pomiń krok 2;
  • jeżeli nie (TRUE), przejdź do kroku 2.
• 2. Wykonaj blok programu ograniczonego dyrektywami #WHILE i #END, następnie przejdź do kroku 1.

Jeżeli pierwsze wartościowanie wyrażenia wykaże, że ma ono wartość zero, to blok programu nigdy nie zostanie wykonany i sterowanie przejdzie do następnej instrukcji programu za dyrektywą #END

#while .byte label>#10 .or .byte label<#5
#end

#while .byte label>#100
 #while .byte label2<#200
 #end
#end

#while .byte label>#100 .and .byte label<#200 .or .word lab=temp
#end

W przeciwieństwie do dwu-przebiegowych asemblerów takich jak QA i XASM, MADS jest wielo-przebiegowy. Co to daje ?

 org $00
 
 lda tmp+1
 
tmp lda #$00

Natomiast MADS uprzejmie wygeneruje rozkaz strony zerowej LDA Z. I to właściwie główna i najprostsza do wytłumaczenia właściwość większej liczby przebiegów.

 org $00
 
 lda.w tmp+1
 
tmp lda #$00

 .b[.z]
 .w[.a][.q]
 .l[.t]

STRUKTURY

Pola takiej struktury zawierają informację o ofsecie do początku struktury.

Struktur dotyczą n/w dyrektywy:

name .STRUCT
     .STRUCT name
     .ENDS [.SEND] [.END]

.STRUCT name

  x .word      ; lda #name.x = 0
  y .word      ; lda #name.y = 2
  z .long      ; lda #name.z = 4
  v .dword     ; lda #name.v = 7

  q :3 .byte   ; lda #name.q = 11

.ENDS          ; lda #name   = 14 (length)

Podsumowując, etykieta name zawiera informację o całkowitej długości struktury (w bajtach). Pozostałe etykiety opisujące pola zawierają informację o ofsecie do początku struktury.

.STRUCT temp

x .word
y .word
v .byte
z .word

.ENDS


.STRUCT test

tmp  temp

.ENDS

 lda #temp.v
 lda #test.tmp.x
 lda #test.tmp.z

Definiowanie danych strukturalnych polega na przypisaniu etykiecie konkretnej struktury z użyciem pseudo rozkazu DTA. Wynikiem takiego przypisania jest zarezerwowana pamięć, nie jest to już twór wirtualny.

label DTA struct_name [count] (data1,data2,data3...) (data1,data2,data3...) ...

COUNT określa liczbę z przedziału <0..COUNT>, która definiuje maksymalną wartość indeksu tablicy jednowymiarowej, a przez to także liczbę odłożonych w pamięci danych typu strukturalnego.

;----------------------;
; deklaracja struktury ;
;----------------------;
.STRUCT temp

x .word
y .word
v .byte
z .word

.ENDS

;---------------------;
; definiowanie danych ;
;---------------------;

data dta temp [12] (1,20,200,32000) (19,2,122,42700)

data2 dta temp [0]

Po nawiasie kwadratowym może wystąpić opcjonalnie lista wartości początkowych (ograniczona nawiasami okrągłymi), jeśli nie wystąpi wówczas domyślnymi wartościami pól struktury są zera. Z kolei jeśli lista wartości początkowych jest mniejsza od liczby pól zadeklarowanych, wówczas pozostałe pola inicjowane są ostatnimi wartościami jakie zostały podane, np.

data dta temp [12] (1,20,200,32000)

Jeśli lista wartości początkowych będzie większa lub mniejsza od liczby pól struktury, wówczas wystąpi błąd z komunikatem Constant expression violates subrange bounds.

 lda data[4].y
 ldx #data[0].v

Brak nawiasu kwadratowego zakończy się komunikatem błędu Undeclared label.

TABLICE

name .ARRAY count type [= default_value]
     .ARRAY name count type [= default_value]
     .ENDA [.AEND] [.END]

COUNT określa maksymalną dopuszczalną wartość indeksu tablicy (0..COUNT), wartość ta powinna być z przedziału <0..65535>.

Ten twór może wydać się dziwny, a jego zastosowanie ograniczone, jednak zdarzają się sytuacje kiedy może się przydać, np. tablica tłumacząca kod naciśniętego klawisza na kod ATASCII czy INTERNAL.

.array TAB [255] .byte = $ff

 [63]:[127] = "A"
 [21]:[85]  = "B"
 [18]:[82]  = "C"
 [58]:[122] = "D"
 [42]:[106] = "E"
 [56]:[120] = "F"
 [61]:[125] = "G"
 [57]:[121] = "H"
 [13]:[77]  = "I"
 [1] :[65]  = "J"
 [5] :[69]  = "K"
 [0] :[64]  = "L"
 [37]:[101] = "M"
 [35]:[99]  = "N"
 [8] :[72]  = "O"
 [10]:[74]  = "P"
 [47]:[111] = "Q"
 [40]:[104] = "R"
 [62]:[126] = "S"
 [45]:[109] = "T"
 [11]:[75]  = "U"
 [16]:[80]  = "V"
 [46]:[110] = "W"
 [22]:[86]  = "X"
 [43]:[107] = "Y"
 [23]:[87]  = "Z"
 [33]:[97]  = " "

 [52]:[180] = $7e
 [12]:[76]  = $9b

.enda

W w/w przykładzie stworzyliśmy tablicę TAB o rozmiarze 0..255, typie danych .BYTE i wypełniliśmy pola wartością = $FF, dodatkowo zapisaliśmy wartości kodów literowych INTERNAL na pozycjach (indeksach tablicy) równych kodowi naciśnięcia klawisza (bez SHIFT-a i z SHIFT-em, czyli duże i małe litery).

 org $bc40

.array txt 39 .byte
 [17] = "ATARI"
.enda

Podsumowując, dyrektywa .ARRAY pozwala na stworzenie tablicy jednowymiarowej i wypełnienie jej wartościami zadeklarowanego typu.

 lda tab,y
 lda tab[23],x
 lda #tab[200]

MAKRA

Makra ułatwiają nam wykonywanie powtarzających się czynności, automatyzują je. Istnieją tylko w pamięci assemblera, dopiero w momencie wywołania są asemblowane. Przy ich pomocy MADS może odkładać i zdejmować z programowego stosu parametry dla procedur zadeklarowanych dyrektywą .PROC oraz przełączać banki rozszerzonej pamięci w trybie BANK SENSITIVE (OPT B+).

Makr dotyczą n/w pseudo rozkazy i dyrektywy:

name .MACRO ['separator'] ["separator"]
     .MACRO name ['separator'] ["separator"]
     .EXITM [.EXIT]
     .ENDM [.MEND]
     :[%%]parameter

Domyślnym separatorem, rozdzielającym parametry przekazywane do makra jest znak przecinka ',' oraz spacji ' '.

name .MACRO 'separator'

name .MACRO "separator"

 test #12 200 <30

test .macro " "
.endm

 #12   ->  tryb adresacji '#' argument 12
 200   ->  tryb adresacji ' ' argument 200
 <30   ->  tryb adresacji '#' argument 0   (obliczona wartość wyrażenia "<30")

 test '#' 12 ' ' 200 '#' 0

UAWAGA #2: Jeśli parametrem makra jest licznik pętli '#' (!!! pojedyńczy znak '#' a nie wyrażenie z udziałem tego znaku !!!) wówczas do makra przekazywana jest wartość licznika pętli (podstawiana pod parametr).

 :32 find #

find .macro
      ift .def label:1
      dta a(label:1)
      eif
     .endm

.EXITM [.EXIT]

.ENDM [.MEND]

 :$2 nop
 :+2 nop
 :%10 nop

  .IF :0<2 || :0>5
    .ERROR "Wrong number of arguments"
  .ENDIF

  IFT %%0<2 .or :0>5
    ERT "Wrong number of arguments"
  EIF 

Przykład makra:

.macro load_word

   lda <:1
   sta :2
   lda >:1
   sta :2+1   
 .endm

 test ne
 test eq

.macro test
  b%%1 skip
.endm

Makro wywołujemy poprzez jego nazwę, po niej mogą wystąpić parametry makra, rozdzielone separatorem którym jest domyślnie znak przecinka ',' lub spacji ' '. Liczba parametrów uzależniona jest od wolnej pamięci komputera PC. Jeśli przekazana liczba parametrów jest mniejsza od liczby parametrów używanych w danym makrze, wówczas pod brakujące parametry zostanie podstawiona wartość -1 ($FFFFFFFF). Tą właściwość można wykorzystać do sprawdzenia czy został przekazany parametr czy też nie, łatwiej jednak tego dokonać za pomocą parametru zerowego %%0.

 macro_name [Par1, Par2, Par3, 'Par4', "string1", "string2" ...]

Parametrem może być wartość, wyrażenie lub ciąg znaków ograniczony apostrofem pojedyńczym '' lub podwójnym "".

Wszelkie definicje etykiet w obrębie makra mają zasięg lokalny.

Przykład wywołania makra:

 macro_name 'a',a,>$a000,cmp    ; dla domyślnego separatora ','
 macro_name 'a'_a_>$a000_cmp    ; dla zadeklarowanego separatora '_'
 macro_name 'a' a >$a000 cmp    ; dla domyślnego separatora ' '

Przykład makra, które spowoduje przepełnienie stosu MADS-a:

jump .macro

      jump

     .endm

 org $2000
 
 proc PutChar,'a'-64    ; wywołanie makra PROC, jako parametr
 proc PutChar,'a'-64    ; nazwa procedury która będzie wywołana przez JSR
 proc PutChar,'r'-64    ; oraz jeden argument (kod znaku INTERNAL)
 proc PutChar,'e'-64
 proc PutChar,'a'-64

 proc Kolor,$23         ; wywołanie innej procedurki zmieniającej kolor tła

;---

loop jmp loop           ; pętla bez końca, aby zobaczyć efekt działania

;---

proc .macro             ; deklaracja makra PROC
 push =:1,:2,:3,:4      ; wywołanie makra PUSH odkładającego na stos argumenty
                        ; =:1 wylicza bank pamieci
 
 jsr :1                 ; skok do procedury (nazwa procedury w pierwszym parametrze)
 
 lmb #0                 ; Load Memory Bank, ustawia bank na wartosc 0
 .endm                  ; koniec makra PROC 

;---

push .macro             ; deklaracja makra PUSH

  lmb #:1               ; ustawia wirtualny bank pamięci

 .if :2<=$FFFF          ; jeśli przekazany argument jest mniejszy równy $FFFF to
  lda <:2               ; odłóż go na stosie
  sta stack
  lda >:2
  sta stack+1
 .endif 

 .if :3<=$FFFF
  lda <:3
  sta stack+2
  lda >:3
  sta stack+3
 .endif 

 .if :4<=$FFFF
  lda <:4
  sta stack+4
  lda >:4
  sta stack+5
 .endif 
 
 .endm
 

* ------------ *            ; procedura KOLOR
*  PROC Kolor  *
* ------------ *
 lmb #1                     ; ustawienie numeru wirtualnego banku na 1
                            ; wszystkie definicje etykiet będą teraz należeć do tego banku
stack org *+256             ; stos dla procedury KOLOR
color equ stack

Kolor                       ; kod procedury KOLOR
 lda color
 sta 712
 rts

 
* -------------- *          ; procedura PUTCHAR
*  PROC PutChar  *
* -------------- *
 lmb #2                     ; ustawienie numeru wirtualnego banku na 2
                            ; wszystkie definicje etykiet będą teraz należeć do tego banku
stack org *+256             ; stos dla procedury PUTCHAR
char  equ stack

PutChar                     ; kod procedury PUTCHAR
 lda char
 sta $bc40
scr equ *-2

 inc scr
 rts

PROCEDURY .PROC

Aktualnie dołączone do MADS-a deklaracje makr (@CALL.MAC, @PULL.MAC, @EXIT.MAC) umożliwiają obsługę stosu programowego o wielkości 256 bajtów, czyli tej samej wielkości jak stos sprzętowy, udostępniają mechanizm zdejmowania ze stosu programowego i odkładania na stos programowy parametrów potrzebnych podczas wywoływania procedur, jak i wychodzenia z takich procedur. MADS uwzględnia możliwość rekurencji takich procedur.

Programista nie jest zaangażowany w ten mechanizm, może skupić uwagę na swoim programie. Musi tylko pamiętać o potrzebie zdefiniowania odpowiednich etykiet i dołączeniu odpowiednich makr podczas asemblacji programu.

Inną właściwością procedur .PROC jest możliwość pominięcia ich podczas asemblacji jeśli nie wystąpiło żadne odwołanie do nich, czyli zostały zdefiniowane ale nie są wykorzystane. Wystąpi wówczas komunikat ostrzeżenia Unreferenced procedure ????. Pominięcie takiej procedury podczas asemblacji możliwe jest poprzez podanie parametru do MADS-a w linii poleceń -x 'Exclude unreferenced procedures'.

Procedur dotyczą n/w dyrektywy:

 name .PROC [(.TYPE PAR1 .TYPE PAR2 ...)] [.REG] [.VAR]
 .PROC name [,address] [(.TYPE PAR1 .TYPE PAR2 ...)] [.REG] [.VAR]
 .ENDP [.PEND] [.END]

.BYTE  (8-bit)  relokowalne
.WORD  (16-bit) relokowalne
.LONG  (24-bit) nierelokowalne
.DWORD (32-bit) nierelokowalne

name .PROC ( .WORD par1 .BYTE par2 )
name .PROC ( .BYTE par1,par2 .LONG par3 )
name .PROC ( .DWORD p1,p2,p3,p4,p5,p6,p7,p8 )

name .PROC ( .BYTE x,y,a .BYTE ) .REG
name .PROC ( .WORD xa .BYTE y ) .REG
name .PROC ( .LONG axy ) .REG

name .PROC ( .BYTE x1,x2,y1,y2 ) .VAR
name .PROC ( .WORD inputPointer, outputPointer ) .VAR
name .PROC ( .WORD src+1, dst+1 ) .VAR

.PROC label,$8000
.ENDP

.PROC label2,$a000 (.word ax) .reg
.ENDP

.macro @EXIT

 ift :1<>0

  ift :1=1
   dec @stack_pointer

  eli :1=2
   dec @stack_pointer
   dec @stack_pointer

  els
   pha
   lda @stack_pointer
   sub #:1
   sta @stack_pointer
   pla

  eif

 eif

.endm