![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c13.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / PDP11 / 11c|
Return to c13.c CVS log | Up to [Research Unix] / researchv10no / cmd / PDP11 / 11c |
1.1 root 1: /*
2: * C second pass -- tables
3: */
4: #include "c1.h"
5: /*
6: * Operator dope table-- see description in c0.
7: */
8: int opdope[] = {
9: 000000, /* EOFC */
10: 000000, /* ; */
11: 000000, /* { */
12: 000000, /* } */
13: 036000, /* [ */
14: 002000, /* ] */
15: 036000, /* ( */
16: 002000, /* ) */
17: 014201, /* : */
18: 007001, /* , */
19: 000000, /* field selection */
20: 000000, /* reverse field selection */
21: 000001, /* temporary field selection */
22: 000001, /* int->ptr */
23: 000001, /* ptr->int */
24: 000001, /* long->ptr */
25: 000001, /* field assignment */
26: 000001, /* >> unsigned */
27: 000001, /* >> unsigned */
28: 000000, /* 19 */
29: 000400, /* name */
30: 000400, /* short constant */
31: 000400, /* string */
32: 000400, /* float */
33: 000400, /* double */
34: 0000400, /* long const */
35: 000400, /* long const <= 16 bits */
36: 000400, /* autoi, *r++ */
37: 000400, /* autod, *--r */
38: 000400, /* () empty arglist */
39: 034213, /* ++pre */
40: 034213, /* --pre */
41: 034213, /* ++post */
42: 034213, /* --post */
43: 034220, /* !un */
44: 034202, /* &un */
45: 034220, /* *un */
46: 034200, /* -un */
47: 034220, /* ~un */
48: 036001, /* . (structure reference) */
49: 030101, /* + */
50: 030001, /* - */
51: 032101, /* * */
52: 032001, /* / */
53: 032001, /* % */
54: 026061, /* >> */
55: 026061, /* << */
56: 020161, /* & */
57: 016161, /* | */
58: 016161, /* ^ */
59: 036001, /* -> */
60: 001000, /* int -> double */
61: 001000, /* double -> int */
62: 000001, /* && */
63: 000001, /* || */
64: 030001, /* &~ */
65: 001000, /* double -> long */
66: 001000, /* long -> double */
67: 001000, /* integer -> long */
68: 000000, /* long -> integer */
69: 022005, /* == */
70: 022005, /* != */
71: 024005, /* <= */
72: 024005, /* < */
73: 024005, /* >= */
74: 024005, /* > */
75: 024005, /* <p */
76: 024005, /* <=p */
77: 024005, /* >p */
78: 024005, /* >=p */
79: 012213, /* += */
80: 012213, /* -= */
81: 012213, /* *= */
82: 012213, /* /= */
83: 012213, /* %= */
84: 012253, /* >>= */
85: 012253, /* <<= */
86: 012253, /* &= */
87: 012253, /* |= */
88: 012253, /* ^= */
89: 012213, /* = */
90: 030001, /* & for tests */
91: 032001, /* * (long) */
92: 032001, /* / (long) */
93: 032001, /* % (long) */
94: 012253, /* &= ~ */
95: 012213, /* *= (long) */
96: 012213, /* / (long) */
97: 012213, /* % (long) */
98: 000000, /* 89 */
99: 014201, /* ? */
100: 026061, /* long << */
101: 012253, /* long <<= */
102: 000101, /* max */
103: 000101, /* maxp */
104: 000101, /* min */
105: 000101, /* minp */
106: 000001, /* , */
107: 000000, /* 98 */
108: 000000, /* 99 */
109: 036001, /* call */
110: 036000, /* mcall */
111: 000000, /* goto */
112: 000000, /* jump cond */
113: 000000, /* branch cond */
114: 000400, /* set nregs */
115: 000000, /* 106 */
116: 030001, /* 107 */
117: 000000, /* 108 */
118: 000000, /* int->char */
119: 000000, /* force r0 */
120: 000000, /* 111 */
121: 000000, /* 112 */
122: 000000, /* 113 */
123: 000000, /* 114 */
124: 000000, /* structure assign */
125: 000001, /* struct assignment setup */
126: 032001, /* unsigned / */
127: 032001, /* unsigned % */
128: 012213, /* unsigned /= */
129: 012213, /* unsigned %= */
130: };
131:
132: char *opntab[] = {
133: 0,
134: 0,
135: 0,
136: 0,
137: 0,
138: 0,
139: 0,
140: 0,
141: ":",
142: ",",
143: "field select",
144: 0,
145: 0,
146: "int->ptr",
147: "ptr->int",
148: "long->ptr",
149: "field assign",
150: ">>",
151: ">>",
152: 0,
153: "name",
154: "short constant",
155: "string",
156: "float",
157: "double",
158: "long constant",
159: "long constant",
160: "*r++",
161: "*--r",
162: "()",
163: "++pre",
164: "--pre",
165: "++post",
166: "--post",
167: "!un",
168: "&",
169: "*",
170: "-",
171: "~",
172: ".",
173: "+",
174: "-",
175: "*",
176: "/",
177: "%",
178: ">>",
179: "<<",
180: "&",
181: "|",
182: "^",
183: "->",
184: "int->double",
185: "double->int",
186: "&&",
187: "||",
188: "&~",
189: "double->long",
190: "long->double",
191: "integer->long",
192: "long->integer",
193: "==",
194: "!=",
195: "<=",
196: "<",
197: ">=",
198: ">",
199: "<p",
200: "<=p",
201: ">p",
202: ">=p",
203: "+=",
204: "-=",
205: "*=",
206: "/=",
207: "%=",
208: ">>=",
209: "<<=",
210: "&=",
211: "|=",
212: "^=",
213: "=",
214: "& for tests",
215: "*",
216: "/",
217: "%",
218: "&= ~",
219: "*=",
220: "/=",
221: "%=",
222: 0,
223: "?",
224: "<<",
225: "<<=",
226: "\\/",
227: "\\/",
228: "/\\",
229: "/\\",
230: 0,
231: "call",
232: "call",
233: "call",
234: 0,
235: "goto",
236: "jump cond",
237: "branch cond",
238: "set nregs",
239: "load value",
240: "ptr->integer",
241: 0,
242: "int->char",
243: "force register",
244: "",
245: "",
246: "",
247: "",
248: "=structure",
249: "= (struct setup)",
250: "/",
251: "%",
252: "/=",
253: "%=",
254: };
255:
256: /*
257: * Strings for instruction tables.
258: */
259: char mov[] = "mov";
260: char clr[] = "clr";
261: char cmp[] = "cmp";
262: char tst[] = "tst";
263: char add[] = "add";
264: char sub[] = "sub";
265: char inc[] = "inc";
266: char dec[] = "dec";
267: char mul[] = "mul";
268: char div[] = "div";
269: char asr[] = "asr";
270: char ash[] = "ash";
271: char asl[] = "asl";
272: char bic[] = "bic";
273: char bic1[] = "bic $1,";
274: char bit[] = "bit";
275: char bit1[] = "bit $1,";
276: char bis[] = "bis";
277: char bis1[] = "bis $1,";
278: char xor[] = "xor";
279: char neg[] = "neg";
280: char com[] = "com";
281: char stdol[] = "*$";
282: char ashc[] = "ashc";
283: char slmul[] = "lmul";
284: char sldiv[] = "ldiv";
285: char slrem[] = "lrem";
286: char almul[] = "almul";
287: char aldiv[] = "aldiv";
288: char alrem[] = "alrem";
289: char udiv[] = "udiv";
290: char urem[] = "urem";
291: char jeq[] = "jeq";
292: char jne[] = "jne";
293: char jle[] = "jle";
294: char jgt[] = "jgt";
295: char jlt[] = "jlt";
296: char jge[] = "jge";
297: char jlos[] = "jlos";
298: char jhi[] = "jhi";
299: char jlo[] = "jlo";
300: char jhis[] = "jhis";
301: char nop[] = "/nop";
302: char jbr[] = "jbr";
303:
304: /*
305: * Instruction tables, accessed by
306: * I (first operand) or I' (second) macros.
307: */
308:
309: struct instab instab[] = {
310: LOAD, mov, tst,
311: ASSIGN, mov, clr,
312: EQUAL, cmp, tst,
313: NEQUAL, cmp, tst,
314: LESSEQ, cmp, tst,
315: LESS, cmp, tst,
316: GREATEQ,cmp, tst,
317: GREAT, cmp, tst,
318: LESSEQP,cmp, tst,
319: LESSP, cmp, tst,
320: GREATQP,cmp, tst,
321: GREATP, cmp, tst,
322: PLUS, add, inc,
323: ASPLUS, add, inc,
324: MINUS, sub, dec,
325: ASMINUS,sub, dec,
326: INCBEF, add, inc,
327: DECBEF, sub, dec,
328: INCAFT, add, inc,
329: DECAFT, sub, dec,
330: TIMES, mul, mul,
331: ASTIMES,mul, mul,
332: DIVIDE, div, div,
333: ASDIV, div, div,
334: MOD, div, div,
335: ASMOD, div, div,
336: PTOI, div, div,
337: RSHIFT, ash, asr,
338: ASRSH, ash, asr,
339: LSHIFT, ash, asl,
340: ASLSH, ash, asl,
341: AND, bic, bic1,
342: ANDN, bic, bic1,
343: ASANDN, bic, bic1,
344: TAND, bit, bit1,
345: OR, bis, bis1,
346: ASOR, bis, bis1,
347: EXOR, xor, xor,
348: ASXOR, xor, xor,
349: NEG, neg, neg,
350: COMPL, com, com,
351: CALL1, stdol, stdol,
352: CALL2, "", "",
353: LLSHIFT,ashc, ashc,
354: ASLSHL, ashc, ashc,
355: LTIMES, slmul, slmul,
356: LDIV, sldiv, sldiv,
357: LMOD, slrem, slrem,
358: LASTIMES,almul, almul,
359: LASDIV, aldiv, aldiv,
360: LASMOD, alrem, alrem,
361: ULSH, ashc, ashc,
362: ASULSH, ashc, ashc,
363: UDIV, udiv, udiv,
364: UMOD, urem, urem,
365: ASUDIV, udiv, udiv,
366: ASUMOD, urem, urem,
367: 0, 0, 0};
368:
369: /*
370: * Similar table for relationals.
371: * The first string is for the positive
372: * test, the second for the inverted one.
373: * The '200+' entries are
374: * used in tests against 0 where a 'tst'
375: * instruction is used; it clears the c-bit
376: * the c-bit so ptr tests are funny.
377: */
378: struct instab branchtab[] = {
379: EQUAL, jeq, jne,
380: NEQUAL, jne, jeq,
381: LESSEQ, jle, jgt,
382: LESS, jlt, jge,
383: GREATEQ,jge, jlt,
384: GREAT, jgt, jle,
385: LESSEQP,jlos, jhi,
386: LESSP, jlo, jhis,
387: GREATQP,jhis, jlo,
388: GREATP, jhi, jlos,
389: 200+EQUAL, jeq, jne,
390: 200+NEQUAL, jne, jeq,
391: 200+LESSEQ, jle, jgt,
392: 200+LESS, jlt, jge,
393: 200+GREATEQ, jge, jlt,
394: 200+GREAT, jgt, jle,
395: 200+LESSEQP, jeq, jne,
396: 200+LESSP, nop, jbr,
397: 200+GREATQP, jbr, nop,
398: 200+GREATP, jne, jeq,
399: 0, 0, 0 };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.