; $$$$$$$$$$$$$$ Z77 ASM LIBRARY $$$$$$$$$$$$$$$$$
; ************** SUNGOD SOFTWARE *****************
; ??????????????? LANGUAGE.INC ???????????????????

; $$$$$$$$$$ EVOLUTION OF HL ASM SYNTAX $$$$$$$$$$

;;;;;;;;;;;;;;;;; VARIABLE.INC ;;;;;;;;;;;;;;;;;;;

; define variable of type

macro !DV type, name, value {
local l
l=$
name type value ; example: msg db 'Hello'
name#.$=$-l     ; size
}

; define b/w/d/q/t variables

macro !D1 name, value { !DV db, name, value }
macro !D2 name, value { !DV dw, name, value }
macro !D4 name, value { !DV dd, name, value }
macro !D8 name, value { !DV dq, name, value }
macro !DF name, value { !DV dt, name, value }

; display error if no match

macro verify.syntax name {
if ?s eq 0
 'Invalid syntax: ' name
end if
}

; verify size of block/text/array

macro verify.size n {
if n eq
 'Size must be specified'
else if ~ n eqtype 0
 'Size must be numeric'
else if n eq 0
 'Size cannot be zero'
end if
}

; define byte array. BLOCK b(size)

macro BLOCK [p] {
forward
define ?s 0
match =0 name(size), ?s p \{
 verify.size size
 !DV db, name, size dup(0)
 define ?s 1
\}
verify.syntax BLOCK
}

macro TEXTA name, [t] {
?nta=0
common
label name dword
forward local l
dd l
?nta=?nta+1
forward l db t, 0
name#.$=?nta
}

; create HL 'text' variable/s. TEXT t='X'.
; note: (n) is the size

macro TEXT [p] {
forward
local l
define ?s 0
; TEXT t(n)='abc'
match =0 name(size)==text, ?s p \{
 l=$
 verify.size size
 !DV db, name, <text,0>
 times (size-($-l)) db 0
 define ?s 1
\}
; TEXT t(n)
match =0 name(size), ?s p \{
 verify.size size
 !DV db, name, size dup(0)
 name\#.$=size
 define ?s 1
\}
; TEXT t='abc'
match =0 name==text, ?s p \{
 !DV db, name, <text,0> ; name db 't', 0
 define ?s 1
\}
; TEXT t
match =0 name, ?s p \{
 'Size must be specified:' name
 define ?s 1
\}
verify.syntax TEXT
}

;;;;;;;;;;;;;; DEFINE HL VARIABLE ;;;;;;;;;;;;;;;;

; define X. syntax: type then any a/a=b
; sequence/s separated with ,s. example:
; NUMBER x, y, w=320, h=240
; variables=0 if there is no initial value

macro !D type, [p] {
common
if p eq
 'Name expected'
end if
forward
define ?s 0
match =0 a==b, ?s p \{ ; a=b
 type a, b
 define ?s 1
\}
match =0 a=,, ?s p \{  ; a, (next)
 type a, 0
 define ?s 1
\}
match =0 a, ?s p \{    ; a (end)
 type a, 0
 define ?s 1
\}
verify.syntax variable
}

; HL variable names

macro BYTE [a]   { !D !D1, a }
macro WBYTE [a]  { !D !D2, a }
macro NUMBER [a] { !D !D4, a }
macro NUMERO [a] { !D !D8, a }
macro REAL [a]   { !D !D4, a }
macro REAL8 [a]  { !D !D8, a }
macro REAL10 [a] { !D !DF, a }

macro VOID [a]   {
if USE=32
 !D !D4, a
else
 !D !D8, a
end if
}

NUMBER.P fix VOID
TEXT.P   fix VOID
IMAGE.P  fix VOID

WORD     fix WBYTE
DWORD    fix NUMBER
BOOLEAN  fix NUMBER
HANDLE   fix VOID

;;;;;;;;;;;;;; NUMERIC CONSTANTS ;;;;;;;;;;;;;;;;;

; create a list of incremental values starting
; at 0. example: numeric A, B=7, D
; here, A=0, D=8

macro numeric [id] {
common
local n
n=0                ; n=0
forward
define ?v 0        ; initial value?
match a==b, id \{
 a=b
 n=b               ; set n
 define ?v 1
\}
if ?v=0            ; else=n (previous+1)
id=n
end if
n=n+1              ; n++
}

numeric YES=1, NO=0, NONE=-1, MAYBE=80h,\
TRUE=1, FALSE=0, NULL=0, DEFAULT=0,\
INVALID=-1, INFINITE=-1, DETECT=-1

; "enumeration" with variable

macro numerate v, [id] {
common NUMBER v
numeric id
}

; create successive powers of 2 starting
; at BIT0, from right to left

macro powers [id] {
common idn=0
forward id=1 shl idn
idn=idn+1
}

; create readable bit structure from
; left to right. example: 0000ABCDb.
; powerz A, B, C, D ; A=8, B=4, C=2, D=1

macro powerz [id] {
common idn=1
forward idn=idn+1
common idn=idn-2
forward id=1 shl idn
idn=idn-1
}

;;;;;;;;;;;;;;;; LITERAL 'TEXT' ;;;;;;;;;;;;;;;;

; create array of literal 'text' addresses
; example: TEXTA colors, 'Black', 'White'
; access: let ecx=[index], eax=[colors+ecx*4]

macro TEXTA name, [t] {
?nta=0
common
label name dword
forward local l
dd l
?nta=?nta+1
forward l db t, 0
name#.$=?nta
}

; same but align each to size

macro TEXTAA name, size, [t] {
common
?nta=0
label name dword
forward
local l
dd l
?nta=?nta+1
forward
l db t, 0
times (size-($-l)) db 0 ; align
common
name#.$=?nta
}

; HL TEXT array syntax...

; TEXTS t[]='abc', 'xyz', '123'
; TEXTS t[](4)='ann', 'kim', 'sue'

macro TEXTS [p] {
common
define ?s 0
match name[](size)==t, p \{
 TEXTAA name, size, t
 define ?s 1
\}
match =0 name[]==t, ?s p \{
 TEXTA name, t
 define ?s 1
\}
verify.syntax TEXTS
}

; same as TEXTA but with ids. example:

; MESSAGES error.messages,\
; E_NONE='None',\
; E_MEMORY='Insufficient Memory',\
; E_LOAD='Error Loading File',\
; E_VGA='Unsupported Resolution',\
; E_ETC='Etc'

macro MESSAGES name, [p] {
common ?n=0
label name dword
forward
local l
dd l
forward
match a==b, p \{
 l db b, 0
 a=?n
 ?n=?n+1
\}
common
name#.$=?n
}

macro MESSAGEZ name, i, prefix, [p] {
common
NUMBER i
?n=0
label name dword
forward
local l
dd l
forward
match a==b, p \{
 l db b, 0
 prefix\#_\#a=?n
 ?n=?n+1
\}
common
name#.$=?n
numeric prefix#_#LAST=?n
}

; create 'text' in code. r/egister='t/ext'
; WARNING: all commands that accept a literal
; 'text' parameter (.t suffix) will alter eax.
; only intended for testing and utilities

macro make.txt r, t {
if t eqtype ""
 local ..t, ..e
 jmp ..e
 ..t db t, 0
 ..e:
 mov r, ..t
else
 mov r, t
end if
}

;;;;;;;;;;;;;;;;;;;;; LET ;;;;;;;;;;;;;;;;;;;;;;;;

; perform HL assignment/s/operation/s. example:

; let esi=[source], ecx>>8, eax=&[esi+ecx*4]

; signed is the default for numbers that can
; be negative (ex, coordinates). some symbols
; are for unsigned operations (>>> is shr)

; WARNING: +/- [b+/-i] sequence will not be
; interpreted correctly. both ++/--/+-/-+ cannot
; used. replace let eax+[?image.x+edx] (has 2 ++)
; with: let ecx=[?image.x+edx], eax+ecx

macro let [p] {
forward
define ?s 0

; a=&[b], lea r, [b]

match =0 a==&b, ?s p \{
 lea a, b
 define ?s 1
\}

; a=>[b], movsx r, byte [b]

match =0 a==>b, ?s p \{
 movsx a, byte b
 define ?s 1
\}

; a=b, mov or push/pop or xor

match =0 a==b, ?s p \{
 if a eqtype [] & b eqtype [] ; m=m
  push dword b
  pop dword a
 else
  if b eq 0 & \
   a in <eax,ecx,edx,ebx,esi,edi>
    xor a, a
  else
   mov a, b
  end if
 end if
 define ?s 1
\}

; increment/decrement

match =0 a--, ?s p \{
 dec a
 define ?s 1
\}

match =0 a++, ?s p \{
 inc a
 define ?s 1
\}

; add/subtract

match =0 a-b, ?s p \{
 if b eq 1
  dec a
 else
  sub a, b
 end if
 define ?s 1
\}

match =0 a+b, ?s p \{
 if b eq 1
  inc a
 else
  add a, b
 end if
 define ?s 1
\}

; multiply/divide

match =0 a*b, ?s p \{
imul a, b
define ?s 1
\}

; for idiv, only eax/n is allowed
; n must be m/ecx, not i. alters edx
; example: eax=n/123 may be written
; as - let eax=n, ecx=123, eax/ecx -
; instead of 4 separate lines

match =0 =eax/n, ?s p \{
cdq
idiv n
define ?s 1
\}

; shifts

match =0 a>>>b, ?s p \{ shr a, b
define ?s 1 \}
match =0 a<<b, ?s p \{ sal a, b
define ?s 1 \}
match =0 a>>b, ?s p \{ sar a, b
define ?s 1 \}

; binary and/or

match =0 a&b, ?s p \{ and a, b
define ?s 1 \}
match =0 a|b, ?s p \{ or a, b
define ?s 1 \}

; neg/not unary prefixes

match =0 =neg a, ?s p \{
 neg a
 define ?s 1
\}

match =0 =not a, ?s p \{
 not a
 define ?s 1
\}

verify.syntax .let
}

; set/end hl block

macro set.hl.block c { HL.BLOCK=c }

macro end.hl.block c {
if HL.BLOCK=c
  HL.BLOCK=0
else
 'end/x unexpected'
end if
}

numeric IF.BLOCK, ELSE.BLOCK,\
LOOP.BLOCK

macro ?list.attach list, item {
match any, list \{ list equ list, item \}
match , list \{ list equ item \}
}

;;;;;;;;;;;;;;; FASM'S STRUCT.INC ;;;;;;;;;;;;;;;;

; an edited version of \MACRO\STRUCT.INC designed
; for Z77 HL variables

; NOTE: VARIABLE.INC>BLOCK can define/reserve
; any byte array so it replaces rb/rw/etc

macro struct name {
virtual at 0
fields@struct equ name
match child parent, name \{
fields@struct equ child,fields@\#parent \}
sub@struct equ
macro define.field.member type \{
struc type [val] \\{ \\common
define field@struct .,type,<val>
fields@struct equ fields@struct,field@struct \\}
\}
macro define.field.macro type \{
macro type [val] \\{ \\common \\local anonymous
define field@struct anonymous,type,<val>
fields@struct equ fields@struct,field@struct \\}
\}
define.field.member db
define.field.member dw
define.field.member dd
define.field.macro db
define.field.macro dw
define.field.macro dd
macro struct \{
fields@struct equ fields@struct,,substruct,<
sub@struct equ substruct
\}
}

macro ends {
match , sub@struct \{
restruc db,dw,dd
purge db,dw,dd
purge struct
match name tail,fields@struct, \\{
 if $
  'Error: Invalid member'
 end if
\\}
match name=,fields,fields@struct \\{
fields@struct equ
make@struct name,fields
define fields@\\#name fields \\}
end virtual \}
match any, sub@struct \{
fields@struct equ fields@struct> \}
restore sub@struct
}

macro make@struct name,[field,type,def] {
common
local define
define equ name
forward
local sub
match , field \{
make@substruct type,name,sub def
define equ define,.,sub, \}
match any, field \{
define equ define,.#field,type,<def> \}
common
match fields, define \{ define@struct fields \}
}

macro define@struct name,[field,type,def] {
common
local list
list equ
forward
if ~ field eq .
name#field type def
sizeof.#name#field=$-name#field
else
label name#.#type
rb sizeof.#type
end if
local value
match any, list \{ list equ list, \}
list equ list <value>
common
sizeof.#name = $
restruc name
match values, list \{
struc name value \\{ \\local \\..base
match any, fields@struct \\\{
fields@struct equ fields@struct,.,name,<values> \\\}
match , fields@struct \\\{ label \\..base
forward
match , value \\\\{ field type def \\\\}
match any, value \\\\{ field type value
if ~ field eq .
 rb sizeof.#name#field - ($-field)
end if \\\\}
common label . at \\..base \\\}
\\}
macro name value \\{
match any, fields@struct \\\{ \\\local anonymous
fields@struct equ fields@struct,anonymous,name,<values> \\\}
match , fields@struct \\\{
forward
match , value \\\\{ type def \\\\}
match any, value \\\\{ \\\\local ..field
..field = $
type value
if ~ field eq .
 rb sizeof.#name#field - ($-..field)
end if \\\\}
common \\\} \\} \}
}

macro enable@substruct {
macro make@substruct substruct,\
parent,name,[field,type,def] \{
\common
\local define
define equ parent,name
\forward
\local sub
match , field \\{ match any, type \\\{ enable@substruct
make@substruct type,parent,sub def
purge make@substruct
define equ define,.,sub, \\\} \\}
 match any, field \\{ define equ define,.\#field,type,<def> \\}
\common
 match fields, define \\{ define@\#substruct fields \\} \}
}

enable@substruct

macro define@substruct parent,name,[field,type,def] {
common
virtual at parent#.#name
forward
if ~ field eq .
parent#field type def
sizeof.#parent#field = $ - parent#field
else
label parent#.#type
rb sizeof.#type
end if
common
sizeof.#name = $ - parent#.#name
end virtual
struc name value \{
label .\#name
forward
match , value \\{ field type def \\}
match any, value \\{ field type value
if ~ field eq .
 rb sizeof.#parent#field - ($-field)
end if \\}
common \}
macro name value \{
\local ..anonymous
..anonymous name \}
}

; $$$$$$$$$$$$$$ Z77 ASM LIBRARY $$$$$$$$$$$$$$$$$
; ************** SUNGOD SOFTWARE *****************
; ??????????????? STRUCTURE.INC ??????????????????

macro STRUCTURE type {
?TYPE equ type
struct _#type
macro type [names] \{  ; IMAGE a, b, c
 forward
 names _\#type
 common
\}
type#.$=sizeof._#type
}

macro TYPE [p] {                      
common
match name==members, p \{
 STRUCTURE name
  members
 ends
\}                                    
}

macro INHERIT [s] { forward s#.X }

macro ASSUME [p] {
match name==type, p \{                
 virtual at 0
  type name
 end virtual
\}                                    
}

macro ENDS name {
ends
if ~p eq
 ASSUME name=?TYPE
end if
}

structure fix STRUCTURE ; optional

; $$$$$$$$$$$$$$ Z77 ASM LIBRARY $$$$$$$$$$$$$$$$$
; ************** SUNGOD SOFTWARE *****************
; ??????????????? FUNCTION.INC ???????????????????

; push parameters forwards or backwards

macro pushf [p] { ; push parameters forward
common if ~p eq
forward pushd p
common end if
}

macro pushr [p] { ; push parameters backwards
common            ; to access forwards
if ~p eq
 reverse
 if p eq
  'Invalid # of parameter/s'
 end if
 pushd p
common
end if
}

; call a/ddress direct or p/ointer indirect

macro calla a, [p] {
common pushr p
call a
}

macro callp c, [p] { common calla [c], p }

; call "variadic" procedure with "variable
; arguments" (...). push invisible # arguments
; last, call, then adjust esp after

macro callv c, [p] {
common ?n=0
reverse pushd p
?n=?n+1
common push ?n
call c
add esp, (?n+1)*4
}

; call "interface"

macro callx c, x, [p] {
common
pushr p            ; push parameters
mov eax, [c]
push eax           ; push class address
mov eax, [eax]
call dword [eax+x] ; call c+m
}

; call function pointer if non-zero

macro callfp f {
cmp dword [f], 0
jz @f
calla dword [f]
@@:
}

; call function if defined

macro ?call name, [p] {
common
if defined name
 calla name, p
end if
}

; call function then get return. example:

; get [n]=text.n [t]
; get [c]=rgb 128, 0, 64

macro get [p] {
common
define ?s 0
match v==f, p \{
 f
 mov v, eax
 define ?s 1
\}
match =0 v==f ps, ?s p \{
 f ps
 mov v, eax
\}
}

; call function then jmp to return
; if it returns 0. example:

; try open my.file
; try [p]=allocate 4*KB

macro try [p] {
common
define ?s 0
match a==b, p \{
 b
 mov a, eax
 define ?s 1
\}
if ?s eq 0
 common p
end if
fail .! ; endf
}

;;;;;;;;;;;;;; FUNCTION/PROCEDURE ;;;;;;;;;;;;;;;

macro DEBUG { ?DEBUG?: }
macro if.debug { if defined ?DEBUG? }

; create "function/proc/edure"

macro function name, [p] {
common

; if debug, insert function name to view
; as a "string" in PE Explorer

if.debug
@@: db `name, 0
end if

; only insert this inside of the executable
; if it was accessed somewhere

if used !#name
!#name: ; real function !name

; macro to call with no prefix: calla,
; "stdcall". example: f a, b, c

macro name p \{
pushr p
call !#name
\}

!#name.$type='c'
?begin equ !#name
?parameters equ p
..n.parameters=0
..n.locals=0
..locals.size=0

; create parameter names and offsets

if ~ p eq          ; if parameters
 virtual at ebp+8
 forward
 local ..p
 ..p dd ?          ; (ebp++i*4
 p equ ..p
 ..n.parameters=\
 ..n.parameters+1
 common
 end virtual
 push ebp          ; create stack frame
 mov ebp, esp
end if
; ...
}

; HL return statement. use this instead of
; ret/n in HL commands. no ret/urn before endf.
; it inserts one automatically

macro return v {
if ~v eq               ; value?
 mov eax, v
end if
if ..n.parameters<>0   ; if parameters
 mov esp, ebp
 pop ebp
 ret ..n.parameters*4 ; ret n
else if ..n.locals<>0  ; if locals
 mov esp, ebp
 pop ebp
 ret
else
 ret
end if
}

; exit function; an effecient "return"
; that jmps to endf without repeating
; epilogue sequence (use this if there
; are locals/parameters and registers
; to preserve)

macro escape v {
if ~v eq         ; value?
 mov eax, v
end if
jmp .!
}

; end function

macro endf {
.!:
return
.$=$-?begin               ; total size
if ..n.parameters<>0      ; if parameters
 match p, ?parameters
 \{ restore p, ?begin \}
end if
if ..n.locals<>0          ; if locals
 match l, local.names
 \{ restore l \}
end if

; end "if used name" at very beginning
; of function

end if
}

; locals ... - create local 32BIT variables.
; example: locals x, y, n, c

macro locals [p] {
common local.names equ p
forward ..n.locals=..n.locals+1
common ..locals.size=..n.locals*4
virtual at ebp-..locals.size
forward
local ..l
..l dd ?
p equ ..l
common
end virtual
if ..n.parameters=0    ; create stack frame?
 push ebp
 mov ebp, esp
end if
sub esp, ..locals.size ; allocate locals
}

;;;;;;;;;;;;;;;;;; TESTING... ;;;;;;;;;;;;;;;;;;;;

; create locals of specified sizes or 32BIT.
; example:

; locale x, y, username(32), filename(256),\
; image(IMAGE.$), etc

macro locale [p] {
common
..locals.size=0
forward                ; get names and sizes
define ?s 0
match name(size), p \{ ; size specified
 ?list.attach local.names, name
 verify.size size
 ..locals.size=..locals.size+size
 define ?s 1
\}
match =0 name, ?s p \{  ; default 32BIT
 ?list.attach local.names, name
 ..locals.size=..locals.size+4
 define ?s 1
\}
..n.locals=..n.locals+1
common
virtual at ebp-..locals.size ; get offsets
forward
local ..l
define ?s 0
match name(size), p \{
 ..l dd (size/4) dup(?)
 name equ ..l
 define ?s 1
\}
match =0 name, ?s p \{ ; default 32BIT
 ..l dd ?
 name equ ..l
 define ?s 1
\}
common
end virtual
if ..n.parameters=0    ; create stack frame?
 push ebp
 mov ebp, esp
end if
sub esp, ..locals.size ; allocate locals
}

; create locals of size

macro localss size, [p] {
common local.names equ p
if ..n.parameters=0 \
 & ..n.locals=0
 push ebp
 mov ebp, esp
end if
forward ..n.locals=..n.locals+1
common ..locals.size=..n.locals*size
virtual at ebp-..locals.size
forward
local ..l
..l: db size dup(0)
p equ ..l
common
end virtual
sub esp, ..locals.size
}

macro localt [p] { common localss 1*KB, p }
macro localst [p] { common localss 256, p }

; load structure members to locals of the
; same name. example:
; get.s eax, ?box, box, x, y, w, h -
; loads box.x/y/w/h to local x/y/w/h using eax
; as a base register and it produces 4 lines
; (# parameters in [v])

macro get.s r, vs, s, [v] {
common let r=[s]
forward let [v]=[vs#.#v+r]
}

; $$$$$$$$$$$$$$$ Z77 ASM LIBRARY $$$$$$$$$$$$$$$$
; *************** SUNGOD SOFTWARE ****************
; ??????????????????? IF.INC ?????????????????????

true equ eax
false equ not eax
result equ eax
?NOT equ 0
?use.r equ 0

; jump if condition to l (or ?NOT if 1)

macro .jif l, [c] {
common
local s
define s 0
macro J O,A,C,B, [X] \{
match =0 X, s c \\{
 if ?use.r eq 0
  O A, B        ; opcode o1, o2
 else
  mov ?use.r, A
  O ?use.r, B
 end if
 if ?NOT eq 0
  j\#C l
 else
  jN\#C l
 end if
 define s 1
\\}
\}
J cmp,a,LE,b, a<==b    ; a<=b
J cmp,a,GE,b, a>==b    ; a>=b
J cmp,a,L,b, a<b       ; a<b
J cmp,a,G,b, a>b       ; a>b
J cmp,a,E,b, a==b      ; a=b
J cmp,a,NE,b, a =not b ; a not b (unequal)
J test,a,NE,b, a&b     ; a&b
J or,a,NE,b, a|b       ; a|b
J cmp,a,E,0, =not a    ; not a (=0)
J cmp,a,NE,0, a        ; a (not 0)
if s eq 0
 'Invalid expression'
end if
purge J
?use.r equ 0           ; only once
}

; jump if NOT condition to l

macro .jifn l, [c] {
common
?NOT equ 1
.jif l, c
?NOT equ 0 ; restore default
}

; HL IF/ELSE

macro .if.begin {
local ..start, ..else, ..end
?IF equ
?START equ ..start
?ELSE equ ..else
?END equ ..end
?START:
}

macro .if [c] {
common
.if.begin
.jifn ?ELSE, c ; if false, jmp to end
}

macro .if.n [c] {
common
.if.begin
.jif ?ELSE, c
}

macro .else {
jmp ?END
?ELSE:
restore ?IF
?IF equ ,
}

macro .else.if [c] {
common
jmp ?END
?ELSE:
restore ?ELSE
local ..else
?ELSE equ ..else
.jifn ?ELSE, c
}

macro .end {
if ?IF eq
 ?ELSE:
end if
?END:
restore ?IF, ?START, ?ELSE, ?END
}

; call function with parameters then
; .if non/zero

macro !if c, [p] {
common c p
.if eax
}

macro !if.n c, [p] {
common c p
.if not eax
}

jNE equ jne
jNNE equ je
jNG equ jng
jNL equ jnl

macro jif r, c, l {
test r, r
j#c l
}

macro success l { jif eax, nz, l }

macro fail l { jif eax, z, l }

macro failn l {
cmp eax, -1
je .r
}

failnz fix success

; $$$$$$$$$$$$$$$ Z77 ASM LIBRARY $$$$$$$$$$$$$$$$
; *************** SUNGOD SOFTWARE ****************
; ?????????????????? LOOP.INC ????????????????????

; .while a<b
; .endw

; .until a=b
; .endu

; .loop i=x to n
; .endl

; .for i=n, i>0, i-- ; assign, compare, operate
; .endf

; WARNING: .loop/.for alters ECX on entry/exit to
; support cmp memory operands. .while/.until do
; not alter any registers

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

macro .while [c] {
common
local ..next, ..out
?NEXT equ ..next
?OUT equ ..out
.if c
  ; ...
}

macro .endw {
  ?NEXT:
  jmp ?START
.end
?OUT:
restore ?NEXT, ?OUT
}

macro .until [c] {
common
?NOT equ 1
.while c
?NOT equ 0
}

.endu fix .endw

; .for let a, .while b, let c

macro .for [p] {
common
local ..nextf
?NEXT equ ..nextf
?FOR equ
define ?s 0

match a=,b=,c, p \{
let a
?use.r equ ecx
.while b            ; {
  ?FOR equ c
  define ?s 1
\}
verify.syntax .for
}

macro .endf {
  let ?FOR
.endw               ; }
}

; .loop [i]=0 to [n]

macro .loop [c] {
common
local ..start, ..end
?START equ ..start
?END equ ..end
define ?s 0
match =0 i==x =to n, ?s c \{
 define ?s 1
 ?INDEX equ i
 push x
 pop i
 ?START:
 mov ecx, i
 cmp ecx, n
 jge ?END
\}
verify.syntax .loop
}

macro .endl {
inc ?INDEX    ; i++
jmp ?START    ; continue
?END:
restore ?START, ?END, ?INDEX
}

; optional let operator . nothing else
; can be named .

. fix let
    

; $$$$$$$$$$$$$$ Z77 ASM LIBRARY $$$$$$$$$$$$$$$$$
; ************** SUNGOD SOFTWARE *****************
; ????????????????? IMPORT.INC ???????????????????

; RVAs of dll names and tables, ending with 20
; zero bytes

macro library [names] {
forward dd 0,0,0, RVA names#_name, RVA names#_table
common dd 0,0,0,0,0
}

; DLL name + import RVA table. each table ends with 0.
; finally, import names. dw 0 is "ordinal" (N/A)

macro import name, [names] {
common
name#_name \            ; TEXT DLL_name='DLL.DLL'
db `name#'.DLL', 0
name#_table:            ; DLL_table:
forward
if used !#names
 !#names dd RVA _#names ; import name RVAs
 macro names [p] \{     ; call with no
  \common               ; invoke prefix
  pushr p
  call [!#names]
 \}
end if
common dd 0             ; end
forward
if used !#names
_#names dw 0            ; import names
db `names, 0            ; 'import'
end if
}
    

; $$$$$$$$$$$$$$ Z77 ASM LIBRARY $$$$$$$$$$$$$$$$$
; ************** SUNGOD SOFTWARE *****************
; ????????????????? ARRAY.INC ????????????????????

; array.create &a, s, n   ; s/ize, # indices
; array.size &a, n        ; allocate n # indices
; array.destroy &a        ; deallocate a.p
; array.expand &a         ; allocate n+1
; array.reduce &a         ; allocate n-1
; array.zero &a, i        ; zero element at i/ndex
; array.erase &a          ; zero entire array
; array.index &a, i       ; return element address
; array.insert &a, i, &p  ; insert a[i]=p
; array.attach &a, &p     ; attach to end: a[n-1]
; array.remove &a, i      ; remove a[i]
; array.replace &a, i, &p ; overwrite a[i]=p
; array.shift &a, i, d    ; shift indices 'l'/'r'
; array.exchange...       ; see definitions...
; array.sort &a, !fp
; array.randomize &a
; array.encrypt &a, $p
; array.decrypt &a, $p

macro \
ARRAY.X \   ; define dynamic array structure
name, s {
if ~s eq    ; name is optional
name:
end if
.p dd 0     ; pointer. one contiguous block
.n dd 0     ; # indices
.s dd s     ; element size
.i dd 0     ; id/type/index. example: ID_IMAGE
if.debug    ; if DEBUG was written somewhere
.name: \    ; store its name after
db `name, 0
end if
}

; HL syntax: ARRAY images(IMAGE.$), files(1*KB),\
; my.fonts(FONT.$), text.lines(2*KB), etc

macro ARRAY [p] {
forward
define ?s 0
match name(s), p \{
 verify.size s
 ARRAY.X name, s
 define ?s 1
\}
if ?s eq 0
 'Invalid array syntax'
end if
common
}

ASSUME ?array(1)=ARRAY ; virtual offsets

macro ARRAYS name { ; create inside structure
VOID name#.p
NUMBER name#.n, name#.s, name#.i
}

; BEGIN: P
; END: P+(N*S)
; INDEX: P+(I*S)
; LAST INDEX: P+(N*S)-S or P+((N-1)*S)

; HL array index. parameter is [m]

; @index images[i]
; @index [p]=fonts[i]

macro @index p {
common
define ?s 0
match v==a i, p \{      ; no comma between a,[i]
 get v=array.index a, i
 define ?s 1
\}
match =0 a i, ?s p \{
 array.index a, i
 define ?s 1
\}
if ?s eq
 'Syntax error'
end if
}

macro @create a, s, n { array.create a, s, n }
macro @expand a { array.expand a }

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

; index array: &a[i] ([scale*index+base]).
; return element address. if DEBUG was written
; somewhere on a line by itself, this will verify
; that index is within boundaries. otherwise,
; it just produces mul+add with no check.
; "calla !name" is for forward references,
; print/log/etc have not been defined yet

TEXT invalid.index.t='Invalid array index: %t[%n]'

function array.index, a, i
let eax=[i], ecx=[a]
if.debug
  cmp eax, [?array.n+ecx]
  jb .ok
  let edx=&[?array.name+ecx]
  callv !print, [?t], invalid.index.t, edx, eax
  calla !erase.log
  calla !log, [?t]
  calla !execute, log.file
  calla !exit
  escape
  .ok:
end if
mul dword [?array.s+ecx]
add eax, [?array.p+ecx]
endf

; get most recent index: n-1

function array.last, a
let ecx=[a], eax=[?array.n+ecx], eax--
mul dword [?array.s+ecx]
add eax, [?array.p+ecx]
endf

array.recent fix array.last

; zero element at i/ndex

function array.zero, a, i
array.index [a], [i]
let edx=[a]
memory.set eax, 0, [?array.s+edx]
endf

; zero entire array

function array.erase, a
locals i, n
let eax=[a], [n]=[?array.n+eax]
.loop [i]=0 to [n]
  array.zero [a], [i]
.endl
endf

; allocate # indices. a.s must be set first

function array.size, a, n
locals p, size, s
let eax=[a],\
[p]=[?array.p+eax],\           ; p=array.p
edx=[?array.s+eax], [s]=edx,\  ; s=array.s
ecx=[n], [?array.n+eax]=ecx,\  ; array.n=n
ecx*edx, [size]=ecx            ; size=n*s
try allocate.x [p], [size]
let edx=[a],\                  ; return last
[?array.p+edx]=eax,\           ; p+size-s
eax+[size], eax-[?array.s+edx]
endf

; create array

function array.create, a, s, n
let eax=[a], [?array.s+eax]=[s],\
dword [?array.i+eax]=0
array.size [a], [n]
endf

; deallocate array.p

function array.destroy, a
let eax=[a]
destroy [?array.p+eax]
endf

; size array.n+1, allocate element at end

function array.expand, a
let eax=[a], ecx=[?array.n+eax], ecx++
array.size eax, ecx
endf

; size array.n-1, deallocate element at end

function array.reduce, a
let eax=[a], ecx=[?array.n+eax], ecx--
array.size eax, ecx
endf

; replace element at i/ndex with p

function array.replace, a, i, p
array.index [a], [i]
let ecx=[a], ecx=[?array.s+ecx]
memory.copy eax, [p], ecx
endf

; copy element to p

function array.copy, a, i, p
array.index [a], [i]
let ecx=[a], ecx=[?array.s+ecx]
memory.copy [p], eax, ecx
endf

; allocate new element at end then copy

function array.attach, a, p
try array.expand [a]
let edx=[a]
memory.copy eax, [p], [?array.s+edx]
endf

; create/copy literal text array

function array.get.t, a, t, n
locals i, p
array.size [a], [n]
array.erase [a]
.loop [i]=0 to [n]
  try [p]=array.index [a], [i]
  let edx=[t], ecx=[i]
  calla !text.copy, [p], [edx+ecx*4]
.endl
endf

array.create.t fix array.get.t

; shift indices from i-a.n once left or right.
; i=0 to shift all. d/irection='l'/'r'

function array.shift, a, i, d
locals index, s, p
cmp [d], 'r'
je .right
.left:                    ; loop index=i+1 to n
let ecx=[i], ecx++,\
[index]=ecx
@@:
let eax=[a],\
ecx=[?array.n+eax]        ; index>=n?
cmp [index], ecx
jae .ret
let ecx=[index], ecx-1
array.index [a], ecx      ; destiny=a[i-1]
let [p]=eax
array.index [a], [index]  ; source=a[i]
let [s]=eax, eax=[a],\
ecx=[?array.s+eax]
memory.copy [p], [s], ecx
inc [index]
jmp @b
.right:                   ; loopr index=n-1 to i
let eax=[a],\
ecx=[?array.n+eax],\
ecx-1, [index]=ecx
@@:
let ecx=[i]
cmp [index], ecx          ; index<=0?
jb .r
array.index [a], [index]  ; destiny=a[i]
let [p]=eax,\
ecx=[index], ecx-1
array.index [a], ecx      ; source=a[i-1]
let [s]=eax, eax=[a],\
ecx=[?array.s+eax]
memory.copy [p], [s], ecx
dec [index]
jmp @b
endf

; insert element at arbitrary index.
; use .attach for end

function array.insert, a, i, p
array.expand [a]
array.shift [a], [i], 'r'
array.replace [a], [i], [p]
endf

; remove index. use .reduce for end

function array.remove, a, i
let eax=[a], ecx=[?array.n+eax]
cmp [i], ecx
jae .!
array.shift [a], [i], 'l'
array.reduce [a]
endf

; exchange indices i and j using b as a
; temporary buffer (must be element size)

function array.exchange, a, i, j, b
locals n, s, p
let ecx=[a],\
ecx=[?array.s+ecx], [n]=ecx
get [p]=array.index [a], [i]
memory.copy [b], eax, [n]    ; tmp=a[i]
get [s]=array.index [a], [j] ; a[i]=a[j]
memory.copy [p], eax, [n]
memory.copy [s], [b], [n]    ; a[j]=tmp
endf

; sort array in ascending or descending
; order (as='a'/'d'). fp=function pointer
; to: !compare(&a, &b). returns <0>

function array.sort, a, fp, as
locals i, x, s, p, n
let eax=[a],\
[s]=[?array.s+eax],\
[n]=[?array.n+eax],\
[n]-1
get [p]=allocate [s]   ; allocate buffer
fail .r                ; once before loop
.loop [i]=0 to [n]
  let [x]=0
  .compare:            ; loop x=0 to n-i
  let eax=[n], eax-[i]
  cmp [x], eax
  jae .el
  array.index [a], [x] ; compare a[x], a[x+1]
  let ecx=eax, ecx+[s]
  callp fp, eax, ecx
  .if [as] not 'd'     ; ascending? default
    .if eax>0
      jmp .exchange
    .end
  .else                ; descending
    .if eax<0
      jmp .exchange
    .end
  .end
  jmp .next
  .exchange:
  let eax=[x], eax+1
  array.exchange [a], [x], eax, [p]
  .next:
    inc [x]
    jmp .compare
  .el:
.endl
@@:
destroy [p]
let eax=1
endf

; sort number array numerically. as='a'/'d'

macro array.sort.n a, as
{ array.sort a, !n.compare, as }

function n.compare, a, b
let eax=[a], edx=[b], eax=[eax], eax-[edx]
endf

; sort text array alphabetically

macro array.sort.t a, as
{ array.sort a, !text.compare, as }

; sort array of structures based on .member
; value, .n/umber or .t/ext

align 4
NUMBER ?s.m ; virtual .offset

macro array.sorts.n a, m, as {
let [?s.m]=m
array.sort a, !s.n.compare, as
}

macro array.sorts.t a, m, as {
let [?s.m]=m
array.sort a, !s.t.compare, as
}

function s.n.compare, a, b
let eax=[a], edx=[b], ecx=[?s.m],\
eax=[eax+ecx], edx=[edx+ecx], eax-edx
endf

function s.t.compare, a, b
let eax=[a], edx=[b], ecx=[?s.m],\
eax=&[eax+ecx], edx=&[edx+ecx]
calla !text.compare, eax, edx
endf

; shuffle all array indices in a unique
; fashion with no duplicates

function array.randomize, a
locals i, j, n, s, max, p
let eax=[a], [s]=[?array.s+eax],\
[n]=[?array.n+eax], ecx=[n],\
ecx-1, [max]=ecx
get [p]=allocate [s]
fail .r
.loop [i]=0 to [n]
  get [j]=random [max]
  array.exchange [a], [i], [j], [p]
.endl
destroy [p]
endf

; encrypt or decrypt array with password.
; see CRYPT.INC

macro array.encrypt a, password
{ array.crypt a, 1, password }

macro array.decrypt a, password
{ array.crypt a, 0, password }

function array.crypt, a, e, password
locals i, n, s, p
let eax=[a], [s]=[?array.s+eax],\
[n]=[?array.n+eax]
.loop [i]=0 to [n]
  get [p]=array.index [a], [i]
  .if [e]
    encrypt [p], [s], [password]
  .else
    decrypt [p], [s], [password]
  .end
.endl
endf

; to load/save array, see FILE.INC
    

; $$$$$$$$$$$$$$ Z77 ASM LIBRARY $$$$$$$$$$$$$$$$$
; ************** SUNGOD SOFTWARE *****************
; ????????????????? TEXT.INC ?????????????????????

; set.case c        ; set case sensitivity
; text.n t          ; get # characters (size-1)
; text.write a, b   ; copy but no 0 after
; text.write.x...   ; write starting at i/ndex
; text.copy a, b    ; standard copy with 0 after
; text.copy.n...    ; copy with maximum size
; text.attach a, b  ; attach b to a; "concencate"
; text.attach.c...  ; attach character
; text.attach.n...  ; attach number with alignment
; text.equal a, b   ; equal? return 0 if not
; text.equal.c t, c ; equals character?
; text.compare a, b ; compare alphabetic. return <0>
; text.search a, b  ; search for text. return &/0
; text.find t, c    ; search for character. return &/0
; text.find.last... ; search for c reverse
; text.count.c t, c ; count # c characters
; text.find.p t, c  ; find previous occurance before t
; text.begins a, b  ; begins with b?
; text.ends a, b    ; ends with b?
; text.lower t      ; convert to lowercase
; text.upper t      ; convert to uppercase
; text.reverse t    ; reverse
; text.expand t, n  ; expand; shift right at t
; text.expand.x...  ; expand at index
; text.prefix t, s  ; expand then insert prefix
; text.insert...    ; insert text at index
; text.insert.c...  ; insert character
; text.delete.c...  ; delete c at index
; text.delete t, n  ; delete # characters at t
; text.delete.x...  ; delete # characters at index
; text.enclose...   ; enclose with 'c' 'c'
; text.align...     ; align. example: '0000FFh'
; text.limit...     ; end with '...'

; text.array.equal... ; see definitions
; text.array.search...

; set.base b ; set conversion mode: 'd', 'h', 'b'
; n2t n, $t  ; convert 32BIT number to text
; t2n $t     ; convert text to 32BIT number

; convert.n2t n, $t, b ; see definitions
; convert.t2n $t, b
; ns2t n, $t

; print t, f, ... ; print formatted text

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

; IT - 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 multiple false comparisons per character:
; if ((a>='a'&a<='z')&(b>='a'&b<='z')) |
; ((a>='A'&a<='Z')&(b>='Z'&b<='Z'))

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

IT db \ ; BYTE IT[128]=
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
TT db \ ; BYTE TT[128]=
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

; is c of type?

macro .if.is c, t {
let ecx=c, ecx&0FFh,\
eax=>[TT+ecx], eax&C_#t
.if true
}

; is cl character type?

macro .if.c c { .if byte [TT+ecx]&C_##c }
macro .if.not.c c { .if.n byte [TT+ecx]&C_##c }
macro .else.if.c c { .else.if byte [TT+ecx]&C_##c }

macro .if.text.equal a, b { !if text.equal, a, b }
macro .if.not.text.equal a, b { !if.n text.equal, a, b }
macro .if.text.find a, b { !if text.find, a, b }
macro .if.text.find.last a, b { !if text.find.last, a, b }
macro .if.text.search a, b { !if text.search, a, b }
macro .if.not.text.search a, b { !if.n text.search, a, b }

C_TEXT=27h
R equ ,0Dh,0Ah,
NL db 0Dh, 0Ah, 0
NO.TEXT db '0', 0

; alternative C names

strlen fix text.n
strcpy fix text.copy
strcmp fix text.compare
strcat fix text.attach
strchr fix text.find
strstr fix text.search

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

; set case sensitivity. c=-1 to export case
; and c table addresses

align 4
NUMBER CASE=YES ; sensitive by default

function set.case, c
let eax=[CASE]
.if [c]=-1
  let edx=IT, ecx=TT
.else
  let [CASE]=[c]
.end
endf

; get # characters

function text.n, t
let eax=[t]
.while byte [eax]
  let eax++
.endw
let eax-[t]
endf

; copy a=b with no 0 after

function text.write, a, b
let eax=[a], edx=[b]
.while byte [edx]
  let cl=[edx], [eax]=cl,\
  eax++, edx++
.endw
endf

; write starting at index. no 0 after

function text.write.x, a, b, i
let eax=[a], eax+[i]
text.write eax, [b]
endf

; standard copy with 0. return advanced &

function text.copy, a, b
let eax=[a], edx=[b]
.while byte [edx]
  let cl=[edx], [eax]=cl,\
  eax++, edx++
.endw
let byte [eax]=0
endf

; copy with maximum size specified

function text.copy.n, a, b, n
text.n [b]
inc eax
.if eax<=[n]
  text.copy [a], [b]
.else
  let eax=[a], edx=[b], [n]--
  @@:
   let cl=[edx], [eax]=cl,\
    eax++, edx++, [n]--
  jnz @b
  let byte [eax]=0
.end
endf

; attach b to a. return advanced &

function text.attach, a, b
text.n [a]
let eax+[a]
text.copy eax, [b]
endf

function text.attach.c, t, c
text.n [t]
let eax+[t], ecx=>[c],\
 byte [eax]=cl, byte [eax+1]=0
endf

; attach number with optional alignment or 0

function text.attach.n, t, n, a
locale p, b(256)
let eax=&[b], [p]=eax
calla !n2t, [n], [p]
.if [a]
  calla !text.align, [p], '0', [a]
.end
calla !text.attach, [t], [p]
endf

; equal? return 0 if not

function text.equal, a, b
push esi edi
let eax=[a],\
edx=[b]
.if [CASE]         ; sensitive
  @@:
   let \
   cl=[eax],\
   ch=[edx],\
   eax++, edx++
   cmp cl, ch      ; while *a++=*b++
   jne .r0
   or cl, ch       ; and both nonzero
  jnz @b
  or cl, ch        ; both must=0 at end
  jnz .r0
  jmp .e
.else              ; insensitive
  @@:
   let \
    esi=>[eax],\
    edi=>[edx],\
    cl=[IT+esi],\
    ch=[IT+edi],\
    eax++, edx++
   cmp cl, ch      ; while it[*a++]=it[*b++]
   jne .r0
   or esi, edi     ; and both nonzero
  jnz @b
  or esi, edi      ; both must=0 at end
  jz .e
.end
.r0: let eax=0
.e: pop edi esi
endf

; 'text' equals 'c'haracter?

function text.equal.c, t, c
let eax=[t], ecx=>[c]
cmp byte [eax], cl
jne .r0
let eax++, cl=[eax]
test cl, cl
jz .!
.r0: let eax=0
endf

; lexical comparison. return <0>

function text.compare, a, b
let eax=[a], edx=[b]
@@:
 let cl=[eax],\
  ch=[edx],\
  eax++, edx++
 cmp cl, ch     ; while equal
 jne @f
 or cl, ch      ; and both nonzero
jnz @b
@@:
 sub cl, ch     ; return *a-*b
 movsx eax, cl
endf

; search for character. return &/0

function text.find, t, c
let eax=[t], edx=[c]
@@:
 let cl=[eax]
 cmp cl, dl   ; if *t=c
 je .!        ; return address
 inc eax
 test cl, cl  ; while *t++ not 0
jnz @b
let eax=0
endf

; search for c reverse

function text.find.last, t, c
locals p
let [p]=[t]
text.n [t]      ; start at end-1
let eax+[t],\
 eax-1, edx=[c]
@@:
let cl=[eax]
 test cl, cl
 jz .r0
 cmp [p], eax   ; beginning?
 je .r0
 cmp cl, dl     ; found
 je .!
 dec eax
jmp @b
.r0: let eax=NO
endf

; count # of characters in text

function text.count.c, t, c
locals p, n
let [p]=[t], [n]=0
@@:
get [p]=text.find [p], [c]
.if true
  let [p]++, [n]++
  jmp @b
.end
let eax=[n]
endf

; find previous occurance of c before t

function text.find.p, t, c
let eax=[t], eax--, edx=[c]
.while byte [eax]
  let cl=[eax], eax--
  cmp cl, dl
  je .!
.endw
let eax=0
endf

; search for text. if a contains b. return
; address of first/next appearance or 0
; if none

function text.search, a, b
locals s
push ebx esi edi
let eax=[a], edx=[b]
.if [CASE]            ; sensitive
  push esi
  let esi=edx
  .sl:
   let ch=[edx]
   @@:
    let cl=[eax],\
     eax++
    test cl, cl       ; if *a=0
    jz .r0
    cmp cl, ch        ; while *a++!=*b
   jne @b
   let eax--,\        ; save start address
    [s]=eax
   @@:
    let cl=[eax],\
     ch=[edx],\
     eax++, edx++
    test ch, ch       ; if *b=0
    jz .r1
    cmp cl, ch        ; while *a++=*b++
   je @b
   @@:
    let eax--,\
    edx=esi
  jmp .sl
.else                 ; insensitive
  let ebx=edx,\
   esi=eax, edi=edx
  .il:
   let edi=>[edx],\
    ch=[IT+edi]
   @@:
    let esi=>[eax],\
     cl=[IT+esi],\
     eax++
    or esi, esi       ; if *a=0
    jz .r0
    cmp cl, ch        ; while it[*a++]!=it[*b]
   jne @b
   let eax--, [s]=eax ; save start address
   @@:
    let esi=>[eax],\
     edi=>[edx],\
      cl=[IT+esi],\
      ch=[IT+edi],\
     eax++, edx++
    test edi, edi     ; if *b=0
    jz .r1
    cmp cl, ch        ; while it[*a++]=it[*b++]
   je @b
   let eax--, edx=ebx
  jmp .il
.end
.r0: let eax=NO
 jmp @f
.r1: let eax=[s]
@@:
 pop edi esi ebx
endf

; begins with? return 0 if not

function text.begins, a, b
locals an
push esi edi
get [an]=text.n [a]
text.n [b]
cmp [an], eax       ; an<bn? can't contain
jl .r0
let eax=[a],\
edx=[b]
.if [CASE]          ; sensitive
  @@:
   let cl=[eax],\
    ch=[edx],\
    eax++, edx++
   test cl, ch      ; if either=0
   jz @f
   cmp cl, ch       ; while *a++=*b++
  je @b
  @@:               ; end
   test ch, ch      ; *b must=0
   jnz .r0
   jmp .e
.else               ; insensitive
  @@:
   let esi=>[eax],\
    edi=>[edx],\
     cl=[IT+esi],\
     ch=[IT+edi],\
    eax++, edx++
   test esi, edi    ; if either=0
   jz @f
   cmp cl, ch       ; while it[*a++]=it[*b++]
  je @b
  @@:               ; end
   test edi, edi    ; *b must=0
  jz .e
.end
.r0: let eax=0
.e: pop edi esi
endf

; ends with? return 0 if not

function text.ends, a, b
locals an, bn
get [an]=text.n [a]
get [bn]=text.n [b]
let eax=[a],\       ; eax=&(a+an-bn)
eax+[an], eax-[bn]
text.equal eax, [b] ; equal?
endf

; convert to lowercase

function text.lower, t
let eax=[t]
@@:
 let cl=[eax]
 cmp cl, 'A'
 jl .a
 cmp cl, 'Z'
 jg .a
 add byte [eax], 32
 .a:
 inc eax
 test cl, cl
jnz @b
endf

; convert to uppercase

function text.upper, t
let eax=[t]
@@:
 let cl=[eax]
 cmp cl, 'a'
 jl .a
 cmp cl, 'z'
 jg .a
 sub byte [eax], 32
 .a:
 inc eax
 test cl, cl
jnz @b
endf

; reverse text

function text.reverse, t
let eax=[t],\
 cl=[eax]       ; eax=start
test cl, cl
jz .!
text.n [t]
let edx=[t],\
 edx+eax,\
 edx--, eax=[t]
@@:             ; exchange *eax++/*edx--
 let cl=[eax],\
  ch=[edx],\
  [eax]=ch,\
  [edx]=cl,\
  eax++, edx--
 cmp eax, edx   ; while not end
jb @b
let eax=[t], eax++
endf

; expand; shift all characters right.
; example: 'abc123' becomes 'XXXabc123'
; after expand 3

function text.expand, t, n
locals tn
get [tn]=text.n [t]
let eax+[t], eax--,\
 edx=eax, eax+[n]
@@:
 let cl=[edx], [eax]=cl,\
 eax--, edx--, [tn]--
jnz @b
endf

; expand starting at index

function text.expand.x, t, i, n
let eax=[t], eax+[i]
text.expand eax, [n]
endf

; insert text at beginning

function text.prefix, a, b
text.n [b]
text.expand [a], eax
text.write [a], [b]
endf

; insert text at index

function text.insert, a, b, i
text.n [b]
text.expand.x [a], [i], eax
text.write.x [a], [b], [i]
endf

; insert character at index

function text.insert.c, t, c, i
locals n
get [n]=text.n [t]
.if [i]>=eax
  text.attach.c [t], [c]
.else
  text.expand.x [t], [i], 1
  let eax=[t], edx=eax, eax+[n],\
  eax++, byte [eax]=0, edx+[i],\
  ecx=[c], byte [edx]=cl
.end
endf

; delete character at index

function text.delete.c, t, i
let eax=[t], eax+[i],\
edx=eax, eax++
.if not byte [eax]     ; ending c
  let byte [eax-1]=0
.else                  ; beginning/middle
  text.copy edx, eax
.end
endf

; delete # characters at t. if n>=tn,
; delete all. else, shift all characters to
; the left

function text.delete, t, n
locals tn
get [tn]=text.n [t]
let eax=[t]
.if [n]>=eax
  let byte [eax]=0
.else
  let edx=eax, edx+[n]
  text.copy eax, edx
.end
let eax=[t], eax+[n]
endf

; delete # characters starting at index

function text.delete.x, t, i, n
locals tn
.if [i]=0              ; delete beginning
  text.delete [t], [n]
  escape
.end
get [tn]=text.n [t]
let ecx=[i], ecx+[n]
.if ecx>=eax           ; delete ending
  let eax=[t],\
   ecx=[i],\
   byte [eax+ecx]=0
.else                  ; delete middle
  let eax=[t],\
   edx=eax, ecx=[i],\
   eax+ecx, edx+ecx,\
   edx+[n]
  text.copy eax, edx
.end
endf

; enclose t in 'c'. insert prefix and attach
; b/egin and e/nd characters. example:
; text.enclose t, '(', ')'

function text.enclose, t, b, e
locals n
get [n]=text.n [t]
text.expand [t], 1
let eax=[t], ecx=[b], byte [eax]=cl,\
 eax=[t], eax+[n], eax++, ecx=[e],\
byte [eax]=cl, byte [eax+1]=0
endf

; prefix text with c's ('0', ' ',
; etc) or ensure maximum n. example:
; before: TEXT t='7FAB'
; text.align t, '0', 8
; after: t='00007FAB', aligned to hex32

function text.align, t, c, n
locals tn
get [tn]=text.n [t]
let ecx=[n]
.if eax=ecx          ; same size
  escape             ; do nothing
.end
.if eax>ecx          ; tn>n? exceeds maximum
  let eax=[t],\      ; end at t+n
  byte [eax+ecx]=0
  escape
.end
let ecx-eax, [n]=ecx ; n>tn? expand t
text.expand [t], ecx
let eax=[t], ecx=[n]
@@:
 let edx=>[c],\
 [eax]=dl, eax++, ecx--
jnz @b
let ecx=[tn], byte [eax+ecx]=0
endf

; end text with ... but do not exceed maximum

_dots: db '...', 0

function text.limit, t, max
locals n
get [n]=text.n [t]
let eax=[t], ecx=[max], edx=[_dots]
.if [n]<4
  jmp .copy ; only ...
.end
.if ecx<4   ; max
  let ecx=4
.end
let eax=[t], eax+ecx, eax-4
.copy: let [eax]=edx
endf

; search text array ta for t using text.equal
; and text.search. case is considered.
; return index or -1/INVALID if not found.
; ta is an array of text addresses (TEXTA)

function text.array.equal, ta, t, n
locals i
.loop [i]=0 to [n]
   let eax=[i], eax<<2, eax+[ta]
   .if.text.equal [t], [eax]
      return [i]
   .end
.endl
let eax=-1
endf

function text.array.search, ta, t, n
locals i
.loop [i]=0 to [n]
   let eax=[i], eax<<2, eax+[ta]
   .if.text.search [t], [eax]
      return [i]
   .end
.endl
let eax=-1
endf

; $$$$$$$$$$$$$$ Z77 ASM LIBRARY $$$$$$$$$$$$$$$$$
; ************** SUNGOD SOFTWARE *****************
; ???????????????? CONVERT.INC ???????????????????

; text/number conversions

; n2t n, $t  ; convert 32BIT number to text
; t2n $t     ; convert text to 32BIT number

; set.base b ; set current base

; 'n' - signed integer; default
; 'u' - unsigned decimal
; 'h' - hexadecimal
; 'b' - binary

; n2t.n/u/h/b must return advanced address (*t=0)
; for "print"

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

align 4
NUMBER BASE='n'
_hex: db '0123456789ABCDEF'

; set base for n2t/t2n. b=-1 to get current

function set.base, b
let eax=[BASE]
.if [b] not -1
  let [BASE]=[b]
.end
endf

macro get.base { set.base -1 }
set.mode fix set.base

; n2t(n, $t) - convert 32BIT number to text

function n2t, n, t
.if [n]=0           ; 0 value? most common
  let eax=[t],\
   byte [eax]='0',\
   eax++,\
   byte [eax]=0     ; convert and return
  escape
.end
let eax=[BASE],\    ; select conversion mode...
 ecx=[n], edx=[t]
test eax, eax       ; 0=default
jz .default
cmp eax, 'n'        ; signed decimal
je .default
.if eax='u'         ; unsigned decimal
  let eax=!n2t.u
.else.if eax='h'    ; hexadecimal
  let eax=!n2t.h
.else.if eax='b'    ; binary
  let eax=!n2t.b
.else
  .default:
  let eax=!n2t.n
.end
calla eax, ecx, edx
endf

; signed number to text

function n2t.n, n, t
push ebx esi edi
let eax=[n], edi=[t]
test eax, eax
jnz .sign
.zero:
 let byte [edi]='0',\
  edi+2, byte [edi]=0, eax=edi
 jmp .e
.sign:
 jns @f
 let byte [edi]='-', edi++, [t]++
 neg eax
@@:
 let ecx=0CCCCCCCDh, esi=edi
.while eax>0
  let ebx=eax
  mul ecx
  let edx>>>3, eax=edx,\
   edx=&[edx+edx*4], edx+edx,\
   ebx-edx, bl+'0',\
  [edi]=bl, edi++
.endw
let byte [edi]=0
push edi
text.reverse [t]
pop eax
.e:
pop edi esi ebx
endf

; unsigned number to text

function n2t.u, n, t
push ebx esi edi
let eax=[n], edi=[t],\
 esi=edi, ecx=1999999Ah
@@:
 let ebx=eax
 mul ecx
 let eax=edx,\
  edx=&[edx*4+edx],\
  edx+edx, ebx-edx,\
  bl+'0', [edi]=bl, edi++
 test eax, eax
jnz @b
let byte [edi]=0
push edi
text.reverse [t]
pop eax
pop edi esi ebx
endf

function n2t.h, n, t   ; number to hexadecimal text
let eax=[n], edx=[t]
@@:
 let ecx=>al, ecx&15,\ ; *t++=*(_hex+(n&(16-1)))
  ecx=>[_hex+ecx],\
  [edx]=cl, edx++,\
 eax>>>4               ; n/16
jnz @b
let byte [edx]=0
push edx
text.reverse [t]
pop eax
endf

function n2t.b, n, t       ; number to binary text
let eax=[n], edx=[t]
@@:
 let cl=al, cl&1, cl+'0',\ ; *t++=n&(2-1)+'0'
 [edx]=cl, edx++,\         ; n/2
 eax>>>1
jnz @b
let byte [edx]=0
push edx
text.reverse [t]
pop eax
endf

; t2n($t) - convert text to 32BIT number

function t2n, t
let edx=[t]
.while byte [edx]='0' ; skip preceding '0's...
  let edx++
.endw
.if not byte [edx]    ; 0 value? most common
  let eax=0
  escape
.end
let eax=[BASE]        ; select conversion mode...
test eax, eax         ; 0=default
jz .default
cmp eax, 'n'          ; signed decimal
je .default
.if eax='u'           ; unsigned decimal
  let eax=!t2n.u
.else.if eax='h'      ; hexadecimal
  let eax=!t2n.h
.else.if eax='b'      ; binary
  let eax=!t2n.b
.else
  .default:
  let eax=!t2n.n
.end
calla eax, edx
endf

function t2n.n, t      ; text to signed number
locals negate
let edx=[t],\
 [negate]=0
cmp byte [edx], '-'    ; negative?
jne @f
let edx++, [negate]=1  ; skip
@@:
 calla !t2n.u, edx
 .if [negate]
   neg eax
 .end
endf

function t2n.u, t      ; text to unsigned number
let edx=[t], eax=0
@@:
 let ecx=>[edx], edx++
 test ecx, ecx
 jz @f
 let \
  eax=&[eax+eax*4],\   ; n=n*10+*t++-'0'
  eax=&[eax+eax-'0'],\
 eax+ecx
jmp @b
@@:
endf

function t2n.h, t      ; hexadecimal text to number
let edx=[t], eax=0
@@:
 let ecx=>[edx], edx++
 test ecx, ecx
 jz .e
 shl eax, 4            ; n=n*16+c2h(*t++)
 cmp ecx, '9'          ; 0-9
 jle .n
 cmp ecx, 'a'          ; A-F
 jl .a
 sub ecx, 'a'-10       ; a-f
 jmp .next
 .a:
  sub ecx, 'A'-10
  jmp .next
 .n:
  sub ecx, '0'
 .next:
  add eax, ecx
jmp @b
.e:
endf

function t2n.b, t      ; binary text to number
let edx=[t], eax=0
@@:
 let ecx=>[edx], edx++
 test ecx, ecx
 jz @f
 let eax<<1,\
 eax=&[eax+ecx-'0']    ; n=n*2+*t++-'0'
jmp @b
@@:
endf

macro convert.n2t n, t, b {
push [BASE]
let [BASE]=b
n2t n, t
pop [BASE]
}

macro convert.t2n t, b {
push [BASE]
let [BASE]=b
t2n t
pop [BASE]
}

; convert numeric size to compact text
; to display in file viewers, progress
; indicators, etc. examples: 4096='4k',
; 16777216='16m', 2147483648='2g'.
; note: unsigned 32BIT arithmetic

TEXT max.size.t='>4GB'

function ns2t, n, t
locals suffix
let eax=[n]
cmp eax, KB
 jae @f
 let ecx='b'
 jmp .e
@@:
cmp eax, MB
 jae @f
 let eax>>>10, ecx='k'
 jmp .e
@@:
cmp eax, GB
 jae @f
 let eax>>>20, ecx='m'
 jmp .e
@@:
cmp eax, ((4*GB)-1)
 jbe @f
 text.copy [t], max.size.t
 escape
@@:
let eax>>>30, ecx='g'
.e:
let [n]=eax, [suffix]=ecx
convert.n2t [n], [t], 'u'
text.attach.c [t], [suffix]
endf

; $$$$$$$$$$$$$$$ Z77 ASM LIBRARY $$$$$$$$$$$$$$$$
; *************** SUNGOD SOFTWARE ****************
; ?????????????????? PRINT.INC ???????????????????

; print t, f, ... - print formatted text to buffer.
; a fast alternative to "wsprintfA" that supports
; binary and is easily portable with minimal
; editing. only about 100 lines!

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

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

; see SYNTAX.INC for callv (with variable
; arguments). it will push invisible n
; (# parameters) then adjust esp after

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

!print:            ; !print(n, $t, $f, ...)
va.n equ esp+4     ; # va
va.i equ edx+ecx*4 ; current va

let \
eax=[esp+8],\      ; text buffer
ecx=[esp+12],\     ; format
edx=&[esp+16]      ; &va[...] start

push esi edi
let edi=eax,\
 esi=ecx, ecx=0    ; index=0
test edi, esi      ; if either address=0
jz .r0             ; return 0

.get:              ; while *text {
let al=[esi]       ; get character
test al, al        ; if *text=0, end
jz .e
let esi++
cmp al, '%'        ; if *text=%
je .key            ; format
.1:                ; else, copy 1 char
let [edi]=al,\     ; to *buffer++
 edi++
jmp .get           ; }

.key:              ; % format key
let eax=>[esi],\   ; get character
 esi++
cmp eax, '%'       ; %% for one %
je .1
cmp eax, '0'       ; %0=NULL?
jz .0
cmp eax, 'a'       ; must be lowercase
jl .x
cmp eax, 'z'
jg .x

; fast a-z jmp table!

sub eax, 97
jmp dword [.jt+eax*4]

align 8
.jt: dd \
.x,.b,.c,.n,.x,.x,.x,.h,.n,\ ; a-i
.x,.x,.x,.x,.n,.x,.x,.x,.r,\ ; j-r
.t,.t,.u,.x,.x,.h,.x,.x      ; s-z
.a: dd 0

.x:                ; unrecognized %?
let byte \
 [edi]='?', edi++  ; replace with ?
jmp .get

.0:                ; 0=NULL
let byte \
 [edi]=0, edi++
jmp .get

.r:
let word \         ; return: CR=0Dh, LF=0Ah
[edi]=0A0Dh, edi+2 ; low endian
jmp .get

.c:                ; %c
let al=[va.i],\    ; get va[i++]
ecx++, [edi]=al,\
edi++
jmp .get

.t:                ; %t %s - text
let eax=[va.i],\   ; get va[i++]
 ecx++
test eax, eax      ; if text=0? error
jz .r0
pusha
text.copy edi, eax ; copy text
let [.a]=eax       ; save end address
popa
let edi=[.a]       ; advance text buffer
jmp .get

.n: let eax='n'    ; %n %i %d - number
 jmp .number
.u: let eax='u'    ; %u
 jmp .number
.h: let eax='h'    ; %h %x
 jmp .number
.b: let eax='b'    ; %b

.number:
push [BASE]
let [BASE]=eax,\   ; get va[i++]
 eax=[va.i], ecx++
pusha
n2t eax, edi       ; copy/convert number to text
let [.a]=eax       ; save end address
popa
pop [BASE]
let edi=[.a]       ; advance text buffer
jmp .get

.r0: let eax=0
jmp @f
.e:
let eax=edi,\      ; return end address
 byte [eax]=0      ; terminate
@@:
pop edi esi
ret                ; callv will adjust esp after
    

; $$$$$$$$$$$$$$ Z77 ASM LIBRARY $$$$$$$$$$$$$$$$$
; ************** SUNGOD SOFTWARE *****************
; ?????????????????? FILE.INC ????????????????????

; open $file   ; attempt open, fail if non-existent
; create $file ; create, replace if exists
; exists $file ; does file exist?
; close        ; close current file

; tell         ; get location
; seek n       ; set location
; seek.r n, r  ; seek relative. r=0/1/2=b/c/e

; read/write to/from current file

; read &p, n      ; read/write memory
; write &p, n
; read.bit        ; read/write 1BIT
; write.bit b
; read.nibble     ; read/write 4BIT
; write.nibble n
; read.c          ; read/write 8BIT byte
; write.c c
; read.n          ; read/write 32BIT number
; write.n n
; read.text $t, n ; until 0 or max
; read.line $t, n ; until NL or max
; write.text $t   ; not including 0
; write.string $t ; including 0
; write.line $t   ; insert NL after
; write.x ...     ; formatted text

; * load.file $file - open, allocate file.p,
; read then close
; * save.file $file, &p, n - create, write p
; then close
; * append.file $file, &p, n - open, attach p
; to file then close
; * flush - deallocate file.p

; array.load &a, $file ; ARRAY.INC
; array.save &a, $file

; copy.file $a, $b, replace
; move.file $a, $b
; delete.file $file
; rename.file $old, $new

; execute $file
; execute.file $file, $action, $ps, show
; execute.program $file, $ps, show, time

                      ; b='C:\FILE.EXT'
; extract.path $a, $b ; a='C:\'
; extract.file $a, $b ; a='FILE.EXT'
; extract.ext $a, $b  ; a='.EXT'
; remove.ext $a
; change.ext $a, $b   ; replace or attach new

; get.directory       ; update [directory]
; up.directory        ; ...
; set.directory $t    ; 'C:\MY\ART\'
; set.folder $t       ; 'IMAGE\'
; reset.directory     ; original
; create.directory $t ; 'C:\MY\VIDEOS\'
; create.folder $t    ; 'FONT\'

; note: in Z77 terminology, a "folder" is
; a simple \NAME\ in the current directory
; or relative path

; find.first $ext ; example: '*.bmp'
; find.next
; find.end
; $found.file     ; result

; where.is folder ; search for folder

; get.file.attributes file
; get.modified.date file, t
; get.modified.time file, t

; log $t ; append message to log.txt

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

; current file structure

align 8
VOID file.p      ; pointer for load/save
NUMBER file.h,\  ; handle
file.n64, file.n ; size 64:32

function _file_
let eax=file.p
endf

;;;;;;;;;; OPEN, CREATE, CLOSE, EXISTS ;;;;;;;;;;;

function close
os.close
let [file.h]=-1, eax=YES
endf

function open, file
os.open [file]
.if eax=-1
  return 0
.end
os.get.file.size
let [file.n]=eax, eax=[file.h]
endf

function create, file
os.create [file]
.if eax=-1
  return 0
.end
let [file.n]=0
endf

function exists, file
open [file]
push eax
close
pop eax
endf

macro .if.exists f { !if exists, f }

;;;;;;;;;;;;;;; GET/SET LOCATION ;;;;;;;;;;;;;;;;;

function seek.r, n, r
os.seek [n], [r]
endf

macro seek n { seek.r n, 0 }

macro tell { seek.r 0, 1 }

;;;;;;;;;;;;; READ/WRITE DATA/TEXT ;;;;;;;;;;;;;;;

function read, p, n
os.read [p], [n]
endf

function write, p, n
os.write [p], [n]
endf

function read.c
locals c
let eax=&[c], dword [eax]=0
read eax, 1
let eax=[c]
endf

function write.c, c
let eax=&[c]
write eax, 1
endf

function read.n
locals n
let eax=&[n], dword [eax]=0
read eax, 4
let eax=[n]
endf

function write.n, n
let eax=&[n]
write eax, 4
endf

; read.text/line have not been tested...

function read.text, t, max
push esi edi
let edi=[t], esi=[max]
@@:
 read edi, 1
 cmp byte [edi], 0
 je @f
 let edi++, esi--
jnz @b
@@:
let byte [edi]=0
pop edi esi
endf

function read.line, t, max
push esi edi
let edi=[t],\
esi=[max]
@@:
 read edi, 1      ; read until 0 or 0Dh or max
 let cl=[edi]
 test cl, cl      ; 0
 jz @f
 cmp cl, 0Dh      ; 0Dh
 je @f
 let edi++, esi--
jnz @b            ; max?
@@:
let byte [edi]=0
.if cl=0Dh
  readc
.end
let byte [edi]=0  ; replace with 0
pop edi esi
endf

function write.text, t
text.n [t]
write [t], eax
endf

function write.string, t
text.n [t]
inc eax ; +0
write [t], eax
endf

function write.line, t
write.text [t]
write.text NL
endf

macro write.texts [t] { forward write.text t }

macro write.lines [t] { forward write.line t }

macro write.text.x f, [p] {
common print [?t], f, p ; alters ?t
write.text [?t]
}

; read/write individual bit from left (7)
; to right (0): 76543210. file # BITs must be
; aligned to byte (&7). example: if 17 BITs,
; write 3 bytes. get/set/zero bit are macros
; defined in MEMORY.INC

align 4
NUMBER c.bit, c.byte, next.byte

function read.bit
dec [c.bit]
.if [c.bit]<0 ; read first/next byte
  get [c.byte]=read.c
  let [c.bit]=7
.end
get.bit [c.byte], [c.bit] ; first/next bit
and eax, 1
endf

function write.bit, b
locals n
let eax=7, eax-[c.bit], [n]=eax
.if [b]
  set.bit [c.byte], [n]
.else
  zero.bit [c.byte], [n]
.end
inc [c.bit]
.if [c.bit]>7
  write.c [c.byte]
  let [c.bit]=0
.end
endf

; read/write 4BITs. next.byte must = 0
; on first call

function read.nibble
xor [next.byte], 1
.if [next.byte]
  get [c.byte]=read.c
  let eax>>4, eax&1111b
.else
  let eax=[c.byte], eax&1111b
.end
endf

function write.nibble, b
let eax=[c.byte], ecx=[b], ecx&1111b
.if [next.byte]
  let eax|ecx
  write.c eax
.else
  let ecx<<4, eax|ecx, [c.byte]=eax
.end
endf

;;;;;;;;;;;;;;;; LOAD/SAVE MEMORY ;;;;;;;;;;;;;;;;

function load.file, file
open [file]
fail .r0
get [file.p]=allocate [file.n]
fail .r0
read [file.p], [file.n]
fail .r0
close
let eax=[file.p], ecx=[file.n]
return
.r0:
close
let eax=0
endf

function save.file, file, p, n
create [file]
fail .r0
write [p], [n]
fail .r0
close
let eax=YES
return
.r0:
close
let eax=0
endf

function load.text, file
open [file]
fail .r0
let eax=[file.n], eax+1
get [file.p]=allocate eax
fail .r0
read [file.p], [file.n]
fail .r0
close
let eax=[file.p],\
ecx=[file.n], byte [eax+ecx]=0
return
.r0:
close
let eax=0
endf

function save.text, file, text
text.n [text]
save.file [file], [text], eax
endf

function append.file, file, p, n
!if open, [file]
  seek.r 0, SEEK_END
.else
  create [file]
  fail .e
.end
write [p], [n]
fail .e
close
let eax=[file]
return
.e:
close
let eax=0
endf

; load/save dynamic array. size=file.n/a.s

function array.load, a, file
locals i, n, s, p
try open [file]
let eax=[file.n], edx=[a],\
ecx=[?array.s+edx], [s]=ecx,\
eax/ecx, [n]=eax
array.size [a], [n]
array.erase [a]
.loop [i]=0 to [n]
  get [p]=array.index [a], [i]
  read [p], [s]
  fail .r0
.endl
close
return 1
.r0:
close
let eax=0
endf

function array.save, a, file
locals i, n, s, p
try create [file]
let eax=[a], [s]=[?array.s+eax],\
[n]=[?array.n+eax]
.loop [i]=0 to [n]
  get [p]=array.index [a], [i]
  write [p], [s]
  fail .r0
.endl
close
return 1
.r0:
close
let eax=0
endf

macro flush { destroy [file.p] }

;;;;;;;;;;; COPY, MOVE, DELETE, RENAME ;;;;;;;;;;;

function copy.file, a, b, r
os.copy.file [a], [b], [r]
endf

function move.file, a, b
os.move.file [a], [b]
endf

function delete.file, file
os.delete.file [file]
endf

function rename.file, file
os.rename.file [file]
endf

;;;;;;;;;;;;;;;;;;;; EXECUTE ;;;;;;;;;;;;;;;;;;;;;

function execute, file
os.execute [file]
endf

function execute.file, file, ps, action, show
os.execute.file [file], [ps], [action], [show]
endf

function execute.program, file, ps, show, time
os.execute.program [file], [ps], [action], [time]
endf

;;;;;;;;;;;;;;;; PARSE FILENAME ;;;;;;;;;;;;;;;;;;

function extract.path, a, b
text.copy [a], [b]
.if.text.find.last [a], '\'
  let eax++, byte [eax]=0
.end
endf

function extract.file, a, b
.if.text.find.last [b], '\'
  let eax++
  text.copy [a], eax
.end
endf

function extract.ext, a, b
.if.text.find.last [b], '.'
  text.copy [a], eax
.end
endf

function remove.ext, t
.if.text.find.last [t], '.'
  let byte [eax]=0
.end
endf

function change.ext, a, b
.if.text.find.last [a], '.'
  text.copy eax, [b]
.else
  text.attach [a], [b]
.end
endf

;;;;;;;;;;; DIRECTORY: GET/SET/CREATE ;;;;;;;;;;;;

function get.directory
os.get.directory
let eax=[directory]
endf

function set.directory, t
text.copy [directory], [t]
os.set.directory [t]
endf

function up.directory
get.directory
extract.path [directory], [directory]
set.directory [directory]
endf

function set.folder, name
get.directory
text.attach.c [directory], '\'
text.attach [directory], [name]
set.directory [directory]
endf

function reset.directory
os.get.file.name
extract.path [directory], [directory]
set.directory [directory]
endf

function create.directory, path
os.create.directory [path]
endf

function create.folder, name
get.directory
text.attach.c [directory], '\'
text.attach [directory], [name]
os.create.directory [directory]
endf

;;;;;;;;;;;;;;;;;; FIND FILES ;;;;;;;;;;;;;;;;;;;;

NUMBER find.data.h
found.file equ os.found.file

function find.first, file
jmp @f
os.find.data
@@:
os.find.first [file]
let [find.data.h]=eax, eax++
endf

function find.next
os.find.next
endf

function find.end
os.find.end
endf

; create dynamic text array containing all
; filenames of *.EXT in current directory
; or return 0 if there are none

function find.files, a, ext
try find.first [ext]
@@:
 array.expand [a]
 text.copy eax, os.found.file
 find.next
success @b
find.end
endf

;;;;;;;;;;;;;;;;;;;;; LOCATE ;;;;;;;;;;;;;;;;;;;;;

; set directory containing \FOLDER\ (relative
; path). it may be located in the current
; directory or 1-2 higher directories (for
; \PROJECTS\NAME\). return 0 if not found
; anywhere. example: where.is font.folder

function where.is, folder
set.folder [folder] ; \FOLDER\
success .!
up.directory
set.folder [folder] ; \..\FOLDER\
success .!
up.directory
set.folder [folder] ; \..\..\FOLDER\
endf

; locate folder, search for files of *.EXT
; then reset current directory

function find.files.in, folder, files, ext
where.is [folder]
fail @f
find.files [files], [ext]
@@: reset.directory
endf

;;;;;;;;;;;;;;; FILE ATTRIBUTES  ;;;;;;;;;;;;;;;;;

os.file.attribute.data

function get.file.attributes, file
os.get.file.attributes [file]
endf

function get.file.time, file
os.get.file.time [file]
endf

function get.modified.time, file, t
os.get.modified.time [file], [t]
endf

function get.modified.date, file, t
os.get.modified.date [file], [t]
endf

;;;;;;;;;;;;;;;;;;; FILE TYPES ;;;;;;;;;;;;;;;;;;;

; most common file types for custom file dialog/
; explorer. uncommon types will have a generic
; "File" icon

macro define.file.types {
TEXT \
file.type.text='txt',\
file.type.document='rtf,doc,pub,pdf',\
file.type.source='asm,inc,c,cpp,h,7',\
file.type.program='exe,scr',\
file.type.system='dll,ini,sys',\
file.type.image=\
'bmp,jpg,jpeg,gif,png,tga,tif,pcx',\
file.type.sound='wav,mp3,mid,wma',\
file.type.movie=\
'avi,mp4,mpeg,mpg,wmv,flv,mov',\
file.type.site='htm,html'
}

;;;;;;;;;;;;;;;;;;;;; LOG ;;;;;;;;;;;;;;;;;;;;;;;;

; log t - append 'text' to log file

BOOLEAN create.log?=YES,\
log.star?=YES, log.nl?=YES
TEXT log.file(16)='LOG.TXT', log.star='* '

function log, t
pusha
.if [create.log?]=YES
  create log.file
  close
  let [create.log?]=NO
.end
.if.text.equal [t], NL ; just NL? 0Dh, 0Ah
  append.file log.file, NL, 2
.else
  .if [log.star?]=YES  ; * prefix?
    append.file log.file, log.star, 2
  .end
    text.n [t]         ; append message
    append.file log.file, [t], eax
  .if [log.nl?]=YES    ; NL after?
    append.file log.file, NL, 2
  .end
.end
popa
endf

function log.n, n ; log number
localt t
pusha
let ecx=&[t]
calla !n2t, [n], ecx
let ecx=&[t]
log ecx
popa
endf

macro logs [t] { forward log t }

macro show.log { execute log.file }

function erase.log
create log.file
close
let [create.log?]=NO
endf