mirror of
https://github.com/irmen/prog8.git
synced 2025-02-16 22:30:46 +00:00
fixed swap()
This commit is contained in:
Irmen de Jong
parent
25e44a54fb
commit
ef12be062b
@ -1,12 +0,0 @@
|
||||
mkdir compiled_java
|
||||
|
||||
java -jar ../antlr/lib/antlr-4.7.2-complete.jar -o ./prog8/parser -Xexact-output-dir -no-listener -no-visitor -package prog8.parser ../antlr/prog8.g4
|
||||
|
||||
@dir /b /S src *.java > sources.txt
|
||||
javac -verbose -d compiled_java -cp ../antlr/lib/antlr-runtime-4.7.2.jar @sources.txt
|
||||
@del sources.txt
|
||||
jar cf parser.jar -C compiled_java prog8
|
||||
|
||||
set KOTLINC=%USERPROFILE%\.IdeaIC2018.3\config\plugins\kotlin\kotlinc\bin\kotlinc.bat
|
||||
|
||||
%KOTLINC% -verbose -include-runtime -d prog8_kotlin.jar -cp ../antlr/lib/antlr-runtime-4.7.2.jar;parser.jar prog8
|
||||
@ -946,43 +946,14 @@ private class StatementTranslator(private val prog: IntermediateProgram,
|
||||
throw AstException("swap requires args of numerical type")
|
||||
// @todo implement these errors as nice AstChecker expression errors.
|
||||
|
||||
// eor trick: Swap(X,Y) :=
|
||||
// X ^= Y
|
||||
// Y ^= X
|
||||
// X ^= Y
|
||||
// this trick is used when we're dealing with: (u)byte or (u)word variables, ... @todo
|
||||
|
||||
if(useEorTrickForSwap(dt1, args[0], args[1])) {
|
||||
val xEorY = BinaryExpression(args[0], "^", args[1], args[0].position)
|
||||
val yEorX = BinaryExpression(args[1], "^", args[0], args[1].position)
|
||||
val xIsXeorY = Assignment(listOf(AssignTarget.fromExpr(args[0])), null, xEorY, args[0].position)
|
||||
val yIsYeorX = Assignment(listOf(AssignTarget.fromExpr(args[1])), null, yEorX, args[1].position)
|
||||
xIsXeorY.linkParents(args[0].parent)
|
||||
yIsYeorX.linkParents(args[0].parent)
|
||||
translate(xIsXeorY)
|
||||
translate(yIsYeorX)
|
||||
translate(xIsXeorY)
|
||||
} else {
|
||||
translate(args[0])
|
||||
translate(args[1])
|
||||
// pop in reverse order
|
||||
popValueIntoTarget(AssignTarget.fromExpr(args[0]), dt1)
|
||||
popValueIntoTarget(AssignTarget.fromExpr(args[1]), dt2)
|
||||
}
|
||||
translate(args[0])
|
||||
translate(args[1])
|
||||
// pop in reverse order
|
||||
popValueIntoTarget(AssignTarget.fromExpr(args[0]), dt1)
|
||||
popValueIntoTarget(AssignTarget.fromExpr(args[1]), dt2)
|
||||
return
|
||||
}
|
||||
|
||||
private fun useEorTrickForSwap(dt: DataType, expr1: IExpression, expr2: IExpression): Boolean {
|
||||
if(dt in IntegerDatatypes) {
|
||||
if (expr1 is IdentifierReference && expr2 is IdentifierReference)
|
||||
return true
|
||||
if(expr1 is ArrayIndexedExpression && expr2 is ArrayIndexedExpression) {
|
||||
return expr1.arrayspec.x is LiteralValue && expr2.arrayspec.x is LiteralValue
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
private fun translateSubroutineCall(subroutine: Subroutine, arguments: List<IExpression>, callPosition: Position) {
|
||||
// evaluate the arguments and assign them into the subroutine's argument variables.
|
||||
var restoreX = Register.X in subroutine.asmClobbers
|
||||
|
||||
@ -195,7 +195,7 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
|
||||
vardecls2asm(block)
|
||||
out("")
|
||||
|
||||
val instructionPatternWindowSize = 7 // increase once patterns occur longer than this.
|
||||
val instructionPatternWindowSize = 8 // increase once patterns occur longer than this.
|
||||
var processed = 0
|
||||
|
||||
if(trace) println("BLOCK: ${block.scopedname} ${block.address ?: ""}")
|
||||
@ -3312,8 +3312,196 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
|
||||
val value = hexVal(segment[0])
|
||||
" lda #<$value | sta ${ESTACK_LO.toHex()},x | lda #>$value | sta ${ESTACK_HI.toHex()},x | dex | jsr prog8_lib.mul_word"
|
||||
}
|
||||
},
|
||||
|
||||
// various variable or memory swaps
|
||||
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.PUSH_VAR_BYTE, Opcode.POP_VAR_BYTE, Opcode.POP_VAR_BYTE)) { segment ->
|
||||
val var1 = segment[0].callLabel
|
||||
val var2 = segment[1].callLabel
|
||||
val var3 = segment[2].callLabel
|
||||
val var4 = segment[3].callLabel
|
||||
if(var1==var3 && var2==var4) {
|
||||
"""
|
||||
lda $var1
|
||||
tay
|
||||
lda $var2
|
||||
sta $var1
|
||||
sty $var2
|
||||
"""
|
||||
} else null
|
||||
},
|
||||
AsmPattern(listOf(Opcode.PUSH_VAR_WORD, Opcode.PUSH_VAR_WORD, Opcode.POP_VAR_WORD, Opcode.POP_VAR_WORD)) { segment ->
|
||||
val var1 = segment[0].callLabel
|
||||
val var2 = segment[1].callLabel
|
||||
val var3 = segment[2].callLabel
|
||||
val var4 = segment[3].callLabel
|
||||
if(var1==var3 && var2==var4) {
|
||||
"""
|
||||
lda $var1
|
||||
tay
|
||||
lda $var2
|
||||
sta $var1
|
||||
sty $var2
|
||||
lda $var1+1
|
||||
tay
|
||||
lda $var2+1
|
||||
sta $var1+1
|
||||
sty $var2+1
|
||||
"""
|
||||
} else null
|
||||
},
|
||||
AsmPattern(listOf(Opcode.PUSH_MEM_B, Opcode.PUSH_MEM_B, Opcode.POP_MEM_BYTE, Opcode.POP_MEM_BYTE),
|
||||
listOf(Opcode.PUSH_MEM_UB, Opcode.PUSH_MEM_UB, Opcode.POP_MEM_BYTE, Opcode.POP_MEM_BYTE)) { segment ->
|
||||
val addr1 = segment[0].arg!!.integerValue()
|
||||
val addr2 = segment[1].arg!!.integerValue()
|
||||
val addr3 = segment[2].arg!!.integerValue()
|
||||
val addr4 = segment[3].arg!!.integerValue()
|
||||
if(addr1==addr3 && addr2==addr4) {
|
||||
"""
|
||||
lda ${addr1.toHex()}
|
||||
tay
|
||||
lda ${addr2.toHex()}
|
||||
sta ${addr1.toHex()}
|
||||
sty ${addr2.toHex()}
|
||||
"""
|
||||
} else null
|
||||
},
|
||||
AsmPattern(listOf(Opcode.PUSH_MEM_W, Opcode.PUSH_MEM_W, Opcode.POP_MEM_WORD, Opcode.POP_MEM_WORD),
|
||||
listOf(Opcode.PUSH_MEM_UW, Opcode.PUSH_MEM_UW, Opcode.POP_MEM_WORD, Opcode.POP_MEM_WORD)) { segment ->
|
||||
val addr1 = segment[0].arg!!.integerValue()
|
||||
val addr2 = segment[1].arg!!.integerValue()
|
||||
val addr3 = segment[2].arg!!.integerValue()
|
||||
val addr4 = segment[3].arg!!.integerValue()
|
||||
if(addr1==addr3 && addr2==addr4) {
|
||||
"""
|
||||
lda ${addr1.toHex()}
|
||||
tay
|
||||
lda ${addr2.toHex()}
|
||||
sta ${addr1.toHex()}
|
||||
sty ${addr2.toHex()}
|
||||
lda ${(addr1+1).toHex()}
|
||||
tay
|
||||
lda ${(addr2+1).toHex()}
|
||||
sta ${(addr1+1).toHex()}
|
||||
sty ${(addr2+1).toHex()}
|
||||
"""
|
||||
} else null
|
||||
},
|
||||
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_BYTE,
|
||||
Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE, Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE)) { segment ->
|
||||
val i1 = segment[0].arg!!.integerValue()
|
||||
val i2 = segment[2].arg!!.integerValue()
|
||||
val i3 = segment[4].arg!!.integerValue()
|
||||
val i4 = segment[6].arg!!.integerValue()
|
||||
val array1 = segment[1].callLabel
|
||||
val array2 = segment[3].callLabel
|
||||
val array3 = segment[5].callLabel
|
||||
val array4 = segment[7].callLabel
|
||||
if(i1==i3 && i2==i4 && array1==array3 && array2==array4) {
|
||||
"""
|
||||
lda $array1+$i1
|
||||
tay
|
||||
lda $array2+$i2
|
||||
sta $array1+$i1
|
||||
sty $array2+$i2
|
||||
"""
|
||||
} else null
|
||||
},
|
||||
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_BYTE, Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_BYTE,
|
||||
Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_BYTE)) { segment ->
|
||||
val vi1 = segment[0].callLabel
|
||||
val vi2 = segment[2].callLabel
|
||||
val vi3 = segment[4].callLabel
|
||||
val vi4 = segment[6].callLabel
|
||||
val array1 = segment[1].callLabel
|
||||
val array2 = segment[3].callLabel
|
||||
val array3 = segment[5].callLabel
|
||||
val array4 = segment[7].callLabel
|
||||
if(vi1==vi3 && vi2==vi4 && array1==array3 && array2==array4) {
|
||||
val load1 = loadAFromIndexedByVar(segment[0], segment[1])
|
||||
val load2 = loadAFromIndexedByVar(segment[2], segment[3])
|
||||
val storeIn1 = storeAToIndexedByVar(segment[0], segment[1])
|
||||
val storeIn2 = storeAToIndexedByVar(segment[2], segment[3])
|
||||
"""
|
||||
$load1
|
||||
pha
|
||||
$load2
|
||||
$storeIn1
|
||||
pla
|
||||
$storeIn2
|
||||
"""
|
||||
} else null
|
||||
},
|
||||
AsmPattern(listOf(Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.PUSH_BYTE, Opcode.READ_INDEXED_VAR_WORD,
|
||||
Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_WORD, Opcode.PUSH_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
|
||||
val i1 = segment[0].arg!!.integerValue()*2
|
||||
val i2 = segment[2].arg!!.integerValue()*2
|
||||
val i3 = segment[4].arg!!.integerValue()*2
|
||||
val i4 = segment[6].arg!!.integerValue()*2
|
||||
val array1 = segment[1].callLabel
|
||||
val array2 = segment[3].callLabel
|
||||
val array3 = segment[5].callLabel
|
||||
val array4 = segment[7].callLabel
|
||||
if(i1==i3 && i2==i4 && array1==array3 && array2==array4) {
|
||||
"""
|
||||
lda $array1+$i1
|
||||
tay
|
||||
lda $array2+$i2
|
||||
sta $array1+$i1
|
||||
sty $array2+$i2
|
||||
lda $array1+${i1+1}
|
||||
tay
|
||||
lda $array2+${i2+1}
|
||||
sta $array1+${i1+1}
|
||||
sty $array2+${i2+1}
|
||||
"""
|
||||
} else null
|
||||
},
|
||||
AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_WORD, Opcode.PUSH_VAR_BYTE, Opcode.READ_INDEXED_VAR_WORD,
|
||||
Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD, Opcode.PUSH_VAR_BYTE, Opcode.WRITE_INDEXED_VAR_WORD)) { segment ->
|
||||
val vi1 = segment[0].callLabel
|
||||
val vi2 = segment[2].callLabel
|
||||
val vi3 = segment[4].callLabel
|
||||
val vi4 = segment[6].callLabel
|
||||
val array1 = segment[1].callLabel
|
||||
val array2 = segment[3].callLabel
|
||||
val array3 = segment[5].callLabel
|
||||
val array4 = segment[7].callLabel
|
||||
if(vi1==vi3 && vi2==vi4 && array1==array3 && array2==array4) {
|
||||
// SCRATCH_B1 = index1
|
||||
// SCRATCH_REG = index2
|
||||
// SCRATCH_W1 = temp storage of array[index2]
|
||||
"""
|
||||
lda ${segment[0].callLabel}
|
||||
asl a
|
||||
sta ${C64Zeropage.SCRATCH_B1}
|
||||
lda ${segment[2].callLabel}
|
||||
asl a
|
||||
sta ${C64Zeropage.SCRATCH_REG}
|
||||
stx ${C64Zeropage.SCRATCH_REG_X}
|
||||
tax
|
||||
lda ${segment[3].callLabel},x
|
||||
ldy ${segment[3].callLabel}+1,x
|
||||
sta ${C64Zeropage.SCRATCH_W1}
|
||||
sty ${C64Zeropage.SCRATCH_W1}+1
|
||||
ldx ${C64Zeropage.SCRATCH_B1}
|
||||
lda ${segment[1].callLabel},x
|
||||
ldy ${segment[1].callLabel}+1,x
|
||||
ldx ${C64Zeropage.SCRATCH_REG}
|
||||
sta ${segment[3].callLabel},x
|
||||
tya
|
||||
sta ${segment[3].callLabel}+1,x
|
||||
ldx ${C64Zeropage.SCRATCH_B1}
|
||||
lda ${C64Zeropage.SCRATCH_W1}
|
||||
sta ${segment[1].callLabel},x
|
||||
lda ${C64Zeropage.SCRATCH_W1}+1
|
||||
sta ${segment[1].callLabel}+1,x
|
||||
ldx ${C64Zeropage.SCRATCH_REG_X}
|
||||
"""
|
||||
} else null
|
||||
}
|
||||
|
||||
|
||||
)
|
||||
|
||||
}
|
||||
|
||||
@ -1,860 +0,0 @@
|
||||
%import c64utils
|
||||
%import c64flt
|
||||
%output raw
|
||||
%launcher none
|
||||
%address $4000
|
||||
|
||||
~ main {
|
||||
|
||||
sub start() {
|
||||
|
||||
byte b = 99
|
||||
byte b2 = 100
|
||||
ubyte ub = 255
|
||||
ubyte ub2 = 0
|
||||
word w = 999
|
||||
word w2 = 3
|
||||
uword uw = 40000
|
||||
uword uw2 = 3434
|
||||
float fl1 = 1.1
|
||||
float fl2 = 2.2
|
||||
|
||||
byte[5] barr1
|
||||
byte[5] barr2
|
||||
ubyte[5] ubarr1
|
||||
ubyte[5] ubarr2
|
||||
word[5] warr1
|
||||
word[5] warr2
|
||||
uword[5] uwarr1
|
||||
uword[5] uwarr2
|
||||
float[5] farr1
|
||||
float[5] farr2
|
||||
|
||||
memory byte mbyte = $c000
|
||||
memory byte mbyte2 = $d000
|
||||
memory ubyte mubyte = $c001
|
||||
memory ubyte mubyte2 = $d001
|
||||
memory word mword = $c002
|
||||
memory word mword2 = $d002
|
||||
memory uword muword = $c004
|
||||
memory uword muword2 = $d004
|
||||
memory float mfloat = $c006
|
||||
memory float mfloat2 = $d006
|
||||
memory byte[mubyte2] mbarr1 = $e000
|
||||
memory ubyte[mubyte2] mubarr1 = $e100
|
||||
memory word[mubyte2] mwarr1 = $e100
|
||||
memory uword[mubyte2] muwarr1 = $e100
|
||||
|
||||
str string = "hello"
|
||||
str_p stringp = "hello"
|
||||
|
||||
|
||||
; some string assignments
|
||||
|
||||
str stringvar = "??????????\n\n\nnext line\r\r\rnext line after carriagereturn"
|
||||
ubyte secretnumber = 0
|
||||
memory uword freadstr_arg = $22 ; argument for FREADSTR
|
||||
uword testword
|
||||
ubyte char1 = '@'
|
||||
ubyte char2 = '\n'
|
||||
ubyte char3 = '\r'
|
||||
ubyte char1b = '@'
|
||||
ubyte char2b = '\n'
|
||||
ubyte char3b = '\r'
|
||||
|
||||
testword = '@'
|
||||
testword = '\n'
|
||||
freadstr_arg = '@'
|
||||
freadstr_arg = '\n'
|
||||
secretnumber = '@'
|
||||
secretnumber = '\r'
|
||||
|
||||
testword = stringvar
|
||||
testword = "stringstring"
|
||||
freadstr_arg = stringvar
|
||||
freadstr_arg = "stringstring"
|
||||
|
||||
|
||||
; all possible assignments to a BYTE VARIABLE (not array)
|
||||
|
||||
|
||||
ubyte_assignment_to_register:
|
||||
A = 42
|
||||
A = X
|
||||
A = ub2
|
||||
A = mubyte2
|
||||
A = string[4]
|
||||
A = string[X]
|
||||
A = string[b]
|
||||
A = string[ub]
|
||||
A = string[mbyte2]
|
||||
A = string[mubyte2]
|
||||
A = ubarr1[2]
|
||||
A = ubarr1[X]
|
||||
A = ubarr1[b]
|
||||
A = ubarr1[ub]
|
||||
A = ubarr1[mbyte2]
|
||||
A = ubarr1[mubyte2]
|
||||
|
||||
ubyte_assignment_to_ubytevar:
|
||||
ub = 42
|
||||
ub = X
|
||||
ub = ub2
|
||||
ub = mubyte2
|
||||
ub = string[4]
|
||||
ub = string[X]
|
||||
ub = string[b]
|
||||
ub = string[ub]
|
||||
ub = string[mbyte2]
|
||||
ub = string[mubyte2]
|
||||
ub = ubarr1[2]
|
||||
ub = ubarr1[X]
|
||||
ub = ubarr1[b]
|
||||
ub = ubarr1[ub]
|
||||
ub = ubarr1[mbyte2]
|
||||
ub = ubarr1[mubyte2]
|
||||
|
||||
|
||||
ubyte_assignment_to_ubytemem:
|
||||
mubyte = 42
|
||||
mubyte = X
|
||||
mubyte = ub2
|
||||
mubyte = mubyte2
|
||||
mubyte = string[4]
|
||||
mubyte = string[X]
|
||||
mubyte = string[b]
|
||||
mubyte = string[ub]
|
||||
mubyte = string[mbyte2]
|
||||
mubyte = string[mubyte2]
|
||||
mubyte = ubarr1[2]
|
||||
mubyte = ubarr1[X]
|
||||
mubyte = ubarr1[b]
|
||||
mubyte = ubarr1[ub]
|
||||
mubyte = ubarr1[mbyte2]
|
||||
mubyte = ubarr1[mubyte2]
|
||||
|
||||
byte_assignment_to_bytevar:
|
||||
b = -42
|
||||
b = b2
|
||||
b = mbyte2
|
||||
b = barr1[2]
|
||||
b = barr1[X]
|
||||
b = barr1[b]
|
||||
b = barr1[ub]
|
||||
b = barr1[mbyte2]
|
||||
b = barr1[mubyte2]
|
||||
|
||||
|
||||
byte_assignment_to_bytemem:
|
||||
mbyte = -42
|
||||
mbyte = b2
|
||||
mbyte = mbyte2
|
||||
mbyte = barr1[2]
|
||||
mbyte = barr1[X]
|
||||
mbyte = barr1[b]
|
||||
mbyte = barr1[ub]
|
||||
mbyte = barr1[mbyte2]
|
||||
mbyte = barr1[mubyte2]
|
||||
|
||||
|
||||
ubyte_assignment_to_ubytearray:
|
||||
ubarr2[3] = 42
|
||||
ubarr2[3] = X
|
||||
ubarr2[3] = ub2
|
||||
ubarr2[3] = mubyte2
|
||||
ubarr2[3] = string[4]
|
||||
ubarr2[3] = string[X]
|
||||
ubarr2[3] = string[b]
|
||||
ubarr2[3] = string[ub]
|
||||
ubarr2[3] = string[mbyte2]
|
||||
ubarr2[3] = string[mubyte2]
|
||||
ubarr2[3] = ubarr1[2]
|
||||
ubarr2[3] = ubarr1[X]
|
||||
ubarr2[3] = ubarr1[b]
|
||||
ubarr2[3] = ubarr1[ub]
|
||||
ubarr2[3] = ubarr1[mbyte2]
|
||||
ubarr2[3] = ubarr1[mubyte2]
|
||||
string[4] = 42
|
||||
string[4] = 'B'
|
||||
string[4] = X
|
||||
string[4] = ub2
|
||||
string[4] = mubyte2
|
||||
string[4] = ubarr1[2]
|
||||
string[4] = ubarr1[X]
|
||||
string[4] = ubarr1[ub]
|
||||
string[4] = ubarr1[mubyte2]
|
||||
string[4] = string[3]
|
||||
string[4] = string[Y]
|
||||
string[4] = string[ub2]
|
||||
string[4] = string[mbyte2]
|
||||
string[4] = string[mubyte2]
|
||||
|
||||
|
||||
ubarr2[Y] = 42
|
||||
ubarr2[Y] = X
|
||||
ubarr2[Y] = ub2
|
||||
ubarr2[Y] = mubyte2
|
||||
ubarr2[Y] = string[4]
|
||||
ubarr2[Y] = string[X]
|
||||
ubarr2[Y] = string[b]
|
||||
ubarr2[Y] = string[ub]
|
||||
ubarr2[Y] = string[mbyte2]
|
||||
ubarr2[Y] = string[mubyte2]
|
||||
ubarr2[Y] = ubarr1[2]
|
||||
ubarr2[Y] = ubarr1[X]
|
||||
ubarr2[Y] = ubarr1[b]
|
||||
ubarr2[Y] = ubarr1[ub]
|
||||
ubarr2[Y] = ubarr1[mbyte2]
|
||||
ubarr2[Y] = ubarr1[mubyte2]
|
||||
string[Y] = 42
|
||||
string[Y] = 'B'
|
||||
string[Y] = X
|
||||
string[Y] = ub2
|
||||
string[Y] = mubyte2
|
||||
string[Y] = ubarr1[2]
|
||||
string[Y] = ubarr1[Y]
|
||||
string[Y] = ubarr1[ub2]
|
||||
string[Y] = ubarr1[mubyte2]
|
||||
string[Y] = string[Y]
|
||||
string[Y] = string[ub2]
|
||||
string[Y] = string[mbyte2]
|
||||
string[Y] = string[mubyte2]
|
||||
|
||||
|
||||
ubarr2[ub2] = 42
|
||||
ubarr2[ub2] = X
|
||||
ubarr2[ub2] = ub2
|
||||
ubarr2[ub2] = mubyte2
|
||||
ubarr2[ub2] = string[4]
|
||||
ubarr2[ub2] = string[X]
|
||||
ubarr2[ub2] = string[b]
|
||||
ubarr2[ub2] = string[ub]
|
||||
ubarr2[ub2] = string[mbyte2]
|
||||
ubarr2[ub2] = string[mubyte2]
|
||||
ubarr2[ub2] = ubarr1[2]
|
||||
ubarr2[ub2] = ubarr1[X]
|
||||
ubarr2[ub2] = ubarr1[b]
|
||||
ubarr2[ub2] = ubarr1[ub]
|
||||
ubarr2[ub2] = ubarr1[mbyte2]
|
||||
ubarr2[ub2] = ubarr1[mubyte2]
|
||||
string[ub2] = 42
|
||||
string[ub2] = 'B'
|
||||
string[ub2] = X
|
||||
string[ub2] = ub2
|
||||
string[ub2] = mubyte2
|
||||
string[ub2] = ubarr1[2]
|
||||
string[ub2] = ubarr1[Y]
|
||||
string[ub2] = ubarr1[ub2]
|
||||
string[ub2] = ubarr1[mubyte2]
|
||||
string[ub2] = string[Y]
|
||||
string[ub2] = string[ub2]
|
||||
string[ub2] = string[mbyte2]
|
||||
string[ub2] = string[mubyte2]
|
||||
|
||||
|
||||
ubarr2[b2] = 42
|
||||
ubarr2[b2] = X
|
||||
ubarr2[b2] = ub2
|
||||
ubarr2[b2] = mubyte2
|
||||
ubarr2[b2] = string[4]
|
||||
ubarr2[b2] = string[X]
|
||||
ubarr2[b2] = string[b]
|
||||
ubarr2[b2] = string[ub]
|
||||
ubarr2[b2] = string[mbyte2]
|
||||
ubarr2[b2] = string[mubyte2]
|
||||
ubarr2[b2] = ubarr1[2]
|
||||
ubarr2[b2] = ubarr1[X]
|
||||
ubarr2[b2] = ubarr1[b]
|
||||
ubarr2[b2] = ubarr1[ub]
|
||||
ubarr2[b2] = ubarr1[mbyte2]
|
||||
ubarr2[b2] = ubarr1[mubyte2]
|
||||
string[b2] = 42
|
||||
string[b2] = 'B'
|
||||
string[b2] = X
|
||||
string[b2] = ub2
|
||||
string[b2] = mubyte2
|
||||
string[b2] = ubarr1[2]
|
||||
string[b2] = ubarr1[Y]
|
||||
string[b2] = ubarr1[ub2]
|
||||
string[b2] = ubarr1[mubyte2]
|
||||
string[b2] = string[Y]
|
||||
string[b2] = string[ub2]
|
||||
string[b2] = string[mbyte2]
|
||||
string[b2] = string[mubyte2]
|
||||
|
||||
ubarr2[mubyte2] = 42
|
||||
ubarr2[mubyte2] = X
|
||||
ubarr2[mubyte2] = ub2
|
||||
ubarr2[mubyte2] = mubyte2
|
||||
ubarr2[mubyte2] = string[4]
|
||||
ubarr2[mubyte2] = ubarr1[2]
|
||||
string[mubyte2] = 42
|
||||
string[mubyte2] = 'B'
|
||||
string[mubyte2] = X
|
||||
string[mubyte2] = ub2
|
||||
string[mubyte2] = mubyte2
|
||||
string[mubyte2] = ubarr1[2]
|
||||
|
||||
ubarr2[mubyte2] = string[Y] ; via evaluation
|
||||
ubarr2[mubyte2] = string[b] ; via evaluation
|
||||
ubarr2[mubyte2] = string[ub] ; via evaluation
|
||||
ubarr2[mubyte2] = string[mbyte2] ; via evaluation
|
||||
ubarr2[mubyte2] = string[mubyte2] ; via evaluation
|
||||
ubarr2[mubyte2] = ubarr1[Y] ; via evaluation
|
||||
ubarr2[mubyte2] = ubarr1[b] ; via evaluation
|
||||
ubarr2[mubyte2] = ubarr1[ub] ; via evaluation
|
||||
ubarr2[mubyte2] = ubarr1[mbyte2] ; via evaluation
|
||||
ubarr2[mubyte2] = ubarr1[mubyte2] ; via evaluation
|
||||
string[mubyte2] = ubarr1[Y] ; via evaluation
|
||||
string[mubyte2] = ubarr1[b] ; via evaluation
|
||||
string[mubyte2] = ubarr1[ub2] ; via evaluation
|
||||
string[mubyte2] = ubarr1[mbyte2] ; via evaluation
|
||||
string[mubyte2] = ubarr1[mubyte2] ; via evaluation
|
||||
string[mubyte2] = string[mubyte2] ; via evaluation
|
||||
ubarr1[ubarr2[A]] = ubarr2[ubarr1[Y]] ; via evaluation
|
||||
|
||||
|
||||
|
||||
byte_assignment_to_bytearray:
|
||||
|
||||
barr2[3] = 42
|
||||
barr2[3] = b2
|
||||
barr2[3] = mbyte2
|
||||
barr2[3] = barr1[2]
|
||||
barr2[3] = barr1[X]
|
||||
barr2[3] = barr1[b]
|
||||
barr2[3] = barr1[ub]
|
||||
barr2[3] = barr1[mbyte2]
|
||||
barr2[3] = barr1[mubyte2]
|
||||
|
||||
barr2[Y] = 42
|
||||
barr2[Y] = b2
|
||||
barr2[Y] = mbyte2
|
||||
barr2[Y] = barr1[2]
|
||||
barr2[Y] = barr1[X]
|
||||
barr2[Y] = barr1[b]
|
||||
barr2[Y] = barr1[ub]
|
||||
barr2[Y] = barr1[mbyte2]
|
||||
barr2[Y] = barr1[mubyte2]
|
||||
|
||||
barr2[b2] = 42
|
||||
barr2[b2] = b2
|
||||
barr2[b2] = mbyte2
|
||||
barr2[b2] = barr1[2]
|
||||
barr2[b2] = barr1[X]
|
||||
barr2[b2] = barr1[b]
|
||||
barr2[b2] = barr1[ub]
|
||||
barr2[b2] = barr1[mbyte2]
|
||||
barr2[b2] = barr1[mubyte2]
|
||||
|
||||
barr2[ub2] = 42
|
||||
barr2[ub2] = b2
|
||||
barr2[ub2] = mbyte2
|
||||
barr2[ub2] = barr1[2]
|
||||
barr2[ub2] = barr1[X]
|
||||
barr2[ub2] = barr1[b]
|
||||
barr2[ub2] = barr1[ub]
|
||||
barr2[ub2] = barr1[mbyte2]
|
||||
barr2[ub2] = barr1[mubyte2]
|
||||
|
||||
barr2[mubyte2] = 42
|
||||
barr2[mubyte2] = b2
|
||||
barr2[mubyte2] = mbyte2
|
||||
barr2[mubyte2] = barr1[2]
|
||||
barr2[mubyte2] = barr1[Y] ; via evaluation
|
||||
barr2[mubyte2] = barr1[b] ; via evaluation
|
||||
barr2[mubyte2] = barr1[ub] ; via evaluation
|
||||
barr2[mubyte2] = barr1[mbyte2] ; via evaluation
|
||||
barr2[mubyte2] = barr1[mubyte2] ; via evaluation
|
||||
barr1[ubarr2[A]] = barr2[ubarr1[Y]] ; via evaluation
|
||||
|
||||
|
||||
byte_assignment_to_membytearray:
|
||||
|
||||
mbarr1[3] = 42
|
||||
mbarr1[3] = b2
|
||||
mbarr1[3] = mbyte2
|
||||
mbarr1[3] = barr1[2]
|
||||
mbarr1[3] = barr1[X]
|
||||
mbarr1[3] = barr1[b]
|
||||
mbarr1[3] = barr1[ub]
|
||||
mbarr1[3] = barr1[mbyte2]
|
||||
mbarr1[3] = barr1[mubyte2]
|
||||
|
||||
mbarr1[Y] = 42
|
||||
mbarr1[Y] = b2
|
||||
mbarr1[Y] = mbyte2
|
||||
mbarr1[Y] = barr1[2]
|
||||
mbarr1[Y] = barr1[X]
|
||||
mbarr1[Y] = barr1[b]
|
||||
mbarr1[Y] = barr1[ub]
|
||||
mbarr1[Y] = barr1[mbyte2]
|
||||
mbarr1[Y] = barr1[mubyte2]
|
||||
|
||||
mbarr1[b2] = 42
|
||||
mbarr1[b2] = b2
|
||||
mbarr1[b2] = mbyte2
|
||||
mbarr1[b2] = barr1[2]
|
||||
mbarr1[b2] = barr1[X]
|
||||
mbarr1[b2] = barr1[b]
|
||||
mbarr1[b2] = barr1[ub]
|
||||
mbarr1[b2] = barr1[mbyte2]
|
||||
mbarr1[b2] = barr1[mubyte2]
|
||||
|
||||
mbarr1[ub2] = 42
|
||||
mbarr1[ub2] = b2
|
||||
mbarr1[ub2] = mbyte2
|
||||
mbarr1[ub2] = barr1[2]
|
||||
mbarr1[ub2] = barr1[X]
|
||||
mbarr1[ub2] = barr1[b]
|
||||
mbarr1[ub2] = barr1[ub]
|
||||
mbarr1[ub2] = barr1[mbyte2]
|
||||
mbarr1[ub2] = barr1[mubyte2]
|
||||
|
||||
mbarr1[mubyte2] = 42
|
||||
mbarr1[mubyte2] = b2
|
||||
mbarr1[mubyte2] = mbyte2
|
||||
mbarr1[mubyte2] = barr1[2]
|
||||
mbarr1[mubyte2] = barr1[Y] ; via evaluation
|
||||
mbarr1[mubyte2] = barr1[b] ; via evaluation
|
||||
mbarr1[mubyte2] = barr1[ub] ; via evaluation
|
||||
mbarr1[mubyte2] = barr1[mbyte2] ; via evaluation
|
||||
mbarr1[mubyte2] = barr1[mubyte2] ; via evaluation
|
||||
mbarr1[ubarr2[A]] = barr2[ubarr1[Y]] ; via evaluation
|
||||
|
||||
|
||||
|
||||
; all possible assignments to a UWORD VARIABLE (not array)
|
||||
|
||||
|
||||
uword_assignment_to_uwordvar:
|
||||
uw = 42
|
||||
uw = 42.w
|
||||
uw = 42555
|
||||
uw = X
|
||||
uw = ub2
|
||||
uw = uw2
|
||||
uw = mubyte2
|
||||
uw = muword2
|
||||
uw = string[4]
|
||||
uw = ubarr1[2]
|
||||
uw = uwarr1[2]
|
||||
uw = string[X]
|
||||
uw = string[b]
|
||||
uw = string[ub]
|
||||
uw = string[mbyte2]
|
||||
uw = string[mubyte2]
|
||||
uw = ubarr1[X]
|
||||
uw = ubarr1[b]
|
||||
uw = ubarr1[ub]
|
||||
uw = ubarr1[mbyte2]
|
||||
uw = ubarr1[mubyte2]
|
||||
uw = uwarr1[X]
|
||||
uw = uwarr1[b]
|
||||
uw = uwarr1[ub]
|
||||
uw = uwarr1[mbyte2]
|
||||
uw = uwarr1[mubyte2]
|
||||
|
||||
|
||||
uword_assignment_to_uwordmem:
|
||||
muword = 42
|
||||
muword = 42.w
|
||||
muword = 42555
|
||||
muword = X
|
||||
muword = ub2
|
||||
muword = uw2
|
||||
muword = mubyte2
|
||||
muword = muword2
|
||||
muword = string[4]
|
||||
muword = ubarr1[2]
|
||||
muword = uwarr1[2]
|
||||
muword = string[X]
|
||||
muword = string[b]
|
||||
muword = string[ub]
|
||||
muword = string[mbyte2]
|
||||
muword = string[mubyte2]
|
||||
muword = ubarr1[X]
|
||||
muword = ubarr1[b]
|
||||
muword = ubarr1[ub]
|
||||
muword = ubarr1[mbyte2]
|
||||
muword = ubarr1[mubyte2]
|
||||
muword = uwarr1[X]
|
||||
muword = uwarr1[b]
|
||||
muword = uwarr1[ub]
|
||||
muword = uwarr1[mbyte2]
|
||||
muword = uwarr1[mubyte2]
|
||||
|
||||
|
||||
uword_assignment_to_uwordarray:
|
||||
uwarr1[2] = 42
|
||||
uwarr1[2] = 42.w
|
||||
uwarr1[2] = 42555
|
||||
uwarr1[2] = X
|
||||
uwarr1[2] = ub2
|
||||
uwarr1[2] = uw2
|
||||
uwarr1[2] = mubyte2
|
||||
uwarr1[2] = muword2
|
||||
uwarr1[2] = string[4]
|
||||
uwarr1[2] = ubarr1[2]
|
||||
uwarr1[2] = uwarr1[2]
|
||||
|
||||
uwarr1[Y] = 42
|
||||
uwarr1[Y] = 42.w
|
||||
uwarr1[Y] = 42555
|
||||
uwarr1[Y] = X
|
||||
uwarr1[Y] = ub2
|
||||
uwarr1[Y] = uw2
|
||||
uwarr1[Y] = mubyte2
|
||||
uwarr1[Y] = muword2
|
||||
uwarr1[Y] = string[4]
|
||||
uwarr1[Y] = ubarr1[2]
|
||||
uwarr1[Y] = uwarr1[2]
|
||||
|
||||
uwarr1[b] = 42
|
||||
uwarr1[b] = 42.w
|
||||
uwarr1[b] = 42555
|
||||
uwarr1[b] = X
|
||||
uwarr1[b] = ub2
|
||||
uwarr1[b] = uw2
|
||||
uwarr1[b] = mubyte2
|
||||
uwarr1[b] = muword2
|
||||
uwarr1[b] = string[4]
|
||||
uwarr1[b] = ubarr1[2]
|
||||
uwarr1[b] = uwarr1[2]
|
||||
|
||||
uwarr1[ub] = 42
|
||||
uwarr1[ub] = 42.w
|
||||
uwarr1[ub] = 42555
|
||||
uwarr1[ub] = X
|
||||
uwarr1[ub] = ub2
|
||||
uwarr1[ub] = uw2
|
||||
uwarr1[ub] = mubyte2
|
||||
uwarr1[ub] = muword2
|
||||
uwarr1[ub] = string[4]
|
||||
uwarr1[ub] = ubarr1[2]
|
||||
uwarr1[ub] = uwarr1[2]
|
||||
|
||||
uwarr1[mbyte2] = 42
|
||||
uwarr1[mbyte2] = 42.w
|
||||
uwarr1[mbyte2] = 42555
|
||||
uwarr1[mbyte2] = X
|
||||
uwarr1[mbyte2] = ub2
|
||||
uwarr1[mbyte2] = uw2
|
||||
uwarr1[mbyte2] = mubyte2
|
||||
uwarr1[mbyte2] = muword2
|
||||
uwarr1[mbyte2] = string[4]
|
||||
uwarr1[mbyte2] = ubarr1[2]
|
||||
uwarr1[mbyte2] = uwarr1[2]
|
||||
|
||||
uwarr1[mubyte2] = 42
|
||||
uwarr1[mubyte2] = 42.w
|
||||
uwarr1[mubyte2] = 42555
|
||||
uwarr1[mubyte2] = X
|
||||
uwarr1[mubyte2] = ub2
|
||||
uwarr1[mubyte2] = uw2
|
||||
uwarr1[mubyte2] = mubyte2
|
||||
uwarr1[mubyte2] = muword2
|
||||
uwarr1[mubyte2] = string[4]
|
||||
uwarr1[mubyte2] = ubarr1[2]
|
||||
uwarr1[mubyte2] = uwarr1[2]
|
||||
|
||||
|
||||
uwarr1[2] = string[Y] ; via evaluation
|
||||
uwarr1[2] = string[b] ; via evaluation
|
||||
uwarr1[2] = string[ub] ; via evaluation
|
||||
uwarr1[2] = string[mbyte2] ; via evaluation
|
||||
uwarr1[2] = string[mubyte2] ; via evaluation
|
||||
uwarr1[2] = ubarr1[Y] ; via evaluation
|
||||
uwarr1[2] = ubarr1[b] ; via evaluation
|
||||
uwarr1[2] = ubarr1[ub] ; via evaluation
|
||||
uwarr1[2] = ubarr1[mbyte2] ; via evaluation
|
||||
uwarr1[2] = ubarr1[mubyte2] ; via evaluation
|
||||
uwarr1[2] = uwarr1[Y] ; via evaluation
|
||||
uwarr1[2] = uwarr1[b] ; via evaluation
|
||||
uwarr1[2] = uwarr1[ub] ; via evaluation
|
||||
uwarr1[2] = uwarr1[mbyte2] ; via evaluation
|
||||
uwarr1[2] = uwarr1[mubyte2] ; via evaluation
|
||||
|
||||
|
||||
word_assignment_to_wordvar:
|
||||
w = -42
|
||||
w = -42.w
|
||||
w = 12555
|
||||
w = X
|
||||
w = ub2
|
||||
w = b2
|
||||
w = w2
|
||||
w = mubyte2
|
||||
w = mbyte2
|
||||
w = mword2
|
||||
w = string[4]
|
||||
w = ubarr1[2]
|
||||
w = barr1[2]
|
||||
w = warr1[2]
|
||||
|
||||
w = string[X]
|
||||
w = string[b]
|
||||
w = string[ub]
|
||||
w = string[mbyte2]
|
||||
w = string[mubyte2]
|
||||
|
||||
|
||||
w = barr1[X]
|
||||
w = ubarr1[X]
|
||||
w = barr1[b]
|
||||
w = ubarr1[b]
|
||||
w = barr1[ub]
|
||||
w = ubarr1[ub]
|
||||
w = barr1[mbyte2]
|
||||
w = ubarr1[mbyte2]
|
||||
w = barr1[mubyte2]
|
||||
w = ubarr1[mubyte2]
|
||||
w = warr1[X]
|
||||
w = warr1[b]
|
||||
w = warr1[ub]
|
||||
w = warr1[mbyte2]
|
||||
w = warr1[mubyte2]
|
||||
|
||||
|
||||
word_assignment_to_wordmem:
|
||||
mword = -42
|
||||
mword = -42.w
|
||||
mword = 12555
|
||||
mword = X
|
||||
mword = ub2
|
||||
mword = b2
|
||||
mword = w2
|
||||
mword = mubyte2
|
||||
mword = mbyte2
|
||||
mword = mword2
|
||||
mword = string[4]
|
||||
mword = ubarr1[2]
|
||||
mword = barr1[2]
|
||||
mword = warr1[2]
|
||||
|
||||
|
||||
mword = string[X]
|
||||
mword = string[b]
|
||||
mword = string[ub]
|
||||
mword = string[mbyte2]
|
||||
mword = string[mubyte2]
|
||||
mword = barr1[X]
|
||||
mword = ubarr1[X]
|
||||
mword = barr1[b]
|
||||
mword = ubarr1[b]
|
||||
mword = barr1[ub]
|
||||
mword = ubarr1[ub]
|
||||
mword = barr1[mbyte2]
|
||||
mword = ubarr1[mbyte2]
|
||||
mword = barr1[mubyte2]
|
||||
mword = ubarr1[mubyte2]
|
||||
mword = warr1[X]
|
||||
mword = warr1[b]
|
||||
mword = warr1[ub]
|
||||
mword = warr1[mbyte2]
|
||||
mword = warr1[mubyte2]
|
||||
|
||||
|
||||
word_assignment_to_wordarray:
|
||||
warr2[2] = -42
|
||||
warr2[2] = -42.w
|
||||
warr2[2] = 12555
|
||||
warr2[2] = X
|
||||
warr2[2] = ub2
|
||||
warr2[2] = b2
|
||||
warr2[2] = w2
|
||||
warr2[2] = mubyte2
|
||||
warr2[2] = mbyte2
|
||||
warr2[2] = mword2
|
||||
warr2[2] = string[4]
|
||||
warr2[2] = ubarr1[2]
|
||||
warr2[2] = barr1[2]
|
||||
warr2[2] = warr1[2]
|
||||
|
||||
warr2[Y] = -42
|
||||
warr2[Y] = -42.w
|
||||
warr2[Y] = 12555
|
||||
warr2[Y] = X
|
||||
warr2[Y] = ub2
|
||||
warr2[Y] = b2
|
||||
warr2[Y] = w2
|
||||
warr2[Y] = mubyte2
|
||||
warr2[Y] = mbyte2
|
||||
warr2[Y] = mword2
|
||||
warr2[Y] = string[4]
|
||||
warr2[Y] = ubarr1[2]
|
||||
warr2[Y] = barr1[2]
|
||||
warr2[Y] = warr1[2]
|
||||
|
||||
warr2[b] = -42
|
||||
warr2[b] = -42.w
|
||||
warr2[b] = 12555
|
||||
warr2[b] = X
|
||||
warr2[b] = ub2
|
||||
warr2[b] = b2
|
||||
warr2[b] = w2
|
||||
warr2[b] = mubyte2
|
||||
warr2[b] = mbyte2
|
||||
warr2[b] = mword2
|
||||
warr2[b] = string[4]
|
||||
warr2[b] = ubarr1[2]
|
||||
warr2[b] = barr1[2]
|
||||
warr2[b] = warr1[2]
|
||||
|
||||
warr2[ub] = -42
|
||||
warr2[ub] = -42.w
|
||||
warr2[ub] = 14255
|
||||
warr2[ub] = X
|
||||
warr2[ub] = ub2
|
||||
warr2[ub] = b2
|
||||
warr2[ub] = w2
|
||||
warr2[ub] = mubyte2
|
||||
warr2[ub] = mbyte2
|
||||
warr2[ub] = mword2
|
||||
warr2[ub] = string[4]
|
||||
warr2[ub] = ubarr1[2]
|
||||
warr2[ub] = barr1[2]
|
||||
warr2[ub] = warr1[2]
|
||||
|
||||
warr2[mbyte2] = -42
|
||||
warr2[mbyte2] = -42.w
|
||||
warr2[mbyte2] = 12555
|
||||
warr2[mbyte2] = X
|
||||
warr2[mbyte2] = ub2
|
||||
warr2[mbyte2] = b2
|
||||
warr2[mbyte2] = w2
|
||||
warr2[mbyte2] = mubyte2
|
||||
warr2[mbyte2] = mbyte2
|
||||
warr2[mbyte2] = mword2
|
||||
warr2[mbyte2] = string[4]
|
||||
warr2[mbyte2] = ubarr1[2]
|
||||
warr2[mbyte2] = barr1[2]
|
||||
warr2[mbyte2] = warr1[2]
|
||||
|
||||
warr2[mubyte2] = -42
|
||||
warr2[mubyte2] = -42.w
|
||||
warr2[mubyte2] = 12555
|
||||
warr2[mubyte2] = X
|
||||
warr2[mubyte2] = ub2
|
||||
warr2[mubyte2] = b2
|
||||
warr2[mubyte2] = w2
|
||||
warr2[mubyte2] = mubyte2
|
||||
warr2[mubyte2] = mbyte2
|
||||
warr2[mubyte2] = mword2
|
||||
warr2[mubyte2] = string[4]
|
||||
warr2[mubyte2] = ubarr1[2]
|
||||
warr2[mubyte2] = barr1[2]
|
||||
warr2[mubyte2] = warr1[2]
|
||||
|
||||
|
||||
warr1[2] = string[Y] ; via evaluation
|
||||
warr1[2] = string[b] ; via evaluation
|
||||
warr1[2] = string[ub] ; via evaluation
|
||||
warr1[2] = string[mbyte2] ; via evaluation
|
||||
warr1[2] = string[mubyte2] ; via evaluation
|
||||
warr1[2] = barr1[Y] ; via evaluation
|
||||
warr1[2] = barr1[b] ; via evaluation
|
||||
warr1[2] = barr1[ub] ; via evaluation
|
||||
warr1[2] = barr1[mbyte2] ; via evaluation
|
||||
warr1[2] = barr1[mubyte2] ; via evaluation
|
||||
warr1[2] = warr1[Y] ; via evaluation
|
||||
warr1[2] = warr1[b] ; via evaluation
|
||||
warr1[2] = warr1[ub] ; via evaluation
|
||||
warr1[2] = warr1[mbyte2] ; via evaluation
|
||||
warr1[2] = warr1[mubyte2] ; via evaluation
|
||||
|
||||
|
||||
;; all possible assignments to a FLOAT VARIABLE
|
||||
float_assignment_to_floatvar:
|
||||
fl1 = 34
|
||||
fl1 = 34555.w
|
||||
fl1 = 3.33e22
|
||||
fl1 = X
|
||||
fl1 = b2
|
||||
fl1 = ub2
|
||||
fl1 = w2
|
||||
fl1 = uw2
|
||||
fl1 = mbyte
|
||||
fl1 = mubyte
|
||||
fl1 = mword
|
||||
fl1 = muword
|
||||
fl1 = fl2
|
||||
fl1 = mfloat2
|
||||
fl1 = barr1[2]
|
||||
fl1 = ubarr1[2]
|
||||
fl1 = warr1[2]
|
||||
fl1 = uwarr1[2]
|
||||
fl1 = string[4]
|
||||
fl1 = farr1[4]
|
||||
|
||||
fl1 = string[Y] ; via evaluation
|
||||
fl1 = string[b] ; via evaluation
|
||||
fl1 = string[ub] ; via evaluation
|
||||
fl1 = string[mbyte2] ; via evaluation
|
||||
fl1 = string[mubyte2] ; via evaluation
|
||||
fl1 = barr1[Y] ; via evaluation
|
||||
fl1 = ubarr1[Y] ; via evaluation
|
||||
fl1 = barr1[b] ; via evaluation
|
||||
fl1 = ubarr1[b] ; via evaluation
|
||||
fl1 = barr1[ub] ; via evaluation
|
||||
fl1 = ubarr1[ub] ; via evaluation
|
||||
fl1 = barr1[mbyte2] ; via evaluation
|
||||
fl1 = ubarr1[mbyte2] ; via evaluation
|
||||
fl1 = barr1[mubyte2] ; via evaluation
|
||||
fl1 = ubarr1[mubyte2] ; via evaluation
|
||||
fl1 = warr1[Y] ; via evaluation
|
||||
fl1 = warr1[b] ; via evaluation
|
||||
fl1 = warr1[ub] ; via evaluation
|
||||
fl1 = warr1[mbyte2] ; via evaluation
|
||||
fl1 = warr1[mubyte2] ; via evaluation
|
||||
|
||||
|
||||
float_assignment_to_floatmem:
|
||||
mfloat = 34
|
||||
mfloat = 34555.w
|
||||
mfloat = 3.33e22
|
||||
mfloat = X
|
||||
mfloat = b2
|
||||
mfloat = ub2
|
||||
mfloat = w2
|
||||
mfloat = uw2
|
||||
mfloat = mbyte
|
||||
mfloat = mubyte
|
||||
mfloat = mword
|
||||
mfloat = muword
|
||||
mfloat = fl2
|
||||
mfloat = mfloat2
|
||||
mfloat = barr1[2]
|
||||
mfloat = ubarr1[2]
|
||||
mfloat = warr1[2]
|
||||
mfloat = uwarr1[2]
|
||||
mfloat = string[4]
|
||||
mfloat = farr1[4]
|
||||
|
||||
mfloat = string[Y] ; via evaluation
|
||||
mfloat = string[b] ; via evaluation
|
||||
mfloat = string[ub] ; via evaluation
|
||||
mfloat = string[mbyte2] ; via evaluation
|
||||
mfloat = string[mubyte2] ; via evaluation
|
||||
mfloat = barr1[Y] ; via evaluation
|
||||
mfloat = ubarr1[Y] ; via evaluation
|
||||
mfloat = barr1[b] ; via evaluation
|
||||
mfloat = ubarr1[b] ; via evaluation
|
||||
mfloat = barr1[ub] ; via evaluation
|
||||
mfloat = ubarr1[ub] ; via evaluation
|
||||
mfloat = barr1[mbyte2] ; via evaluation
|
||||
mfloat = ubarr1[mbyte2] ; via evaluation
|
||||
mfloat = barr1[mubyte2] ; via evaluation
|
||||
mfloat = ubarr1[mubyte2] ; via evaluation
|
||||
mfloat = warr1[Y] ; via evaluation
|
||||
mfloat = warr1[b] ; via evaluation
|
||||
mfloat = warr1[ub] ; via evaluation
|
||||
mfloat = warr1[mbyte2] ; via evaluation
|
||||
mfloat = warr1[mubyte2] ; via evaluation
|
||||
|
||||
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
}
|
||||
BIN
examples/compiled/cube3d-float.prg
Normal file
BIN
examples/compiled/cube3d-float.prg
Normal file
Binary file not shown.
BIN
examples/compiled/cube3d-sprites.prg
Normal file
BIN
examples/compiled/cube3d-sprites.prg
Normal file
Binary file not shown.
BIN
examples/compiled/cube3d.prg
Normal file
BIN
examples/compiled/cube3d.prg
Normal file
Binary file not shown.
BIN
examples/compiled/hello.prg
Normal file
BIN
examples/compiled/hello.prg
Normal file
Binary file not shown.
BIN
examples/compiled/mandelbrot.prg
Normal file
BIN
examples/compiled/mandelbrot.prg
Normal file
Binary file not shown.
BIN
examples/compiled/numbergame.prg
Normal file
BIN
examples/compiled/numbergame.prg
Normal file
Binary file not shown.
BIN
examples/compiled/rasterbars.prg
Normal file
BIN
examples/compiled/rasterbars.prg
Normal file
Binary file not shown.
6
examples/compiled/readme.txt
Normal file
6
examples/compiled/readme.txt
Normal file
@ -0,0 +1,6 @@
|
||||
These .prg files are the compiled versions of most of the examples.
|
||||
They can be loaded and ran on a C64 or in an emulator, for example in Vice:
|
||||
|
||||
x64 hello.prg
|
||||
|
||||
will load and run the hello example.
|
||||
BIN
examples/compiled/sprites.prg
Normal file
BIN
examples/compiled/sprites.prg
Normal file
Binary file not shown.
BIN
examples/compiled/swirl-float.prg
Normal file
BIN
examples/compiled/swirl-float.prg
Normal file
Binary file not shown.
BIN
examples/compiled/swirl.prg
Normal file
BIN
examples/compiled/swirl.prg
Normal file
Binary file not shown.
BIN
examples/compiled/wizzine.prg
Normal file
BIN
examples/compiled/wizzine.prg
Normal file
Binary file not shown.
@ -1,78 +0,0 @@
|
||||
%import c64utils
|
||||
%import c64flt
|
||||
|
||||
|
||||
; The classic number guessing game.
|
||||
; This version uses more low-level subroutines (calls directly into the C64's ROM routines)
|
||||
; and instead of a loop (with the added behind the scenes processing), uses absolute jumps.
|
||||
; It's less readable I think, but produces a smaller program.
|
||||
|
||||
|
||||
~ main {
|
||||
sub start() {
|
||||
str name = "????????????????????????????????????????"
|
||||
str input = "??????????"
|
||||
ubyte guess
|
||||
ubyte secretnumber = 0
|
||||
ubyte attempts_left = 10
|
||||
memory uword freadstr_arg = $22 ; argument for FREADSTR ($22/$23)
|
||||
|
||||
; greeting
|
||||
c64.VMCSB |= 2 ; switch lowercase chars
|
||||
c64.STROUT("Please introduce yourself: ")
|
||||
c64scr.input_chars(name)
|
||||
c64.CHROUT('\n')
|
||||
c64.CHROUT('\n')
|
||||
c64.STROUT("Hello, ")
|
||||
c64.STROUT(name)
|
||||
c64.STROUT(".\nLet's play a number guessing game.\nI am thinking of a number from 1 to 100!You'll have to guess it!\n")
|
||||
|
||||
; create a secret random number from 1-100
|
||||
c64flt.RND() ; fac = random number between 0 and 1
|
||||
c64flt.MUL10() ; fac *= 10
|
||||
c64flt.MUL10() ; .. and now *100
|
||||
c64flt.FADDH() ; add 0.5..
|
||||
c64flt.FADDH() ; and again, so +1 total
|
||||
A, Y = c64flt.GETADRAY()
|
||||
secretnumber = A ; secret number = rnd()*100+1
|
||||
|
||||
ask_guess:
|
||||
|
||||
c64.STROUT("\nYou have ")
|
||||
c64scr.print_ub(attempts_left)
|
||||
c64.STROUT(" guess")
|
||||
if(attempts_left>1)
|
||||
c64.STROUT("es")
|
||||
|
||||
c64.STROUT(" left.\nWhat is your next guess? ")
|
||||
Y=c64scr.input_chars(input)
|
||||
c64.CHROUT('\n')
|
||||
freadstr_arg = input
|
||||
c64flt.FREADSTR(Y)
|
||||
A, Y = c64flt.GETADRAY()
|
||||
guess=A
|
||||
if(guess==secretnumber) {
|
||||
c64.STROUT("\nThat's my number, impressive!\n")
|
||||
goto goodbye
|
||||
}
|
||||
c64.STROUT("\nThat is too ")
|
||||
if(guess < secretnumber)
|
||||
c64.STROUT("low!\n")
|
||||
else
|
||||
c64.STROUT("high!\n")
|
||||
|
||||
attempts_left--
|
||||
if_nz goto ask_guess
|
||||
|
||||
; game over.
|
||||
c64.STROUT("\nToo bad! It was: ")
|
||||
c64scr.print_ub(secretnumber)
|
||||
c64.CHROUT('\n')
|
||||
|
||||
goodbye:
|
||||
c64.STROUT("\nThanks for playing, ")
|
||||
c64.STROUT(name)
|
||||
c64.STROUT(".\n")
|
||||
return
|
||||
}
|
||||
}
|
||||
@ -13,10 +13,19 @@
|
||||
word w1
|
||||
word w2
|
||||
|
||||
ubyte[3] uba
|
||||
byte[3] ba
|
||||
uword[3] uwa
|
||||
word[3] wa
|
||||
memory ubyte mub1 = $c000
|
||||
memory ubyte mub2 = $c001
|
||||
memory uword muw1 = $c100
|
||||
memory uword muw2 = $c102
|
||||
|
||||
ubyte[3] uba1
|
||||
byte[3] ba1
|
||||
uword[3] uwa1
|
||||
word[3] wa1
|
||||
ubyte[3] uba2
|
||||
byte[3] ba2
|
||||
uword[3] uwa2
|
||||
word[3] wa2
|
||||
|
||||
; ub1 = ub2 & 44
|
||||
; b1 = b2 & 44
|
||||
@ -48,24 +57,28 @@
|
||||
swap(b1, b2)
|
||||
swap(uw1, uw2)
|
||||
swap(w1, w2)
|
||||
swap(@($d020), @($d021))
|
||||
swap(mub1, mub2)
|
||||
swap(muw1, muw2)
|
||||
swap(mub1, ub2)
|
||||
swap(muw1, uw2)
|
||||
|
||||
swap(uba[0], uba[1])
|
||||
swap(ba[0], ba[1])
|
||||
swap(uwa[0], uwa[1])
|
||||
swap(wa[0], wa[1])
|
||||
swap(uba1[1], uba2[2])
|
||||
swap(ba1[1], ba2[2])
|
||||
swap(uwa1[1], uwa2[2])
|
||||
swap(wa1[1], wa2[2])
|
||||
|
||||
; this goes without xor trick:
|
||||
ubyte i1
|
||||
ubyte i2
|
||||
swap(uba[i1], uba[i2])
|
||||
swap(ba[i1], ba[i2])
|
||||
swap(uwa[i1], uwa[i2])
|
||||
swap(wa[i1], wa[i2])
|
||||
swap(uba1[i1], uba2[i2])
|
||||
swap(ba1[i1], ba2[i2])
|
||||
swap(uwa1[i1], uwa2[i2])
|
||||
swap(wa1[i1], wa2[i2])
|
||||
|
||||
swap(uba[1], ub1)
|
||||
swap(uba[i1], ub1)
|
||||
swap(uwa[1], uw1)
|
||||
swap(uwa[i1], uw1)
|
||||
swap(uba1[1], ub1)
|
||||
swap(uba1[i1], ub1)
|
||||
swap(uwa1[1], uw1)
|
||||
swap(uwa1[i1], uw1)
|
||||
}
|
||||
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user