mirror of
https://github.com/samsonjs/sectorlisp.git
synced 2026-03-25 09:05:48 +00:00
322 lines
7.7 KiB
ArmAsm
322 lines
7.7 KiB
ArmAsm
/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8 -*-│
|
|
│vi: set et ft=asm ts=8 tw=8 fenc=utf-8 :vi│
|
|
╞══════════════════════════════════════════════════════════════════════════════╡
|
|
│ Copyright 2020 Justine Alexandra Roberts Tunney │
|
|
│ Copyright 2021 Alain Greppin │
|
|
│ Some size optimisations by Peter Ferrie │
|
|
│ │
|
|
│ Permission to use, copy, modify, and/or distribute this software for │
|
|
│ any purpose with or without fee is hereby granted, provided that the │
|
|
│ above copyright notice and this permission notice appear in all copies. │
|
|
│ │
|
|
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
|
|
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
|
|
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
|
|
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
|
|
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
|
|
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
|
|
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
|
|
│ PERFORMANCE OF THIS SOFTWARE. │
|
|
╚─────────────────────────────────────────────────────────────────────────────*/
|
|
|
|
// LISP meta-circular evaluator in a MBR
|
|
|
|
.set ONE, %bp
|
|
.set NIL, 1
|
|
.set ATOM_T, 23
|
|
.set ATOM_QUOTE, 27
|
|
.set ATOM_COND, 39
|
|
.set ATOM_ATOM, 49
|
|
.set ATOM_CAR, 59
|
|
.set ATOM_CDR, 67
|
|
.set ATOM_CONS, 75
|
|
.set ATOM_EQ, 85
|
|
|
|
.set g_token, 0x7800
|
|
.set g_str, 0x0
|
|
.set g_mem, 0x8000
|
|
.set boot, 0x7c00
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// Currently requires i686+ in real mode
|
|
// Can be easily tuned for the IBM PC XT
|
|
// Quoth xed -r -isa-set -i sectorlisp.o
|
|
|
|
.section .text,"ax",@progbits
|
|
.globl _start
|
|
.code16
|
|
|
|
_start:
|
|
.type kSymbols,@object;
|
|
kSymbols:
|
|
.ascii "NIL\0\xC0"
|
|
.type .init,@function
|
|
.init: ljmp $0x7c00>>4,$_begin
|
|
.ascii "\0T\0QUOTE\0COND\0ATOM\0CAR\0CDR\0CONS\0EQ\0"
|
|
|
|
_begin: mov $g_mem,%cx
|
|
mov %cx,%fs # fs = &g_mem
|
|
xor %ax,%ax
|
|
mov %cx,%di
|
|
cld
|
|
rep stosb # clears our bss memory
|
|
push %cs # memory model cs=ds=es = 0x7c0
|
|
push %cs
|
|
push %cs
|
|
pop %ds
|
|
pop %es
|
|
pop %ss
|
|
mov %cx,%sp
|
|
mov $NIL,ONE
|
|
main: mov $'\n',%dl
|
|
call GetToken
|
|
call GetObject
|
|
mov ONE,%dx
|
|
call Eval
|
|
call PrintObject
|
|
mov $'\r',%al
|
|
call PutChar
|
|
jmp main
|
|
|
|
GetToken: # GetToken():al, dl is g_look
|
|
mov %fs,%di # mov $g_token,%di
|
|
mov %di,%si
|
|
1: mov %dl,%al
|
|
cmp $' ',%al
|
|
jbe 2f
|
|
stosb
|
|
xchg %ax,%cx
|
|
2: call GetChar # bh = 0 after PutChar
|
|
xchg %ax,%dx # dl = g_look
|
|
cmp $' ',%al
|
|
jbe 1b
|
|
cmp $')',%al
|
|
jbe 3f
|
|
cmp $')',%dl
|
|
ja 1b
|
|
3: movb %bh,(%di)
|
|
xchg %cx,%ax
|
|
ret
|
|
|
|
.PutObject: # .PutObject(c:al,x:di)
|
|
call PutChar # preserves di
|
|
xchg %di,%ax
|
|
# jmp PrintObject
|
|
|
|
PrintObject: # PrintObject(x:ax)
|
|
test $1,%al
|
|
xchg %ax,%di
|
|
jz .PrintList
|
|
.PrintAtom:
|
|
shr %di
|
|
mov %di,%si # lea g_str(%di),%si
|
|
.PrintString: # nul-terminated in si
|
|
lodsb
|
|
test %al,%al
|
|
jz .ret # -> ret
|
|
call PutChar
|
|
jmp .PrintString
|
|
.PrintList:
|
|
mov $'(',%al
|
|
2: push 2(%di) # save 1 Cdr(x)
|
|
mov (%di),%di # di = Car(x)
|
|
call .PutObject
|
|
pop %ax # restore 1
|
|
cmp ONE,%ax
|
|
je 4f
|
|
test $1,%al
|
|
xchg %ax,%di
|
|
mov $' ',%al
|
|
jz 2b
|
|
mov $249,%al # bullet (A∙B)
|
|
call .PutObject
|
|
4: mov $')',%al
|
|
jmp PutChar
|
|
|
|
GetObject: # called just after GetToken
|
|
cmpb $'(',%al
|
|
je GetList
|
|
.Intern:
|
|
xor %di,%di # mov $g_str,%di
|
|
xor %al,%al
|
|
0: push %di # save 1
|
|
1: cmpsb
|
|
jne 2f
|
|
dec %di
|
|
scasb
|
|
jne 1b
|
|
jmp 5f
|
|
2: pop %si # drop 1
|
|
mov %fs,%si # mov $g_token,%si
|
|
3: scasb
|
|
jne 3b
|
|
cmp (%di),%al
|
|
jne 0b
|
|
push %di # StpCpy
|
|
4: movsb
|
|
dec %di
|
|
scasb
|
|
jnz 4b
|
|
5: pop %ax # restore 1
|
|
# add $-g_str,%ax
|
|
add %ax,%ax # ax = 2 * ax
|
|
inc %ax # + 1
|
|
.ret: ret
|
|
|
|
GetChar:
|
|
xor %ax,%ax # get keystroke
|
|
int $0x16 # keyboard service
|
|
# ah is bios scancode
|
|
# al is ascii character
|
|
PutChar:
|
|
# push %bx # don't clobber di,si,cx,dx
|
|
# push %bp # original ibm pc scroll up bug
|
|
xor %bx,%bx # normal mda/cga style page zero
|
|
mov $0x0e,%ah # teletype output al cp437
|
|
int $0x10 # vidya service
|
|
# pop %bp # preserves al
|
|
# pop %bx
|
|
cmp $'\r',%al # don't clobber stuff
|
|
jne .ret
|
|
mov $'\n',%al
|
|
jmp PutChar # bx volatile
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Pairlis:cmp ONE,%di # Pairlis(x:di,y:si,a:dx):ax
|
|
je 1f # it's zip() basically
|
|
push 2(%di) # save 1 Cdr(x)
|
|
lodsw
|
|
push (%si) # save 2 Cdr(y)
|
|
mov (%di),%di
|
|
xchg %ax,%si
|
|
call Cons # preserves dx
|
|
pop %si # restore 2
|
|
pop %di # restore 1
|
|
push %ax # save 3
|
|
call Pairlis
|
|
xchg %ax,%si
|
|
pop %di # restore 3
|
|
jmp Cons # can be inlined here
|
|
1: xchg %dx,%ax
|
|
ret
|
|
|
|
Evlis: cmp ONE,%di # Evlis(m:di,a:dx):ax
|
|
je 1f
|
|
push 2(%di) # save 1 Cdr(m)
|
|
mov (%di),%ax
|
|
push %dx # save a
|
|
call Eval
|
|
pop %dx # restore a
|
|
pop %di # restore 1
|
|
push %ax # save 2
|
|
call Evlis
|
|
|
|
xCons: xchg %ax,%si
|
|
pop %di # restore 2
|
|
# jmp Cons
|
|
Cons: xchg %di,%ax
|
|
mov %fs,%di
|
|
stosw
|
|
xchg %si,%ax
|
|
stosw
|
|
xchg %di,%ax
|
|
mov %fs,%di
|
|
mov %ax,%fs
|
|
1: xchg %di,%ax
|
|
ret
|
|
|
|
GetList:call GetToken
|
|
cmpb $')',%al
|
|
je .retF
|
|
call GetObject
|
|
push %ax # save 1
|
|
call GetList
|
|
jmp xCons
|
|
|
|
1: mov 2(%di),%di # di = Cdr(c)
|
|
Evcon: push %di # save c
|
|
mov (%di),%di # di = Car(c)
|
|
mov (%di),%ax # ax = Caar(c)
|
|
push %dx # save a
|
|
call Eval
|
|
pop %dx # restore a
|
|
pop %di # restore c
|
|
cmp ONE,%ax
|
|
jz 1b
|
|
mov (%di),%di # di = Car(c)
|
|
.EvCadr:call Cadr # ax = Cadar(c)
|
|
# jmp Eval
|
|
|
|
Eval: test $1,%al # Eval(e:ax,a:dx):ax
|
|
jnz Assoc
|
|
xchg %ax,%di # di = e
|
|
mov (%di),%ax # ax = Car(e)
|
|
cmp $ATOM_QUOTE,%ax # maybe CONS
|
|
mov 2(%di),%di # di = Cdr(e)
|
|
je .retA
|
|
cmp $ATOM_COND,%ax
|
|
je Evcon
|
|
.Ldflt2:push %ax # save 2
|
|
call Evlis # preserves dx
|
|
xchg %ax,%si
|
|
pop %ax # restore 2
|
|
# jmp Apply
|
|
|
|
Apply: test $1,%al # Apply(fn:ax,x:si:a:dx):ax
|
|
jnz .switch
|
|
xchg %ax,%di # di = fn
|
|
.lambda:mov 2(%di),%di # di = Cdr(fn)
|
|
push %di # save 1
|
|
mov (%di),%di # di = Cadr(fn)
|
|
call Pairlis
|
|
xchg %ax,%dx
|
|
pop %di # restore 1
|
|
jmp .EvCadr
|
|
.ifCons:mov 2(%si),%si # si = Cdr(x)
|
|
mov (%si),%si # si = Cadr(x)
|
|
cmp $ATOM_CONS,%al
|
|
je Cons
|
|
.isEq: cmp %di,%si
|
|
jne .retF
|
|
.retT: mov $ATOM_T,%al # ax = ATOM_T
|
|
ret
|
|
.switch:cmp $ATOM_EQ,%ax
|
|
ja .dflt1
|
|
mov (%si),%di # di = Car(x)
|
|
.ifCar: cmp $ATOM_CAR,%al
|
|
je .retA
|
|
.ifCdr: cmp $ATOM_CDR,%al
|
|
cmove 2(%di),%ax # i686+
|
|
je .retD
|
|
.ifAtom:cmp $ATOM_ATOM,%al
|
|
jne .ifCons
|
|
test ONE,%di
|
|
jnz .retT
|
|
.retF: mov ONE,%ax # ax = NIL
|
|
.retD: ret
|
|
.dflt1: push %si # save x
|
|
push %dx # save a
|
|
call Eval
|
|
pop %dx # restore a
|
|
pop %si # restore x
|
|
jmp Apply
|
|
|
|
Cadr: mov 2(%di),%di # contents of decrement register
|
|
.retA: mov (%di),%ax # contents of address register
|
|
ret
|
|
|
|
1: mov 2(%si),%dx # dx = Cdr(y)
|
|
Assoc: cmp ONE,%dx # Assoc(x:ax,y:dx):ax
|
|
mov %dx,%si
|
|
je .retF
|
|
mov (%si),%bx # bx = Car(y)
|
|
cmp %ax,(%bx) # (%bx) = Caar(y)
|
|
jne 1b
|
|
mov 2(%bx),%ax # ax = Cdar(y)
|
|
ret
|
|
|
|
.type .sig,@object;
|
|
.sig:
|
|
.fill 510 - (. - _start), 1, 0xce
|
|
.word 0xAA55
|