![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cc3.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 / n3|
Return to cc3.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n3 |
1.1 root 1: /*
2: * This program prints out
3: * C compiler intermediate language files.
4: * It is a machine dependent program, however
5: * most, if not all, of the machine dependencies
6: * are in tables. It understands all favours of
7: * intermediate files (that is, it understands
8: * both trees and CODE nodes!).
9: */
10: #ifdef vax
11: #include "INC$LIB:cc3.h"
12: #else
13: #include "cc3.h"
14: #endif
15:
16: /*
17: * Possibly impure areas.
18: * All external impure data is here
19: * and is reinitialized by the overlaid version of the mainline.
20: * This permits the compiler to be called many times if loaded
21: * as one big block.
22: */
23: #if !OVERLAID
24: int line; /* Source line */
25: int dotseg; /* Current segment */
26: char file[NFNAME]; /* Source file name */
27: char id[NCSYMB]; /* Identifier buffer */
28: FILE *ifp; /* Input file pointer */
29: FILE *ofp; /* Output file pointer */
30: VARIANT variant; /* Variant template */
31: #endif
32:
33: extern char *segnames[];
34: /*
35: * Temp. file opcodes.
36: */
37: char *ilonames[] = {
38: 0,
39: "file name",
40: 0,
41: 0,
42: "global label",
43: "static label",
44: "block",
45: "prolog",
46: "epilog",
47: 0,
48: 0,
49: 0,
50: 0,
51: "line number",
52: "return expression",
53: "effect expression",
54: "switch expression",
55: "switch body",
56: "initialization expression",
57: "initialize absolute block",
58: 0,
59: "jump if true",
60: "jump if false",
61: 0, /* ENTER */
62: "module name",
63: 0, /* COMM */
64: "", /* DLOCAT */
65: "", /* DLABEL */
66: "segment guess",
67: "undefined reference"
68: };
69:
70: #if !OVERLAID
71: main(argc, argv)
72: char *argv[];
73: {
74: passname = "cc3";
75: if (argc < 3)
76: usage();
77: getvariant(argv[1]);
78: #if GEMDOS
79: {
80: extern long gemdos();
81: extern char *lmalloc();
82: free(lmalloc((gemdos(0x48,-1L)-4096) & ~1023L));
83: }
84: #endif
85: if ((ifp=fopen(argv[2], SRMODE)) == NULL) {
86: fprintf(stderr, "%s: cannot open.\n", argv[2]);
87: exit(BAD);
88: }
89: if (argc == 4) {
90: if ((ofp=fopen(argv[3], "w")) == NULL) {
91: fprintf(stderr, "%s: cannot create.\n", argv[3]);
92: exit(BAD);
93: }
94: } else {
95: ofp = stdout;
96: }
97: exit(work3());
98: }
99:
100: usage()
101: {
102: fprintf(stderr, "Usage: cc3 variant input [output]\n");
103: exit(BAD);
104: }
105:
106: #else
107: /*
108: * This is the mainline of the intermediate interpreter
109: * if the compiler is being run as an overlay job.
110: * The impure area must be reinitialized if monolithic
111: * because the code can be called over and over again.
112: */
113: cc3()
114: {
115: passname = "cc3";
116: if (setjmp(death) != 0) {
117: return (ABORT);
118: }
119: dotseg = -1;
120: #if MONOLITHIC
121: line = 0;
122: #endif
123: return (work3());
124: }
125: #endif
126:
127: /*
128: * This is the nuts and bolts of the operation.
129: */
130: work3()
131: {
132: register int op;
133: register long ifseek;
134:
135: for (;;) {
136: #if TEMPBUF
137: ifseek = (ifp == NULL) ? inbufp - inbuf : ftell(ifp);
138: #else
139: ifseek = ftell(ifp);
140: #endif
141: if ((op=bget())==EOF || op==FINISH)
142: break;
143: if (notvariant(VASM))
144: fprintf(ofp, "%ld:\t", ifseek);
145: switch (op) {
146:
147: case FNAME:
148: case MNAME:
149: case GLABEL:
150: case SLABEL:
151: case UREFER:
152: sget(id, NCSYMB);
153: if (isvariant(VASM))
154: genname(op, id);
155: else {
156: fprintf(ofp, "\t%s\t%s\n", ilonames[op], id);
157: if (op==GLABEL || op==SLABEL)
158: fprintf(ofp, "\t%s:\n", id);
159: }
160: break;
161:
162: case LLABEL:
163: if (isvariant(VASM))
164: genival(op, (long)iget());
165: else
166: fprintf(ofp, "L%d:\n", iget());
167: break;
168:
169: case LINE:
170: line = iget();
171: if (isvariant(VASM))
172: genival(op, (long)line);
173: else
174: fprintf(ofp, "\t%s\t%d\n", ilonames[op], line);
175: break;
176:
177: case BLOCK:
178: if (isvariant(VASM))
179: genival(op, (long)zget());
180: else
181: fprintf(ofp, "%s\t%ld\n",
182: ilonames[op], (long)zget());
183: break;
184:
185: case DLOCAT:
186: cc3dloc();
187: break;
188: case DLABEL:
189: cc3dbug(1);
190: break;
191:
192: case PROLOG:
193: case EPILOG:
194: fprintf(ofp, "\t%s\n", ilonames[op]);
195: break;
196:
197: case AUTOS:
198: genautos();
199: break;
200:
201: case JUMP:
202: fprintf(ofp, "\tjump\tL%d\n", iget());
203: break;
204:
205: case COMM:
206: gencomm();
207: break;
208:
209: case ENTER:
210: if (isvariant(VASM))
211: genival(op, (long)bget());
212: else
213: fprintf(ofp, "\tenter %s\n", segnames[bget()]);
214: break;
215:
216: case ALIGN:
217: if (isvariant(VASM))
218: genival(op, (long)bget());
219: else
220: fprintf(ofp, "\talign %d\n", bget());
221: break;
222:
223: case SBODY:
224: {
225: register int deflab, ncases, clabel;
226: register ival_t cvalue;
227:
228: deflab = iget();
229: ncases = iget();
230: fprintf(ofp, "%s\n", ilonames[op]);
231: while (ncases--) {
232: cvalue = iget();
233: clabel = iget();
234: fprintf(ofp, "\t\t%d\tL%d\n", cvalue, clabel);
235: }
236: fprintf(ofp, "\t\tdef\tL%d\n", deflab);
237: break;
238: }
239:
240: case IBLOCK:
241: {
242: register int firstb, nitems;
243:
244: fprintf(ofp, "byte block\t");
245: nitems = bget();
246: firstb = 0;
247: while (nitems--) {
248: if (firstb++ != 0)
249: fprintf(ofp, " ");
250: fprintf(ofp, "%d", bget());
251: }
252: fprintf(ofp, "\n");
253: break;
254: }
255:
256: case REXPR:
257: case SEXPR:
258: case TEXPR:
259: case FEXPR:
260: case IEXPR:
261: case EEXPR:
262: itree(op);
263: break;
264:
265: case CODE:
266: icode();
267: break;
268:
269: case EOF:
270: cfatal("unexpected EOF");
271:
272: default:
273: cbotch("bad temporary file opcode %d", op);
274: }
275: }
276: if (op != FINISH)
277: cfatal("unexpected EOF");
278: return (OK);
279: }
280:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.