test1.asm -showmem -debug -execute "c:/c64/winvice-1.22/x64.exe -confirmexit +sound +truedrive  -VICIIdsize" -vicesymbols -o myfile.prg

-log c64error.txt INPUT -o OUTPUT

:irqStart
.. code ..
:irqEnd	#$00 ; #irq2  // D012 value ; next irq

:irqStart_stableRaster
.. code ..
:irqEnd	#$00 ; #irq2  // D012 value ; next irq

.function _16bit_nextArgument(arg) { 
	.if (arg.getType()==AT_IMMEDIATE) .return CmdArgument(arg.getType(),>arg.getValue()) 
	.return CmdArgument(arg.getType(),arg.getValue()+1)
}

.pseudocommand mov16 src;tar { 
	lda src
	sta tar 
	lda _16bit_nextArgument(src) 
	sta _16bit_nextArgument(tar)
} 

:mov16 #irq ; $fffe
:mov16 irqTable,x ; $fffe
etc.

pseudocommand irqEnd d12 ; irq {
      lda d12
      sta $d012
      :mov16 irq ; $fffe
}

:irqEnd #$10 ; #irq1  
or 
:irqEnd d012Table,y ; irqTable,x  

.pseudocommand irqEnd d12 ; irq {

       .var hiArg 
       .if (irq.getType()==AT_IMMEDIATE) .eval hiArg= CmdArgument(arg.getType(),>arg.getValue()) 
       else .eval hiArg= CmdArgument(arg.getType(),arg.getValue()+1)

      lda d12
      sta $d012
      lda irq
      sta $fffe	
      lda hiArg
      sta $ffff	
}

!macro sw_register ~.name, .dst {
.name	= *+1
	lda #$ff
	sta .dst
}

	+macro(MySoftwareRegisterName, $d020)

!Macro Voice_Level voice_number, ~.level_timer, ~.level_destination, ~.level_lo, ~.level_hi, ~.level_delta_lo, ~.level_delta_hi, ~.waveform, ~.setlevel, ~.process, v0, v1, v2, v3 {
.start:
.l_timer	ldx #0
		cpx #1
		bne .still_active
		;	Switch off the level flag..
		lda voice_flags+voice_number
		and #!FLAGS_LEVEL_ACTIVE
		sta voice_flags+voice_number
		;	Snap the level interpolation into place by zeroing the rates..
		lda #0
		sta .ld_lo+1
		sta .ld_hi+1
		sta .l_lo+1
		;	And snap to the final level value to where we should be..
.l_dest		lda #0
		jmp .l_hi_write
.still_active
		dex
		stx .l_timer+1
		clc
.l_lo		lda #0
.ld_lo		adc #0
		sta .l_lo+1
.l_hi		lda #0
.ld_hi		adc #0
.l_hi_write	sta .l_hi+1
		clc
.l_wave		adc	#0		; Waveform base.. Should be the base of one of the 16 waveforms..
.l_wave_cmp	cmp #0
		beq +
		sta .l_wave_cmp+1
		sta v0
		sta v1
		sta v2
		sta v3
+
		rts
.level_timer		= .l_timer+1
.level_destination	= .l_dest+1
.level_lo		= .l_lo+1
.level_hi		= .l_hi+1
.level_delta_lo		= .ld_lo+1
.level_delta_hi		= .ld_hi+1
.waveform		= .l_wave+1
.setlevel		= .l_hi_write
.process		= .start
}

+Voice_Level 0, ~Voice_0_Level_Timer, ~Voice_0_Level_Final, ~Voice_0_Level_lo, ~Voice_0_Level_hi, ~Voice_0_Level_Delta_lo, ~Voice_0_Level_Delta_hi, ~Voice_0_Waveform, ~Voice_0_Set_Level, ~Voice_0_Level_Process, .v0_0+2, .v0_1+2, .v0_2+2, .v0_3+2

:VoiceLevel(0, Voice_0_Level_Timer++, Voice_0_Level_Final++, ect 

.eval setLevel=*+27 
.eval process=*
:VoiceLevel(0,….)

lda #10
sta v1.l_hi_write+1
vl: :VoiceLevel(…) 

.eval setLevel=*+27

fadeRow: lda fader

-- snip --

         beq tasm
         rts
tasm:    jmp wrap //change to $9000 to get back to tasm

-- snip --
more code
-- snip --

fader:   ldx $53
         lda $1ac0,x
         sta a3+1

fadeRow: lda fader

         beq tasm
         rts
tasm:    jmp wrap //change to $9000 to get back to tasm
wrap:


fader:   ldx $53
         lda $1ac0,x
         sta a3+1
a3:

.pc = $1000
    lda #5
    sta somewhere.mem+1
    :CopyPseudoCodeToTarget()
    jsr somewhere   // pseudo/VMA which is how it works already.
// Acc = 5
    rts
    
.pseudopc $2000 {
somewhere:
    lda #0
    rts
}

.pc = $2000
  .for(var x=0; x<64; x++) {
    .print x
  }

.pc = $2000
  lda #$01
  sta $d020
  rts

.fill $100, List().add($fe,$82,$82,$82,$82,$82,$fe,$00).get(mod(i,8)) 

.for(var i=0; i<10; i++)
   .print "i="+i

//------------------------------------------------------------------------ -------------------------------------------
//-Routine for pulling $d800 Collors.
//------------------------------------------------------------------------------ -------------------------------------
.pc = * "Collor Puller Routine"
.label coll1 = CollPull
.label coll2 = CollPull+235
.label coll3 = CollPull+235*2
.label coll4 = CollPull+235*3
.label coll5 = CollPull+235*4
.label coll6 = CollPull+235*5
.label coll7 = CollPull+235*6
.label coll8 = CollPull+235*7
.label coll9 = CollPull+235*8
.label coll10 = CollPull+235*9
.label coll11 = CollPull+235*10
.label coll12 = CollPull+235*11
.label coll13 = CollPull+235*12
.label coll14 = CollPull+235*13
.label coll15 = CollPull+235*14
.label coll16 = CollPull+235*15
.label coll17 = CollPull+235*16
.label coll18 = CollPull+235*17
.label coll19 = CollPull+235*18
.label coll20 = CollPull+235*19
.label coll21 = CollPull+235*20
.label coll22 = CollPull+235*21
.label coll23 = CollPull+235*22
.label coll24 = CollPull+235*23
.label coll25 = CollPull+235*24
CollPull:
    .for (y=0;y<25;y++) {
        .for (x=0;x<39;x++) {
            lda $d801+x+[y*40]
            sta $d800+x+[y*40]
        }
        rts
    }
//-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ -+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-

    .for (y=0;y<25;y++) {
.label "coll"+toIntString(y+1)
        .for (x=0;x<39;x++) {
            lda $d801+x+[y*40]
            sta $d800+x+[y*40]
        }
        rts
    }

.macro Move(source, target, size) {
	.if (size <= $1000) :FastMove(source,target,size)
	else                :GeneralMove(source,target,size)
}

.macro FastMove(source, target, size) {
…..
}

.macro GeneralMove(source, target, size) {
...
}

.pseudocommand adc arg1;arg2;tar {
	.if (tar.getType()==AT_NONE) .eval tar=arg2
	lda arg2
	adc arg1
	sta tar
}

.pseudocommand adc16 arg1 ; arg2 ; tar {
	.if (tar.getType()==AT_NONE) .eval tar=arg2
	lda arg2
	adc arg1
	sta tar
	lda _16bit_nextArgument(arg2)
	adc _16bit_nextArgument(arg1)
	sta _16bit_nextArgument(tar)
}

.function _16bit_nextArgument(arg) {
	.if (arg.getType()==AT_IMMEDIATE) .return CmdArgument(arg.getType(),>arg.getValue())
	.return CmdArgument(arg.getType(),arg.getValue()+1)
}

// the above macro is use like this:
:add16 #$2800 ; $1000
:add16 screen ; offset ; zpPointer

for (;hashtable.getKeys().getsize()< noOfDesiredElements;) {
   .var randomNo = random()
   .eval hashtable.put(randomNo, randomNo) 
}

.var x=0

.var x=0
.var x=0 // This gives an error

.var x=0
{var x=1} // This declares another x variable inside a scope

.var x=0
.eval x=1

.macro mymacro(str)
{
  for (var i = 0; i < str.size(); i++)
  {
    .var asciivalue = ASCIIVALUE(str.charAt(i))
  }
}

.var asciivalue = 0 + s.charAt(i)

Byte 1 @ $x000
Byte 2 @ $x040
Byte 3 @ $x080
Byte 4 @ $x0c0
.
.
.
Byte 9 @ $x001
Byte 10@ $x041
.
.
.
Byte 17@ $x002 etc.

	.var theData = LoadBinary "data.prg"

	.for (var TelA=0; TelA<8; TelA++) {
		.pc = NewData + TelA*64
		.for (var TelB=0; TelB<64; TelB=TelB) {
			.byte theData.get(TelA + [TelB*8])
		}
	}

java -jar KickAss.jar -libdir "c:\kickass\Retroinvaders\" source.asm

.import source "include\macroslib.asm"
.import source "include\16bitcmds.asm"
.import source "include\graphics.asm"

//Examples of use
.print "$12->"+byteSize($12)   
.print "$123->"+byteSize($123)       
.print "$123456->"+byteSize($123456)

// The function
.function byteSize(x) {
	.if (x==0) .return 0
	.return 1+byteSize(x>>8)			
}

:add #1 ; label

.pseudocommand MEMFILL destination_address ; number_of_bytes ; value {


  .if (number_of_bytes.getValue()<=5) {

  "DO THE FIRST THING"

  }

  .if (number_of_bytes.getValue()>5 && number_of_bytes.getValue()<=256) {

  "DO THE SECOND THING"

  }

  .if (number_of_bytes.getValue()>256) {

  "DO THE THIRD THING"

  }

}

import source "file.asm"

-----------main.asm---------------
.import source "file1.asm"
.import source "file2.asm"

.var myNumber=42

-----------file1.asm---------------
lda #myNumber

-----------main.asm---------------
.import source "file1.asm"
.import source "file2.asm"

.label myNumber=42

-----------file1.asm---------------
lda #myNumber

.var base64Str = "sfkjfsjdfisjhfijsifjsdkjfskdjf";
:Base64Decode(base64Str)

.marcro Base64Decode(str) {
	// for all chars in str look up value in decode table and make a .byte directive to output the data
}

.macro equalCharPack(filename, screenAdr, charsetAdr) {
	.var charMap = Hashtable()
	.var charNo = 0
	.var screenData = List()
	.var charsetData = List()
	.var pic = LoadPicture(filename)
	.for (var charY=0; charY<25; charY++) {
		.for (var charX=0; charX<40; charX++) {
			.var currentCharBytes = List()
			.var key = ""
			.for (var i=0; i<8; i++) {
				.var byteVal = pic.getSinglecolorByte(charX, charY*8 + i)
				.eval key = key + toHexString(byteVal) + ","
				.eval currentCharBytes.add(byteVal)
			}
			.var currentChar = charMap.get(key)
			.if (currentChar == null) {
				.eval currentChar = charNo
				.eval charMap.put(key, charNo)
				.eval charNo++
				.for (var i=0; i<8; i++) {
					.eval charsetData.add(currentCharBytes.get(i))
				}
			}
			.eval screenData.add(currentChar)
		}
	}
	.pc = screenAdr "screen"
	.fill screenData.size(), screenData.get(i)
	.pc = charsetAdr "charset"
	.fill charsetData.size(), charsetData.get(i)
}

:equalCharPack("pic.png", $2800, $2000)

  // Graphics should fit in 8x8 Single collor / 4 x 8 Multi collor blocks
  .var PictureSizeX = pic.width/8
  .var PictureSizeY = pic.height/8

	.for (var charY=0; charY<PictureSizeY; charY++) {
		.for (var charX=0; charX<PictureSizeX; charX++) {

	.struct RGB {r,g,b}
	
	.var s_palette = List().add(
			RGB(0,0,0),		// black 0
			RGB(255,255,255),	// white 1
			RGB(104,55,43),		// red 2
			RGB(131,240,220),	// cyan 3
			RGB(111,61,134),	// purple 4
			RGB(89,205,54),		// green 5
			RGB(65,55,205),		// blue 6
			RGB(184,199,111),	// yellow 7
			RGB(209,127,48),	// orange 8
			RGB(67,57,0),		// brown 9	
			RGB(154,103,89),	// light_red 10
			RGB(91,91,91),		// dark_gray 11
			RGB(142,142,142),	// gray 12
			RGB(157,255,157),	// light_green 13
			RGB(117,161,236),	// light_blue 14
			RGB(193,193,193)	// light_gray 15
			);
	
	.function colorDistance(c1,c2)
	{
		.var cr = c1.r-c2.r
		.var cg = c1.g-c2.g
		.var cb = c1.b-c2.b
		.return sqrt([cr*cr] + [cg*cg] + [cb*cb])
	}

	.function getClosestColorIndex(rgb)
	{
		.return getClosestColorIndex(
			rgb, s_palette
			)
	}

	.function getClosestColorIndex(rgb, palette)
	{
		.var distance = colorDistance(rgb, palette.get(0))
		.var closestColorIndex = 0

		.for (var index = 1; index < palette.size(); index++)
		{
			.var d = colorDistance(rgb, palette.get(index))
			.if (d < distance)
			{
				.eval distance = d
				.eval closestColorIndex = index
			}
		}

		.return closestColorIndex
	}

.const str = "TESTING"
text:
	.fill	str.size(), str.charAt(i) & $3f

.const str = "TESTING"
.function to_scr(c) {
    .return c & $3f
}
text:
	.fill	str.size(), to_scr(str.charAt(i))

.const str = "TESTING"
text:
	.fill	str.size(), $3f & str.charAt(i)

.var a = 'x' & 1

.var b = 1 & 'x'

.var a = [0+'x'] & 1 

   java -jar KickAss.jar mySource

   KickAss.exe mySource

.pc=$1000
.pseudopc $90
{
some_label:
	lda $1000
	inc some_label+1
	inc some_other_label+1
some_other_label:
	lda $1000
}

AD 00 10
E6 91
EE 99 00
AD 00 10

AD 00 10
E6 91
E6 98
AD 00 10

.pc = $fd	
	lda label
label:

.pc=$1000
.pseudopc $90
{
some_label:
	lda $1000
	inc some_label+1
	inc CmdArgument(2, some_other_label+1)
some_other_label:
	lda $1000
}

inc.zp label
lda.abs $0000

buf_zp:
 .fill 4                  do <ctrl>-t here
 ^                            |
                              v
Error: Invalid number of arguemnts
at line 122, column 2 in test.asm

inc.zp label
lda.abs $0000

inc.z label
lda.a $0000

inc.zp label
lda.abs $0000

inc.z label
lda.a $0000

	.pc = $0801
	ldy.a	$c000,x
	sta.z	$fb,x

	.pc = $0801
	stx	lab,y
.label lab = $fb

	ldy.a	$c000,x		// Abolute mode - No indexing
	ldy.ax  $c000,x		// Absolute,x
	sta.z	$fb,x		// Zeropage mode - No indexing
	sta.zx	$fb,x		// Zeropage mode,x

.var length = end - start
start:
    nop
end:
.print "length:" + length

	.pc = $1000

.const TEST_ENABLE = true

.macro test(v) {
	.byte v
}

.if (TEST_ENABLE) {
	:test(2)
}

	.pc = $1000

.const TEST_ENABLE = true

.if (TEST_ENABLE) {
.macro test(v) {
	.byte v
}
	:test(2)
}

--------- KickAss Library File: ---------
.importonce 
... your code

--------- C++ Library File: ---------
#ifndef __MYLIB__ 
#define __MYLIB__
... your code
#endif

	.ascii	"Header Ident!"
	.byte	0

	.pc = $1000
start:
	lda	#<msg
	ldy	#>msg
	jmp	$ab1e
	
msg:
	.text	"LEN $"+toHexString(end-start)
	.byte	0
end:

   .text_u "HELLO WORLD!"
   .text_l "Hello World!"
   .scr_u "HELLO WORLD!"
   .scr_l "Hello World!"

   .text "STRING",0
   .byte TOKEN_SYS,"2061",0,0,0

.pseudocommand MUL_S a ; b ; tar { :MUL 1 ; a ; b ; tar}
.pseudocommand MUL_U a ; b ; tar { :MUL -1 ; a ; b ; tar}
.pseudocommand MUL sign ; a ; b ; tar {

/* CODE..  
Use .if (sign==1) {...} etc. 
*/

}

//---------------------------------------------
// Mode Control
//---------------------------------------------
.enum {MODE1, MODE2, UNSET}
.const defaultMode = MODE1
.var mode=UNSET
.function getMode() { 
	.if (mode==UNSET) return defaultMode
	.return mode
}  
//---------------------------------------------
// Commands
//---------------------------------------------
.psesudocommand myCmd a; b {
	.if (getMode()==MODE1) {
	 	/* DO SOMETHING */
	}	

	.if (getMode()==MODE2) {
	 	/* DO SOMETHING */
	}	

}

	.pc = $6000 "Zoomed Font"

	.const c_zoomLevelCount = 19
	.const c_zoomMin = 0.15
	.const c_zoomMax = 1
	.const c_charCount = 30

	//
	// load the font into 16x16 pixel chunks
	//  

		.var originalFont = List()

		.var charsetFont = LoadPicture("data/fonts/2x2_formaterad.gif", List().add($000000, $ffffff))
		.for (var c = 0; c < c_charCount; c++)
		{
			.var theChar = List()
			.for (var y = 0; y < 16; y++)
			{
				.for (var x = 0; x < 16; x++)
				{
					.var p = charsetFont.getPixel(x + c * 16, y) & 255
					.eval theChar.add(p)
				}
			}
			.eval originalFont.add(theChar)
		}

	//
	// create zoomed versions
	//  
		.function linearInterpolate(a,b,t)
		{
			.return [a*[1.0-t]] + [b*t]
		}

		.macro scale16x16(source, dest, zoom)
		{
			.var xratio = zoom
			.var yratio = zoom

			.var xoffset = [1-xratio] * 8
			.var yoffset = [1-yratio] * 8

			.for (var dy = 0; dy < 16; dy++)
			{
				.var sY = round([dy * yratio] + yoffset)
				.for (var dx = 0; dx < 16; dx++)
				{
					.var sX = round([dx * xratio] + xoffset)
					.eval dest.set(sX + sY*16 , source.get(dx + dy * 16))
				}
			}
		}

		.for (var c = 0; c < c_charCount; c++)
		{
			.for (var zoom = 0; zoom < c_zoomLevelCount; zoom++)
			{
				.var t = zoom / [c_zoomLevelCount-1]
				.var zoomLevel = linearInterpolate(c_zoomMin, c_zoomMax, t)

				.var originalChar = originalFont.get(c)
				.var destChar = List()
				.for (var i = 0; i < 256; i++)
					.eval destChar.add(0)

				:scale16x16(originalChar, destChar, zoomLevel)

				.for (var j = 0; j < 2; j++)
				{
					.for (var y = 0; y < 16; y++)
					{
						.var theByte = 0
						.for (var x = 0; x < 8; x++)
						{
							.var yy = y
							.var xx = x + j * 8

							.var addr = xx + yy * 16

							.if (destChar.get(addr) == 255)
								.eval theByte = theByte | [1 << [7-x]]

						}
						.byte theByte

					}
				}

			}
		}

.macro mymacro(location) {
.define mymacro {
 .var mylist=List()
 .for (i=0;i<256;i++)
 mylist.add (value of location)
 mylist.add ($06) - lets say add to all elements..
 //;dump to memory

 .fill mylist.size(),mylist.get(i)


 }

}
:mymacro($0400)

// Bank 1
.pc=$1000 

lda foo
sta bar
..


.pc=$1400 "Some routine"
lda this
sta that
...

// Bank 2
.pc=$2000 

.pseudopc $1000   
{
	lda foo
	sta bar
	..
}

// Bank 2
.pc=$2000 
.pseudopc $1000   
{
	lda foo
	sta bar
	..
}

.pc=$2400 
.pseudopc $1400   
{
	lda foo
	sta bar
	..
}

// Bank 2
.pc=$2000 
.pseudopc $1000   
{
	lda foo
	sta bar
	..

.align $400
	lda foo
	sta bar
	..
}

.pc=$2000
.pseudopc $1000
{
   lda blabla
   ...

.pc=$1400
   bla (code that ends up on $2400 here)
   
.pc=$1f3c
  blabla (code that ends up on $2f3c here)
   
}

.macro myMacro(NumberValue x) {
  //do something
}

.macro myMacro(String x) {
  //do something else
}

.macro myMacro(x) {
  if (x.type()==NUMBERVALUE) :myMacro_value()
  else (x.type()==STRING) :myMacro_string()
  else .error("Unkown Type")

 

.macro myMacro_value(x) {
  //do something 
}

.macro myMacro_string(x) {
  //do something else
}

// Use it like this
         :irqEnd #$60 ; #irq2

// The macro
.pseudocommand irqEnd nextIrqYpos ; nextIrq ; extraArg {
	.if (nextIrqYpos.getType()!=AT_NONE) {
		:mov nextIrqYpos ; $d012
	}	
	.if (nextIrq.getType()!=AT_NONE) {
		:mov16 nextIrq ; $fffe
	}	
	.if (SAVE01==extraArg.getValue()) {
		:mov _ds_irq01 ; $01
	}
	lda _ds_irqa
	ldx _ds_irqx
	ldy _ds_irqy
	rti
}

getStructName() - returns the structure name
getNoOfFields() - returns the number of defined fields
getFieldNames() - returns a list of field names
get(fieldName) - returns a field value by field name.
get(index)     - returns a field value by field index 
set(index, value) - sets a field by field name
set(fieldName, value) - sets a fields by field index

.const MyConst = $d012

.macro myMacro(val)
{
        ldy #val
	sty MyConst
}

:MyMacro($32) 	// This won't work
.const MyConst = $d012
:MyMacro($32) 	// This will work
.macro myMacro(val)
{
    ldy #val
    sty MyConst
}

:MyMacro($32) 	// This will work
.label MyLabel = $d012
.macro myMacro(val)
{
    ldy #val
    sty MyLabel
}

// System.asm

.const MyConst = $d012

.macro myMacro(val)
{
        ldy #val
	sty MyConst
}