256b-demo-1.js

//.386
//.model tiny
//.code
//org 100h
function init_graphics() {
    document.body.appendChild(canvas = document.createElement('canvas')) 
    canvas.width = 640
    canvas.height = 480
    ctx = canvas.getContext('2d')
    var data = ctx.getImageData(0,0, 640,480),
    i=640*480
    while (i--) {
        data.data[i*4] = 0
        data.data[i*4 + 1] = 0
        data.data[i*4 + 2] = 0
        data.data[i*4 + 3] = 255
    }
    ctx.putImageData(data, 0,0)
}
function stosw(rep) {
    while (--cx) {
        mem[es + ++di] = ax & 0xFF
        mem[es + ++di] = ax >> 8
    }
}
function stosd(rep) {
        mem[es + ++di] = ax & 0xFF
        mem[es + ++di] = ax >> 8
        mem[es + ++di] = 0
        mem[es + ++di] = 0
}
function out() {

}
function outsb(rep) {
    if (rep) {
        di -= cx
        cx = 0
    }
//TODO
}
function movsw(rep) {
    var data = ctx.getImageData(0,0, 640,480)
    while (--cx) {
        data.data[0|((di*4)/3)] = mem[ds + si++] * 4
        di++
    }
    ctx.putImageData(data, 0,0)
    delete data
}
function push(val) {
    sp -= 2
    mem[sp] = val & 0xFF
    mem[sp + 1] = val >> 8
}
function pop() {
    var val = mem[sp] | mem[sp + 1] << 8
    sp += 2
    return val
}
var mems = 1024 * 1024,
    bp = mems / 4,
    mem = new Uint8Array(mems),
    ax = 0,
    bx = 0,
    cx = 0,
    dx = 0,
    di = 0,
    si = 0,
    sp = mems - 1,
    es = bp,
    ds = bp,
    al, bl,
    canvas, ctx
//start:

di = 0x030C                             //        mov     di, 30Ch
push(di)                                //        push    di

cx = 0x7D00                             //        mov     ch, 7Dh
stosw(true)                             //        rep stosw

                                        //        mov     ax, 13h
init_graphics()                         //        int     10h
di = pop()                              //        pop     di
push(di)                                //        push    di
bx = 0x3C8                              //        mov     bx, 3C8h
push(bx)                                //        push    bx
cx = 4                                  //        mov     cl, 4

loc_11F: do {                           //loc_11F:        
    push(cx)                            //        push    cx
    cx = (cx & 0xFF00) + 0x0020           //        mov     cl, 20h
    loc122: do {                        //loc_122:        
        ax = 0x20                       //        mov     ax, 20h
        ax -= cx                        //        sub     ax, cx
        ax = (ax << 1) & 0xFFFF         //        shl     ax, 1
        stosd()                         //        stosd
        ax = ((ax & 0xFF) << 8) | ((ax & 0xFF00) >> 8) //        xchg    ah, al
        mem[bx] = ax & 0xFF             //        mov     [bx], eax
        mem[bx + 1] = ax >> 8
        mem[bx + 2] = 0
        mem[bx + 3] = 0
        di--                            //        dec     di
        bx -= 3                         //        sub     bx, 3
    } while (--cx)                      //        loop    loc_122
    cx = pop()                          //        pop     cx
    di += 0x5F                          //        add     di, 5Fh
    bx += 0x11F                         //        add     bx, 11Fh
} while (--cx)                          //        loop    loc_11F
dx = pop()                              //        pop     dx
//set palette
out(dx, ax & 0xFF)                      //        out     dx, al
dx++                                    //        inc     dx
si = pop()                              //        pop     si
cx = 0x300 + (cx & 0xFF)                //        mov     ch, 3
outsb(true)                             //        rep outsb
       
bx = 0x798F                             //        mov     bx, 798Fh
bp = 0xFF                               //        mov     bp, 0FFh
 
loc_14E: do {                           //loc_14E:        
    ax = 0xFFD9                         //        mov     ax, 0FFD9h
    bx = (bx * ax) & 0xFFFF             //        imul    bx
    cx += dx                            //        add     cx, dx
    bx += cx                            //        add     bx, cx
    mem[ds + bp + 0x30C] = (bx & 0xFF00) >> 8   //        mov     ds:[bp+30Ch], bh
} while (--bp)                          //        dec     bp
                                        //        jns     short loc_14E
push(0xA000)                            //        push    0A000h
es = pop()                              //        pop     es
       
// loc_163: do { //loc_163:
function the_loop() {
    si = 0x30C                          //        mov     si, 30Ch
    bp = 0x63                           //        mov     bp, 63h
    loc_169: do { //loc_169:
        bx = bp                         //        mov     bx, bp
        bl += mem[ds + 0x1ED]           //        add     bl, ds:1EDh
        bx = (bx & 0xFF00) | bl
        al = mem[bx + si]               //        mov     al, [bx+si]
        mem[ds + 0x1EC] = al            //        mov     ds:1ECh, al
        bx = bp                         //        mov     bx, bp
        al = mem[bx + si]               //        mov     al, [bx+si]
        mem[ds + 0x1EF] = al            //        mov     ds:1EFh, al
        ax = bp                         //        mov     ax, bp
        ax = (ax << 8) & 0xFFFF         //        shl     ax, 1
        dx = ax + ax * 4                //        lea     dx, [eax+eax*4]
        dx = (dx << 6) & 0xFFFF         //        shl     dx, 6
        di = 0x9F                       //        mov     di, 9Fh
 
        loc_189: do {                   // loc_189:        
            bx = di                     //        mov     bx, di
            bl = bx & 0xFF
            bl = bl - mem[ds + 0x1ED]   //        sub     bl, ds:1EDh
            al = al & 0xFF
            al = mem[bx + si]           //        mov     al, [bx+si]
            al += mem[ds + 0x1EF]       //        add     al, ds:1EFh
            mem[ds + 0x1EE] = al        //        mov     ds:1EEh, al
            bx = di                     //        mov     bx, di
            bx = (bx << 1) & 0xFFFF     //        shl     bx, 1
            bx += dx                    //        add     bx, dx
            ax = ax & 0xFF00 | (al & 0xFF)
            ax = (ax << 8) & 0xFFFF     //        shl     ax, 8
            al = ax & 0xFF
            al += mem[ds + 0x1EC]       //        add     al, ds:1ECh
            al -= mem[ds + 0x1EE]       //        sub     al, ds:1EEh
            ax = ax & 0xFF00 | (al & 0xFF)
            mem[bx + 0x54C] = ax & 0xFF //        mov     [bx+54Ch], ax
            mem[bx + 0x54C + 1] = ax >> 8
            al = mem[ds + 0x1EE]        //        mov     al, ds:1EEh
            al += mem[ds + 0x1EC]       //        add     al, ds:1ECh
            ax = al << 8                //        mov     ah, al
            al -= mem[ds + 0x1EF]       //        sub     al, ds:1EFh
            ax = ax & 0xFF00 | al
            mem[bx + 0x40C] = ax & 0xFF //        mov     [bx+40Ch], ax
            mem[bx + 0x40C + 1] = ax >> 8
        } while (--di)                  //        dec     di
                                        //        jns     short loc_189
    } while (--bp)                      //        dec     bp
                                        //        jns     short loc_169
    dx = 0x3DA                          //        mov     dx, 3DAh
 
// vsync?
//    loc_1C7: while((ax = _in(dx)) === 8);   //loc_1C7:        
                                        //      in      al, dx
                                        //        test    al, 8
                                        //        jz      short loc_1C7
 
//    loc_1CC: while((ax = _in(dx)) !== 8);   //loc_1CC:
                                        //      in      al, dx
                                        //        test    al, 8
                                        //        jnz     short loc_1CC
    cx = (0x7D << 8) | (cx & 0xFF)      //        mov     ch, 7Dh
    si = 0x40C                          //        mov     si, 40Ch
    di = 0                              //        xor     di, di
    // this actually stores image
    movsw(true)                             //        rep movsw
    mem[ds + 0x1ED]++                   //        inc     byte ptr ds:1EDh

// waiting for ctrl-c?
//    ax = (ax & 0xFF00) | _in(0x60)    //        in      al, 60h
//    ax = ax & 0xFF                    //        cbw
//    ax--                              //        dec     ax
//    if (!ax) break loc_163            //        jnz     loc_163
//} while (true)

    window.requestAnimationFrame(the_loop)

}
//        mov     al, 3
//        int     10h
the_loop()
//        retn
//end start