Subversion Repositories Kolibri OS

Rev

Rev 7745 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 7745 Rev 7844
Line 1... Line 1...
1 
/*
 1 
/*
2 
 * Author Pavel Iakovlev
 2 
 * Author Pavel Iakovlev by PaulCodeman
3 
*/
 3 
*/
Line 4... Line 4...
4 
 
 4 
 
Line 5... Line 5...
5 
#define MEMSIZE 4096*10
 5 
#define MEMSIZE 4096*10
6 
 
 6 
 
7 
#include "../lib/io.h"
 - 
 
Line 8... Line 7...
8 
#include "../lib/obj/console.h"
 7 
#include "../lib/io.h"
9 
#include "../lib/array.h"
 - 
 
10 
 
 8 
#include "../lib/obj/console.h"
11 
byte initConsole = 0;
 - 
 
12 
Dictionary functions = {0};
 9 
 
13 
Dictionary variables = {0};
 - 
 
14 
 
 10 
#define TString 1
15 
#include "stdcall.h"
 11 
#define TSymbol 2
16 
 
 12 
#define TNumber 3
17 
#define bufferSize 10000;
 13 
#define TList   4
Line 18... Line -...
18 
#define memoryBrainfuck 30000*4
 - 
 
19 
#define memoryByteBF 1
 - 
 
20 
#define stackBrainFuck 4*1024
 - 
 
21 
 
 - 
 
22 
#define TStr 1
 - 
 
23 
#define TInt 2
 14 
#define Proc    5
Line -... Line 15...
- 
 
 15 
#define Lambda  6
- 
 
 16 
#define TObject 7
24 
#define TSym 3
 17 
 
25 
#define TBol 4
 18 
#define sizeStruct 4*4
26 
 
 19 
 
27 
#define TLen 4*5
 - 
 
28 
 
 20 
byte initConsole = 0;
29 
dword buffer = 0;
 21 
dword maxLoop = 100;
30 
word bufferSymbol = 0;
 22 
dword buffer = 0;
Line 31... Line 23...
31 
dword memory = 0;
 23 
dword bufferSize = 1000;
32 
 
 24 
dword variable = 0;
33 
dword stack = 0;
 25 
dword key = 0;
34 
dword code = 0;
 26 
dword treeItem = 0;
Line 42... Line 34...
42 
		con_init stdcall (-1, -1, -1, -1, "Lisp interpreter");
 34 
		con_init stdcall (-1, -1, -1, -1, "Lisp interpreter");
43 
		initConsole = 0xFF;
 35 
		initConsole = 0xFF;
44 
	}
 36 
	}
45 
}
 37 
}
Line -... Line 38...
- 
 
 38 
 
- 
 
 39 
dword error_message(dword text)
- 
 
 40 
{
- 
 
 41 
	con_printf stdcall (text);
- 
 
 42 
	ExitProcess();
- 
 
 43 
}
46 
 
 44 
 
- 
 
 45 
dword crc32Table = 0;
47 
dword evalLisp()
 46 
dword makeCRCTable(void)
48 
{
 - 
 
49 
	byte s = 0;
 - 
 
50 
	byte args = 0;
 - 
 
51 
	dword pos = 0;
 - 
 
52 
	dword name = 0;
 - 
 
53 
	dword tmp = 0;
 - 
 
54 
	dword tmp2 = 0;
 - 
 
55 
	dword dataArgs = 0;
 - 
 
56 
	dword posArgs = 0;
 - 
 
57 
	dword ret = 0;
 - 
 
58 
	dword p = 0;
 47 
{
- 
 
 48 
	dword i = 0;
59 
	dword i = 0;
 49 
	dword c = 0;
- 
 
 50 
	dword ii = 0;
- 
 
 51 
	dword crcTable = 0;
60 
	dword ii = 0;
 52 
	IF (crc32Table) RETURN 0;
61 
	dataArgs = malloc(16*4);
 53 
	crc32Table = malloc(4*256);
62 
	posArgs = dataArgs;
 - 
 
63 
 
 54 
	crcTable = crc32Table;
64 
	loop()
 55 
	WHILE (i < 256)
65 
	{
 56 
	{
- 
 
 57 
		c = i;
66 
		s = DSBYTE[code];
 58 
		ii = 0;
67 
		while (s == ' ') || (s == 9) || (s == 10) || (s == 13)
 59 
		WHILE (ii < 8)
- 
 
 60 
		{
- 
 
 61 
			IF (c&1)
- 
 
 62 
			{
- 
 
 63 
				c >>= 1;
- 
 
 64 
				c ^= 0xEDB88320;
- 
 
 65 
			}
68 
		{
 66 
			ELSE c >>= 1;
- 
 
 67 
			ii++;
69 
			code++;
 68 
		}
- 
 
 69 
		DSDWORD[crcTable] = c;
- 
 
 70 
		crcTable += 4;
70 
			s = DSBYTE[code];
 71 
		i++;
- 
 
 72 
	}
71 
		}
 73 
}
72 
		if (!s) return 0;
 - 
 
73 
		if (s==')')
74 
dword crc32(dword bytes)
74 
		{
 75 
{
75 
			code++;
 76 
	dword crc = 0;
76 
			args--;
 77 
	byte b = 0;
- 
 
 78 
	IF (!crc32Table) makeCRCTable();
- 
 
 79 
	crc = 0xFFFFFFFF;
- 
 
 80 
	WHILE (DSBYTE[bytes])
- 
 
 81 
	{
- 
 
 82 
		b = DSBYTE[bytes];
- 
 
 83 
		bytes++;
77 
			ret = StdCall(args, name, dataArgs);
 84 
		EDX = crc^b;
- 
 
 85 
		EDX &= 0xFF;
78 
			free(name);
 86 
		EDX <<= 2;
79 
			//free(dataArgs);
 87 
		EDX += crc32Table;
- 
 
 88 
		crc >>= 8;
- 
 
 89 
		crc ^= DSDWORD[EDX];
- 
 
 90 
	}
80 
			return ret;
 91 
	RETURN crc ^ 0xFFFFFFFF;
- 
 
 92 
}
81 
		}
 93 
 
82 
		if(s == '(')
94 
dword indexArray(dword address, key)
83 
		{
 95 
{
84 
			code++;
 96 
	dword offset = key&11b;
85 
			DSDWORD[posArgs] = evalLisp();
 97 
	dword offsetAddress = offset*4+address;
86 
			args++;
 98 
	IF (key==offset) RETURN 4*4+offsetAddress;
87 
			posArgs += 4;
 99 
	IF (!DSDWORD[offsetAddress]) DSDWORD[offsetAddress] = malloc(4*4*2);
88 
			continue;
 100 
	RETURN indexArray(DSDWORD[offsetAddress], key>>2);
- 
 
 101 
}
89 
		}
 102 
 
90 
		else if (!args)
103 
void set_procedure(dword name, address)
- 
 
 104 
{
91 
		{
 105 
	dword data = 0;
- 
 
 106 
	data = malloc(sizeStruct);
- 
 
 107 
	DSDWORD[data] = Proc;
- 
 
 108 
	DSDWORD[data+4] = address;
- 
 
 109 
	indexArray(variable, crc32(name));
- 
 
 110 
	DSDWORD[EAX] = data;
- 
 
 111 
}
- 
 
 112 
 
92 
			if (s != ')') // name function
 113 
void set_variable(dword name, data)
93 
			{
 114 
{
94 
				name = malloc(100);
 115 
	indexArray(variable, crc32(name));
- 
 
 116 
	DSDWORD[EAX] = data;
- 
 
 117 
}
95 
				pos = name;
 118 
 
96 
				while (s) && (s != ' ') && (s != ')')
 119 
dword string(dword lisp)
- 
 
 120 
{
97 
				{
 121 
	dword buffer = 0;
98 
					DSBYTE[pos] = s;
 122 
	if (DSDWORD[lisp] == TList)
- 
 
 123 
	{
99 
					pos++;
 124
100 
					code++;
 - 
 
101 
					s = DSBYTE[code];
 125 
		return "";
- 
 
 126 
	}
- 
 
 127 
	switch (DSDWORD[lisp])
- 
 
 128 
	{
- 
 
 129 
		case TString:
- 
 
 130 
		case TSymbol:
- 
 
 131 
			return DSDWORD[lisp+4];
- 
 
 132 
		case TNumber:
- 
 
 133
- 
 
 134 
			return itoa(DSDWORD[lisp+4]);
102 
				}
135 
		case Lambda:
103 
				DSBYTE[pos] = 0;
 136 
			return "[LAMBDA]";
- 
 
 137 
		case Proc:
- 
 
 138 
			return "[PROC]";
- 
 
 139 
		case TObject:
104 
				args++;
 140 
			return "[OBJECT]";
- 
 
 141 
		case TList:
105 
				continue;
 142 
			return "[LIST]";
106 
			}
 143 
	}
107 
		}
 144 
}
- 
 
 145 
 
108 
		else
 146 
dword number(dword lisp)
109 
		{
 147 
{
110 
			if (s >= '0') && (s <= '9')
 148 
	if (DSDWORD[lisp] == TNumber)
111 
			{
 149 
	{
- 
 
 150 
		return DSDWORD[lisp+4];
112 
				tmp = 0;
 151 
	}
113 
				while (s >= '0') && (s <= '9')
 152 
	if (DSDWORD[lisp] == TString)
114 
				{
 - 
 
115 
					tmp *= 10;
 - 
 
116 
					tmp += s-'0';
 - 
 
117 
					code++;
 153 
	{
118 
					s = DSBYTE[code];
 154 
		//return atoi(DSDWORD[lisp+4]);
119 
				}
 155 
	}
120 
				args++;
 - 
 
121 
				EDX = malloc(TLen);
 - 
 
122 
				DSDWORD[EDX] = tmp;
 - 
 
123 
				DSDWORD[EDX+4] = TInt;
 - 
 
124 
				DSDWORD[posArgs] = EDX;
 - 
 
125 
				posArgs += 4;
 - 
 
126 
				continue;
 156 
	return 0;
- 
 
 157 
}
- 
 
 158 
 
- 
 
 159 
dword lexer(dword code)
- 
 
 160 
{
- 
 
 161 
	byte s = 0;
127 
			}
 162 
	dword alloc = 0;
- 
 
 163 
	dword buffer = 0;
- 
 
 164 
	dword position = 0;
- 
 
 165 
	dword key = 0;
- 
 
 166 
	alloc = malloc(32);
- 
 
 167 
	//con_printf stdcall(code);
128 
			else if (s == '"')
 168 
	while(DSBYTE[code])
129 
			{
 - 
 
130 
				i = 1;
 169 
	{
131 
				tmp = malloc(1<
 - 
 
132 
				p = tmp;
 170 
		s = DSBYTE[code];
- 
 
 171 
		code++;
- 
 
 172 
		if (s == ' ') || (s == '\n') || (s == '\t') || (s == '\r') continue;
- 
 
 173 
		if (s == '(') || (s == ')')
- 
 
 174 
		{
- 
 
 175 
			buffer = malloc(2);
- 
 
 176 
			DSBYTE[buffer] = s;
- 
 
 177 
			indexArray(alloc, key);
- 
 
 178 
			DSDWORD[EAX] = buffer;
- 
 
 179 
			key++;
- 
 
 180 
			continue;
- 
 
 181 
		}
- 
 
 182 
		buffer = malloc(25);
- 
 
 183 
		position = buffer;
- 
 
 184 
		DSBYTE[position] = s;
- 
 
 185 
		if (s == '"')
- 
 
 186 
		{
- 
 
 187 
			while(DSBYTE[code])
133 
				code++;
 188 
			{
134 
				s = DSBYTE[code];
 189 
				s = DSBYTE[code];
135 
				ii = 0;
 190 
				position++;
- 
 
 191 
				DSBYTE[position] = s;
- 
 
 192 
				code++;
- 
 
 193 
				if (s == '"') && (DSBYTE[code-2] != '\\') break;
- 
 
 194 
			}
- 
 
 195 
		}
136 
				while (s != '"') && (s)
 196 
		else
- 
 
 197 
		{
- 
 
 198 
			while(DSBYTE[code])
- 
 
 199 
			{
- 
 
 200 
				s = DSBYTE[code];
- 
 
 201 
				if (s == ' ') || (s == '\n') || (s == '\t') || (s == '\r') || (s == '(') || (s == ')') break;
- 
 
 202 
				position++;
137 
				{
 203 
				DSBYTE[position] = s;
- 
 
 204 
				code++;
- 
 
 205 
			}
- 
 
 206 
		}
- 
 
 207 
		indexArray(alloc, key);
- 
 
 208 
		DSDWORD[EAX] = buffer;
- 
 
 209 
		key++;
- 
 
 210 
	}
138 
					ii++;
 211 
	indexArray(alloc, key);
- 
 
 212 
	DSDWORD[EAX] = 0;
- 
 
 213 
	/*key = 0;
- 
 
 214 
	do {
- 
 
 215 
	buffer = indexArray(alloc, key);
- 
 
 216 
	if (!DSDWORD[buffer]) break;
- 
 
 217 
	con_printf stdcall ("\r\n");
- 
 
 218 
	con_printf stdcall (DSDWORD[buffer]);key++;
- 
 
 219 
	} while(1);*/
- 
 
 220 
	return alloc;
- 
 
 221 
}
- 
 
 222 
 
- 
 
 223 
 
139 
					if (1<
 224 
dword tree(dword alloc)
- 
 
 225 
{
- 
 
 226 
	dword token = 0;
- 
 
 227 
	dword list = 0;
- 
 
 228 
	dword buffer = 0;
- 
 
 229 
	dword temp = 0;
- 
 
 230 
	dword listBuffer = 0;
- 
 
 231 
	dword i = 0;
- 
 
 232 
	token = indexArray(alloc, treeItem);
- 
 
 233 
	treeItem++;
- 
 
 234 
	buffer = DSDWORD[token];
- 
 
 235 
 
- 
 
 236 
	if (DSBYTE[buffer] == '(')
- 
 
 237 
	{
- 
 
 238 
		list = malloc(32);
- 
 
 239 
		while(1) {
- 
 
 240 
			token = indexArray(alloc, treeItem);
- 
 
 241 
			token = DSDWORD[token];
- 
 
 242 
			if (!token) || (DSBYTE[token] == ')') break;
- 
 
 243 
			buffer = indexArray(list, i);
140 
					{
 244 
			DSDWORD[buffer] = tree(alloc);
141 
						i++;
 - 
 
142 
						tmp2 = p-tmp;
 - 
 
143 
						tmp = realloc(tmp, 1<
 - 
 
144 
						p = tmp+tmp2;
 245 
			i++;
- 
 
 246 
		}
- 
 
 247 
		treeItem++;
145 
					}
 248 
		indexArray(list, i);
- 
 
 249 
		DSDWORD[EAX] = 0;
- 
 
 250 
		malloc(sizeStruct);
- 
 
 251 
		DSDWORD[EAX] = TList;
146 
					DSBYTE[p] = s;
 252 
		DSDWORD[EAX+4] = list;
- 
 
 253 
		return EAX;
- 
 
 254 
	}
- 
 
 255 
	return atom(DSDWORD[token]);
Line -... Line 256...
- 
 
 256 
}
- 
 
 257 
 
147 
					p++;
 258 
dword hexdec2(dword buffer, length)
148
259 
{
- 
 
 260 
	dword r = 0;
- 
 
 261 
	length += buffer;
- 
 
 262 
	while (length != buffer)
- 
 
 263 
	{
- 
 
 264 
		length--;
- 
 
 265 
		r <<= 4;
- 
 
 266 
		if (DSBYTE[length] >= 'A') && (DSBYTE[length] <= 'F') r |= DSBYTE[length]-'A'+10;
149 
					code++;
 267 
		else if (DSBYTE[length] >= 'a') && (DSBYTE[length] <= 'f') r |= DSBYTE[length]-'a'+10;
150 
					s = DSBYTE[code];
 - 
 
151 
				}
 - 
 
152 
				DSBYTE[p] = 0;
 - 
 
153 
				EDX = malloc(TLen);
 - 
 
154 
				DSDWORD[EDX] = tmp;
 - 
 
155 
				DSDWORD[EDX+4] = TStr;
 - 
 
156 
				DSDWORD[EDX+8] = p-tmp;
 - 
 
157 
				DSDWORD[posArgs] = EDX;
 - 
 
158 
				posArgs += 4;
 268 
		else if (DSBYTE[length] >= '0') && (DSBYTE[length] <= '9') r |= '9'-DSBYTE[length];
159 
				code++;
 - 
 
160 
				args++;
 269 
	}
161 
				continue;
 270 
	return r;
- 
 
 271 
}
162 
			}
 272 
 
163 
			else
 273 
dword atom(dword token)
164 
			{
 274 
{
- 
 
 275 
	dword buffer = 0;
165 
				tmp = malloc(20);
 276 
	dword pos = 0;
166 
				p = tmp;
 277 
	dword data = 0;
167 
				while (s) && (s != ')') && (s != '(') && (s != ' ') && (s != 10) && (s != 13)
 278 
	if (DSBYTE[token] == '-') && (DSBYTE[token+1] >= '0') && (DSBYTE[token+1] <= '9')
168 
				{
 279 
	{
169 
					DSBYTE[p] = s;
 280 
		malloc(sizeStruct);
170 
					p++;
 281 
		DSDWORD[EAX] = TNumber;
171 
					code++;
 282 
		DSDWORD[EAX+4] = atoi(token);
172 
					s = DSBYTE[code];
 283 
		return EAX;
173 
				}
 284 
	}
174 
				DSBYTE[p] = 0;
 285 
	if (DSBYTE[token] >= '0') && (DSBYTE[token] <= '9')
175 
				args++;
 286 
	{
176 
				EDX = malloc(TLen);
 287 
		while (DSBYTE[token]) && (DSBYTE[token] >= '0') && (DSBYTE[token] <= '9')
177 
				DSDWORD[EDX] = tmp;
 288 
		{
178 
				DSDWORD[EDX+4] = TSym;
 - 
 
179 
				DSDWORD[posArgs] = EDX;
 289 
			data *= 10;
180 
				posArgs += 4;
 290 
			data += DSBYTE[token]-'0';
Line -... Line 291...
- 
 
 291 
			token++;
- 
 
 292 
		}
181 
				continue;
 293 
 
182 
			}
 294 
		malloc(sizeStruct);
183
295 
		DSDWORD[EAX] = TNumber;
- 
 
 296 
		DSDWORD[EAX+4] = data;
- 
 
 297 
		return EAX;
- 
 
 298 
	}
- 
 
 299 
	if (DSBYTE[token] == '"')
184 
			DSDWORD[posArgs] = tmp;
 300 
	{
- 
 
 301 
		pos = token;
- 
 
 302 
		buffer = token;
- 
 
 303 
		pos++;
- 
 
 304 
		while (DSBYTE[pos]) && (DSBYTE[pos] != '"')
- 
 
 305 
		{
- 
 
 306 
			if (DSBYTE[pos] == '\\')
- 
 
 307 
			{
- 
 
 308 
				pos++;
- 
 
 309 
				switch (DSBYTE[pos])
- 
 
 310 
				{
- 
 
 311 
					case 'n': DSBYTE[buffer] = 13; break;
- 
 
 312 
					case 'r': DSBYTE[buffer] = 10; break;
- 
 
 313 
					case 't': DSBYTE[buffer] = 9;  break;
- 
 
 314 
					case 'x':
- 
 
 315 
						pos++;
- 
 
 316 
						DSBYTE[buffer] = hexdec2(pos, 2);
- 
 
 317 
						pos++;
- 
 
 318 
					break;
- 
 
 319 
					default:
- 
 
 320 
						DSBYTE[buffer] = DSBYTE[pos];
- 
 
 321 
				}
185 
			posArgs += 4;
 322 
			}
- 
 
 323 
			else DSBYTE[buffer] = DSBYTE[pos];
- 
 
 324 
			buffer++;
- 
 
 325 
			pos++;
- 
 
 326 
		}
- 
 
 327 
		DSBYTE[buffer] = 0;
- 
 
 328 
		malloc(sizeStruct);
- 
 
 329 
		DSDWORD[EAX] = TString;
- 
 
 330 
		DSDWORD[EAX+4] = token;
- 
 
 331 
		DSDWORD[EAX+8] = token-buffer;
- 
 
 332 
		return EAX;
- 
 
 333 
	}
- 
 
 334 
	pos = token;
- 
 
 335 
	while (DSBYTE[pos])
- 
 
 336 
	{
- 
 
 337 
		if (DSBYTE[pos] >= 'a') && (DSBYTE[pos] <= 'z') DSBYTE[pos] = DSBYTE[pos]-'a'+'A';
- 
 
 338 
		pos++;
- 
 
 339 
	}
- 
 
 340 
	malloc(sizeStruct);
- 
 
 341 
	DSDWORD[EAX] = TSymbol;
- 
 
 342 
	DSDWORD[EAX+4] = token;
- 
 
 343 
	return EAX;
- 
 
 344 
}
- 
 
 345 
 
- 
 
 346 
dword lisp(dword tree)
- 
 
 347 
{
- 
 
 348 
	dword buffer = 0;
- 
 
 349 
	dword list = 0;
- 
 
 350 
	dword args = 0;
- 
 
 351 
	dword key = 0;
- 
 
 352 
	dword item = 0;
- 
 
 353 
 
- 
 
 354 
	switch (DSDWORD[tree])
- 
 
 355 
	{
- 
 
 356 
		case TSymbol:
- 
 
 357 
			buffer = indexArray(variable, crc32(DSDWORD[tree+4]));
- 
 
 358 
			IF (!DSDWORD[buffer]) return tree;
- 
 
 359 
			return DSDWORD[buffer];
- 
 
 360 
		case TNumber:
- 
 
 361 
		case TString:
- 
 
 362 
			return tree;
- 
 
 363 
		case TList:
- 
 
 364 
			list = DSDWORD[tree+4];
- 
 
 365 
			buffer = indexArray(list, 0);
- 
 
 366 
			if (!buffer) {
- 
 
 367 
				malloc(sizeStruct);
- 
 
 368 
				DSDWORD[buffer] = TSymbol;
- 
 
 369 
				DSDWORD[buffer+4] = NIL;
- 
 
 370 
				return buffer;
- 
 
 371 
			}
- 
 
 372
- 
 
 373 
			buffer = DSDWORD[buffer];
- 
 
 374 
			if (DSDWORD[buffer] == TSymbol) || (DSDWORD[buffer] == TList)
- 
 
 375 
			{
- 
 
 376 
				buffer = DSDWORD[buffer+4];
- 
 
 377 
				if (DSBYTE[buffer] == '\'') return tree;
- 
 
 378 
 
- 
 
 379 
				args = malloc(32);
- 
 
 380 
				key = 0;
- 
 
 381 
				while (1)
- 
 
 382 
				{
- 
 
 383 
					buffer = indexArray(list, key);
- 
 
 384 
					buffer = DSDWORD[buffer];
- 
 
 385 
					if (!buffer) break;
- 
 
 386 
					item = indexArray(args, key);
- 
 
 387 
					DSDWORD[item] = lisp(buffer);
- 
 
 388 
					key++;
- 
 
 389 
				}
- 
 
 390 
				item = indexArray(args, 0);
- 
 
 391 
				item = DSDWORD[item];
- 
 
 392 
				if (DSDWORD[item] == Proc)
- 
 
 393 
				{
- 
 
 394 
					EAX = DSDWORD[item+4];
- 
 
 395 
					EAX(args);
- 
 
 396 
					if (!EAX)
- 
 
 397 
					{
- 
 
 398 
						malloc(sizeStruct);
- 
 
 399 
						DSDWORD[EAX] = TSymbol;
- 
 
 400 
						DSDWORD[EAX+4] = NIL;
- 
 
 401 
						return EAX;
- 
 
 402 
					}
- 
 
 403 
					return EAX;
- 
 
 404 
				}
- 
 
 405 
				malloc(sizeStruct);
- 
 
 406 
				DSDWORD[EAX] = TSymbol;
- 
 
 407 
				DSDWORD[EAX+4] = NIL;
- 
 
 408 
				return EAX;
- 
 
 409 
			}
- 
 
 410 
 
- 
 
 411 
			malloc(sizeStruct);
186 
		}
 412 
				DSDWORD[EAX] = TSymbol;
187 
		code++;
 - 
 
188 
		args++;
 - 
 
189 
	}
 - 
 
190 
	args--;
 - 
 
191 
	ret = StdCall(args, name, dataArgs);
 - 
 
192 
	free(name);
 413 
				DSDWORD[EAX+4] = NIL;
Line -... Line 414...
- 
 
 414 
				return EAX;
- 
 
 415 
	}
193 
	//free(dataArgs);
 416 
}
194 
	return ret;
 417 
 
195 
}
 418 
#include "stdcall.h"
196 
 
 419 
 
197 
void main()
 420 
void main()
Line 198... Line 421...
198 
{
 421 
{
199 
	dword brainFuckCode = 0;
 - 
 
200 
	word maxLoop = 1000;
 - 
 
Line -... Line 422...
- 
 
 422 
	dword xxx = 0;
201 
	dword txt = "(set name (input \"Enter you name: \"))(print \"You name \" (get name))";
 423 
	dword item = 0;
- 
 
 424 
	dword data = 0;
- 
 
 425
Line 202... Line 426...
202
426 
	buffer = malloc(bufferSize);
203 
	buffer = malloc(bufferSize);
 427 
 
204 
	memory = malloc(memoryBrainfuck);
 428 
	variable = malloc(32);
205 
	stack = malloc(stackBrainFuck);
 429 
	NIL = "NIL";
206
- 
 
207 
	Init();
 430 
 
208
431 
	initFunctionLisp();
209 
	IF(DSBYTE[I_Param])
 432
210 
	{
 433 
	if(DSBYTE[I_Param])
211 
		IF(io.read(I_Param))
 434 
	{
212 
		{
 435 
		IF(io.read(I_Param))
213 
			code = EAX;
 436 
		{
214 
			evalLisp();
 437 
			lisp(tree(lexer(EAX)));
215 
		}
 438 
		}
- 
 
 439 
	}
216 
	}
 440 
	else
217 
	else
441 
	{
218 
	{
 442 
		consoleInit();
219 
		consoleInit();
 443 
		con_printf stdcall ("Lisp v2.0\r\n");
220 
		con_printf stdcall ("Lisp interpreter v1.5\r\n");
 444 
		while(maxLoop)
221 
		while(maxLoop)
 - 
 
222 
		{
 445 
		{
223 
			con_printf stdcall ("\r\n$ ");
 446 
			treeItem = 0;
224 
			con_gets stdcall(buffer, bufferSize);
 447 
			con_printf stdcall ("\r\n$ ");
Line 225... Line 448...
225 
			code = EAX;
 448 
			con_gets stdcall(buffer+1, bufferSize);