Blog about learning machine code for the MSX

nice one.
for the record,when doing ASM we use an ASSEMBLER, not a compiler. And the process of making a binary is called ASSEMBLING, not compiling. That's all "C" talk

@ro: Thanks, I changed it in the blogpost.

@wolf_ Just to temper expectations
But in the end it is the intention to be able to make a simple game. I'll get there ... eventually

Some time ago I wrote a small guide to introduce ASM to people who already knows some high level language.
It's focused on conditional statements, which on my personal experience I had most difficult at start.
Not the most optimized code, the focus here is being easy to understand.

Feel free to use it on your blog, if you wish:
PS: sorry about the wall of code. Is there any way to make it collapsible?

if(A == 14) {
    // do something
}
// rest of code


    cp    14            ; compares A with 14, setting Z flag
    jp    z, .then
    jp    .restOfCode

.then:
    ; do something

.restOfCode:
    ; rest of code


-----------------------------------------

if(A == 14) {
    // do something
}
else {
    // do other thing
}
// rest of code


    cp    14
    jp    z, .then
    jp    .else

.then:
    ; do something
    jp    .restOfCode

.else:
    ; do other thing

.restOfCode:
    ; rest of code

-----------------------------------------

if(A == 14 && B == 98) {
    // do something
}
else {
    // do other thing
}
// rest of code


    cp    14
    jp    z, .equalA
    jp    .else

.equalA:
    ld    a, b
    cp    98
    jp    z, .equalB
    jp    .else

.equalB:
    ; do something
    jp    .restOfCode

.else:
    ; do other thing

.restOfCode:
    ; rest of code

-----------------------------------------

if(A == 14 && B == 98) {
    // do something
}
else if (C == 145) {
    // do other thing
}
// rest of code


    cp    14
    jp    z, .equalA
    jp    .elseIf

.equalA:
    ld    a, b
    cp    98
    jp    z, .equalB
    jp    .elseIf

.equalB:
    ; do something
    jp    .restOfCode

.elseIf:
    ld    a, c
    cp    145
    jp    z, .equalC
    jp    .restOfCode

.equalC:
    ; do other thing

.restOfCode:
    ; rest of code

-----------------------------------

if (A >= 15) {
    // do something
}
// rest of code


    cp    15
    jp    nc, .then
    jp    .restOfCode

.then:
    ; do something

.restOfCode:
    ; rest of code

-----------------------------------

if (A < 15) {
    // do something
}
// rest of code


    cp    15
    jp    c, .then
    jp    .restOfCode

.then:
    ; do something

.restOfCode:
    ; rest of code

----------------------------------

for(B=10; B>0; B--) {
    // do something
}
// rest of code

   
; reverse loops are easier (and faster) on assembly
    ld    b, 10
.loop:
    ; do something
    djnz    .loop


----------------------------------

for(B=0; B<10; B++) {
    // do something
}
// rest of code

   
    ld    b, 0
.loop:
    ; do something
    inc    b
    ld     a, b                      ; cp only works with A register, so we have to copy B to A
    cp    10
    jp    nz, .loop

    ; rest of code

-------------------------------------

function byte Sum(byte A, byte B) {
    A = A + B;
    return A;
}

A = 7; B = 99;
A = Sum(A, B);



; define subroutine
Sum:
    add     b        ; sums A and B, output of add is always the A register
    ret

; call subroutine
ld    a, 7
ld    b, 99
call    Sum

@albs_br: Thanks! These are very handy routines and I'm sure that I can use them at some point in my blog.

Thanks again! There's a lot to learn about assembly and this is all very usefull.