jAsm

[bjonte]

Jag har suttit och knåpat på en ny assembler på fritiden i fem månader nu. Jag tänkte starta en tråd här för att visa lite vad som händer under utvecklingen och ta emot lite feedback. För mig kommer den här assemblern att ersätta DAsm, som jag har använt i många år, och därför kommer jag att kalla den för jAsm. Målet är att den ska klara allt som DAsm kan men vara en värdig och modern uppföljare. Assemblern har inte alls samma syntax, men vissa drag lånas, mest för att jag är van. Det tydligaste är att lokala variabler börjar med en punkt. Ett minimalt programexempel:

Kod: Markera allt

   section code, "main", $8000
   {
       rts
   }


Tvånget att använda hakparenteser i uttryck är borta. Bara parenteser kan användas. Både variabler och konstanter kan definieras. Konstanter kan inte ändras i källkoden medan variabler kan omdefinieras.

Kod: Markera allt

   const SCREEN = $0400

   section code, "main", $8000
   {
       var line = 0
       lda #1
       sta SCREEN + 40*line

       ++line // increase line number
       lda #1
       sta SCREEN + 40*line
       rts
   }


Jepp, syntaxen i uttryck är lik C. Man kan avsluta en rad med semikolon om man vill. Det finns ett par fall där man måste ha semikolon för att skilja instruktioner, annars går det att skriva ihop flera saker på samma rad utan semikolon.

[bjonte]

Jag har saknat namnrymder i DAsm så det har jag lagt till i jAsm. Lokala variabler och konstanter påverkas inte av namnrymden men globala variabler och konstanter gör det. Namnrymden definieras och används som i C++.

Kod: Markera allt

   namespace c64 {
      const VOLUME = $d418
   }
   namespace vic20 {
      const VOLUME = $900e
   }

   section code, "main", $8000
   {
      lda #0
      sta c64::VOLUME // rätt volym sänks
      rts
   }


Villkorsstyrd assemblering stöds, annars blir det svårt att skriva kod som anpassar sig efter situationen.

Kod: Markera allt

   const IS_C64 = true

   section code, "main", $8000
   {
      lda #0

      if (IS_C64) {
         sta c64::VOLUME
      } else {
         sta vic20::VOLUME
      }

      rts
   }


[bjonte]

Jag har nyligen fått igång macrohanteringen i språket. Det är mer kraftfullt än DAsm i det här avseendet. Det som gör DAsm överlägset andra assemblerare är att macroargument inte måste vara evaluerade i första assemblerpasset. Då kan man referera till saker längre ner i programmet i argumenten, typiskt end-start på någon datamängd. Detta stöds, men utöver det kan man lagra typer i konstanter och variabler. Det innebär att det går att lagra ett macro själv i en variabel eller skicka det som en parametrar till ett annat macro. Här är ett krystat exempel på detta.

Kod: Markera allt

section code, "main", $8000 {
   apply(load, 1)
   rts
}

macro apply(.func, .arg) {
   .func(.arg)
}

macro load(.a) {
   lda #.a
}


Det här gör det möjligt att injicera kod i macros. Man kan ha en algoritm som beskrivs i ett macro men där delar abstraheras ut till användaren genom att man till exempel skickar in ett macro som gör beräkningar. En sorteringsalgoritm skulle kunna göras helt generell, där det man anger som argument är macros för jämförelse av element och för att byta plats.

[Redreamer]

Ser spännande ut. Kommer du släppa detta på csdb eller något, så man kanske kan prova på lite =)

[bjonte]

Jag kommer att göra klart version 1 och porta Cosmos och Bruce Lee II till den för att få lite ordentlig testning. Efter det så kommer jag att släppa den för allmänheten och fortsätta med planerade förbättringar.

[Redreamer]

Ok. Finns det några optimeringsmöjligheter nu med din jasm eller är det bara som verifiering du vill assemblera om cosmos och bruce2?

[bjonte]

Det finns inga optimeringsfunktioner än. Jag ska porta spelen för att testa att assemblern funkar på ordentligt stora projekt. Jag vill mäta hur lång tid det tar att assemblera jämfört med DAsm, som säger sig vara snabb men som börjat kännas slö på slutet av Bruce Lee II då många olika format skulle produceras.

[bjonte]

Man kan reservera minne utan att generera någon data i sitt program genom att man definierar en sektion av typen bss. I en sådan sektion kan man inte generera data utan det är bara tillåtet att reservera utrymme för variabler. Det görs på det här sättet.

Kod: Markera allt

const NUM_JOYSTICK_DEVICES = 2

section bss, "vars", $8000 {
   reserve byte num_lives
   reserve byte[NUM_JOYSTICK_DEVICES] devices
}


Notera att här så skapar man inte en label på raden ovanför som i de flesta andra assemblatorer. I DAsm ser det ut såhär.

Kod: Markera allt

NUM_JOYSTICK_DEVICES = 2

   org $8000
   seg.u bss
num_lives:
   ds.b 1
items:
   ds.b NUM_JOYSTICK_DEVICES


Även i jAsm så kan man deklarera labels på rader men i reserveringsfallet så tillförs typinformation till symbolen. Det gör att man kan fråga hur mycket minne som den upptar. Låt säga att man har ett macro memset(addr, size) som kan fylla minne med ett värde. Då kan man i exemplet ovan tömma alla joystickenheter såhär:

Kod: Markera allt

section code, "main", $1000 {
   // clear devices
   lda #0
   memset(devices, sizeof(devices))
}


Det går också att indexera devices som en array i C.

Kod: Markera allt

section code, "main", $1000 {
   lda #0
   sta devices[0]
   sta devices[1]
}


[bjonte]

Man kan göra loopar för att generera större mängder liknande kod utan att behöva skriva ihjäl sig. Det görs med en for-loop likt den i C. Punkten framför i betyder att den är lokal till skillnad från global.

Kod: Markera allt

const SCREEN = $0400

section code, "main", $1000 {
   // töm skärmen så fort det går genom att rulla ut loopen
   lda #0
   for(var .i = 0; .i < 40*25; ++.i) {
      sta SCREEN + .i
   }
   rts
}


Med det tidigare tricket för att reservera ram så kan detta skrivas om såhär.

Kod: Markera allt

section bss, "screen bank", $0400 {
   reserve byte[40*25] screen
   reserve byte[16] unused
   reserve byte[8] sprite_blocks
}

section code, "main", $1000 {
   // töm skärmen så fort det går genom att rulla ut loopen
   lda #0
   for(var .i = 0; .i < sizeof(screen); ++.i) {
      sta screen + .i
   }
   rts
}


Det trevliga med detta är att det blir lättare att få en överblick av vad som används och vad som är ledigt. Assemblern spottar ur sig en lista över sektionerna när den är klar.

Kod: Markera allt

$0400 - $0800 ($0400)  bss: screen bank
$1000 - $1bbb ($0bbb) code: main


[bjonte]

Ett vanligt problem som jag har haft är att jag vill få in strängar till mitt program och måste konvertera ASCII till petascii eller skärmkoder och lägga in detta som datadeklarationer i programmet. I jAsm är det här löst genom stöd för PetASCII direkt i strängangivelser. Det finns flera olika sorters angivelser.

1. Unicode: "test"
2. PetASCII med gemener: p"test"
3. PetASCII utan gemener: P"test"
4. Skärmkoder med gemener: s"test"
5. Skärmkoder utan gemener: S"test"

Kod: Markera allt

const SCREEN = $0400
const COLORS = $d800
const WHITE = 1

section code, "main", $8000 {
   
   ldx #sizeof(static_text) - 1
.loop:
      lda static_text,x
      sta SCREEN,x
      lda #WHITE
      sta COLORS,x
      dex
   bpl .loop
   rts

   define byte[] static_text = s"Se det funkar!"
}


Define används för att definiera data som ska tas med i programmet. Det går att definiera byte, word och long samt arrayer av sådana.

Kod: Markera allt

section code, "main", $8000 {

   define byte[8] bits = 1, 2, 4, 8, 16, 32, 64, 128
   define word[] addresses = $1000, $2000, $3000

}


[carlsson]

Det ser lovande ut!

[Redreamer]

Snart blir det ju för lätt att koda!

Kommer du göra några tools för chars, sprites m.m eller blir det bara "koden"?

[bjonte]

För lätt blir det nog aldrig, hehe. Nej, jag har inga planer på att göra något i stil med ett IDE eller specialhantering av den typen av data. Det går att inkludera binärfiler i sitt program och det är standard i alla assemblatorer jag har använt.

[bjonte]

En sak som jag har läst att folk velat ha i Kickassembler som inte jag har använt är att det i Acme går att generera labels programmatiskt. Man kan också skicka "tomma" labels som referenser till macros som i sin tur kan tilldela dem. Jag ska fundera på detta, men jag kommer inte att stödja sådant i första versionen.

[herdware]

På tal om tomma labels så finns det en sak jag tycker är väldigt smidig. Använda + och - som lables.

Kod: Markera allt

   lda ramlinkOpcode
   cmp #$91
   bne rlPageOpWrite
   dex
   dey
   beq +
-  lda rlPageData,x
   sta (zp),y
   dex
   dey
   bne -
+  lda rlPageData,x
   sta (zp),y
   jmp rlPageOpContinue

Vissa assemblatorer kan även hoppa flera steg med ++, -- osv.
(Kod från CMDs dubbel-dma teknik för ramlink. Se C=H #11)