/programs/cmm/lisp/example/str.lisp |
---|
File deleted |
\ No newline at end of file |
/programs/cmm/lisp/lisp.c |
---|
1,5 → 1,5 |
/* |
* Author Pavel Iakovlev |
* Author Pavel Iakovlev by PaulCodeman |
*/ |
#define MEMSIZE 4096*10 |
6,34 → 6,26 |
#include "../lib/io.h" |
#include "../lib/obj/console.h" |
#include "../lib/array.h" |
byte initConsole = 0; |
Dictionary functions = {0}; |
Dictionary variables = {0}; |
#define TString 1 |
#define TSymbol 2 |
#define TNumber 3 |
#define TList 4 |
#define Proc 5 |
#define Lambda 6 |
#define TObject 7 |
#include "stdcall.h" |
#define sizeStruct 4*4 |
#define bufferSize 10000; |
#define memoryBrainfuck 30000*4 |
#define memoryByteBF 1 |
#define stackBrainFuck 4*1024 |
#define TStr 1 |
#define TInt 2 |
#define TSym 3 |
#define TBol 4 |
#define TLen 4*5 |
byte initConsole = 0; |
dword maxLoop = 100; |
dword buffer = 0; |
word bufferSymbol = 0; |
dword memory = 0; |
dword bufferSize = 1000; |
dword variable = 0; |
dword key = 0; |
dword treeItem = 0; |
dword NIL = 0; |
dword stack = 0; |
dword code = 0; |
byte tempBuffer[100] = {0}; |
void consoleInit() |
{ |
IF(!initConsole) |
44,188 → 36,419 |
} |
} |
dword evalLisp() |
dword error_message(dword text) |
{ |
byte s = 0; |
byte args = 0; |
dword pos = 0; |
dword name = 0; |
dword tmp = 0; |
dword tmp2 = 0; |
dword dataArgs = 0; |
dword posArgs = 0; |
dword ret = 0; |
dword p = 0; |
con_printf stdcall (text); |
ExitProcess(); |
} |
dword crc32Table = 0; |
dword makeCRCTable(void) |
{ |
dword i = 0; |
dword c = 0; |
dword ii = 0; |
dataArgs = malloc(16*4); |
posArgs = dataArgs; |
dword crcTable = 0; |
IF (crc32Table) RETURN 0; |
crc32Table = malloc(4*256); |
crcTable = crc32Table; |
WHILE (i < 256) |
{ |
c = i; |
ii = 0; |
WHILE (ii < 8) |
{ |
IF (c&1) |
{ |
c >>= 1; |
c ^= 0xEDB88320; |
} |
ELSE c >>= 1; |
ii++; |
} |
DSDWORD[crcTable] = c; |
crcTable += 4; |
i++; |
} |
} |
dword crc32(dword bytes) |
{ |
dword crc = 0; |
byte b = 0; |
IF (!crc32Table) makeCRCTable(); |
crc = 0xFFFFFFFF; |
WHILE (DSBYTE[bytes]) |
{ |
b = DSBYTE[bytes]; |
bytes++; |
EDX = crc^b; |
EDX &= 0xFF; |
EDX <<= 2; |
EDX += crc32Table; |
crc >>= 8; |
crc ^= DSDWORD[EDX]; |
} |
RETURN crc ^ 0xFFFFFFFF; |
} |
loop() |
dword indexArray(dword address, key) |
{ |
s = DSBYTE[code]; |
while (s == ' ') || (s == 9) || (s == 10) || (s == 13) |
dword offset = key&11b; |
dword offsetAddress = offset*4+address; |
IF (key==offset) RETURN 4*4+offsetAddress; |
IF (!DSDWORD[offsetAddress]) DSDWORD[offsetAddress] = malloc(4*4*2); |
RETURN indexArray(DSDWORD[offsetAddress], key>>2); |
} |
void set_procedure(dword name, address) |
{ |
code++; |
s = DSBYTE[code]; |
dword data = 0; |
data = malloc(sizeStruct); |
DSDWORD[data] = Proc; |
DSDWORD[data+4] = address; |
indexArray(variable, crc32(name)); |
DSDWORD[EAX] = data; |
} |
if (!s) return 0; |
if (s==')') |
void set_variable(dword name, data) |
{ |
code++; |
args--; |
ret = StdCall(args, name, dataArgs); |
free(name); |
//free(dataArgs); |
return ret; |
indexArray(variable, crc32(name)); |
DSDWORD[EAX] = data; |
} |
if(s == '(') |
dword string(dword lisp) |
{ |
code++; |
DSDWORD[posArgs] = evalLisp(); |
args++; |
posArgs += 4; |
continue; |
dword buffer = 0; |
if (DSDWORD[lisp] == TList) |
{ |
return ""; |
} |
else if (!args) |
switch (DSDWORD[lisp]) |
{ |
if (s != ')') // name function |
case TString: |
case TSymbol: |
return DSDWORD[lisp+4]; |
case TNumber: |
return itoa(DSDWORD[lisp+4]); |
case Lambda: |
return "[LAMBDA]"; |
case Proc: |
return "[PROC]"; |
case TObject: |
return "[OBJECT]"; |
case TList: |
return "[LIST]"; |
} |
} |
dword number(dword lisp) |
{ |
name = malloc(100); |
pos = name; |
while (s) && (s != ' ') && (s != ')') |
if (DSDWORD[lisp] == TNumber) |
{ |
DSBYTE[pos] = s; |
pos++; |
code++; |
s = DSBYTE[code]; |
return DSDWORD[lisp+4]; |
} |
DSBYTE[pos] = 0; |
args++; |
continue; |
if (DSDWORD[lisp] == TString) |
{ |
//return atoi(DSDWORD[lisp+4]); |
} |
return 0; |
} |
else |
dword lexer(dword code) |
{ |
if (s >= '0') && (s <= '9') |
byte s = 0; |
dword alloc = 0; |
dword buffer = 0; |
dword position = 0; |
dword key = 0; |
alloc = malloc(32); |
//con_printf stdcall(code); |
while(DSBYTE[code]) |
{ |
tmp = 0; |
while (s >= '0') && (s <= '9') |
s = DSBYTE[code]; |
code++; |
if (s == ' ') || (s == '\n') || (s == '\t') || (s == '\r') continue; |
if (s == '(') || (s == ')') |
{ |
tmp *= 10; |
tmp += s-'0'; |
buffer = malloc(2); |
DSBYTE[buffer] = s; |
indexArray(alloc, key); |
DSDWORD[EAX] = buffer; |
key++; |
continue; |
} |
buffer = malloc(25); |
position = buffer; |
DSBYTE[position] = s; |
if (s == '"') |
{ |
while(DSBYTE[code]) |
{ |
s = DSBYTE[code]; |
position++; |
DSBYTE[position] = s; |
code++; |
s = DSBYTE[code]; |
if (s == '"') && (DSBYTE[code-2] != '\\') break; |
} |
args++; |
EDX = malloc(TLen); |
DSDWORD[EDX] = tmp; |
DSDWORD[EDX+4] = TInt; |
DSDWORD[posArgs] = EDX; |
posArgs += 4; |
continue; |
} |
else if (s == '"') |
else |
{ |
i = 1; |
tmp = malloc(1<<i); |
p = tmp; |
while(DSBYTE[code]) |
{ |
s = DSBYTE[code]; |
if (s == ' ') || (s == '\n') || (s == '\t') || (s == '\r') || (s == '(') || (s == ')') break; |
position++; |
DSBYTE[position] = s; |
code++; |
s = DSBYTE[code]; |
ii = 0; |
while (s != '"') && (s) |
} |
} |
indexArray(alloc, key); |
DSDWORD[EAX] = buffer; |
key++; |
} |
indexArray(alloc, key); |
DSDWORD[EAX] = 0; |
/*key = 0; |
do { |
buffer = indexArray(alloc, key); |
if (!DSDWORD[buffer]) break; |
con_printf stdcall ("\r\n"); |
con_printf stdcall (DSDWORD[buffer]);key++; |
} while(1);*/ |
return alloc; |
} |
dword tree(dword alloc) |
{ |
ii++; |
if (1<<i < ii) |
dword token = 0; |
dword list = 0; |
dword buffer = 0; |
dword temp = 0; |
dword listBuffer = 0; |
dword i = 0; |
token = indexArray(alloc, treeItem); |
treeItem++; |
buffer = DSDWORD[token]; |
if (DSBYTE[buffer] == '(') |
{ |
list = malloc(32); |
while(1) { |
token = indexArray(alloc, treeItem); |
token = DSDWORD[token]; |
if (!token) || (DSBYTE[token] == ')') break; |
buffer = indexArray(list, i); |
DSDWORD[buffer] = tree(alloc); |
i++; |
tmp2 = p-tmp; |
tmp = realloc(tmp, 1<<i); |
p = tmp+tmp2; |
} |
DSBYTE[p] = s; |
p++; |
treeItem++; |
indexArray(list, i); |
DSDWORD[EAX] = 0; |
malloc(sizeStruct); |
DSDWORD[EAX] = TList; |
DSDWORD[EAX+4] = list; |
return EAX; |
} |
return atom(DSDWORD[token]); |
} |
code++; |
s = DSBYTE[code]; |
dword hexdec2(dword buffer, length) |
{ |
dword r = 0; |
length += buffer; |
while (length != buffer) |
{ |
length--; |
r <<= 4; |
if (DSBYTE[length] >= 'A') && (DSBYTE[length] <= 'F') r |= DSBYTE[length]-'A'+10; |
else if (DSBYTE[length] >= 'a') && (DSBYTE[length] <= 'f') r |= DSBYTE[length]-'a'+10; |
else if (DSBYTE[length] >= '0') && (DSBYTE[length] <= '9') r |= '9'-DSBYTE[length]; |
} |
DSBYTE[p] = 0; |
EDX = malloc(TLen); |
DSDWORD[EDX] = tmp; |
DSDWORD[EDX+4] = TStr; |
DSDWORD[EDX+8] = p-tmp; |
DSDWORD[posArgs] = EDX; |
posArgs += 4; |
code++; |
args++; |
continue; |
return r; |
} |
else |
dword atom(dword token) |
{ |
tmp = malloc(20); |
p = tmp; |
while (s) && (s != ')') && (s != '(') && (s != ' ') && (s != 10) && (s != 13) |
dword buffer = 0; |
dword pos = 0; |
dword data = 0; |
if (DSBYTE[token] == '-') && (DSBYTE[token+1] >= '0') && (DSBYTE[token+1] <= '9') |
{ |
DSBYTE[p] = s; |
p++; |
code++; |
s = DSBYTE[code]; |
malloc(sizeStruct); |
DSDWORD[EAX] = TNumber; |
DSDWORD[EAX+4] = atoi(token); |
return EAX; |
} |
DSBYTE[p] = 0; |
args++; |
EDX = malloc(TLen); |
DSDWORD[EDX] = tmp; |
DSDWORD[EDX+4] = TSym; |
DSDWORD[posArgs] = EDX; |
posArgs += 4; |
continue; |
if (DSBYTE[token] >= '0') && (DSBYTE[token] <= '9') |
{ |
while (DSBYTE[token]) && (DSBYTE[token] >= '0') && (DSBYTE[token] <= '9') |
{ |
data *= 10; |
data += DSBYTE[token]-'0'; |
token++; |
} |
DSDWORD[posArgs] = tmp; |
posArgs += 4; |
malloc(sizeStruct); |
DSDWORD[EAX] = TNumber; |
DSDWORD[EAX+4] = data; |
return EAX; |
} |
code++; |
args++; |
if (DSBYTE[token] == '"') |
{ |
pos = token; |
buffer = token; |
pos++; |
while (DSBYTE[pos]) && (DSBYTE[pos] != '"') |
{ |
if (DSBYTE[pos] == '\\') |
{ |
pos++; |
switch (DSBYTE[pos]) |
{ |
case 'n': DSBYTE[buffer] = 13; break; |
case 'r': DSBYTE[buffer] = 10; break; |
case 't': DSBYTE[buffer] = 9; break; |
case 'x': |
pos++; |
DSBYTE[buffer] = hexdec2(pos, 2); |
pos++; |
break; |
default: |
DSBYTE[buffer] = DSBYTE[pos]; |
} |
args--; |
ret = StdCall(args, name, dataArgs); |
free(name); |
//free(dataArgs); |
return ret; |
} |
else DSBYTE[buffer] = DSBYTE[pos]; |
buffer++; |
pos++; |
} |
DSBYTE[buffer] = 0; |
malloc(sizeStruct); |
DSDWORD[EAX] = TString; |
DSDWORD[EAX+4] = token; |
DSDWORD[EAX+8] = token-buffer; |
return EAX; |
} |
pos = token; |
while (DSBYTE[pos]) |
{ |
if (DSBYTE[pos] >= 'a') && (DSBYTE[pos] <= 'z') DSBYTE[pos] = DSBYTE[pos]-'a'+'A'; |
pos++; |
} |
malloc(sizeStruct); |
DSDWORD[EAX] = TSymbol; |
DSDWORD[EAX+4] = token; |
return EAX; |
} |
dword lisp(dword tree) |
{ |
dword buffer = 0; |
dword list = 0; |
dword args = 0; |
dword key = 0; |
dword item = 0; |
switch (DSDWORD[tree]) |
{ |
case TSymbol: |
buffer = indexArray(variable, crc32(DSDWORD[tree+4])); |
IF (!DSDWORD[buffer]) return tree; |
return DSDWORD[buffer]; |
case TNumber: |
case TString: |
return tree; |
case TList: |
list = DSDWORD[tree+4]; |
buffer = indexArray(list, 0); |
if (!buffer) { |
malloc(sizeStruct); |
DSDWORD[buffer] = TSymbol; |
DSDWORD[buffer+4] = NIL; |
return buffer; |
} |
buffer = DSDWORD[buffer]; |
if (DSDWORD[buffer] == TSymbol) || (DSDWORD[buffer] == TList) |
{ |
buffer = DSDWORD[buffer+4]; |
if (DSBYTE[buffer] == '\'') return tree; |
args = malloc(32); |
key = 0; |
while (1) |
{ |
buffer = indexArray(list, key); |
buffer = DSDWORD[buffer]; |
if (!buffer) break; |
item = indexArray(args, key); |
DSDWORD[item] = lisp(buffer); |
key++; |
} |
item = indexArray(args, 0); |
item = DSDWORD[item]; |
if (DSDWORD[item] == Proc) |
{ |
EAX = DSDWORD[item+4]; |
EAX(args); |
if (!EAX) |
{ |
malloc(sizeStruct); |
DSDWORD[EAX] = TSymbol; |
DSDWORD[EAX+4] = NIL; |
return EAX; |
} |
return EAX; |
} |
malloc(sizeStruct); |
DSDWORD[EAX] = TSymbol; |
DSDWORD[EAX+4] = NIL; |
return EAX; |
} |
malloc(sizeStruct); |
DSDWORD[EAX] = TSymbol; |
DSDWORD[EAX+4] = NIL; |
return EAX; |
} |
} |
#include "stdcall.h" |
void main() |
{ |
dword brainFuckCode = 0; |
word maxLoop = 1000; |
dword txt = "(set name (input \"Enter you name: \"))(print \"You name \" (get name))"; |
dword xxx = 0; |
dword item = 0; |
dword data = 0; |
buffer = malloc(bufferSize); |
memory = malloc(memoryBrainfuck); |
stack = malloc(stackBrainFuck); |
Init(); |
variable = malloc(32); |
NIL = "NIL"; |
IF(DSBYTE[I_Param]) |
initFunctionLisp(); |
if(DSBYTE[I_Param]) |
{ |
IF(io.read(I_Param)) |
{ |
code = EAX; |
evalLisp(); |
lisp(tree(lexer(EAX))); |
} |
} |
else |
{ |
consoleInit(); |
con_printf stdcall ("Lisp interpreter v1.5\r\n"); |
con_printf stdcall ("Lisp v2.0\r\n"); |
while(maxLoop) |
{ |
treeItem = 0; |
con_printf stdcall ("\r\n$ "); |
con_gets stdcall(buffer, bufferSize); |
code = EAX; |
//code = txt; |
con_printf stdcall ("Output: "); |
evalLisp(); |
con_gets stdcall(buffer+1, bufferSize); |
DSBYTE[buffer] = '('; |
xxx= lisp(tree(lexer(buffer))); |
con_printf stdcall (string(xxx)); |
maxLoop--; |
} |
} |
/programs/cmm/lisp/stdcall.h |
---|
1,293 → 1,193 |
/* |
STDCALL function |
Author: PaulCodeman |
*/ |
/* Lisp functions */ |
:dword std_sleep(dword count, args) |
void initFunctionLisp() |
{ |
dword ret = 0; |
dword arg = 0; |
dword val = 0; |
WHILE(count) |
{ |
arg = DSDWORD[args]; |
REPEAT1: |
IF (DSDWORD[arg+4] == TSym) |
{ |
arg = std_get(1, args); |
goto REPEAT1; |
set_procedure("TEST", #lisp_test); |
set_procedure("SLEEP", #lisp_sleep); |
set_procedure("PRINT", #lisp_print); |
set_procedure("INPUT", #lisp_input); |
set_procedure("STDCALL", #lisp_stdcall); |
set_procedure("SETQ", #lisp_setq); |
set_procedure("DEFVAR", #lisp_setq); |
set_procedure("+", #lisp_add); |
set_procedure("-", #lisp_sub); |
set_procedure("=", #lisp_cmp); |
} |
IF (DSDWORD[arg+4] == TInt) |
dword lisp_test(dword args) |
{ |
EAX = 5; |
EBX = DSDWORD[arg]; |
$int 0x40 |
malloc(sizeStruct); |
DSDWORD[EAX] = TString; |
DSDWORD[EAX+4] = "ZZZ"; |
return EAX; |
} |
args+=4; |
count--; |
} |
RETURN ret; |
} |
:dword std_set(dword count, args) |
dword lisp_setq(dword args) |
{ |
dword i = 0; |
dword name = 0; |
dword value = 0; |
WHILE(count > 0) |
dword data = 0; |
while(1) |
{ |
name = DSDWORD[args]; |
IF (DSDWORD[name+4] == TSym) name = DSDWORD[name]; |
ELSE |
i++; |
data = indexArray(args, i); |
data = DSDWORD[data]; |
IF (!data) break; |
if (i&1) |
{ |
con_printf stdcall ("Error variable!"); |
ExitProcess(); |
name = DSDWORD[data+4]; |
} |
args += 4; |
value = DSDWORD[args]; |
args += 4; |
variables.set(name, value); |
count -= 2; |
else |
{ |
set_variable(name, data); |
} |
} |
return 0; |
} |
:dword std_get(dword count, args) |
dword lisp_print(dword args) |
{ |
dword name = 0; |
IF(!count) RETURN 0; |
name = DSDWORD[args]; |
IF (DSDWORD[name+4] != TSym) |
dword i = 0; |
consoleInit(); |
while(1) |
{ |
con_printf stdcall ("Error variable!"); |
ExitProcess(); |
i++; |
indexArray(args, i); |
IF (!DSDWORD[EAX]) break; |
con_printf stdcall (string(DSDWORD[EAX])); |
} |
RETURN variables.get(DSDWORD[name]); |
con_printf stdcall ("\r\n"); |
return 0; |
} |
:dword std_str(dword count, args) |
dword lisp_stdcall(dword args) |
{ |
dword tmp = 0; |
IF(!count) RETURN ""; |
tmp = malloc(15); |
itoa_(tmp,DSDWORD[args]); |
RETURN tmp; |
} |
/* Math functions */ |
:dword std_add(dword count, args) |
dword i = 0; |
dword buffer = 0; |
while(1) |
{ |
dword ret = 0; |
WHILE(count) |
{ |
ret += DSDWORD[args]; |
args+=4; |
count--; |
i++; |
indexArray(args, i); |
buffer = DSDWORD[EAX]; |
IF (!buffer) break; |
$push DSDWORD[buffer+4]; |
} |
RETURN ret; |
IF (i == 2) $pop eax |
IF (i == 3) $pop ebx |
IF (i == 4) $pop ecx |
$int 0x40 |
return EAX; |
} |
:dword std_exit(dword count, args) |
dword lisp_input(dword args) |
{ |
IF(initConsole) con_exit stdcall (1); |
ExitProcess(); |
dword buffer = 0; |
consoleInit(); |
buffer = malloc(100); |
con_gets stdcall(buffer, 100); |
malloc(sizeStruct); |
DSDWORD[EAX] = TString; |
DSDWORD[EAX+4] = buffer; |
return EAX; |
} |
:dword std_sub(dword count, args) |
dword lisp_inc(dword args) |
{ |
dword ret = 0; |
IF(count) |
dword i = 0; |
dword sum = 0; |
dword buffer = 0; |
while(1) |
{ |
ret = DSDWORD[args]; |
count--; |
args+=4; |
i++; |
buffer = indexArray(args, i); |
IF (!DSDWORD[buffer]) break; |
buffer = DSDWORD[buffer]; |
} |
WHILE(count) |
{ |
ret -= DSDWORD[args]; |
args += 4; |
count--; |
return 0; |
} |
RETURN ret; |
} |
:dword std_type(dword count, args) |
dword lisp_add(dword args) |
{ |
dword ret = 0; |
dword arg = 0; |
dword val = 0; |
ret = malloc(TLen); |
DSDWORD[ret] = "nil"; |
DSDWORD[ret+4] = TStr; |
WHILE(count) |
dword i = 0; |
dword sum = 0; |
dword buffer = 0; |
while(1) |
{ |
arg = DSDWORD[args]; |
REPEAT1: |
IF (DSDWORD[arg+4] == TSym) |
{ |
arg = std_get(1, args); |
goto REPEAT1; |
i++; |
buffer = indexArray(args, i); |
IF (!DSDWORD[buffer]) break; |
buffer = DSDWORD[buffer]; |
sum += number(buffer); |
} |
switch (DSDWORD[arg+4]) |
{ |
case TStr: |
DSDWORD[ret] = "string"; |
break; |
case TInt: |
DSDWORD[ret] = "integer"; |
break; |
malloc(sizeStruct); |
DSDWORD[EAX] = TNumber; |
DSDWORD[EAX+4] = sum; |
return EAX; |
} |
args+=4; |
count--; |
} |
RETURN ret; |
} |
/* Console functions */ |
:dword std_print(dword count, args) |
dword lisp_sub(dword args) |
{ |
dword ret = 0; |
dword arg = 0; |
dword val = 0; |
consoleInit(); |
IF (!count) con_printf stdcall ("nil"); |
WHILE(count) |
dword i = 0; |
dword sum = 0; |
while(1) |
{ |
arg = DSDWORD[args]; |
REPEAT1: |
IF (DSDWORD[arg+4] == TInt) val = itoa(DSDWORD[arg]); |
ELSE IF (DSDWORD[arg+4] == TStr) val = DSDWORD[arg]; |
ELSE IF (DSDWORD[arg+4] == TSym) |
{ |
arg = std_get(1, args); |
goto REPEAT1; |
i++; |
indexArray(args, i); |
IF (!DSDWORD[EAX]) break; |
sum -= number(DSDWORD[EAX]); |
} |
IF(!arg) con_printf stdcall ("nil"); |
ELSE con_printf stdcall (val); |
args+=4; |
count--; |
malloc(sizeStruct); |
DSDWORD[EAX] = TNumber; |
DSDWORD[EAX+4] = sum; |
return EAX; |
} |
RETURN ret; |
} |
:dword std_len(dword count, args) |
dword lisp_cmp(dword args) |
{ |
dword ret = 0; |
dword arg = 0; |
dword val = 0; |
ret = malloc(TLen); |
DSDWORD[ret] = 0; |
DSDWORD[ret+4] = TInt; |
WHILE(count) |
{ |
arg = DSDWORD[args]; |
REPEAT1: |
IF (DSDWORD[arg+4] == TStr) val = DSDWORD[arg]; |
ELSE IF (DSDWORD[arg+4] == TSym) |
{ |
arg = std_get(1, args); |
goto REPEAT1; |
} |
ELSE return ret; |
DSDWORD[ret] += DSDWORD[arg+8]; |
args+=4; |
count--; |
} |
RETURN ret; |
} |
dword i = 0; |
dword first = 0; |
dword buffer = 0; |
:dword std_cmp(dword count, args) |
while(1) |
{ |
dword ret = 0; |
dword arg = 0; |
dword val = 0; |
dword tmp = 0; |
dword x = 0; |
dword y = 0; |
byte start = 0; |
ret = malloc(TLen); |
DSDWORD[ret] = 0; |
DSDWORD[ret+4] = TInt; |
IF (!count) return ret; |
while(count) |
i++; |
buffer = indexArray(args, i); |
buffer = DSDWORD[buffer]; |
IF (!buffer) break; |
if (i == 1) |
{ |
arg = DSDWORD[args]; |
REPEAT2: |
IF (DSDWORD[arg+4] == TSym) |
{ |
arg = std_get(1, args); |
goto REPEAT2; |
first = buffer; |
} |
IF (!start) |
else |
{ |
start = 1; |
tmp = arg; |
args+=4; |
count--; |
continue; |
} |
IF (DSDWORD[tmp+4] != DSDWORD[arg+4]) return ret; |
IF (DSDWORD[tmp+4] == TInt) |
if (DSDWORD[first+4] != DSDWORD[buffer+4]) |
{ |
IF (DSDWORD[tmp] != DSDWORD[arg]) return ret; |
malloc(sizeStruct); |
DSDWORD[EAX] = TSymbol; |
DSDWORD[EAX+4] = NIL; |
return EAX; |
} |
ELSE IF (DSDWORD[tmp+4] == TStr) |
{ |
/*IF (!DSDWORD[tmp+8]) DSDWORD[tmp+8] = crc32(DSDWORD[tmp]); |
IF (!DSDWORD[arg+8]) DSDWORD[arg+8] = crc32(DSDWORD[arg]); |
IF (DSDWORD[tmp+8] != DSDWORD[arg+8]) return ret;*/ |
IF (strcmp(DSDWORD[tmp], DSDWORD[arg])) return ret; |
} |
args+=4; |
count--; |
} |
DSDWORD[ret] = 1; |
return ret; |
if (i == 1) error_message("*** - EVAL: too few arguments given to =: (=)"); |
malloc(sizeStruct); |
DSDWORD[EAX] = TSymbol; |
DSDWORD[EAX+4] = "T"; |
return EAX; |
} |
:dword std_input(dword count, args) |
dword lisp_sleep(dword args) |
{ |
dword buf = 0; |
consoleInit(); |
buf = malloc(100); |
IF (count) std_print(count, args); |
con_gets stdcall(buf, 100); |
EDX = malloc(TLen); |
DSDWORD[EDX] = buf; |
DSDWORD[EDX+4] = TStr; |
RETURN EDX; |
dword time = 0; |
indexArray(args, 1); |
time = number(DSDWORD[EAX]); |
EAX = 5; |
EBX = time; |
$int 0x40 |
return 0; |
} |
void Init() |
{ |
functions.init(100); |
/* Console functions */ |
functions.set("print", #std_print); |
functions.set("input", #std_input); |
/* String functions */ |
functions.set("str", #std_str); |
functions.set("len", #std_len); |
/* System functions */ |
functions.set("exit", #std_exit); |
/* Math functions */ |
functions.set("+", #std_add); |
functions.set("-", #std_sub); |
functions.set("==", #std_cmp); |
/* Lisp functions */ |
functions.set("set", #std_set); |
functions.set("get", #std_get); |
functions.set("type", #std_type); |
functions.set("sleep", #std_sleep); |
variables.init(100); |
} |
dword StdCall(dword count, name, args) |
{ |
functions.get(name); |
IF(EAX) RETURN EAX(count, args); |
RETURN 0; |
} |