kolibrios/programs/games/codemaster/include/text.inc

; $$$$$$$$$$$$$$$$$$$ ABAKIS $$$$$$$$$$$$$$$$$$$$$
; *************** STAR^2 SOFTWARE ****************
; ???????????????????? TEXT ??????????????????????

; fast portable text operations

; text.zero t       ; initialize, *t=0
; text.end t        ; return end address (*t=0)
; text.n t          ; get # characters
; text.copy a, b    ; standard copy with 0
; text.copy.n...    ; copy with maximum size
; text.attach a, b  ; attach b to a
; text.attach.c...  ; attach c/haracter
; text.compare a, b ; compare lexical. <0>
; text.equal a, b   ; equal? return 1/0
; text.search a, b  ; search for text. &/0
; text.find a, c    ; search for c. &/0
; text.find.r a, c  ; search for c in reverse
; text.count.c t, c ; count # of 'c's
; text.count.w t    ; count # of words: 'a b c'
; text.count.n t    ; count # of lines
; text.go t, n      ; advance to line #
; text.upper t      ; uppercase
; text.lower t      ; lowercase
; text.reverse t    ; reverse
; text.begins a, b  ; begins with b?
; text.ends a, b    ; ends with b?
; text.skip.0 t     ; skip '0's. return &
; text.shift.l t, n ; shift characters left
; text.shift.la...  ; shift left and assign
; text.expand t, n  ; expand; shift right at 0
; text.align t, n   ; align; prefix with '0's

; x2t n, t ; convert number to text
; u2t n, t ; unsigned decimal
; h2t n, t ; hexadecimal
; b2t n, t ; binary

; t2x t    ; convert text to number
; t2u t    ; unsigned decimal
; t2h t    ; hexadecimal
; t2b t    ; binary

; print t, f, ... - a fast print formatted
; text to buffer

macro debug { callf _say, bug.t, bug.t }

RET equ ,0Dh,0Ah,

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; text.zero t - initialize

macro text.zero t { . r0=t, *r0=0 }

; text.end t - return end address: *p=0

function text.end, t
  alias p=r0, c=r1
  . p=t, c=1
  while c, c=*p++, endw, p--
endf

; text.n t - get length, # characters

function text.n, t
  alias p=r0, s=r1, c=r2
  . p=t, s=p, c=1
  while c, c=*p++, endw, p-s, p--
endf

; text.copy a, b - standard copy with
; 0 after. return advanced address

function text.copy, a, b
  alias p=r0, s=r1, c=r2
  . p=a, s=b, c=1
  while c, c=*s++, *p++=c, endw, p--
endf

; text.copy.n a, b, n - copy with maximum
; size specified. return &

function text.copy.n, a, b, n
  alias p=r0, s=r1, c=r2
  . p=a, s=b
  loop n, c=*s++, *p++=c
    if c=0, break, end
  endl, p--
endf

; text.attach a, b - attach b to a. return &

function text.attach, a, b
  text.end a
  text.copy r0, b
endf

; text.attach.c t, c - attach c/haracter.
; return &

function text.attach.c, t, c
  alias p=r0, x=r1
  text.end t
  . x=c, *p++=x, *p=0
endf

; text.compare a, b - lexical comparison.
; return <0>

function text.compare, a, b
  alias p=r0, s=r1, c=r2, d=r3
  . p=a, s=b, c=d
  while c=d, c=*p++, d=*s++
    if c=0, break, end
    if d=0, break, end
  endw, p=c, p-d
endf

; text.equal a, b - equal? return 1/0

function text.equal, a, b
  text.compare a, b
  if false, return 1, end
endf 0

; text.find t, c - search for character:
; if t contains c. return &/0

function text.find, t, x
  alias p=r0, c=r1, k=r2
  . p=t, k=x
  loop, c=*p
    if c=0, return 0, end
    if c=k, return p, end, p++
  endl
endf

; text.count.c t, c - count # of c/haracters

function text.count.c, t, x
  locals n
  alias p=r0, c=r1, k=r2
  . p=t, k=x, n=0, c=1
  while c, c=*p++
    if c=k, n++, end
  endw
endf n

; text.count.w t - count # words 'a b c'

function text.count.w, t
  try text.count.c t, ' '
  . r0++
endf

; text.count.n t - count # lines

function text.count.n, t
  try text.count.c t, 0Dh
  . r0++
endf

; text.go t, n - advance to line #

function text.go, t, n
  loop n
    try t=text.find t, 0Dh
    . t+2
  endl
endf t

; text.upper t - convert to uppercase

function text.upper, t
  alias p=r0, c=r1
  . p=t
  loop, c=*p
    if c=0, return, end
    if c>=97
      if c<=122, c-32, *p=c, end
    end, p++
  endl
endf

; text.lower t - convert to lowercase

function text.lower, t
  alias p=r0, c=r1
  . p=t
  loop, c=*p
    if c=0, return, end
    if c>=65
      if c<=90, c+32, *p=c, end
    end, p++
  endl
endf

; text.reverse t - reverse text

function text.reverse, t
  locals p
  alias s=r0, e=r1, c=r2
  get p=text.end t
  . e=&(s-1), s=t
  while s<e, c=*s, *s++=*e, *e--=c, endw
endf p

; text.begins a, b - a begins with b?

function text.begins, a, b
  alias p=r0, q=r1, c=r2, d=r3
  . p=a, q=b, d=c
  while c=d, c=*p++, d=*q++
    if c=0, break, end
    if d=0, break, end
  endw
  if d<>0, return 0, end
endf

; text.ends a, b - a ends with b?

function text.ends, a, b
  locals p
  get p=text.end a
  text.n b
  . p-r0
  text.equal p, b
endf

; text.search t, c - search for text:
; if a contains b. return &/0

function text.search, a, b
  locals n, p
  get n=text.n a
  . p=a
  loop n
    text.begins p, b
    if true, return p, end
    . p++
  endl
endf 0

; text.skip.0 a - skip 0s, return address or 0

function text.skip.0, a
  alias p=r0, c=r1
  . p=a, c='0'
  while c='0', c=*p++, endw, p--
  if c=0, return 0, end
endf

; shift all characters left

; before:    'abc123'
; after <<3: '123'

function text.shift.l, t, n
  alias p=r0, q=r1
  . p=t, q=p, q+n
  text.copy p, q
endf

; shift left and assign s to BITs
; copied out ('abc' in example above)

function text.shift.la, t, s, n
  alias p=r0, q=r1
  . p=t, q=p, q+n
  text.copy.n s, t, n
  text.shift.l t, n
endf

; expand; shift all characters right.
; example: 'abc123' becomes 'XXXabc123'
; after expand 3 where X is unknown

function text.expand, t, n
  locals x
  alias p=r0, q=r1, c=r2
  get x=text.n t
  . p+t, p--, q=p, p+n, *p=0
  loop x, *p--=*q--, endl
endf

; prefix text with '0's or ensure maximum n.
; example: before: t='7FAB'
; text.align t, 8 ; after: t='00007FAB'

function text.align, t, n
  locals tn
  alias n1=r0, n2=r1,\
   c=r1, p=r2
  get tn=text.n t
  . n2=n
  if n1=n2, return, end    ; same size
  if n1>n2, p=t, *(p+n1)=0 ; exceeds maximum
    return                 ; end at t+n
  end, n-n1                ; else, n2>n1
  text.expand t, n         ; expand t
  . p=t, c='0'             ; write '0's
  loop n, *p++=c, endl
endf

; search text array ta for t using text.equal.
; return index or -1 (<0) if not found. ta is
; an array of text addresses (text[])

function text.array.equal, ta, t, n
  locals i
  alias p=r0, q=r1, x=r2
  . i=0
  loop n, x=i, q=ta, (u32) p=*(q+x*4)
    text.equal p, t
    if true, return i, end
    . i++
  endl
endf -1

;;;;;;;;;;;;;;;;;; CONVERSIONS ;;;;;;;;;;;;;;;;;;;

; u2t n, t ; unsigned decimal
; h2t n, t ; hexadecimal
; b2t n, t ; binary

; convert unsigned 32BIT integer to text

function u2t, n, t
  alias i=r0, x=r1, y=r2, c=r3, p=r7
  push c p
  . i=n, p=t
  if i=0, *p++='0', *p=0
    . r0=p
    go .r
  end
  . x=1999999Ah
  while i, c=i, mul x, i=y, y=&(y+y*4)
    . y+y, c-y, c+'0', *p++=c
  endw, *p=0
  text.reverse t
  .r:
  pop p c
endf

; convert 32BIT hexadecimal number to text

function h2t, n, t
  alias p=r0, x=r1
  . p=t
  if n=0, *p++='0', *p=0
    return
  end
  while n, x=n, x&15
    . x=*(@HEX+x), *p++=x, n>>>4
  endw, *p=0
  text.reverse t
endf

align @HEX: db '0123456789ABCDEF'

; convert 32BIT binary number to text

function b2t, n, t
  alias p=r0, x=r1
  . p=t
  if n=0, *p++='0', *p=0
    return
  end
  while n, x=n, x&1, x+'0'
    . *p++=x, n>>>1
  endw, *p=0
  text.reverse t
endf

; t2u t ; unsigned decimal
; t2h t ; hexadecimal
; t2b t ; binary

; convert text to unsigned 32BIT integer

function t2u, t
  alias p=r0, c=r1, n=r2, x=r3
  try text.skip.0 t
  . n=0
  loop, c=*p++
    if c=0, return n, end
    . x=n, x<<2, n+x, n+n, n-'0', n+c
  endl
endf

; convert text to 32BIT hexadecimal

function t2h, t
  alias p=r0, c=r1, n=r2
  try text.skip.0 t
  . n=0
  loop, c=*p++
    if c=0, return n, end
    if c<=39h, c-30h
    else.if c>=61h, c-57h
    else, c-37h, end, n<<4, n+c
  endl
endf

; convert text to 32BIT binary

function t2b, t
  alias p=r0, c=r1, n=r2
  try text.skip.0 t
  . n=0
  loop, c=*p++
    if c=0, return n, end
    . n<<1, n-'0', n+c
  endl
endf

; convert number to text with alignment.
; example: n2t.a 1234h, t, 8, h
; after: t='00001234'

macro n2t.a n, t, a, b {
  b#2t n, t
  text.align t, a
}

macro u2t.a n, t, a { n2t.a n, t, a, u }
macro h2t.a n, t, a { n2t.a n, t, a, h }
macro b2t.a n, t, a { n2t.a n, t, a, b }

;;;;;;;;;;;;;;;;;;;;; PRINT ;;;;;;;;;;;;;;;;;;;;;;

; print t, f, ... - a fast print formatted
; text to buffer

; %t %s - 'text'; "string"
; %c    - character
; %n %u - 32BIT decimal unsigned
; %b    - 32BIT binary
; %h    - 32BIT hexadecimal
; %r    - return. insert 0Dh, 0Ah
; %0    - 0/NULL
; %%    - %

macro print t, f, [p] {
  common callv !print, t, f, p
}

; note: text.copy/reverse/etc and x2t
; must return end (*p=0) address for this

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

align integer BASE='n'

; !print(n, $t, $f, ...)

!print:
 alias \               ; aliases...
  s=r6, p=r7,\         ; source, destiny
  c=r0, i=r1,\
  va.s=r2,\            ; &va[...] start
  va.n=[esp+4],\       ; # va
  va=[r2+r1*4],\       ; current va[i]
  n=[.a], z=[.z]       ; temporary

  . (u32) c=*(esp+8)   ; text buffer
  . (u32) i=*(esp+12)  ; format
  . va.s=&(esp+16)     ; &va[...] start

  push s p
  . p=c, s=i, i=0      ; index=0

  .get: . c=*s++       ; get c/haracter
  if c=0, go .e, end   ; end? *s=0
  if c<>'%'            ; not %
    .1: . *p++=c       ; copy c
    go .get            ; next
  end
  . c=*s++             ; %x
  if c='%', go .1      ; 2 %% = %
  end

  if c='0', *p++=0     ; '0' = 0/NULL
    go .get
  end

  if c='r'             ; 'r' = return
    .  *p++=\
     0A0Dh, go .get
  end

  if c='c'             ; %c
    . c=va, i++        ; get va[i++]
    . *p++=c
    go .get
  end

  if c='t'
    .t:                ; %t %s - text
    . z=va, i++        ; get va[i++]
    pusha
    get z=\
     text.copy p, z    ; copy, save &
    popa
    . p=z              ; advance text buffer
    go .get
  end
  if c='s', go .t
  end

  if c='n', go .n, end
  if c='u', go .n, end
  if c='h', go .n, end
  if c='b', go .n, end

  go .x                ; unrecognized

  .n:
  . n=va, i++          ; get va[i]
  pusha                ; copy/convert
  if c='n'             ; number to text
    u2t n, p           ; in selected base
  else.if c='u'
    u2t n, p
  else.if c='h'
    h2t n, p
  else.if c='b'
    b2t n, p
  end
  . z=r0               ; save end address
  popa
  . p=z                ; advance text buffer
  go .get

  .x: . *p++='?'       ; else, unrecognized,
  go .get              ; replace with '?'

  .0: . r0=0, go .q    ; error
  .e: . r0=p, *r0=0    ; success. terminate
  .q:                  ; return end
  pop p s
 ret                   ; callv adjusts esp after

endal                  ; end alias

.a dd 0
.z dd 0

;;;;;;;;;;;;;;; CHARACTER TABLES ;;;;;;;;;;;;;;;;;

; ILT - insensitive lookup table. A-Z/a-z are
; the same. this increases processing speed by
; many times. example: if (tt[a]=tt[b]) instead
; of: if ((a>='a'&a<='z')&(b>='a'&b<='z')) |
; ((a>='A'&a<='Z')&(b>='Z'&b<='Z'))

; TLT - type lookup table. each byte contains
; C.X BITs to determine its type fast in one
; comparison. example: if tt[c]&SYMBOL

align 8

; byte XLT[128]=

ILT db \
 00h,01h,02h,03h,04h,05h,06h,07h,08h,09h,0Ah,0Bh,0Ch,0Dh,0Eh,0Fh,\
 10h,11h,12h,13h,14h,15h,16h,17h,18h,19h,1Ah,1Bh,1Ch,1Dh,1Eh,1Fh,\
 20h,21h,22h,23h,24h,25h,26h,27h,28h,29h,2Ah,2Bh,2Ch,2Dh,2Eh,2Fh,\
 30h,31h,32h,33h,34h,35h,36h,37h,38h,39h,3Ah,3Bh,3Ch,3Dh,3Eh,3Fh,\
 40h,41h,42h,43h,44h,45h,46h,47h,48h,49h,4Ah,4Bh,4Ch,4Dh,4Eh,4Fh,\
 50h,51h,52h,53h,54h,55h,56h,57h,58h,59h,5Ah,5Bh,5Ch,5Dh,5Eh,5Fh,\
 60h,41h,42h,43h,44h,45h,46h,47h,48h,49h,4Ah,4Bh,4Ch,4Dh,4Eh,4Fh,\
 50h,51h,52h,53h,54h,55h,56h,57h,58h,59h,5Ah,7Bh,7Ch,7Dh,7Eh,7Fh

TLT db \
 00h,80h,80h,80h,80h,80h,80h,80h,80h,80h,40h,80h,80h,40h,80h,80h,\
 80h,80h,80h,80h,80h,80h,80h,80h,80h,80h,80h,80h,80h,80h,80h,80h,\
 20h,10h,04h,04h,10h,04h,04h,04h,04h,04h,04h,04h,04h,04h,10h,04h,\
 01h,01h,01h,01h,01h,01h,01h,01h,01h,01h,04h,04h,04h,04h,04h,10h,\
 10h,0Ah,0Ah,0Ah,0Ah,0Ah,0Ah,02h,0Ah,02h,02h,0Ah,02h,0Ah,02h,02h,\
 02h,02h,02h,02h,02h,02h,02h,02h,02h,02h,02h,04h,04h,04h,04h,10h,\
 04h,0Ah,0Ah,0Ah,0Ah,0Ah,0Ah,02h,0Ah,02h,02h,0Ah,02h,0Ah,02h,02h,\
 02h,02h,02h,02h,02h,02h,02h,02h,02h,02h,02h,04h,04h,04h,04h,80h

;            76543210b
C.NULL     = 00000000b ; 0
C.NUMBER   = 00000001b ; 0-9
C.ALPHA    = 00000010b ; A-Z, a-z
C.SYMBOL   = 00000100b ; all symbols except _.?!@$
C.NUMERIC  = 00001000b ; A-F/a-f, h,b,k,m/H,B,K,M
C.SYMBOLIC = 00010000b ; _.?!@$
C.SPACE    = 00100000b ; ' ', '/t'
C.RETURN   = 01000000b ; 0Dh, 0Ah
C.IGNORE   = 10000000b ; extended: 1.XXXXXXXb
C.KEYWORD  = 11111111b

C.DIGIT    = C.NUMBER or C.NUMERIC
C.NAME     = C.ALPHA or C.NUMBER or C.SYMBOLIC
C.SYMBOLS  = C.SYMBOL or C.SYMBOLIC
C.ALPHAN   = C.ALPHA or C.NUMBER
C.VISIBLE  = C.ALPHAN or C.SYMBOLS
C.WHITE    = C.SPACE or C.RETURN
C.BLANK    = C.WHITE or C.IGNORE
C.END      = C.SYMBOL or C.WHITE
C.0        = 0

function is.c, c, type
  . r0=c, r0=*(TLT+r0), r0&type
endf

macro if.is c, t {
  is.c c, t
  if true
}

;;;;;;;;;;;;;;;;;;; PARSE TEXT ;;;;;;;;;;;;;;;;;;;

; skip while type and not 0

; get p=text.skip.while p, C.WHITE

function text.skip.while, t, type
  alias p=r0, q=r1, c=r2
  . p=t, c=1
  while c, c=*p++
    . c=*(TLT+c), c&type
  endw, p--
endf

; skip until type and while not 0.
; kind of tricky

; get p=text.skip.until p, C.RETURN

function text.skip.until, t, type
  alias p=r0, q=r1, c=r2
  . p=t, c=0
  while c=0, c=*p++
    if c=0, return 0, end
    . c=*(TLT+c), c&type
  endw, p--
endf

; copy while type and not 0

; get s=text.copy.while t, s, C.NAME

function text.copy.while, t, s, type
  alias a=r7, b=r6, c=r1, x=r2
  . a=t, b=s, c=*b
  if c=0, return 0, end
  while c, c=*b++, *a++=c
    . x=*(TLT+c), x&type
    if x=0, break, end
  endw, a--, *a=0, b--
endf b

; copy until type and while not 0

; get s=text.copy.until t, s, C.END

function text.copy.until, t, s, type
  alias a=r7, b=r6, c=r1, x=r2
  . a=t, b=s, c=*b
  if c=0, return 0, end
  while c, c=*b++, *a++=c
    . x=*(TLT+c), x&type
    if x, break, end
  endw, a--, *a=0, b--
endf b

; copy until 'c'/x. if 0 or return is
; encountered before, return 0

function text.copy.until.c, t, s, x
  alias a=r7, b=r6, c=r1
  . a=t, b=s, c=*b
  if c=0, return 0, end
  while c, c=*b++, *a++=c
    if c=x, break, end
    if c=0, return 0, end
    if c=0Dh, return 0, end
  endw, a--, *a=0, b--
endf b

; skip whitespace and returns
; (if parse.skip.r?) or only spaces
; and tabs. return advanced &

align boolean parse.skip.r?=YES

function text.skip.ws, t
  if parse.skip.r?
    text.skip.while t, C.WHITE
  else
    text.skip.while t, C.SPACE
  end
endf

; skip all whitespace, returns
; (if parse.skip.r?) and comments.
; return advanced &

function text.skip.x, t
  locals q
  alias p=r0, c=r1
  . p=t, q=p
  .get:
  . p=q, c=*p
  if c=0
    return 0
  end
  if.is c, C.WHITE
    try q=text.skip.ws q
  end
  . p=q, c=*p
  if c=';'
    try q=text.skip.until \
     q, C.RETURN
    . p+2
    go .get
  end
endf q

function text.get, a, b
  locals q
  alias p=r0, c=r1
  . q=b
  try q=text.skip.x q
  . c=*p
  if c=0, return 0, end
  if.is c, C.SYMBOL
    . p=a, *p++=c, *p=0, q++
    return q
  end
  text.copy.until a, q, C.END
endf

;;;;;;;;;;;;;;;; SOURCE, DESTINY ;;;;;;;;;;;;;;;;;

align

void source.p, destiny.p, token.p
integer source.n, destiny.n, token.n

macro set.source p  { . source.p=p }
macro set.destiny p { . destiny.p=p }
macro set.token p   { . token.p=p }

function skip.while, type
  get source.p=text.skip.while \
   source.p, type
endf

function skip.until, type
  get source.p=text.skip.until \
   source.p, type
endf

function copy.while, type
  get source.p=text.copy.while \
   token.p, source.p, type
endf

function copy.until, type
  get source.p=text.copy.until \
   token.p, source.p, type
endf

function copy.until.c, c
  get source.p=text.copy.until.c \
   token.p, source.p, c
endf

macro skip.space { skip.while C.SPACE }
macro skip.white { skip.while C.WHITE }
macro skip.line  { skip.until C.RETURN }

; skip all whitespace, returns
; (if parse.skip.r?) and comments.
; return advanced &

function skip.x
  alias p=r0, c=r1
  .get:
  . p=source.p, c=*p
  if c=0, return 0, end
  if.is c, C.WHITE
    try skip.while C.WHITE
  end
  . p=source.p, c=*p
  if c=';'
    try skip.until C.RETURN
    . source.p+2
    go .get
  end
  . p=source.p
endf p

; get token

function get.token
  alias p=r0, c=r1
  try skip.x
  . c=*p
  if c=0, return 0, end
  if.is c, C.SYMBOL
    . p=token.p, *p++=c, *p++=0
    . source.p++, p=source.p
    if c='''', c=*p
      if c='''', source.p++
        return source.p
      end
      try copy.until.c ''''
      . source.p++
    end
    . p=source.p
    return
  end
  copy.until C.END
endf

; MOVE TO PARSE.INC...

;;;;;;;;;;;;;;;;;;; NAME TABLE ;;;;;;;;;;;;;;;;;;;

; name table:

; 'ann',0, 'kim',0, 'sue',0

align 4

void name.table, name.table.p,\
 name.table.n, name.table.size, name.table.end

; allocate name.table

function create.name.table, size
  try name.table=call !allocate, size
  . name.table.p=r0, r0+size
  . name.table.end=r0, name.table.n=0
  . name.table.size=0
endf 1

; get name address by index

function get.name, i
  locals p
  . p=name.table
  loop i
    get p=text.end p
    . p++
  endl
endf p

; search for name. return index or -1

function search.name, t
  locals i, p
  . p=name.table, i=name.table.n
  loop i
    get.name i
    text.equal p, r0
    if true, return i, end
  endl
endf -1

; attach 'text'. return address

function create.name, t
  locals p, n
  . p=name.table.p
  text.n t
  . r0++, n=r0, r0+p
  if r0>=name.table.end
    return 0
  end
  text.copy name.table.p, t
  . r0=p, r0+n, name.table.p=r0
  . name.table.n++, r0=n
  . name.table.size+r0
endf p

; remove name at index

function remove.name, i
  locals p, q, n, size
  get p=get.name i
  get n=text.n p
  . i++
  get q=get.name i
  . r0=name.table.p, r0+name.table.size
  . r0-p, size=r0, r0=n
  . name.table.size-r0, name.table.p-r0
  memory.copy p, q, size
  . name.table.n--
endf

; get name at index

function copy.name, i, t
  get.name i
  text.copy t, r0
endf

; name structure: 16 bytes

virtual at 0
  ?define:
  .type dd 0  ; type: TTTT...
  .value dd 0 ; name index
  .name dd 0  ; value or index
  .i dd 0     ; anything, align 16
  .$=$
END virtual

powers DEFINE.*, ALIVE, USED,\
 D, ABLE, NUMERIC

; .type =

; TTTT.SSSS XXXXXXXX XXXXXXXX XXX.NR.DUA
;           23-16    15-8     7-0

; T: type: number, define, constant, label,
; macro, register, instruction, variable
; S: data size
; P: parameter 1
; Q: parameter 2
; X: anything
; N: 1=numeric, 0=symbolic
; R: 1=redefinable, 0=not
; D: 1=defined, 0=not
; U: 1=used, 0=not
; A: 1=alive, 0=dead

; name structures. last structure is
; defines.p+((defines.n-1)*48)

align 4

void defines.p     ; name structures
void defines.end.p ; end allocation
integer defines.n

;;;;;;;;;;;;;;;;;;;;; ERRORS ;;;;;;;;;;;;;;;;;;;;;

; MOVE TO ASSEMBLER.INC

text errors.ta[]=\
 E.NONE     ='None',\
 E.SYNTAX   ='Syntax',\
 E.LOAD     ='Error loading',\
 E.FILE     ='File I/O error',\
 E.UNEXPECT ='Unexpected',\
 E.CPU      ='Unsupported by CPU',\
 E.ADDRESS  ='Address not aligned',\
 E.OPERANDS ='Invalid operand/s',\
 E.AMODE    ='Invalid addressing mode',\
 E.SHIFT    ='Invalid shift #',\
 E.NUMBER   ='Invalid number',\
 E.NUMBER2  ='Number can''t be encoded',\
 E.VALUE    ='Value exceeds size',\
 E.ALIGN    ='Number must be aligned',\
 E.POWER    ='# must be power of 2',\
 E.REGISTER ='Register expected',\
 E.EXPECTN  ='Number expected',\
 E.EXPECTA  ='Name expected',\
 E.INAME    ='Invalid name',\
 E.NAME     ='Name too long',\
 E.RESERVE  ='Reserved name',\
 E.UNDEFINE ='Undefined',\
 E.REDEFINE ='Redefinition',\
 E.EXPECTT  ='Text expected',\
 E.ENDT     ='Text has no end ''',\
 E.COMMA    =', expected',\
 E.END      ='end expected',\
 E.MISMATCH ='Mismatched parenthesis'

;;;;;;;;;;;;;;;;;;; KEYWORDS ;;;;;;;;;;;;;;;;;;;;;

; MOVE TO ASSEMBLER.INC

text keywords.ta[]=\
 K.ALIGN='align', K.BYTE='byte',\
 K.D1='d1', K.D2='d2', K.D4='d4', K.D8='d8',\
 K.DEFINE='define', K.DOUBLE='double',\
 K.EQUATE='equate', K.FLOAT='float',\
 K.FORMAT='format', K.INCLUDE='include',\
 K.INJECT='inject', K.INTEGER='integer',\
 K.MAIN='main', K.ORG='org',\
 K.RESTORE='restore', K.TEXT='text',\
 K.USE='use', K.VOID='void'

align 4

void keywords.ta.p=keywords.ta
integer keywords.n=keywords.ta.$

function is.keyword, t
  if keywords.n=0, return -1, end
  text.array.equal \
   keywords.ta.p, t, keywords.n
endf