![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cc0.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n0|
Return to cc0.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n0 |
1.1 root 1: /*
2: * C compiler.
3: * Syntax analyser mainline.
4: * Impure stuff.
5: */
6: #ifdef vax
7: #include "INC$LIB:cc0.h"
8: #else
9: #include "cc0.h"
10: #endif
11:
12: /*
13: * Impure areas.
14: * All external impure data is here
15: * and is reinitialized by the overlaid version of the mainline.
16: * This permits the compiler to be called many times if loaded as a big block.
17: */
18: #if !OVERLAID
19: int line = 1; /* Source line */
20: char file[NFNAME]; /* Source file name */
21: TOK *tfile; /* Source file token */
22: char id[NCSYMB]; /* Identifier buffer */
23: FILE *ifp; /* Input file pointer */
24: FILE *ofp; /* Output file pointer */
25: VARIANT variant; /* Variant template */
26: #endif
27:
28: /* Cpp variables */
29: char dbuf[NDBUF]; /* Substitution buffer */
30: char *dputp = dbuf; /* Define buffer pointer */
31: char *dpshp = dbuf+sizeof(dbuf); /* Define buffer pointer */
32: DSTACK dstack[NDLEV]; /* Substitution stack */
33: DSTACK *dlistp=dstack; /* Substitution list */
34: DSTACK *dstackp=dstack+NDLEV-1; /* Input stack */
35: ISTACK istack[NLEV]; /* Include stack */
36: ISTACK *istackp=istack+NLEV; /* Include stack pointer */
37: CSTACK cstack[NLEV]; /* Condition stack pointer */
38: CSTACK *cstackp=cstack+NLEV; /* Condition stack pointer */
39: int cstate = 0; /* Conditional state == true */
40: int ndirs; /* Number of include directories */
41: char *incdirs[NDIRS+3]; /* Include directory list */
42: char deftrue[] = "1";
43: char deffalse[] = "0";
44: long curtime; /* NB should be time_t */
45:
46: int incpp; /* "in a cpp control" flag */
47: int instring; /* "in a string" flag */
48: int notskip; /* count of not skipped chars */
49: int lastchar; /* Last character read from a file */
50: int ininit; /* "in an initializer" flag */
51: int incase; /* "in a case" flag */
52: int nargs; /* # of args this function */
53: SYM *args[NARGS]; /* The args themselves */
54: int llex; /* Lexical level */
55: int lsym = SL_MOS; /* Symbol table level */
56: ival_t ival; /* Return for lex */
57: lval_t lval; /* Return for lex */
58: dval_t dval; /* Return for lex */
59: short tval; /* Return for lex int/long constant type */
60: unsigned idhash; /* Hash number for symbol */
61: unsigned idhide; /* Hide set for symbol */
62: HIDESET *hidefree, *hidesets; /* Hide set management */
63: int idsize; /* Length of symbol */
64: TOK *idp; /* Hashed identifier token */
65: TOK *hash0[NHASH]; /* Hash table */
66: int cblab; /* Break label */
67: int cclab; /* Continue label */
68: SBLOCK *sbp; /* Current switch block */
69: SYM *cfsym; /* Current symbol */
70: int cflab; /* Current return label */
71: int s; /* Lexical window */
72:
73: /*
74: * It all starts here.
75: * Open the source file.
76: * Open the output stream file.
77: * Put reserved words into the symbol table.
78: * Parse externals until end of file.
79: * Finish off the output stream and exit.
80: */
81: #if !OVERLAID
82: main(argc, argv)
83: char *argv[];
84: {
85: register char *p;
86: register int i;
87: extern char *index();
88: extern char *getenv();
89:
90: passname = "cc0";
91: if (argc < 4)
92: usage();
93: getvariant(argv[1]);
94: if ((ifp=fopen(argv[2], "r")) == NULL) {
95: fprintf(stderr, "%s: cannot open.\n", argv[2]);
96: exit(BAD);
97: }
98: if (isvariant(VCPP)) {
99: if (strcmp(argv[3], "-") == 0)
100: ofp = stdout;
101: else if ((ofp = fopen(argv[3], "w")) == NULL) {
102: fprintf(stderr, "%s: cannot create.\n", argv[3]);
103: exit(BAD);
104: }
105: } else if ((ofp=fopen(argv[3], SWMODE)) == NULL) {
106: fprintf(stderr, "%s: cannot create.\n", argv[3]);
107: exit(BAD);
108: }
109: vinit();
110: kinit();
111: time(&curtime);
112: newtree(sizeof(TREE));
113: cppd(MACHINE, deftrue);
114: cppd(SYSTEM, deftrue);
115: cppd(LOCATION, deftrue);
116: cppi(argv[2]); /* Source directory will be parsed later */
117: for (i=4; i<argc; ++i) {
118: if (argv[i][0] != '-')
119: break;
120: switch (argv[i][1]) {
121: case 'I': cppi(argv[i]+2); break;
122: case 'U': cppu(argv[i]+2); break;
123: case 'D':
124: if (p = index(argv[i]+2, '='))
125: *p++ = 0;
126: else
127: p = deftrue;
128: cppd(argv[i]+2, p);
129: break;
130: default:
131: usage();
132: }
133: }
134: if ((p = getenv("INCDIR")) == 0)
135: p = DEFDISK;
136: cppi(p);
137: cppi(argv[2]); /* Second copy of source directory */
138: setid(argv[2]);
139: setfname();
140: /* Now parse the source file directory */
141: i = 0;
142: #if COHERENT
143: for (p = argv[2]; *p != 0; p += 1)
144: if (*p == '/')
145: i = p-argv[2];
146: #endif
147: #if GEMDOS || MSDOS
148: for (p = argv[2]; *p != 0; p += 1)
149: if (*p == '\\')
150: i = p-argv[2];
151: #endif
152: argv[2][i] = 0;
153: emptyfilep();
154: if (notvariant(VCPP)) {
155: dbfname(file);
156: setmname();
157: labgen = 0;
158: oldseg = -1;
159: while (lex() != EOF)
160: xdef();
161: llex = -1;
162: downlex();
163: bput(FINISH);
164: } else
165: cppwork();
166: if (nerr != 0)
167: exit(BAD);
168: exit(OK);
169: }
170:
171: /*
172: * Print usage message.
173: */
174: usage()
175: {
176: fprintf(stderr,
177: "Usage: cc0 variant in out [-Dname[=value]] [-Idirectory] [-Uname]\n"
178: );
179: exit(BAD);
180: }
181:
182: #else
183: #assert 0 /* This is not ready for the new conventions */
184: /* The argv syntax needs to be worked out */
185: /* Cleaning up the HIDESET and TOK and SYM pools as well */
186: /*
187: * This is the mainline of the syntax analysis phase
188: * if the compiler is being run as an overlay job.
189: * The impure area must be reinitialized if monolithic,
190: * because the code can be called again and again.
191: */
192: cc0()
193: {
194: register char *p;
195: register int i;
196: extern char *index();
197:
198: passname = "cc0";
199: if (setjmp(death) != 0) {
200: llex = -1;
201: downlex();
202: cppfinal();
203: return (ABORT);
204: }
205: vinit();
206: kinit();
207: cppi("");
208: time(&curtime);
209: newtree(sizeof(TREE));
210: for (i=4; i<argc; ++i) {
211: if (argv[i][0] != '-')
212: break;
213: switch (argv[i][1]) {
214: case 'I':
215: cppi(argv[i]+2);
216: break;
217: case 'U':
218: cppu(argv[i]+2);
219: break;
220: case 'D':
221: if (p = index(argv[i]+2, '='))
222: *p++ = 0;
223: else
224: p = deftrue;
225: cppd(argv[i]+2, p);
226: break;
227: default:
228: cbotch("cpp args");
229: }
230: }
231: cppi(DEFDISK);
232: cppi("");
233: labgen = 0;
234: oldseg = -1;
235: line = 1;
236: #if MONOLITHIC
237: incpp = 0;
238: instring = 0;
239: lastchar = 0;
240: ininit = 0;
241: incase = 0;
242: cblab = 0;
243: cclab = 0;
244: sbp = NULL;
245: cfsym = NULL;
246: lsym = SL_MOS;
247: ndirs = 0;
248: dputp = dbuf;
249: dpshp = dbuf+sizeof(dbuf);
250: dstackp = dstack + NDLEV-1;
251: dlistp = dstack;
252: istackp = istack + NLEV;
253: cstackp = cstack + NLEV;
254: cstate = 0;
255: #endif
256: setid(argv[2]);
257: setfname();
258: if (notvariant(VCPP)) {
259: setmname();
260: while (lex() != EOF)
261: xdef();
262: llex = -1;
263: downlex();
264: bput(FINISH);
265: } else
266: cppwork();
267: cppfinal();
268: if (nerr != 0)
269: return (BAD);
270: return (OK);
271: }
272: #endif
273:
274: /*
275: * Given the file name token in idp,
276: * inform the usual parties of the change.
277: */
278: setfname()
279: {
280: tfile = idp;
281: strncpy(file, idp->t_id, NFNAME);
282: if (notvariant(VCPP)) {
283: bput(FNAME);
284: sput(file);
285: } else if (notvariant(VCPPE))
286: fprintf(ofp, "#line %d \"%s\"\n", line, file);
287: }
288:
289: /*
290: * Given a file name string,
291: * make up the associated module name.
292: * And then send it on it's way.
293: * This routine is tinkered for UDI, DEC systems, MS-DOS
294: * and for the Coherent-like systems.
295: * Of course, the MNAME item is pointless
296: * to all systems except .omf, but we do
297: * it anyway.
298: * NB, id[] is used as a buffer
299: * to construct the module name.
300: */
301: setmname()
302: {
303: register char *tp, *p1, *p2;
304:
305: tp = id;
306: p1 = file;
307: while (*p1 != 0)
308: ++p1;
309: p2 = p1;
310: while (p1>file
311: && (p1[-1]!=':' && p1[-1]!='/' && p1[-1]!=']' && p1[-1]!='\\'))
312: --p1;
313: while (p2>p1 && p2[0]!='.')
314: --p2;
315: while (p1 < p2)
316: *tp++ = *p1++;
317: *tp = 0;
318: bput(MNAME);
319: sput(id);
320: }
321:
322: /*
323: * Process an external declaration.
324: * On entry, 's' contains the first token of the external.
325: * On exit, 's' contains the last token in the declaration.
326: */
327: xdef()
328: {
329: register SYM *sp;
330: SYM *nsp;
331: DIM *dp, *ndp;
332: INFO *ip;
333: int c;
334: int t;
335: int rf;
336: int seg;
337:
338: if (s == SEMI)
339: return;
340: gcandt(&c, &t, &dp, &ip, &rf);
341: if (c == C_NONE)
342: c = C_GDEF;
343: else if (c == C_SIN)
344: c = C_SEX;
345: else if (c!=C_GREF && c!=C_TYPE) {
346: cerror("bad external storage class");
347: c = C_GDEF;
348: }
349: if (s == SEMI) {
350: xdropinfo(t, ip);
351: return;
352: }
353: if (t == T_NONE)
354: t = T_INT;
355: for (;;) {
356: if (!gdecl(&nsp, &ndp, dp, c, SL_VAR)) {
357: cerror("external syntax");
358: while (s!=EOF && s!=SEMI && s!=LBRACE && s!=RBRACE)
359: skip();
360: if (s == LBRACE)
361: statement();
362: break;
363: }
364: sp = nsp;
365: sp = declare(sp, c, t, ndp, ip, rf);
366: if (c!=C_GREF && sp->s_class!=C_GREF && sp->s_class!=C_TYPE) {
367: if (isfunc(sp)) {
368: xfunc(sp);
369: break;
370: }
371: seg = SPURE;
372: if (s==EOF || s==COMMA || s==SEMI) {
373: if ((rf&S_RONLY) == 0)
374: seg = SBSS;
375: sp->s_seg = seg;
376: if (isvariant(VCOMM)
377: && sp->s_class == C_GDEF
378: && seg == SBSS) {
379: sp->s_class = C_GREF;
380: bput(COMM);
381: nput(sp->s_id);
382: } else {
383: newseg(seg);
384: align(sp);
385: xlabel(sp);
386: bput(BLOCK);
387: }
388: zput(ssize(sp));
389: } else {
390: if ((rf&S_RONLY) == 0)
391: seg = SDATA;
392: sp->s_seg = seg;
393: newseg(seg);
394: align(sp);
395: xlabel(sp);
396: /*
397: * The following gives a warning rather than an
398: * error (over steve's objection) so programs
399: * using old style initializers e.g. "int i 1;"
400: * will compile; see K&R "Anachronisms" p. 212.
401: */
402: if (s != ASSIGN)
403: cwarn("missing '='");
404: else
405: lex();
406: init(sp, sp->s_dp, (sizeof_t)0, 1);
407: }
408: dbdecl(sp);
409: }
410: if (s != COMMA) {
411: if (s != SEMI)
412: cerror("missing semicolon");
413: break;
414: }
415: lex();
416: }
417: xdropinfo(t, ip);
418: }
419:
420: /*
421: * Test if the symbol pointed to by 'sp' is a function.
422: */
423: isfunc(sp)
424: SYM *sp;
425: {
426: register DIM *dp;
427:
428: if ((dp=sp->s_dp)!=NULL && dp->d_type==D_FUNC)
429: return (1);
430: return (0);
431: }
432:
433: /*
434: * Compile a function.
435: * 'sp' points at the symbol table node for the function name.
436: * 's' is the first token after the function declaration.
437: */
438: xfunc(sp)
439: register SYM *sp;
440: {
441: register SYM *fsp;
442: SYM *nfsp;
443: DIM *dp, *fdp;
444: INFO *ip;
445: int c;
446: int t;
447: int rf;
448: int fline;
449:
450: fline = line;
451: for (;;) {
452: gcandt(&c, &t, &dp, &ip, &rf);
453: if (c==C_NONE && t==T_NONE)
454: break;
455: if (c == C_NONE)
456: c = C_PAUTO;
457: else if (c == C_REG)
458: c = C_PREG;
459: else {
460: cerror("bad argument storage class");
461: c = C_PAUTO;
462: }
463: if (t == T_NONE)
464: t = T_INT;
465: for (;;) {
466: if (gdecl(&nfsp, &fdp, dp, c, SL_VAR)) {
467: fsp = nfsp;
468: fsp = declare(fsp, c, t, fdp, ip, rf);
469: }
470: if (s != COMMA)
471: break;
472: lex();
473: }
474: xdropinfo(t, ip);
475: mustbe(SEMI);
476: }
477: initlocals();
478: bindargs();
479: newseg(SCODE);
480: sp->s_seg = SCODE;
481: xlabel(sp);
482: bput(PROLOG);
483: loadargs();
484: dbdecl(sp);
485: dbargs();
486: dbstat(LBRACE, line);
487: cfsym = sp;
488: cflab = newlab();
489: if (s != LBRACE)
490: cerror("compound statement required");
491: else
492: lex();
493: llex = LL_AUTO;
494: locals();
495: putautos();
496: while (s!=EOF && s!=RBRACE)
497: statement();
498: if (s != RBRACE)
499: cerror("missing right brace");
500: llex = LL_EXT;
501: downlex();
502: label(cflab);
503: dbstat(RBRACE, line);
504: bput(EPILOG);
505: cfsym = NULL;
506: }
507:
508: /*
509: * Emit an external label.
510: */
511: xlabel(sp)
512: register SYM *sp;
513: {
514: bput((sp->s_class==C_GDEF) ? GLABEL : SLABEL);
515: nput(sp->s_id);
516: }
517:
518: /*
519: * Conditionally drop a structure information block.
520: * Sometimes a non null info pointer is a symbol table pointer!
521: */
522: xdropinfo(t, ip)
523: register int t;
524: register INFO *ip;
525: {
526: if (t==T_FSTRUCT || t==T_FUNION || t==T_FENUM)
527: return;
528: dropinfo(ip);
529: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.