?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed buffer overflow in mserver; fixed type of checkinfo () 2nd parameter; memory
[ZeXOS.git] / apps / zasm / source.c
blob164018a2e51e81750f6a5aab5f6f0410e4c221a8
1 /*
2 * ZeX/OS
3 * Copyright (C) 2008 Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
4 * Copyright (C) 2009 Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <fcntl.h>
24 #include <ctype.h>
25 #include <unistd.h>
26 #include "buffer.h"
27 #include "source.h"
28
29 var_t var_list;
30 var_t *function_curr;
31 unsigned bin_pos;
32 unsigned data_pos;
33
34
35 var_t *var_find (char *name)
36 {
37 var_t *var;
38
39 for (var = var_list.next; var != &var_list; var = var->next) {
40 if (!strcmp (var->name, name))
41 return var;
42 }
43
44 return 0;
45 }
46
47 var_t *var_create (char type, char *name, unsigned len, void *address, unsigned line)
48 {
49 var_t *var;
50
51 /* alloc and init context */
52 var = (var_t *) malloc (sizeof (var_t));
53
54 if (!var)
55 return 0;
56
57 var->type = type;
58
59 var->name = (char *) malloc (sizeof (char) * (len + 1));
60
61 if (!var->name)
62 return 0;
63
64 memcpy (var->name, name, len);
65 var->name[len] = '\0';
66
67 var->address = address;
68 var->offset = 0;
69
70 /* add into list */
71 var->next = &var_list;
72 var->prev = var_list.prev;
73 var->prev->next = var;
74 var->next->prev = var;
75
76 printf ("var_create () -> '%s' on line %d\n", var->name, line);
77
78 return var;
79 }
80
81 int source_nextline (char *source, unsigned size)
82 {
83 unsigned i;
84
85 for (i = 0; i < size; i ++) {
86 //printf ("znak: %c : %d\n", source[i], source[i]);
87 if (source[i] == '\n') {
88 //printf ("source_nextline: %d\n", i);
89 return i;
90 }
91 }
92
93 return 0;
94 }
95
96 char *source_param (char *source, unsigned *size)
97 {
98 unsigned i;
99 char *param = (char *) 0;
100 unsigned len = *size;
101
102 for (i = 0; i < len; i ++) {
103 if (!param) {
104 if (source[i] == ' ' || source[i] == '\t') {
105 i ++;
106 continue;
107 }
108
109 if ((source[i] >= 'a' && source[i] <= 'z') ||
110 (source[i] >= 'A' && source[i] <= 'Z') ||
111 (source[i] >= '0' && source[i] <= '9'))
112 param = source + i;
113 } else if (source[i] == ' ' || source[i] == '\t' || source[i] == '\n' || source[i] == ';') {
114 *size = i;
115 return param;
116 }
117 }
118
119 return 0;
120 }
121
122 char *source_paramfirst (char *source, unsigned *size)
123 {
124 unsigned i;
125 char *param = (char *) 0;
126 unsigned len = *size;
127
128 for (i = 0; i < len; i ++) {
129 if (!param) {
130 if (source[i] == ' ' || source[i] == '\t')
131 continue;
132
133 if ((source[i] >= 'a' && source[i] <= 'z') ||
134 (source[i] >= 'A' && source[i] <= 'Z') ||
135 (source[i] >= '0' && source[i] <= '9'))
136 param = source + i;
137 } else if (source[i] == ' ' || source[i] == ',' || source[i] == '\t') {
138 *size = i;
139 return param;
140 }
141 }
142
143 return 0;
144 }
145
146 char *source_paramsecond (char *source, unsigned *size)
147 {
148 unsigned i;
149 char *param = (char *) 0;
150 unsigned len = *size;
151
152 for (i = 0; i < len; i ++) {
153 if (!param) {
154 if (source[i] == ' ' || source[i] == '\t' || source[i] == ',')
155 continue;
156
157 if ((source[i] >= 'a' && source[i] <= 'z') ||
158 (source[i] >= 'A' && source[i] <= 'Z') ||
159 (source[i] >= '0' && source[i] <= '9'))
160 param = source + i;
161 else if (source[i] == '\'')
162 param = source + i;
163 } else if (source[i] == ' ' || source[i] == '\t' || source[i] == '\n' || source[i] == ';') {
164 *size = i-2;
165 return param;
166 }
167 }
168
169 return 0;
170 }
171
172 int source_parse (char *source, unsigned size)
173 {
174 unsigned i;
175 unsigned line = 1;
176
177 for (i = 0; i < size; i ++) {
178 /* GLOBAL */
179 if (!strncmp ("global ", source+i, 7)) {
180 unsigned var = size-i-7;
181 char *param = source_param (source+i+7, &var);
182
183 if (!param) {
184 printf ("ERROR -> !param\n");
185 return 0;
186 }
187
188 var_create (VAR_TYPE_GLOBAL, param, var, (void *) 0x0 + i, line);
189
190 i += source_nextline (source+i, size-i);
191
192 line ++;
193 continue;
194 }
195
196 /* MOV */
197 if (!strncmp ("mov ", source+i, 4)) {
198 unsigned reg_len = size-i-4;
199 char *paramreg = source_paramfirst (source+i+4, &reg_len);
200
201 if (!paramreg) {
202 printf ("ERROR -> !paramreg\n");
203 return 0;
204 }
205
206 unsigned val_len = size-reg_len-i-4;
207 char *paramval = source_paramsecond (source+i+reg_len+4, &val_len);
208
209 if (!paramval) {
210 printf ("ERROR -> !val_len\n");
211 return 0;
212 }
213
214 i += source_nextline (source+i, size-i);
215
216 paramreg[reg_len] = '\0';
217 paramval[val_len] = '\0';
218
219 printf ("mov: %s, %s\n", paramreg, paramval);
220
221 unsigned char reg = 0;
222
223 if (paramval[0] != 'e') { /* MOV 8bit/32bit */
224 if (paramreg[0] == 'e' && paramreg[1] == 'a' && paramreg[2] == 'x')
225 reg = 0xb8; // eax
226 else if (paramreg[0] == 'e' && paramreg[1] == 'b' && paramreg[2] == 'x')
227 reg = 0xbb; // ebx
228 else if (paramreg[0] == 'e' && paramreg[1] == 'c' && paramreg[2] == 'x')
229 reg = 0xb9; // ecx
230 else if (paramreg[0] == 'e' && paramreg[1] == 'd' && paramreg[2] == 'x')
231 reg = 0xba; // edx
232
233 buffer_copy (bin_pos, (void *) &reg, 1);
234 bin_pos ++;
235
236 /* Let's convert parameter to binary number */
237 if (paramval[0] == '\'') {
238 if (val_len < 3) {
239 printf ("ERROR -> wrong parameter syntax - %d != 3, line: %d\n", val_len, line);
240 return 0;
241 }
242
243 if (paramval[2] != '\'' || paramval[1] == '\'') {
244 printf ("ERROR -> wrong parameter syntax, line: %d\n", line);
245 return 0;
246 }
247
248 int c = paramval[1];
249 //printf ("mov val char = %c\n", c);
250
251 buffer_copy (bin_pos, (void *) &c, sizeof (int));
252 bin_pos += sizeof (int);
253
254 } else if (paramval[0] == '0' && paramval[1] == 'x') {
255 char *endptr, *str = paramval+2;
256
257 long val = strtol (str, &endptr, 16);
258
259 //printf ("mov val hexa = %d\n", val);
260
261 buffer_copy (bin_pos, (void *) &val, sizeof (int));
262 bin_pos += sizeof (int);
263 } else if (paramval[0] >= '0' && paramval[0] <= '9') {
264 unsigned x;
265 for (x = 1; x < val_len-1; x ++) {
266 if (!(paramval[x] >= '0' && paramval[x] <= '9')) {
267 printf ("ERROR -> wrong parameter syntax - only numbers are allowed, line: %d\n", line);
268 return 0;
269 }
270 }
271
272 int num = atoi (paramval);
273
274 //printf ("mov val digit = %d\n", num);
275
276 buffer_copy (bin_pos, (void *) &num, sizeof (int));
277 bin_pos += sizeof (int);
278
279 } else {
280 var_t *var = var_find (paramval);
281
282 if (!var) {
283 printf ("ERROR -> unknown mov variable '%s', line %d\n", paramval, line);
284 return 0;
285 }
286
287 unsigned num = (unsigned) var->offset + 0x800000;
288
289 buffer_copy (bin_pos, (void *) &num, sizeof (unsigned));
290 bin_pos += sizeof (unsigned);
291 }
292
293 } else { /*MOV 32bit */
294
295 reg = 0x89; // 32bit
296
297 buffer_copy (bin_pos, (void *) &reg, 1);
298 bin_pos ++;
299
300 unsigned char regb = 0;
301
302 if (!strncmp (paramreg, "eax", 3)) {
303 if (!strncmp (paramval, "eax", 3))
304 regb = 0xc0;
305 else if (!strncmp (paramval, "ebx", 3))
306 regb = 0xd8;
307 else if (!strncmp (paramval, "ecx", 3))
308 regb = 0xc8;
309 else if (!strncmp (paramval, "edx", 3))
310 regb = 0xd0;
311 } else if (!strncmp (paramreg, "ebx", 3)) {
312 if (!strncmp (paramval, "eax", 3))
313 regb = 0xc3;
314 else if (!strncmp (paramval, "ebx", 3))
315 regb = 0xdb;
316 else if (!strncmp (paramval, "ecx", 3))
317 regb = 0xcb;
318 else if (!strncmp (paramval, "edx", 3))
319 regb = 0xd3;
320 } else if (!strncmp (paramreg, "ecx", 3)) {
321 if (!strncmp (paramval, "eax", 3))
322 regb = 0xc1;
323 else if (!strncmp (paramval, "ebx", 3))
324 regb = 0xd9;
325 else if (!strncmp (paramval, "ecx", 3))
326 regb = 0xc9;
327 else if (!strncmp (paramval, "edx", 3))
328 regb = 0xd1;
329 } else if (!strncmp (paramreg, "edx", 3)) {
330 if (!strncmp (paramval, "eax", 3))
331 regb = 0xc2;
332 else if (!strncmp (paramval, "ebx", 3))
333 regb = 0xda;
334 else if (!strncmp (paramval, "ecx", 3))
335 regb = 0xca;
336 else if (!strncmp (paramval, "edx", 3))
337 regb = 0xd2;
338 }
339
340 buffer_copy (bin_pos, (void *) &regb, 1);
341 bin_pos ++;
342
343 }
344
345 line ++;
346 continue;
347 }
348
349 /* CMP */
350 if (!strncmp ("cmp ", source+i, 4)) {
351 unsigned reg_len = size-i-4;
352 char *paramreg = source_paramfirst (source+i+4, &reg_len);
353
354 if (!paramreg) {
355 printf ("ERROR -> !paramreg\n");
356 return 0;
357 }
358
359 unsigned val_len = size-reg_len-i-4;
360 char *paramval = source_paramsecond (source+i+reg_len+4, &val_len);
361
362 if (!paramval) {
363 printf ("ERROR -> !val_len\n");
364 return 0;
365 }
366
367 i += source_nextline (source+i, size-i);
368
369 paramreg[reg_len] = '\0';
370 paramval[val_len] = '\0';
371
372 printf ("cmp: %s, %s\n", paramreg, paramval);
373
374 unsigned short reg = 0;
375 unsigned x = 2;
376
377 if (paramval[0] != 'e') { /* CMP 8bit/32bit */
378 if (paramreg[0] == 'e' && paramreg[1] == 'a' && paramreg[2] == 'x') {
379 reg = 0x3d; // eax
380 x = 1;
381 } else if (paramreg[0] == 'e' && paramreg[1] == 'b' && paramreg[2] == 'x')
382 reg = 0xfb81; // ebx
383 else if (paramreg[0] == 'e' && paramreg[1] == 'c' && paramreg[2] == 'x')
384 reg = 0xf981; // ecx
385 else if (paramreg[0] == 'e' && paramreg[1] == 'd' && paramreg[2] == 'x')
386 reg = 0xfa81; // edx
387
388 buffer_copy (bin_pos, (void *) &reg, x);
389 bin_pos += x;
390
391 /* Let's convert parameter to binary number */
392 if (paramval[0] == '\'') {
393 if (val_len < 3) {
394 printf ("ERROR -> wrong parameter syntax - %d != 3, line: %d\n", val_len, line);
395 return 0;
396 }
397
398 if (paramval[2] != '\'' || paramval[1] == '\'') {
399 printf ("ERROR -> wrong parameter syntax, line: %d\n", line);
400 return 0;
401 }
402
403 int c = paramval[1];
404 //printf ("mov val char = %c\n", c);
405
406 buffer_copy (bin_pos, (void *) &c, sizeof (int));
407 bin_pos += sizeof (int);
408
409 } else if (paramval[0] == '0' && paramval[1] == 'x') {
410 char *endptr, *str = paramval+2;
411
412 long val = strtol (str, &endptr, 16);
413
414 //printf ("mov val hexa = %d\n", val);
415
416 buffer_copy (bin_pos, (void *) &val, sizeof (int));
417 bin_pos += sizeof (int);
418 } else if (paramval[0] >= '0' && paramval[0] <= '9') {
419 unsigned x;
420 for (x = 1; x < val_len-1; x ++) {
421 if (!(paramval[x] >= '0' && paramval[x] <= '9')) {
422 printf ("ERROR -> wrong parameter syntax - only numbers are allowed, line: %d\n", line);
423 return 0;
424 }
425 }
426
427 int num = atoi (paramval);
428
429 //printf ("mov val digit = %d\n", num);
430
431 buffer_copy (bin_pos, (void *) &num, sizeof (int));
432 bin_pos += sizeof (int);
433
434 } else {
435 var_t *var = var_find (paramval);
436
437 if (!var) {
438 printf ("ERROR -> unknown mov variable '%s', line %d\n", paramval, line);
439 return 0;
440 }
441
442 unsigned num = (unsigned) var->offset + 0x800000;
443
444 buffer_copy (bin_pos, (void *) &num, sizeof (unsigned));
445 bin_pos += sizeof (unsigned);
446 }
447
448 } else { /* CMP 32bit */
449
450 reg = 0x39; // 32bit
451
452 buffer_copy (bin_pos, (void *) &reg, 1);
453 bin_pos ++;
454
455 unsigned char regb = 0;
456
457 if (!strncmp (paramreg, "eax", 3)) {
458 if (!strncmp (paramval, "eax", 3))
459 regb = 0xc0;
460 else if (!strncmp (paramval, "ebx", 3))
461 regb = 0xd8;
462 else if (!strncmp (paramval, "ecx", 3))
463 regb = 0xc8;
464 else if (!strncmp (paramval, "edx", 3))
465 regb = 0xd0;
466 } else if (!strncmp (paramreg, "ebx", 3)) {
467 if (!strncmp (paramval, "eax", 3))
468 regb = 0xc3;
469 else if (!strncmp (paramval, "ebx", 3))
470 regb = 0xdb;
471 else if (!strncmp (paramval, "ecx", 3))
472 regb = 0xcb;
473 else if (!strncmp (paramval, "edx", 3))
474 regb = 0xd3;
475 } else if (!strncmp (paramreg, "ecx", 3)) {
476 if (!strncmp (paramval, "eax", 3))
477 regb = 0xc1;
478 else if (!strncmp (paramval, "ebx", 3))
479 regb = 0xd9;
480 else if (!strncmp (paramval, "ecx", 3))
481 regb = 0xc9;
482 else if (!strncmp (paramval, "edx", 3))
483 regb = 0xd1;
484 } else if (!strncmp (paramreg, "edx", 3)) {
485 if (!strncmp (paramval, "eax", 3))
486 regb = 0xc2;
487 else if (!strncmp (paramval, "ebx", 3))
488 regb = 0xda;
489 else if (!strncmp (paramval, "ecx", 3))
490 regb = 0xca;
491 else if (!strncmp (paramval, "edx", 3))
492 regb = 0xd2;
493 }
494
495 buffer_copy (bin_pos, (void *) &regb, 1);
496 bin_pos ++;
497
498 }
499
500 line ++;
501 continue;
502 }
503
504 /* INT */
505 if (!strncmp ("int ", source+i, 4)) {
506 unsigned var = size-i-4;
507 char *param = source_param (source+i+4, &var);
508
509 if (!param) {
510 printf ("ERROR -> !param\n");
511 return 0;
512 }
513
514 i += source_nextline (source+i, size-i);
515
516 unsigned char intr = 0xcd; // int
517 buffer_copy (bin_pos, (void *) &intr, 1);
518 bin_pos ++;
519
520 param[var] = '\0';
521
522 if (param[0] == '0' && param[1] == 'x') {
523 char *endptr, *str = param+2;
524
525 long val = strtol (str, &endptr, 16);
526
527 //printf ("int: 0x%x\n", val);
528
529 buffer_copy (bin_pos, (void *) &val, 1);
530 bin_pos ++;
531 } else {
532 unsigned x;
533 for (x = 0; x < var; x ++) {
534 if (!isdigit (param[x])) {
535 printf ("ERROR -> wrong parameter syntax - only numbers are allowed, line: %d\n", line);
536 return 0;
537 }
538 }
539
540 int num = atoi (param);
541
542 buffer_copy (bin_pos, (void *) &num, 1);
543 bin_pos ++;
544 }
545
546 printf ("int: %s\n", param);
547
548 line ++;
549 continue;
550 }
551
552 /* JMP */
553 if (!strncmp ("jmp ", source+i, 4)) {
554 unsigned v = size-i-4;
555 char *param = source_param (source+i+4, &v);
556
557 if (!param) {
558 printf ("ERROR -> !param\n");
559 return 0;
560 }
561
562 i += source_nextline (source+i, size-i);
563
564 unsigned char jmp = 0xeb; // jmp
565 buffer_copy (bin_pos, (void *) &jmp, 1);
566 bin_pos ++;
567
568 param[v] = '\0';
569
570 var_t *var = var_find (param);
571
572 if (!var) {
573 printf ("ERROR -> unknown variable '%s', line %d\n", source+i, line);
574 return 0;
575 }
576
577 unsigned diff = (bin_pos - var->offset);
578
579 if (diff > 0xff) {
580 printf ("ERROR -> it is not 'near jump', line %d\n", line);
581 return 0;
582 }
583
584 unsigned char val = 0xff - diff;
585
586 buffer_copy (bin_pos, (void *) &val, 1);
587 bin_pos ++;
588
589 printf ("jmp: %s\n", param);
590
591 line ++;
592 continue;
593 }
594
595 /* JNZ */
596 if (!strncmp ("jnz ", source+i, 4)) {
597 unsigned v = size-i-4;
598 char *param = source_param (source+i+4, &v);
599
600 if (!param) {
601 printf ("ERROR -> !param\n");
602 return 0;
603 }
604
605 i += source_nextline (source+i, size-i);
606
607 unsigned char jmp = 0x75; // jnz
608 buffer_copy (bin_pos, (void *) &jmp, 1);
609 bin_pos ++;
610
611 param[v] = '\0';
612
613 var_t *var = var_find (param);
614
615 if (!var) {
616 printf ("ERROR -> unknown variable '%s', line %d\n", source+i, line);
617 return 0;
618 }
619
620 unsigned diff = (bin_pos - var->offset);
621
622 if (diff > 0xff) {
623 printf ("ERROR -> it is not 'near jump not-zero', line %d\n", line);
624 return 0;
625 }
626
627 unsigned char val = 0xff - diff;
628
629 buffer_copy (bin_pos, (void *) &val, 1);
630 bin_pos ++;
631
632 printf ("jnz: %s\n", param);
633
634 line ++;
635 continue;
636 }
637
638 /* JZ */
639 if (!strncmp ("jz ", source+i, 3)) {
640 unsigned v = size-i-3;
641 char *param = source_param (source+i+3, &v);
642
643 if (!param) {
644 printf ("ERROR -> !param\n");
645 return 0;
646 }
647
648 i += source_nextline (source+i, size-i);
649
650 unsigned char jmp = 0x74; // jz
651 buffer_copy (bin_pos, (void *) &jmp, 1);
652 bin_pos ++;
653
654 param[v] = '\0';
655
656 var_t *var = var_find (param);
657
658 if (!var) {
659 printf ("ERROR -> unknown variable '%s', line %d\n", source+i, line);
660 return 0;
661 }
662
663 unsigned diff = (bin_pos - var->offset);
664
665 if (diff > 0xff) {
666 printf ("ERROR -> it is not 'near jump zero', line %d\n", line);
667 return 0;
668 }
669
670 unsigned char val = 0xff - diff;
671
672 buffer_copy (bin_pos, (void *) &val, 1);
673 bin_pos ++;
674
675 printf ("jz: %s\n", param);
676
677 line ++;
678 continue;
679 }
680
681 /* INC */
682 if (!strncmp ("inc ", source+i, 4)) {
683 unsigned v = size-i-4;
684 char *param = source_param (source+i+4, &v);
685
686 if (!param) {
687 printf ("ERROR -> !param\n");
688 return 0;
689 }
690
691 i += source_nextline (source+i, size-i);
692
693 param[v] = '\0';
694
695 if (v < 2) {
696 printf ("ERROR -> inc: bad register name '%s', line %d\n", param, line);
697 return 0;
698 }
699
700 unsigned char reg = 0;
701
702 if (!strncmp (param, "eax", 3))
703 reg = 0x40;
704 else if (!strncmp (param, "ebx", 3))
705 reg = 0x43;
706 else if (!strncmp (param, "ecx", 3))
707 reg = 0x41;
708 else if (!strncmp (param, "edx", 3))
709 reg = 0x42;
710
711 buffer_copy (bin_pos, (void *) &reg, 1);
712 bin_pos ++;
713
714 printf ("inc: %s\n", param);
715
716 line ++;
717 continue;
718 }
719
720 /* RET */
721 if (!strncmp ("ret", source+i, 3)) {
722 if (!function_curr) {
723 printf ("ERROR -> ret cannot be called out of function, line: %d\n", line);
724 return 0;
725 }
726
727 printf ("Function %s end on line %d\n", function_curr->name, line);
728
729 function_curr = 0;
730
731 unsigned char ret = 0xc3;
732 buffer_copy (bin_pos, (void *) &ret, 1);
733 bin_pos ++;
734
735 i += source_nextline (source+i, size-i);
736
737 line ++;
738 continue;
739 }
740
741 /* HLT */
742 if (!strncmp ("hlt", source+i, 3)) {
743 unsigned char hlt = 0xf4;
744 buffer_copy (bin_pos, (void *) &hlt, 1);
745 bin_pos ++;
746
747 i += source_nextline (source+i, size-i);
748
749 line ++;
750 continue;
751 }
752
753 if ((source[i] >= 'a' && source[i] <= 'z') || (source[i] >= 'A' && source[i] <= 'Z')) {
754 unsigned y;
755
756 for (y = i; y < size-i; y ++) {
757 /* Function */
758 if (source[y] == ':') {
759 source[y] = '\0';
760
761 var_t *var = var_find (source+i);
762
763 if (!var) {
764 printf ("ERROR -> unknown variable '%s', line %d\n", source+i, line);
765 return 0;
766 }
767
768 printf ("Function '%s' on line %d\n", var->name, line);
769
770 var->offset = bin_pos;
771
772 function_curr = var; // set current function
773 break;
774 }
775
776 if (source[y] == ' ' || source[y] == '\t' || source[y] == '\n' || source[y] == 32 || source[y] == ';') {
777 /* register db variable */
778 if (!strncmp (source+y, " db ", 4)) {
779 unsigned m = 0;
780 while (m < y) {
781 if (source[i+m] == ' ')
782 break;
783
784 m ++;
785 }
786 var_t *var = var_create (VAR_TYPE_DB, source+i, m, (void *) 0x0 + i, line);
787
788 if (!var)
789 return 0;
790
791 var->offset = data_pos;
792
793 unsigned r = source_nextline (source+y+4, size-y-4);
794
795 if (r > 2) {
796 if (source[y+4] == '\'') {
797 unsigned k = 0;
798 while (k < r) {
799 if (source[y+6+k] == '\'')
800 break;
801
802 k ++;
803 }
804
805 buffer_copy (data_pos, (char *) source+y+5, k+1);
806 data_pos += (k+1);
807
808 if (source[y+7+k] == ',') {
809 char *param = source+y+8+k;
810
811 /* jump over space */
812 if (param[0] == ' ')
813 param ++;
814
815 k = 0;
816 while (k < r) {
817 if (!(param[k] >= 'a' && param[k] <= 'z') &&
818 !(param[k] >= 'A' && param[k] <= 'Z') &&
819 !(param[k] >= '0' && param[k] <= '9')) {
820 param[k] = '\0';
821 break;
822 }
823
824 k ++;
825 }
826
827 if (param[0] == '0' && param[1] == 'x') {
828 char *endptr2, *str2 = param+2;
829
830 long v = strtol (str2, &endptr2, 16);
831
832 buffer_copy (data_pos, (void *) &v, 1);
833 data_pos ++;
834 } else {
835 unsigned x;
836 for (x = 0; x < 4; x ++) {
837 if (!isdigit (param[x])) {
838 printf ("ERROR -> wrong parameter syntax - only numbers are allowed, line: %d\n", line);
839 return 0;
840 }
841 }
842
843 int num = atoi (param);
844
845 buffer_copy (data_pos, (void *) &num, 1);
846 data_pos ++;
847 }
848 }
849 }
850 } else {
851 printf ("ERROR -> db variable - wrong syntax, line: %d\n", line);
852 return 0;
853 }
854
855 y += r+4;
856
857 break;
858 } else {
859 source[y] = '\0';
860 printf ("ERROR -> unknown command '%s', line: %d\n", source+i, line);
861 return 0;
862 }
863 }
864 }
865
866 i = y;
867 } else {
868 //if (source[i] != ' ' || source[i] != ';')
869 //printf ("ERROR -> unspecified character '%c', line: %d\n", source[i], line);
870 if (source[i] == ';') {
871 i += source_nextline (source+i, size-i);
872 line ++;
873 continue;
874 }
875 }
876
877 if (source[i] == '\n')
878 line ++;
879 }
880
881 return 1;
882 }
883
884 char *source_open (char *file, unsigned *size)
885 {
886 /* int fd = open (file, O_RDONLY);
887
888 if (!fd) {
889 printf ("error -> file '%s' not found !\n", file);
890 return 0;
891 }
892
893 char *buffer = (char *) malloc (sizeof (char) * 10240);
894
895 if (!buffer) {
896 printf ("ERROR -> out of memory !\n");
897 return 0;
898 }
899
900 int ret;
901 unsigned l = 0;
902
903 while (1) {
904 ret = read (fd, buffer+l, 512);
905
906 if (ret < 1)
907 break;
908
909 l += (unsigned) ret;
910 }
911
912 *size = l;
913
914 close (fd);
915
916 printf ("Source: %s\n-=-=-=-=-=-=-=-=-\n\n", buffer);*/
917
918 FILE *f = fopen (file, "r");
919
920 if (!f) {
921 printf ("error -> file '%s' not found !\n", file);
922 return 0;
923 }
924
925 fseek (f, 0, SEEK_END);
926 unsigned flen = ftell (f);
927 fseek (f, 0, SEEK_SET);
928
929 *size = flen;
930
931 char *buffer = (char *) malloc (sizeof (char) * flen + 1);
932
933 if (!buffer) {
934 printf ("ERROR -> out of memory !\n");
935 return 0;
936 }
937
938 fread (buffer, flen, 1, f);
939
940 fclose (f);
941
942 return buffer;
943 }
944
945 int source_init ()
946 {
947 var_list.next = &var_list;
948 var_list.prev = &var_list;
949
950 bin_pos = 0x1000;
951 data_pos = 0x2000;
952
953 function_curr = 0;
954
955 return 1;
956 }
Operating System