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