WebSVN – Kolibri OS – Diff – /programs/cmm/lisp/lisp.c


/*
 * Author Pavel Iakovlev
*/
 
#define MEMSIZE 4096*10
 
#include "../lib/io.h"
#include "../lib/obj/console.h"
#include "../lib/array.h"
 
byte initConsole = 0;
Dictionary functions = {0};
Dictionary variables = {0};
 
#include "stdcall.h"
 
#define bufferSize 10000;
#define memoryBrainfuck 30000*4
#define memoryByteBF 1
#define stackBrainFuck 4*1024
 
dword buffer = 0;
word bufferSymbol = 0;
dword memory = 0;
 
dword stack = 0;
dword code = 0;
byte tempBuffer[100] = {0};
 
void consoleInit()
{
	IF(!initConsole) 
	{
		load_dll(libConsole, #con_init, 0);
		con_init stdcall (-1, -1, -1, -1, "Lisp interpreter");
		initConsole = 0xFF;
	}
}
 
dword evalLisp()
{
	byte s = 0;
	byte args = 0;
	dword pos = 0;
	dword name = 0;
	dword tmp = 0;
	dword dataArgs = 0;
	dword posArgs = 0;
	dword ret = 0;
	dword p = 0;
	dataArgs = malloc(16*4);
	posArgs = dataArgs;
 
 
	loop()
	{
		s = DSBYTE[code];
		
		while(s == ' ')
		{
			code++;
			s = DSBYTE[code];
		}
		if (!s) return 0;
		if (s==')') 
		{
			code++;
			args--;
			ret = StdCall(args, name, dataArgs);
			free(name);
			//free(dataArgs);
			return ret;
		}
		if(s == '(') 
		{
			code++;
			DSDWORD[posArgs] = evalLisp();
			args++;
			posArgs += 4;
			continue;
		}
 
		else if (!args) 
		{
			if (s != ')') // name function
			{
				name = malloc(100);
				pos = name;
				while (s) && (s != ' ') && (s != ')')
				{
					DSBYTE[pos] = s;
					pos++;
					code++;
					s = DSBYTE[code];
				}	
				DSBYTE[pos] = 0;
				args++;
				continue;
			}
		}
		else
		{
 
 
 
 
 
			if (s >= '0') && (s <= '9')
			{
				tmp = 0;
				while (s >= '0') && (s <= '9')
				{
					tmp *= 10;
					tmp += s-'0';
					code++;
					s = DSBYTE[code];
				}
				args++;
				DSDWORD[posArgs] = tmp;
				posArgs += 4;
				continue;
			}
			else if (s == '"')
			{
				tmp = malloc(100);
				p = tmp;
				code++;
				s = DSBYTE[code];
				while (s != '"') && (s)
				{
					DSBYTE[p] = s;
					p++;
					
					code++;
					s = DSBYTE[code];
				}
				DSBYTE[p] = 0;
			}
			else if(s >= 'A') && (s <= 'z')
			{
				tmp = malloc(100);
				p = tmp;
				while (s >= 'A') && (s <= 'z') 
				{
					DSBYTE[p] = s;
					p++;
					
					code++;
					s = DSBYTE[code];
				}
				DSBYTE[p] = 0;
				args++;
				DSDWORD[posArgs] = tmp;
				posArgs += 4;
				continue;
			}
			
			DSDWORD[posArgs] = tmp;
			posArgs += 4;
		}
		code++;
		args++;
	}
	args--;
	ret = StdCall(args, name, dataArgs);
	free(name);
	//free(dataArgs);
	return ret;
}
 
void main()
{
	dword brainFuckCode = 0;
	word maxLoop = 1000;
	dword txt = "(print (input \"test:\"))";
	
	buffer = malloc(bufferSize);
	memory = malloc(memoryBrainfuck);
	stack = malloc(stackBrainFuck);
	
	Init();
	
	IF(DSBYTE[I_Param])
	{
		IF(io.read(I_Param))
		{
			code = EAX;
			loop()
			{
				WHILE(DSBYTE[code] == ' ') code++;
				IF(DSBYTE[code]!='(') BREAK;
				ELSE code++;
				evalLisp();
				code--;
				IF(DSBYTE[code]!=')') BREAK;
				ELSE code++;
			}
		}
	}
	else 
	{
		consoleInit();
		con_printf stdcall ("Lisp interpreter v1.3");
		while(maxLoop)
		{
			con_printf stdcall ("\r\n\r\nEnter code: ");
			con_gets stdcall(buffer, bufferSize);
			code = EAX;
			//code = txt;
			con_printf stdcall ("Output: ");
 
 
 
 
			evalLisp();
 
 
 
 
 
 
			maxLoop--;
		}
	}
	
	IF(initConsole) con_exit stdcall (0);
	ExitProcess();
}

Rev 7564	Rev 7565
1	/*	1	/*
2	* Author Pavel Iakovlev	2	* Author Pavel Iakovlev
3	*/	3	*/
4		4
5	#define MEMSIZE 4096*10	5	#define MEMSIZE 4096*10
6		6
7	#include "../lib/io.h"	7	#include "../lib/io.h"
8	#include "../lib/obj/console.h"	8	#include "../lib/obj/console.h"
9	#include "../lib/array.h"	9	#include "../lib/array.h"
10		10
11	byte initConsole = 0;	11	byte initConsole = 0;
12	Dictionary functions = {0};	12	Dictionary functions = {0};
13	Dictionary variables = {0};	13	Dictionary variables = {0};
14		14
15	#include "stdcall.h"	15	#include "stdcall.h"
16		16
17	#define bufferSize 10000;	17	#define bufferSize 10000;
18	#define memoryBrainfuck 30000*4	18	#define memoryBrainfuck 30000*4
19	#define memoryByteBF 1	19	#define memoryByteBF 1
20	#define stackBrainFuck 4*1024	20	#define stackBrainFuck 4*1024
21		21
22	dword buffer = 0;	22	dword buffer = 0;
23	word bufferSymbol = 0;	23	word bufferSymbol = 0;
24	dword memory = 0;	24	dword memory = 0;
25		25
26	dword stack = 0;	26	dword stack = 0;
27	dword code = 0;	27	dword code = 0;
28	byte tempBuffer[100] = {0};	28	byte tempBuffer[100] = {0};
29		29
30	void consoleInit()	30	void consoleInit()
31	{	31	{
32	IF(!initConsole)	32	IF(!initConsole)
33	{	33	{
34	load_dll(libConsole, #con_init, 0);	34	load_dll(libConsole, #con_init, 0);
35	con_init stdcall (-1, -1, -1, -1, "Lisp interpreter");	35	con_init stdcall (-1, -1, -1, -1, "Lisp interpreter");
36	initConsole = 0xFF;	36	initConsole = 0xFF;
37	}	37	}
38	}	38	}
39		39
40	dword evalLisp()	40	dword evalLisp()
41	{	41	{
42	byte s = 0;	42	byte s = 0;
43	byte args = 0;	43	byte args = 0;
44	dword pos = 0;	44	dword pos = 0;
45	dword name = 0;	45	dword name = 0;
46	dword tmp = 0;	46	dword tmp = 0;
47	dword dataArgs = 0;	47	dword dataArgs = 0;
48	dword posArgs = 0;	48	dword posArgs = 0;
49	dword ret = 0;	49	dword ret = 0;
50	dword p = 0;	50	dword p = 0;
51	dataArgs = malloc(16*4);	51	dataArgs = malloc(16*4);
52	posArgs = dataArgs;	52	posArgs = dataArgs;
53	name = malloc(100);	-
54	pos = name;	53
55	loop()	54	loop()
56	{	55	{
57	s = DSBYTE[code];	56	s = DSBYTE[code];
58		57
59	while(s == ' ')	58	while(s == ' ')
60	{	59	{
61	code++;	60	code++;
62	s = DSBYTE[code];	61	s = DSBYTE[code];
63	}	62	}
-		63	if (!s) return 0;
-		64	if (s==')')
64		65	{
-		66	code++;
-		67	args--;
-		68	ret = StdCall(args, name, dataArgs);
-		69	free(name);
-		70	//free(dataArgs);
-		71	return ret;
-		72	}
65	if (!s) \|\| (s==')')	73	if(s == '(')
66	{	74	{
67	code++;	75	code++;
-		76	DSDWORD[posArgs] = evalLisp();
68	break;	77	args++;
-		78	posArgs += 4;
-		79	continue;
69	}	80	}
70		-
71	if (!args)	81	else if (!args)
72	{	82	{
73	if (s != ')') // name function	83	if (s != ')') // name function
74	{	84	{
-		85	name = malloc(100);
-		86	pos = name;
75	while (s != ' ') && (s != ')')	87	while (s) && (s != ' ') && (s != ')')
76	{	88	{
77	DSBYTE[pos] = s;	89	DSBYTE[pos] = s;
78	pos++;	90	pos++;
79	code++;	91	code++;
80	s = DSBYTE[code];	92	s = DSBYTE[code];
81	}	93	}
-		94	DSBYTE[pos] = 0;
-		95	args++;
82	code--;	96	continue;
83	}	97	}
84	}	98	}
85	else	99	else
86	{	100	{
87	if(s == '(')	-
88	{	-
89	code++;	-
90	tmp = evalLisp();	-
91	}	-
92	else if (s >= '0') && (s <= '9')	101	if (s >= '0') && (s <= '9')
93	{	102	{
94	tmp = 0;	103	tmp = 0;
95	while (s >= '0') && (s <= '9')	104	while (s >= '0') && (s <= '9')
96	{	105	{
97	tmp *= 10;	106	tmp *= 10;
98	tmp += s-'0';	107	tmp += s-'0';
99	code++;	108	code++;
100	s = DSBYTE[code];	109	s = DSBYTE[code];
101	}	110	}
-		111	args++;
-		112	DSDWORD[posArgs] = tmp;
-		113	posArgs += 4;
102	code--;	114	continue;
103	}	115	}
104	else if (s == '"')	116	else if (s == '"')
105	{	117	{
106	tmp = malloc(100);	118	tmp = malloc(100);
107	p = tmp;	119	p = tmp;
108	code++;	120	code++;
109	s = DSBYTE[code];	121	s = DSBYTE[code];
110	while (s != '"') && (s)	122	while (s != '"') && (s)
111	{	123	{
112	DSBYTE[p] = s;	124	DSBYTE[p] = s;
113	p++;	125	p++;
114		126
115	code++;	127	code++;
116	s = DSBYTE[code];	128	s = DSBYTE[code];
117	}	129	}
118	DSBYTE[p] = 0;	130	DSBYTE[p] = 0;
119	}	131	}
120	else if(s >= 'A') && (s <= 'z')	132	else if(s >= 'A') && (s <= 'z')
121	{	133	{
122	tmp = malloc(100);	134	tmp = malloc(100);
123	p = tmp;	135	p = tmp;
124	while (s >= 'A') && (s <= 'z')	136	while (s >= 'A') && (s <= 'z')
125	{	137	{
126	DSBYTE[p] = s;	138	DSBYTE[p] = s;
127	p++;	139	p++;
128		140
129	code++;	141	code++;
130	s = DSBYTE[code];	142	s = DSBYTE[code];
131	}	143	}
132	DSBYTE[p] = 0;	144	DSBYTE[p] = 0;
-		145	args++;
-		146	DSDWORD[posArgs] = tmp;
-		147	posArgs += 4;
-		148	continue;
133	}	149	}
134		150
135	DSDWORD[posArgs] = tmp;	151	DSDWORD[posArgs] = tmp;
136	posArgs += 4;	152	posArgs += 4;
137	}	153	}
138	code++;	154	code++;
139	args++;	155	args++;
140	}	156	}
141	args--;	157	args--;
142	ret = StdCall(args, name, dataArgs);	158	ret = StdCall(args, name, dataArgs);
143	free(name);	159	free(name);
144	free(dataArgs);	160	//free(dataArgs);
145	return ret;	161	return ret;
146	}	162	}
147		163
148	void main()	164	void main()
149	{	165	{
150	dword brainFuckCode = 0;	166	dword brainFuckCode = 0;
151	word maxLoop = 1000;	167	word maxLoop = 1000;
152	dword txt = " (print 1)(print 2)";	168	dword txt = "(print (input \"test:\"))";
153		169
154	buffer = malloc(bufferSize);	170	buffer = malloc(bufferSize);
155	memory = malloc(memoryBrainfuck);	171	memory = malloc(memoryBrainfuck);
156	stack = malloc(stackBrainFuck);	172	stack = malloc(stackBrainFuck);
157		173
158	Init();	174	Init();
159		175
160	IF(DSBYTE[I_Param])	176	IF(DSBYTE[I_Param])
161	{	177	{
162	IF(io.read(I_Param))	178	IF(io.read(I_Param))
163	{	179	{
164	code = EAX;	180	code = EAX;
165	loop()	181	loop()
166	{	182	{
167	WHILE(DSBYTE[code] == ' ') code++;	183	WHILE(DSBYTE[code] == ' ') code++;
168	IF(DSBYTE[code]!='(') BREAK;	184	IF(DSBYTE[code]!='(') BREAK;
169	ELSE code++;	185	ELSE code++;
170	evalLisp();	186	evalLisp();
171	code--;	187	code--;
172	IF(DSBYTE[code]!=')') BREAK;	188	IF(DSBYTE[code]!=')') BREAK;
173	ELSE code++;	189	ELSE code++;
174	}	190	}
175	}	191	}
176	}	192	}
177	else	193	else
178	{	194	{
179	consoleInit();	195	consoleInit();
180	con_printf stdcall ("Lisp interpreter v1.2");	196	con_printf stdcall ("Lisp interpreter v1.3");
181	while(maxLoop)	197	while(maxLoop)
182	{	198	{
183	con_printf stdcall ("\r\n\r\nEnter code: ");	199	con_printf stdcall ("\r\n\r\nEnter code: ");
184	con_gets stdcall(buffer, bufferSize);	200	con_gets stdcall(buffer, bufferSize);
185	code = EAX;	201	code = EAX;
186	//code = txt;	202	//code = txt;
187	con_printf stdcall ("Output: ");	203	con_printf stdcall ("Output: ");
188	nextLispLine:	-
189	while(DSBYTE[code] == ' ') code++;	-
190	if(DSBYTE[code] == '(') code++;	-
191	else goto endNext;	-
192	evalLisp();	204	evalLisp();
193	code--;	-
194	if(DSBYTE[code]==')') code++;	-
195	else goto endNext;	-
196	IF(!DSBYTE[code]) goto endNext;	-
197	goto nextLispLine;	-
198	endNext:	-
199	maxLoop--;	205	maxLoop--;
200	}	206	}
201	}	207	}
202		208
203	IF(initConsole) con_exit stdcall (0);	209	IF(initConsole) con_exit stdcall (0);
204	ExitProcess();	210	ExitProcess();
205	}	211	}

Subversion Repositories Kolibri OS

(root)/programs/cmm/lisp/lisp.c – Rev 7564 → 7565