skilldrick / easy6502 Goto Github PK
View Code? Open in Web Editor NEWHome Page: http://skilldrick.github.com/easy6502/
Home Page: http://skilldrick.github.com/easy6502/
The RTS must increment the PC value which it pulls off the stack.
At present, that increment does not correctly carry from the low byte to the high byte - which can be seen if the high byte is even.
Test program:
jmp $7fd
*=$7fd
jsr tst
nop
tst:
rts
The link to http://www.obelisk.me.uk/6502/registers.html seems to be dead.
The easiest solution might be to use the Wayback Machine link instead: https://web.archive.org/web/20210626024532/http://www.obelisk.me.uk/6502/registers.html
Please consider adding support for macros.
Is it okay to copy and paste a few things (only as needed) from here for my own projects?
I'll credit skilldrick of course if they let me, I am always grateful for this kind of thing (I always try to credit people regardless but I know that people sometimes don't want you using their stuff)
If it's not okay that's fine, I can still learn a lot from this awesome tutorial. I know that lots of people copy from other people's code but I feel weird not asking first. Cheers
Currently, when you copy and paste code overtop of existing code into the simulator, it does not recognize that the code has changed and leaves the assemble button greyed out.
I imagine this is something to do with the event you are using to detect changes in the textfield. Certain events aren't thrown for pasting.
Similarly, if you delete a character, the assemble button still remains grey. Again, this is likely because the event used to watch for changes in the code does not fire when non character-producing keys are pressed.
I can dig into the source and submit a PR if need be.
Thanks,
Bailey
The monitor is useful for debugging programs, but when stepping through a program it's often difficult to keep track of what is happening in memory.
I think it would be a nice enhancement if the monitor output had smart color coding to give some context to what is going on and where in memory you are. Examples include color coding locations read and written to by the previous instruction, where the special memory locations are, where the program is (and where the PC is), and where the display is.
Have you seen https://floooh.github.io/visual6502remix/index.html?highdpi=true ?
It would really add to the effect if it was in the corner flashing around while the page executed your programs. It can be very small, doesn't need to show all the wires or anything, just seeing it would be enough for a lot of people I think. You could add a full screen button to open the CPU in full screen. You'd need to figure out how to message pass the memory to the WASM and back though.
Wondering how I would create/store variables or constants given define does not work on a local copy of the assembler
Is there a reason why monitor takes a starting address and a length instead of a starting address and an ending address? It seems to me the latter would make more sense since you often know the starting and ending address of where your program modifies memory. This eliminates the need to do some hex subtraction to figure out the appropriate length.
This also makes monitoring the entire memory more intuitive in my opinion, since currently $0000 with length $ffff is missing memory location $ffff. To see the last memory location you need a length of $10000, which doesn't make sense given that all 6502 addresses are 2 bytes.
This came about when I discovered the bug detailed in #16.
Tabbing is common in 6502 assembly since typically instructions and addresses are tab separated. However, the code editor loses focus when you press tab inside it. The editor should allow you to insert tab characters (in a way that is easier than copying and pasting a tab from another location!).
I'm just getting used to the built-in 6502 emulator. I'm having problems trying a code even a simple cursor. All I want is a single dot that could move up, down, left, and right by my command. What could I do to accomplish this?
It would be nice if the approx clock cycles could be added up automatically and displayed somewhere during assembly. Would help with metrics when trying to learn to optimize code.
Addresses are not wrapping within zeropage as they do on a real 6502.
When running LDA ($FF), Y
with Y = 0, the 6502 simulator takes the low byte from $FF and the high byte from $0100.
It can be seen when running this code:
LDA #$00
STA $00
LDA #$02
STA $FF
LDA #$04
STA $0100
LDA #$AC
STA $0402
LDA #$c2
STA $02
LDY #$00
LDA ($FF), Y
After executing this code, A should be equal to C2 and not AC.
PinoBatch, on the Nesdev wiki figured out that it is due to getWord()
which does not handle wrapping:
easy6502/simulator/assembler.js
Lines 587 to 593 in bb213ae
I hope this is not too trivial to ask. I would like to use Easy6502 for a course I am teaching, but I'd like to make sure that it stays accessible for the life of the assignments that I'll give. So I'd prefer to mirror the entire working Easy6502 site in a way to insulates me from changes. Can that be done in a straightforward way? Is it enough to just grab everything from the gh-pages that host the tutorial and slap it on my own server? Or is everything heavily tied into github specific things?
As you describe the snake game, you have this paragraph:
"The hex value $03 is represented in binary as 00000111. The AND opcode performs a bitwise AND of the argument with the accumulator. For example, if the accumulator contains the binary value 01010101, then the result of AND with 00000111 will be 00000101."
The binary value of $03 is 00000011. This could be very confusing to people.
The link for Western Design Center is dead on your tutorial FYI
It used to go to to http://www.obelisk.demon.co.uk/6502/registers.html. But it would appear the link is dead.
In the Indexed indirect example you overwrite program memory with STY $0605
. Also, you setup $01 $02 with #$0605 but then do not use it. I think the example needs a tweak.
###Indexed indirect: ($c0,X)###
This one’s kinda weird. It’s like a cross between zero page,X and indirect. Basically, you take the zero page address, add the value of the X register to it, then use that to look up a two-byte address. For example:
LDX #$01
LDA #$05
STA $01
LDA #$06
STA $02
LDY #$0a
STY $0605
LDA ($00,X)
https://skilldrick.github.io/easy6502/#addressing
Also, github apparently changed their markdown engine and your headers now need a space between the ### and the text to render properly.
###Indexed indirect: ($c0,X)###
###Indexed indirect: ($c0,X)###
### Indexed indirect: ($c0,X) ###
It seems that SBC is not calculating correctly
Address Hexdump Dissassembly
-------------------------------
$0600 a9 09 LDA #$09
$0602 e9 01 SBC #$01
0600: a9 09 e9 01
A=$07 X=$00 Y=$00
SP=$ff PC=$0605
NV-BDIZC
00110001
The following code
asl a
lsr a
rol a
ror a
should result in 0A 4A 2A 6A, but instead it is assembled as 0e ff ff 4e ff ff 2e ff ff 6e ff ff
I'd like to adapt this to work on physical hardware.
Can you clarify which open source/creative commons licence(s) you'd like derivatives to be released under?
First, thanks so much for making Easy 6502! 🤩
I noticed something funny when trying to draw a single-pixel border around the edge of the "screen": my program has different behavior after a "Reset".
The first time I run the code, it works correctly:
But if I then click "reset" and "run", my program behaves differently: it gets stuck in an infinite loop while trying to draw the right-hand border:
If I then make a trivial change (e.g. add an extra space), I can click "Assemble" and "Run" and the program works again.
Is this a bug? I would have expected that "Reset" would perform a full reset, but it appears there is some leftover state which is causing my program to behave differently the second time around.
If you accidentally try to monitor beyond the address space of the 6502, the browser will hang (at least it does for me in Chrome/Ubuntu and Chrome/OSX).
This can be fixed with some simple guarding on the monitor function (and possible a nice error message). But I'd wait on #15 since this somewhat depends on that.
I wrote a code for rendering Tetris blocks:
define Angle $100
define BlockNumber $101
define ascii $ff
define rotateLeft $63
define rotateRight $76
define dropDown $7a
define PositionCounter $105
define moveLeft $61
define moveRight $73
Start:
ldy #$10
lda #$01
sta Angle
lda $fe
sta $102
FindBlockNumber:
jsr Compare2TBlock
jsr Compare2OBlock
jsr Compare2IBlock
jsr Compare2JBlock
jsr Compare2LBlock
jsr Compare2SBlock
jsr Compare2ZBlock
jmp Start
detectKeys:
lda ascii
jsr RightMove
jsr LeftMove
jsr RightRotate
jsr LeftRotate
jsr DownDrop
rts
RightMove:
cmp #moveRight
beq newRightPosition
rts
newRightPosition:
lda #$00
sta ascii
sta $200,y
sta $201,y
sta $202,y
sta $203,y
sta $220,y
sta $221,y
sta $222,y
sta $223,y
sta $240,y
sta $241,y
sta $242,y
sta $243,y
sta $260,y
sta $261,y
sta $262,y
sta $263,y
iny
rts
LeftMove:
cmp #moveLeft
beq newLeftPosition
rts
newLeftPosition:
lda #$00
sta ascii
sta $200,y
sta $201,y
sta $202,y
sta $203,y
sta $220,y
sta $221,y
sta $222,y
sta $223,y
sta $240,y
sta $241,y
sta $242,y
sta $243,y
sta $260,y
sta $261,y
sta $262,y
sta $263,y
dey
rts
RightRotate:
cmp #rotateRight
beq newRightAngle
rts
newRightAngle:
lda #$00
sta ascii
sta $200,y
sta $201,y
sta $202,y
sta $203,y
sta $220,y
sta $221,y
sta $222,y
sta $223,y
sta $240,y
sta $241,y
sta $242,y
sta $243,y
sta $260,y
sta $261,y
sta $262,y
sta $263,y
inc Angle
lda Angle
cmp #$05
bpl resetAngle
rts
resetAngle:
lda #$01
sta Angle
rts
LeftRotate:
cmp #rotateLeft
beq newLeftAngle
rts
newLeftAngle:
lda #$00
sta ascii
sta $200,y
sta $201,y
sta $202,y
sta $203,y
sta $220,y
sta $221,y
sta $222,y
sta $223,y
sta $240,y
sta $241,y
sta $242,y
sta $243,y
sta $260,y
sta $261,y
sta $262,y
sta $263,y
dec Angle
lda Angle
cmp #$01
bmi resetAngle2
rts
resetAngle2:
lda #$04
sta Angle
rts
DownDrop:
cmp #dropDown
beq newDownPosition
rts
newDownPosition:
lda #$00
sta ascii
sta $200,y
sta $201,y
sta $202,y
sta $203,y
sta $220,y
sta $221,y
sta $222,y
sta $223,y
sta $240,y
sta $241,y
sta $242,y
sta $243,y
sta $260,y
sta $261,y
sta $262,y
sta $263,y
upTo20:
iny
inc PositionCounter
lda PositionCounter
cmp #$20
bne upTo20
lda #$00
sta PositionCounter
rts
Compare2TBlock:
cmp #$01
beq TBlockPicked
rts
TBlockPicked:
lda #$01
sta BlockNumber
lda Angle
cmp #$01
beq TBlockAngle0
cmp #$02
beq TBlockAngle90
cmp #$03
beq TBlockAngle180
cmp #$04
beq TBlockAngle270
TBlockAngle0:
jsr TBlock1
jsr detectKeys
jmp TBlockPicked
TBlockAngle90:
jsr TBlock2
jsr detectKeys
jmp TBlockPicked
TBlockAngle180:
jsr TBlock3
jsr detectKeys
jmp TBlockPicked
TBlockAngle270:
jsr TBlock4
jsr detectKeys
jmp TBlockPicked
TBlock1:
lda #$01
sta $220,y
sta $221,y
sta $222,y
sta $241,y
rts
TBlock2:
lda #$01
sta $201,y
sta $221,y
sta $222,y
sta $241,y
rts
TBlock3:
lda #$01
sta $201,y
sta $221,y
sta $222,y
sta $220,y
rts
TBlock4:
lda #$01
sta $201,y
sta $220,y
sta $221,y
sta $241,y
rts
Compare2OBlock:
cmp #$02
beq OBlockPicked
rts
OBlockPicked:
lda #$02
sta BlockNumber
OBlocksubRoutines:
jsr OBlock
jsr detectKeys
jmp OBlocksubRoutines
OBlock:
lda #$03
sta $200,y
sta $201,y
sta $220,y
sta $221,y
rts
Compare2IBlock:
cmp #$03
beq IBlockPicked
rts
IBlockPicked:
lda #$03
sta BlockNumber
lda Angle
cmp #$01
beq IBlockAngle0
cmp #$02
beq IBlockAngle90
cmp #$03
beq IBlockAngle0
cmp #$04
beq IBlockAngle90
IBlockAngle0:
jsr IBlock1
jsr detectKeys
jmp IBlockPicked
IBlockAngle90:
jsr IBlock2
jsr detectKeys
jmp IBlockPicked
IBlock1:
lda #$04
sta $220,y
sta $221,y
sta $222,y
sta $223,y
rts
IBlock2:
lda #$04
sta $222,y
sta $202,y
sta $242,y
sta $262,y
rts
Compare2JBlock:
cmp #$04
beq JBlockPicked
rts
JBlockPicked:
lda #$01
sta BlockNumber
lda Angle
cmp #$01
beq JBlockAngle0
cmp #$02
beq JBlockAngle90
cmp #$03
beq JBlockAngle180
cmp #$04
beq JBlockAngle270
JBlockAngle0:
jsr JBlock1
jsr detectKeys
jmp JBlockPicked
JBlockAngle90:
jsr JBlock2
jsr detectKeys
jmp JBlockPicked
JBlockAngle180:
jsr JBlock3
jsr detectKeys
jmp JBlockPicked
JBlockAngle270:
jsr JBlock4
jsr detectKeys
jmp JBlockPicked
JBlock1:
lda #$05
sta $201,y
sta $221,y
sta $241,y
sta $240,y
rts
JBlock2:
lda #$05
sta $200,y
sta $220,y
sta $221,y
sta $222,y
rts
JBlock3:
lda #$05
sta $201,y
sta $202,y
sta $221,y
sta $241,y
rts
JBlock4:
lda #$05
sta $221,y
sta $220,y
sta $222,y
sta $242,y
rts
Compare2LBlock:
cmp #$05
beq LBlockPicked
rts
LBlockPicked:
lda #$01
sta BlockNumber
lda Angle
cmp #$01
beq LBlockAngle0
cmp #$02
beq LBlockAngle90
cmp #$03
beq LBlockAngle180
cmp #$04
beq LBlockAngle270
LBlockAngle0:
jsr LBlock1
jsr detectKeys
jmp LBlockPicked
LBlockAngle90:
jsr LBlock2
jsr detectKeys
jmp LBlockPicked
LBlockAngle180:
jsr LBlock3
jsr detectKeys
jmp LBlockPicked
LBlockAngle270:
jsr LBlock4
jsr detectKeys
jmp LBlockPicked
LBlock1:
lda #$07
sta $201,y
sta $221,y
sta $241,y
sta $242,y
rts
LBlock2:
lda #$07
sta $240,y
sta $220,y
sta $221,y
sta $222,y
rts
LBlock3:
lda #$07
sta $201,y
sta $200,y
sta $221,y
sta $241,y
rts
LBlock4:
lda #$07
sta $221,y
sta $220,y
sta $222,y
sta $202,y
rts
Compare2SBlock:
cmp #$06
beq SBlockPicked
rts
SBlockPicked:
lda #$01
sta BlockNumber
lda Angle
cmp #$01
beq SBlockAngle0
cmp #$02
beq SBlockAngle90
cmp #$03
beq SBlockAngle180
cmp #$04
beq SBlockAngle270
SBlockAngle0:
jsr SBlock1
jsr detectKeys
jmp SBlockPicked
SBlockAngle90:
jsr SBlock2
jsr detectKeys
jmp SBlockPicked
SBlockAngle180:
jsr SBlock1
jsr detectKeys
jmp SBlockPicked
SBlockAngle270:
jsr SBlock2
jsr detectKeys
jmp SBlockPicked
SBlock1:
lda #$08
sta $221,y
sta $201,y
sta $222,y
sta $242,y
rts
SBlock2:
lda #$08
sta $221,y
sta $220,y
sta $202,y
sta $201,y
rts
Compare2ZBlock:
cmp #$07
beq ZBlockPicked
rts
ZBlockPicked:
lda #$01
sta BlockNumber
lda Angle
cmp #$01
beq ZBlockAngle0
cmp #$02
beq ZBlockAngle90
cmp #$03
beq ZBlockAngle180
cmp #$04
beq ZBlockAngle270
ZBlockAngle0:
jsr ZBlock1
jsr detectKeys
jmp ZBlockPicked
ZBlockAngle90:
jsr ZBlock2
jsr detectKeys
jmp ZBlockPicked
ZBlockAngle180:
jsr ZBlock1
jsr detectKeys
jmp ZBlockPicked
ZBlockAngle270:
jsr ZBlock2
jsr detectKeys
jmp ZBlockPicked
ZBlock1:
lda #$0c
sta $221,y
sta $241,y
sta $222,y
sta $202,y
rts
ZBlock2:
lda #$0c
sta $221,y
sta $220,y
sta $242,y
sta $241,y
rts
I've got some things that I need to accomplish:
Currently if you try to branch to an address (that I presume is more than 128 bytes away, although I'm not positive on this exact number), the simulator will just jump to some high memory address and everything will eventually fail.
On a real 6502, I realize that this is expected behavior, however since this is a simulator, I think it would be beneficial to display a warning message in the log indicating that a too distant branch was attempted.
I can (as before) submit a PR after I have a chance to comb through the responsible code if you agree that this would be a good feature to add.
I attempted to plug the disassembled code back into the assembler, at which point it will not run. Below is the disassembly of snake. it is throwing an error Syntax error line 38: BEQ $0660
JSR $0606
JSR $0638
JSR $060d
JSR $062a
RTS
LDA #$02
STA $02
LDA #$04
STA $03
LDA #$11
STA $10
LDA #$10
STA $12
LDA #$0f
STA $14
LDA #$04
STA $11
STA $13
STA $15
RTS
LDA $fe
STA $00
LDA $fe
AND #$03
CLC
ADC #$02
STA $01
RTS
JSR $064d
JSR $068d
JSR $06c3
JSR $0719
JSR $0720
JSR $072d
JMP $0638
LDA $ff
CMP #$77
BEQ $0660
CMP #$64
BEQ $066b
CMP #$73
BEQ $0676
CMP #$61
BEQ $0681
RTS
LDA #$04
BIT $02
BNE $068c
LDA #$01
STA $02
RTS
LDA #$08
BIT $02
BNE $068c
LDA #$02
STA $02
RTS
LDA #$01
BIT $02
BNE $068c
LDA #$04
STA $02
RTS
LDA #$02
BIT $02
BNE $068c
LDA #$08
STA $02
RTS
RTS
JSR $0694
JSR $06a8
RTS
LDA $00
CMP $10
BNE $06a7
LDA $01
CMP $11
BNE $06a7
INC $03
INC $03
JSR $062a
RTS
LDX $02
LDA $10,X
CMP $10
BNE $06b6
LDA $11,X
CMP $11
BEQ $06bf
INX
INX
CPX $03
BEQ $06c2
JMP $06aa
JMP $0735
RTS
LDX $03
DEX
TXA
LDA $10,X
STA $12,X
DEX
BPL $06c7
LDA $02
LSR A
BCS $06dc
LSR A
BCS $06ef
LSR A
BCS $06f8
LSR A
BCS $070b
LDA $10
SEC
SBC #$20
STA $10
BCC $06e6
RTS
DEC $11
LDA #$01
CMP $11
BEQ $0716
RTS
INC $10
LDA #$1f
BIT $10
BEQ $0716
RTS
LDA $10
CLC
ADC #$20
STA $10
BCS $0702
RTS
INC $11
LDA #$06
CMP $11
BEQ $0716
RTS
DEC $10
LDA $10
AND #$1f
CMP #$1f
BEQ $0716
RTS
JMP $0735
LDY #$00
LDA $fe
STA ($00),Y
RTS
LDX $03
LDA #$00
STA ($10,X)
LDX $00
LDA #$01
STA ($10,X)
RTS
LDX $00
NOP
NOP
DEX
BNE $082f
RTS
Love your emulator; it's the perfect learning tool for 6502. On the note of learning, I managed to write some impossible 6502 and the assembler didn't throw a syntax error. :^)
LDA #$01
LDX #$01
LDY #$00
loop:
EOR X ; Nope
STA $0200,Y
INY
CPY #$10
BNE loop
Assembled output:
0600: a9 01 a2 01 a0 00 4d ff ff 99 00 02 c8 c0 10 d0
0610: f5
Expected output:
An error message calling me silly names for writing that.
This table:
0 1 2 3 4
Head Tail
[1,5][1,4][1,3][1,2][2,2] Starting position
[1,5][1,4][1,3][1,2][1,2] Value of (3) is copied into (4)
[1,5][1,4][1,3][1,2][1,2] Value of (2) is copied into (3)
[1,5][1,4][1,3][1,2][1,2] Value of (1) is copied into (2)
[1,5][1,4][1,3][1,2][1,2] Value of (0) is copied into (1)
[0,4][1,4][1,3][1,2][1,2] Value of (0) is updated based on direction
Should read as follows:
0 1 2 3 4
Head Tail
[1,5][1,4][1,3][1,2][2,2] Starting position
[1,5][1,4][1,3][1,2][1,2] Value of (3) is copied into (4)
[1,5][1,4][1,3][1,3][1,2] Value of (2) is copied into (3)
[1,5][1,4][1,4][1,3][1,2] Value of (1) is copied into (2)
[1,5][1,5][1,4][1,3][1,2] Value of (0) is copied into (1)
[0,5][1,5][1,4][1,3][1,2] Value of (0) is updated based on direction
Note the changes on the last 4 lines.
Firstly, I think this assembler is amazing and I love that I can mess with an app that is actually fun in my spare time. Now, I have been trying to move a pixel on the screen up, down, left, and right. Sounds easy enough, but the amount of bytes that the addresses can store is only so much and I can only move the pixel on the top section of the screen, Obviously! XD I know that this was the case back then with the 6502, but I was wondering how I could add to my atrocious code to make the pixel move all over the screen I just don't think that I am getting how all the addressing modes work, actually a bit of clarification on how indirect and indirect indexed addressing modes work would be greatly appreciated in the tutorials because they are kind of confusing the way they are worded, the rest is great though, good work.
`;$01 is color of pixel
;$02 is empty for color black
;$03 is color for up and down's X increment
;$04 is counter for next set of pixels
LDA #$01
STA $01
JMP input
reset:
LDA $03
DEC $03
CMP #$00
BNE reset
DEC $ff
CMP #$00
BEQ input
input:
LDA $ff
CMP #$77 ;UP
BEQ up
LDA $ff
CMP #$61 ;LEFT
BEQ left
LDA $ff
CMP #$73 ;DOWN
BEQ down
LDA $ff
CMP #$64 ;RIGHT
BEQ right
JMP input
up:
LDA $02
STA $01ff, X
DEX
LDA $03
ADC #$01
STA $03
CMP #$20
BNE up
LDA $01
STA $01ff, X
JMP reset
left:
LDA $02
STA $01ff, X
DEX
LDA $02
STA $01ff, X
LDA $01
STA $01ff, X
JMP reset
down:
LDA $02
STA $01ff, X
INX
LDA $03
ADC #$01
STA $03
CMP #$20
BNE down
LDA $01
STA $01ff, X
JMP reset
right:
LDA $02
STA $01ff, X
INX
LDA $02
STA $01ff, X
LDA $01
STA $01ff, X
JMP reset`
When digging through the source I discovered that the assembler allows you to input decimal numbers by simply not prefixing them with $
. This is interesting (and not documented...PR to tutorial?), and it made me wonder if it would be helpful to toggle the interface between hex and dec mode.
After thinking about it, I've concluded that it could be useful to be able to toggle (at the least) the A, X, and Y debug output between hex and dec display. It might even be useful to even make this apply to the monitor (say for example, you are writing a program on an array of integers, such as a simple sort).
Thoughts?
The README.md fails to say how to run the gh-pages site, would you mind responding as to how to do so? node's md-server isn't enough.
I tried the tutorial and I noted a bug with STA instruction. This is an example from tutorial (##Indexed indirect: ($c0,X)###):
Address Hexdump Dissassembly
-------------------------------
$0600 a2 01 LDX #$01
$0602 a9 05 LDA #$05
$0604 85 0a STA $0a
$0606 a9 06 LDA #$06
$0608 85 02 STA $02
$060a a0 0a LDY #$0a
$060c 8c 05 06 STY $0605
$060f a1 00 LDA ($00,X)
First run, value $05 was written to address $0001. It is a bug:
A=$0a X=$01 Y=$0a
SP=$ff PC=$0611
NV-BDIZC
00110000
0000: 00 05 06 00 00 00 00 00 00 00 00 00 00 00 00 00
0010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
RESET:
A=$00 X=$00 Y=$00
SP=$ff PC=$0600
NV-BDIZC
00110000
0000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Second run, note that value $05 is written to memory $000a: That is OK:
A=$a2 X=$01 Y=$0a
SP=$ff PC=$0611
NV-BDIZC
10110000
0000: 00 00 06 00 00 00 00 00 00 00 05 00 00 00 00 00
0010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
This code looks reasonable.
define Screen $200
LDY #$21
LDA #1
STA Screen,Y ; this works
LDA #<Screen
STA $2
LDA #>Screen
STA $3
LDA #4
STA ($2),Y ; this does not work
but the #> and #< both always appear to generate #0 constants
If you define the label as a memory address it does work, but this really should be equivalent.
*= $200
Screen:
this was the standard behavior of the EQU directive in most assemblers
can you make the text higher contrast please?
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.