History

Initial revision

bellard committed 25 years ago

Commit 27f6e16No parent (first commit)3 files · +978 −0Browse files

Unified · Split

3 files
  1. Makefile +52 −0
  2. TODO +6 −0
  3. tcc.c +920 −0
Makefile+52−0
@@ -0,0 +1,52 @@
1all: test cvt
2
3test: prog.bin
4 cmp -l prog.bin prog.bin.ref
5
6run: tc prog.c
7 ./tc prog.c
8
9run2: tc tc1.c prog.c
10 ./tc tc1.c prog.c
11
12run3: tc tc1.c prog.c
13 ./tc tc1.c tc1.c prog.c
14
15prog.bin: prog.c tct
16 ./tct prog.c $@
17 ndisasm -b 32 $@
18
19p2.bin: p2.c tct
20 ./tct $< $@
21 ndisasm -b 32 $@
22
23tct: tc.c
24 gcc -DTEST -O2 -g -o $@ $< -ldl
25
26tc: tc.c Makefile
27 gcc -O2 -Wall -g -o $@ $< -ldl
28
29tc1: tc1.c
30 gcc -O2 -Wall -g -o $@ $<
31
32cvt: cvt.c
33 gcc -O2 -Wall -g -o $@ $<
34
35instr.o: instr.S
36 gcc -O2 -Wall -g -c -o $@ $<
37
38tc.i: tc.c Makefile
39 gcc -E -P -DTINY -o $@ tc.c
40
41tc1.c: tc.i cvt Makefile
42 ./cvt $< $@
43 @ls -l $@
44
45test2: tct tc1.c
46 ./tct tc1.c tc2
47 ndisasm -b 32 tc2
48
49tc2: tc
50 ./tct < tc1.c > tc2
51 ndisasm -b 32 tc2
52
TODO+6−0
@@ -0,0 +1,6 @@
1
2- 'x'=
3- shifts
4- conditionnal ?:
5- constant propagation for '+', '-' and [].
6- verify function types
tcc.c+920−0
@@ -0,0 +1,920 @@
1#include <stdio.h>
2
3#define TEXT_SIZE 20000
4#define DATA_SIZE 2000
5#define SYM_TABLE_SIZE 10000
6#define VAR_TABLE_SIZE 4096
7
8/* vac: offset of variables
9 vat: type of variables
10 loc : local variable index
11 glo : global variable index
12 parm : parameter variable index
13 ind : output code ptr
14 lsym: loop symbol stack
15 rsym: return symbol
16 prog: output code
17 astk: arg position stack
18*/
19int tok, *vac, *vat, *lsym, rsym,
20 prog, ind, loc, glo, file, vt,
21 vc, *macro_stack, *macro_stack_ptr;
22char *idtable, *idptr, *idlast;
23
24/* The current value can be: */
25#define VT_CONST 0x0002 /* constant in vc */
26#define VT_VAR 0x0004 /* value is in eax */
27#define VT_LOCAL 0x0008 /* offset on stack */
28
29#define VT_LVAL 0x0010 /* const or var is an lvalue */
30#define VT_CMP 0x0020 /* the value is stored in processor flags (in vc) */
31#define VT_FORWARD 0x0040 /* value is forward reference (only used for functions) */
32#define VT_JMP 0x0080 /* value is the consequence of jmp. bit 0 is set if inv */
33
34#define VT_LVALN -17 /* ~VT_LVAL */
35
36/*
37 *
38 * VT_FUNC indicates a function. The return type is the stored type. A
39 * function pointer is stored as a 'char' pointer.
40 *
41 * If VT_PTRMASK is non nul, then it indicates the number of pointer
42 * iterations to reach the basic type.
43 *
44 * Basic types:
45 *
46 * VT_BYTE indicate a char
47 *
48 *
49 * otherwise integer type is assumed.
50 * */
51
52#define VT_BYTE 0x00001 /* byte pointer. HARDCODED VALUE */
53#define VT_PTRMASK 0x00f00 /* pointer mask */
54#define VT_PTRINC 0x00100 /* pointer increment */
55#define VT_FUNC 0x01000 /* function type */
56#define VT_TYPE 0x01f01 /* type mask */
57
58#define VT_TYPEN 0xffffe0fe /* ~VT_TYPE */
59#define VT_FUNCN -4097
60
61/* Special infos */
62#define VT_DEFINE 0x02000 /* special value for #defined symbols */
63
64/* token values */
65#define TOK_INT 256
66#define TOK_VOID 257
67#define TOK_CHAR 258
68#define TOK_IF 259
69#define TOK_ELSE 260
70#define TOK_WHILE 261
71#define TOK_BREAK 262
72#define TOK_RETURN 263
73#define TOK_DEFINE 264
74#define TOK_MAIN 265
75
76#define TOK_EQ 0x94 /* warning: depend on asm code */
77#define TOK_NE 0x95 /* warning: depend on asm code */
78#define TOK_LT 0x9c /* warning: depend on asm code */
79#define TOK_GE 0x9d /* warning: depend on asm code */
80#define TOK_LE 0x9e /* warning: depend on asm code */
81#define TOK_GT 0x9f /* warning: depend on asm code */
82
83#define TOK_LAND 0xa0
84#define TOK_LOR 0xa1
85
86#define TOK_DEC 0xa2
87#define TOK_MID 0xa3 /* inc/dec, to void constant */
88#define TOK_INC 0xa4
89
90#define TOK_SHL 0xe0 /* warning: depend on asm code */
91#define TOK_SHR 0xf8 /* warning: depend on asm code */
92
93#ifdef TEST
94void error(char *msg)
95{
96 printf("%d: %s\n", ftell(file), msg);
97 exit(1);
98}
99void warning(char *msg)
100{
101 printf("%d: warning: %s\n", ftell(file), msg);
102}
103#endif
104
105int inp()
106{
107#if 0
108 int c;
109 c = fgetc(file);
110 printf("c=%c\n", c);
111 return c;
112#else
113 return fgetc(file);
114#endif
115}
116
117int isid(c)
118{
119 return (c >= 'a' & c <= 'z') |
120 (c >= 'A' & c <= 'Z') |
121 c == '_';
122}
123
124int isnum(c)
125{
126 return c >= '0' & c <= '9';
127}
128
129#ifdef TEST
130void skip(c)
131{
132 if (tok != c) {
133 fprintf(stderr, "%d: '%c' expected\n", ftell(file), c);
134 exit(1);
135 }
136 next();
137}
138#else
139#define skip(c) next()
140#endif
141
142void next()
143{
144 int c, v;
145 char *q, *p;
146
147 while(1) {
148 c = inp();
149 if (c == 35) {
150 /* preprocessor: we handle only define */
151 next();
152 if (tok == TOK_DEFINE) {
153 next();
154 /* now tok is the macro symbol */
155 vat[tok] = VT_DEFINE;
156 vac[tok] = ftell(file);
157 }
158 /* ignore preprocessor or shell */
159 while (c != '\n')
160 c = inp();
161 } else if (c == '\n') {
162 /* end of line : check if we are in macro state. if so,
163 pop new file position */
164 if (macro_stack_ptr > macro_stack)
165 fseek(file, *--macro_stack_ptr, 0);
166 } else if (c != ' ' & c != 9)
167 break;
168 }
169 if (isid(c)) {
170 q = idptr;
171 idlast = q;
172 while(isid(c) | isnum(c)) {
173 *q++ = c;
174 c = inp();
175 }
176 *q++ = '\0';
177 ungetc(c, file);
178 p = idtable;
179 tok = 256;
180 while (p < idptr) {
181 if (strcmp(p, idptr) == 0)
182 break;
183 while (*p++);
184 tok++;
185 }
186 /* if not found, add symbol */
187 if (p == idptr)
188 idptr = q;
189 /* eval defines */
190 if (vat[tok] & VT_DEFINE) {
191 *macro_stack_ptr++ = ftell(file);
192 fseek(file, vac[tok], 0);
193 next();
194 }
195 } else {
196 q = "<=\236>=\235!=\225&&\240||\241++\244--\242==\224<<\340>>\370";
197 /* two chars */
198 v = inp();
199 while (*q) {
200 if (*q == c & q[1] == v) {
201 tok = q[2] & 0xff;
202 return;
203 }
204 q = q + 3;
205 }
206 ungetc(v, file);
207 /* single char substitutions */
208 if (c == '<')
209 tok = TOK_LT;
210 else if (c == '>')
211 tok = TOK_GT;
212 else
213 tok = c;
214 }
215}
216
217void g(c)
218{
219 *(char *)ind++ = c;
220}
221
222void o(c)
223{
224 while (c) {
225 g(c);
226 c = c / 256;
227 }
228}
229
230/* output a symbol and patch all calls to it */
231void gsym(t)
232{
233 int n;
234 while (t) {
235 n = *(int *)t; /* next value */
236 *(int *)t = ind - t - 4;
237 t = n;
238 }
239}
240
241/* psym is used to put an instruction with a data field which is a
242 reference to a symbol. It is in fact the same as oad ! */
243#define psym oad
244
245/* instruction + 4 bytes data. Return the address of the data */
246int oad(c, s)
247{
248 o(c);
249 *(int *)ind = s;
250 s = ind;
251 ind = ind + 4;
252 return s;
253}
254
255/* push to value stack */
256void vset(t, v)
257{
258 vt = t;
259 vc = v;
260}
261
262/* generate a value in eax from vt and vc */
263void gv()
264{
265#ifndef TINY
266 int t;
267#endif
268 if (vt & VT_LVAL) {
269 if ((vt & VT_TYPE) == VT_BYTE)
270 o(0xbe0f); /* movsbl x, %eax */
271 else
272 o(0x8b); /* movl x,%eax */
273 if (vt & VT_CONST)
274 oad(0x05, vc);
275 else if (vt & VT_LOCAL)
276 oad(0x85, vc);
277 else
278 g(0x00);
279 } else {
280 if (vt & VT_CONST) {
281 oad(0xb8, vc); /* mov $xx, %eax */
282 } else if (vt & VT_LOCAL) {
283 oad(0x858d, vc); /* lea xxx(%ebp), %eax */
284 } else if (vt & VT_CMP) {
285 oad(0xb8, 0); /* mov $0, %eax */
286 o(0x0f); /* setxx %al */
287 o(vc);
288 o(0xc0);
289 }
290#ifndef TINY
291 else if (vt & VT_JMP) {
292 t = vt & 1;
293 oad(0xb8, t); /* mov $1, %eax */
294 oad(0xe9, 5); /* jmp after */
295 gsym(vc);
296 oad(0xb8, t ^ 1); /* mov $0, %eax */
297 }
298#endif
299 }
300 vt = (vt & VT_TYPE) | VT_VAR;
301}
302
303/* generate a test. set 'inv' to invert test */
304/* XXX: handle constant */
305int gtst(inv, t)
306{
307 if (vt & VT_CMP) {
308 /* fast case : can jump directly since flags are set */
309 g(0x0f);
310 t = psym((vc - 16) ^ inv, t);
311 } else
312#ifndef TINY
313 if (vt & VT_JMP) {
314 /* && or || optimization */
315 if ((vt & 1) == inv)
316 t = vc;
317 else {
318 t = psym(0xe9, t);
319 gsym(vc);
320 }
321 } else
322 if ((vt & (VT_CONST | VT_LVAL)) == VT_CONST) {
323 /* constant jmp optimization */
324 if ((vc != 0) != inv)
325 t = psym(0xe9, t);
326 } else
327#endif
328 {
329 gv();
330 o(0xc085); /* test %eax, %eax */
331 g(0x0f);
332 t = psym(0x85 ^ inv, t);
333 }
334 return t;
335}
336
337/* return the size (in bytes) of a given type */
338int type_size(t)
339{
340 if ((t & VT_PTRMASK) > VT_PTRINC | (t & VT_TYPE) == VT_PTRINC)
341 return 4;
342 else
343 return 1;
344}
345
346#define POST_ADD 0x1000
347#define PRE_ADD 0
348
349/* a defines POST/PRE add. c is the token ++ or -- */
350void inc(a, c)
351{
352#ifdef TEST
353 if (!(vt & VT_LVAL))
354 error("lvalue expected\n");
355#endif
356 vt = vt & VT_LVALN;
357 gv();
358 o(0x018bc189); /* movl %eax, %ecx ; mov (%ecx), %eax */
359 o(0x408d | a); /* leal x(%eax), %eax/%edx */
360 g((c - TOK_MID) * type_size(vt));
361 o(0x0189 | a); /* mov %eax/%edx, (%ecx) */
362}
363
364/* op is '-' or '+' (or 0) */
365/* t is the type of the first operand */
366/* XXX: handle ptr sub and 'int + ptr' case (only 'ptr + int' handled) */
367void gen_op(op, t)
368{
369 gv();
370 o(0x59); /* pop %ecx */
371 if (op == '+' | op == '-') {
372 /* XXX: incorrect for short (futur!) */
373 if (type_size(t) != 1)
374 o(0x02e0c1); /* shl $2, %eax */
375 if (op == '-')
376 o(0xd8f7); /* neg %eax */
377 o(0xc801); /* add %ecx, %eax */
378 vt = t;
379 } else if (op == '&')
380 o(0xc821);
381 else if (op == '^')
382 o(0xc831);
383 else if (op == '|')
384 o(0xc809);
385 else if (op == '*')
386 o(0xc1af0f); /* imul %ecx, %eax */
387 else if (op == TOK_SHL | op == TOK_SHR) {
388 o(0xd391); /* xchg %ecx, %eax, shl/sar %cl, %eax */
389 o(op);
390 } else if (op == '/' | op == '%') {
391 o(0xd231); /* xor %edx, %edx */
392 o(0xf9f791); /* xchg %ecx, %eax, idiv %ecx, %eax */
393 if (op == '%')
394 o(0x92); /* xchg %edx, %eax */
395 } else {
396 o(0xc139); /* cmp %eax,%ecx */
397 vset(VT_CMP, op);
398 }
399}
400
401/* return 0 if no type declaration. otherwise, return the basic type
402 and skip it.
403 XXX: A '2' is ored to ensure non zero return if int type.
404 */
405int ist()
406{
407 int t;
408
409 if (tok == TOK_INT | tok == TOK_CHAR | tok == TOK_VOID) {
410 t = tok;
411 next();
412 return (t != TOK_INT) | 2;
413 } else {
414 return 0;
415 }
416}
417
418/* Read a type declaration (except basic type), and return the
419 type. If v is true, then also put variable name in 'vc' */
420int typ(v,t)
421{
422 int u, p, n;
423
424 t = t & -3; /* suppress the ored '2' */
425 while (tok == '*') {
426 next();
427 t = t + VT_PTRINC;
428 }
429
430 /* recursive type */
431 /* XXX: incorrect if abstract type for functions (e.g. 'int ()') */
432 if (tok == '(') {
433 next();
434 u = typ(v, 0);
435 skip(')');
436 } else {
437 u = 0;
438 /* type identifier */
439 if (v) {
440 vc = tok;
441 next();
442 }
443 }
444 /* function declaration */
445 if (tok == '(') {
446 next();
447 p = 4;
448 n = vc; /* must save vc there */
449 while (tok != ')') {
450 /* read param name and compute offset */
451 if (t = ist())
452 t = typ(1, t); /* XXX: should accept both arg/non arg if v == 0 */
453 else {
454 vc = tok;
455 t = 0;
456 next();
457 }
458 p = p + 4;
459 vat[vc] = VT_LOCAL | VT_LVAL | t;
460 vac[vc] = p;
461 if (tok == ',')
462 next();
463 }
464 next(); /* skip ')' */
465 vc = n;
466 if (u)
467 t = u + VT_BYTE;
468 else
469 t = t | VT_FUNC;
470 }
471 return t;
472}
473
474int getq(n)
475{
476 int c;
477 if (n == '\\') {
478 n = inp();
479 if (n == 'n')
480 n = '\n';
481 else if (isnum(n)) {
482 c = 0;
483 while (isnum(n)) {
484 c = c * 8 + n - '0';
485 n = inp();
486 }
487 ungetc(n, file);
488 return c;
489 }
490 }
491 return n;
492}
493
494void unary()
495{
496 int n, t, ft, fc, p;
497
498 if (isnum(tok)) {
499 /* number */
500 n = 0;
501 while (isnum(tok)) {
502 n = n * 10 + tok - '0';
503 next();
504 }
505 vset(VT_CONST, n);
506 } else if (tok == '\'') {
507 vset(VT_CONST, getq(inp()));
508 next(); /* skip char */
509 skip('\'');
510 } else if (tok == '\"') {
511 vset(VT_CONST | VT_PTRINC | VT_BYTE, glo);
512 while((n = inp()) != 34) {
513 *(char *)glo = getq(n);
514 glo++;
515 }
516 *(char *)glo = 0;
517 glo = (glo + 4) & -4; /* align heap */
518 next();
519 } else {
520 t = tok;
521 next();
522 if (t == '(') {
523 /* cast ? */
524 if (t = ist()) {
525 ft = typ(0, t);
526 skip(')');
527 unary();
528 vt = (vt & VT_TYPEN) | ft;
529 } else {
530 expr();
531 skip(')');
532 }
533 } else if (t == '*') {
534 unary();
535 if (vt & VT_LVAL)
536 gv();
537#ifdef TEST
538 if (!(vt & VT_PTRMASK))
539 error("pointer expected");
540#endif
541 vt = (vt - VT_PTRINC) | VT_LVAL;
542 } else if (t == '&') {
543 unary();
544#ifdef TEST
545 if (!(vt & VT_LVAL))
546 error("lvalue expected");
547#endif
548 vt = vt & VT_LVALN;
549 vt = vt + VT_PTRINC;
550 } else
551#ifndef TINY
552 if (t == '!') {
553 unary();
554 if (vt & VT_CMP)
555 vc = vc ^ 1;
556 else
557 vset(VT_JMP, gtst(1, 0));
558 } else
559 if (t == '~') {
560 unary();
561 if ((vt & (VT_CONST | VT_LVAL)) == VT_CONST)
562 vc = ~vc;
563 else {
564 gv();
565 o(0xd0f7);
566 }
567 } else
568#endif
569 if (t == TOK_INC | t == TOK_DEC) {
570 unary();
571 inc(PRE_ADD, t);
572 } else if (t == '-') {
573 unary();
574 if ((vt & (VT_CONST | VT_LVAL)) == VT_CONST)
575 vc = -vc;
576 else {
577 gv();
578 o(0xd8f7); /* neg %eax */
579 }
580 } else if (t == '+') {
581 unary();
582 } else {
583 vset(vat[t], vac[t]);
584 /* forward reference or external reference ? */
585 if (vt == 0) {
586 n = dlsym(0, idlast);
587 if (n == 0)
588 vset(VT_CONST | VT_FORWARD | VT_LVAL, vac + t);
589 else
590 vset(VT_CONST | VT_LVAL, n);
591 }
592 }
593 }
594
595 /* post operations */
596 if (tok == TOK_INC | tok == TOK_DEC) {
597 inc(POST_ADD, tok);
598 next();
599 } else
600 if (tok == '[') {
601#ifdef TEST
602 if (!(vt & VT_PTRMASK))
603 error("pointer expected");
604#endif
605 gv();
606 ft = vt;
607 fc = vc;
608 next();
609 o(0x50); /* push %eax */
610 expr();
611 gen_op('+', ft);
612 /* dereference pointer */
613 vt = (ft - VT_PTRINC) | VT_LVAL;
614 vc = fc;
615 skip(']');
616 } else
617 if (tok == '(') {
618 /* function call */
619 /* lvalue is implied */
620 vt = vt & VT_LVALN;
621 if ((vt & VT_CONST) == 0) {
622 /* evaluate function address */
623 gv();
624 o(0x50); /* push %eax */
625 }
626 ft = vt;
627 fc = vc;
628
629 next();
630 t = 0;
631 while (tok != ')') {
632 t = t + 4;
633 expr();
634 gv();
635 o(0x50); /* push %eax */
636 if (tok == ',')
637 next();
638 }
639 skip(')');
640 /* horrible, but needed : convert to native ordering (could
641 parse parameters in reverse order, but would cost more
642 code) */
643 n = 0;
644 p = t - 4;
645 while (n < p) {
646 oad(0x24848b, p); /* mov x(%esp,1), %eax */
647 oad(0x248487, n); /* xchg x(%esp,1), %eax */
648 oad(0x248489, p); /* mov %eax, x(%esp,1) */
649 n = n + 4;
650 p = p - 4;
651 }
652 if (ft & VT_CONST) {
653 /* forward reference */
654 if (ft & VT_FORWARD)
655 *(int *)fc = psym(0xe8, *(int *)fc);
656 else
657 oad(0xe8, fc - ind - 5);
658 } else {
659 oad(0x2494ff, t); /* call *xxx(%esp) */
660 t = t + 4;
661 }
662 if (t)
663 oad(0xc481, t);
664 /* return value is variable */
665 vt = VT_VAR;
666 }
667}
668
669void uneq()
670{
671 int ft, fc, b;
672
673 unary();
674 if (tok == '=') {
675#ifdef TEST
676 if (!(vt & VT_LVAL))
677 error("lvalue expected");
678#endif
679 next();
680 fc = vc;
681 ft = vt;
682 b = (vt & VT_TYPE) == VT_BYTE;
683 if (ft & VT_VAR)
684 o(0x50); /* push %eax */
685 expr();
686#ifdef TEST
687 if ((vt & VT_PTRMASK) != (ft & VT_PTRMASK))
688 warning("incompatible type");
689#endif
690 gv(); /* generate value */
691
692 if (ft & VT_VAR) {
693 o(0x59); /* pop %ecx */
694 o(0x0189 - b); /* mov %eax/%al, (%ecx) */
695 } else {
696 if (ft & VT_LOCAL)
697 oad(0x8589 - b, fc); /* mov %eax/%al,xxx(%ebp) */
698 else
699 oad(0xa3 - b, fc); /* mov %eax/%al,xxx */
700 }
701 }
702}
703
704void sum(l)
705{
706 int op, t;
707 if (l == 0)
708 uneq();
709 else {
710 l--;
711 sum(l);
712 while (1) {
713 op = tok;
714 if ((l == 0 & op != '*' & op != '/' & op != '%') |
715 (l == 1 & op != '+' & op != '-') |
716 (l == 2 & op != TOK_SHL & op != TOK_SHR) |
717 (l == 3 & (op < TOK_LT | op > TOK_GT)) |
718 (l == 4 & op != TOK_EQ & op != TOK_NE) |
719 (l == 5 & op != '&') |
720 (l == 6 & op != '^') |
721 (l == 7 & op != '|'))
722 break;
723 gv();
724 t = vt;
725 o(0x50); /* push %eax */
726 next();
727 sum(l);
728 gen_op(op, t);
729 }
730 }
731}
732
733#ifdef TINY
734void expr()
735{
736 sum(8);
737}
738#else
739void eand()
740{
741 int t;
742
743 sum(8);
744 t = 0;
745 while (1) {
746 if (tok != TOK_LAND) {
747 if (t) {
748 t = gtst(1, t);
749 vset(VT_JMP | 1, t);
750 }
751 break;
752 }
753 t = gtst(1, t);
754 next();
755 sum(8);
756 }
757}
758
759void expr()
760{
761 int t, u;
762
763 eand();
764 t = 0;
765 while (1) {
766 if (tok != TOK_LOR) {
767 if (t) {
768 t = gtst(0, t);
769 vset(VT_JMP, t);
770 }
771 break;
772 }
773 t = gtst(0, t);
774 next();
775 eand();
776 }
777}
778#endif
779
780void block()
781{
782 int a, c, d;
783
784 if (tok == TOK_IF) {
785 /* if test */
786 next();
787 skip('(');
788 expr();
789 skip(')');
790 a = gtst(1, 0);
791 block();
792 c = tok;
793 if (c == TOK_ELSE) {
794 next();
795 d = psym(0xe9, 0); /* jmp */
796 gsym(a);
797 block();
798 gsym(d); /* patch else jmp */
799 } else
800 gsym(a);
801 } else if (tok == TOK_WHILE) {
802 next();
803 d = ind;
804 skip('(');
805 expr();
806 skip(')');
807 *++lsym = gtst(1, 0);
808 block();
809 oad(0xe9, d - ind - 5); /* jmp */
810 gsym(*lsym--);
811 } else if (tok == '{') {
812 next();
813 /* declarations */
814 decl(VT_LOCAL);
815 while (tok != '}')
816 block();
817 next();
818 } else if (tok == TOK_RETURN) {
819 next();
820 if (tok != ';') {
821 expr();
822 gv();
823 }
824 skip(';');
825 rsym = psym(0xe9, rsym); /* jmp */
826 } else if (tok == TOK_BREAK) {
827 /* compute jump */
828 *lsym = psym(0xe9, *lsym);
829 next();
830 skip(';');
831 } else {
832 if (tok != ';')
833 expr();
834 skip(';');
835 }
836}
837
838/* 'l' is true if local declarations */
839void decl(l)
840{
841 int *a, t, b;
842
843 while (b = ist()) {
844 while (1) { /* iterate thru each declaration */
845 vt = typ(1, b);
846 if (tok == '{') {
847 /* patch forward references (XXX: does not work for
848 function pointers) */
849 if (vat[vc] == 0)
850 gsym(vac[vc]);
851 /* put function address */
852 vat[vc] = VT_CONST | VT_LVAL | vt;
853 vac[vc] = ind;
854 loc = 0;
855 o(0xe58955); /* push %ebp, mov %esp, %ebp */
856 a = oad(0xec81, 0); /* sub $xxx, %esp */
857 rsym = 0;
858 block();
859 gsym(rsym);
860 o(0xc3c9); /* leave, ret */
861 *a = loc; /* save local variables */
862 break;
863 } else {
864 /* variable */
865 vat[vc] = l | VT_LVAL | vt;
866 if (l == VT_LOCAL) {
867 loc = loc + 4;
868 vac[vc] = -loc;
869 } else {
870 vac[vc] = glo;
871 glo = glo + 4;
872 }
873 if (tok != ',') {
874 skip(';');
875 break;
876 }
877 next();
878 }
879 }
880 }
881}
882
883int main(int c, char **v)
884{
885 int (*t)();
886
887 if (c < 2) {
888 printf("usage: tc src\n");
889 return 1;
890 }
891 v++;
892 file = fopen(*v, "r");
893
894 idtable = malloc(SYM_TABLE_SIZE);
895 memcpy(idtable,
896 "int\0void\0char\0if\0else\0while\0break\0return\0define\0main", 53);
897 idptr = idtable + 53;
898 glo = malloc(DATA_SIZE);
899 prog = malloc(TEXT_SIZE);
900 vac = malloc(VAR_TABLE_SIZE);
901 vat = malloc(VAR_TABLE_SIZE);
902 lsym = malloc(256);
903 macro_stack = malloc(256);
904 macro_stack_ptr = macro_stack;
905 ind = prog;
906 next();
907 decl(VT_CONST);
908#ifdef TEST
909 {
910 FILE *f;
911 f = fopen(v[1], "w");
912 fwrite((void *)prog, 1, ind - prog, f);
913 fclose(f);
914 return 0;
915 }
916#else
917 t = vac[TOK_MAIN];
918 return (*t)(c - 1, v);
919#endif
920}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t