![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to asmexpr.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 / as|
Return to asmexpr.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / as |
1.1 root 1: #include "asm.h"
2:
3: expr(esp, n)
4: register struct expr *esp;
5: {
6: register c, p;
7: address lv, rv;
8: int lt, rt;
9: struct expr re;
10:
11: term(esp);
12: for (;;) {
13: c = getnb();
14: if (ctype[c] != BINOP)
15: break;
16: if (c == '|')
17: p = 10;
18: else if (c == '*')
19: p = 9;
20: else
21: p = 8;
22: if (p <= n)
23: break;
24: expr(&re, p);
25: lt = esp->e_type;
26: lv = esp->e_addr;
27: rt = re.e_type;
28: rv = re.e_addr;
29: if (c == '|') {
30: if (rt != E_ACON)
31: aerr("non constant in segment construction");
32: switch (lt) {
33: case E_ACON:
34: esp->e_type = E_ASEG;
35: esp->e_base.e_segn = lv;
36: break;
37:
38: case E_SYM:
39: esp->e_type = E_SEG;
40: break;
41:
42: default:
43: aerr("bad segment construction");
44: }
45: esp->e_addr = rv;
46: continue;
47: }
48: if (c == '^') {
49: if ((esp->e_type = rt) == E_DIR)
50: esp->e_base.e_lp = re.e_base.e_lp;
51: else if (rt==E_SYM || rt==E_SEG)
52: esp->e_base.e_sp = re.e_base.e_sp;
53: else if (rt == E_ASEG)
54: esp->e_base.e_segn = re.e_base.e_segn;
55: continue;
56: }
57: if (c == '+') {
58: if (lt == E_ACON) {
59: esp->e_type = rt;
60: if (rt == E_ASEG)
61: esp->e_base.e_segn = re.e_base.e_segn;
62: else if (rt == E_DIR)
63: esp->e_base.e_lp = re.e_base.e_lp;
64: else if (rt==E_SYM || rt==E_SEG)
65: esp->e_base.e_sp = re.e_base.e_sp;
66: } else if (rt != E_ACON)
67: rerr("add of 2 non constants");
68: esp->e_addr += rv;
69: continue;
70: }
71: if (c == '-') {
72: if (lt == E_ACON) {
73: if (rt != E_ACON)
74: rerr("constant - non-constant");
75: } else if (rt != E_ACON) {
76: if (lt!=E_DIR || rt!=E_DIR ||
77: esp->e_base.e_lp!=re.e_base.e_lp)
78: rerr("cannot fold this expression");
79: esp->e_type = E_ACON;
80: }
81: esp->e_addr -= rv;
82: continue;
83: }
84: if (c == '*') {
85: if (lt!=E_ACON || rt!=E_ACON)
86: aerr("non-constant in multiply");
87: esp->e_addr *= rv;
88: continue;
89: }
90: fprintf(stderr, "Internal error, c=%d in expr.\n", c);
91: exit( 1);
92: }
93: unget(c);
94: }
95:
96: address
97: absexpr()
98: {
99: struct expr e;
100:
101: expr(&e, 0);
102: abscheck(&e);
103: return (e.e_addr);
104: }
105:
106: term(esp)
107: register struct expr *esp;
108: {
109: register c;
110: address n;
111: char id[NCPLN];
112: struct sym *sp;
113: struct tsym *tp;
114: int r, v;
115:
116: if ((c=getnb()) == '[') {
117: expr(esp, 0);
118: if (getnb() != ']')
119: qerr("missing ']'");
120: return;
121: }
122: if (c == '-') {
123: expr(esp, 100);
124: abscheck(esp);
125: esp->e_addr = -esp->e_addr;
126: return;
127: }
128: if (c == '~') {
129: expr(esp, 100);
130: abscheck(esp);
131: esp->e_addr = ~esp->e_addr;
132: return;
133: }
134: if (c == '\'') {
135: esp->e_type = E_ACON;
136: esp->e_addr = getmap(-1);
137: return;
138: }
139: esp->e_type = E_ACON;
140: esp->e_addr = 0;
141: if (ctype[c] == DIGIT) {
142: r = 10;
143: if (c == '0') {
144: r = 8;
145: if ((c = *ip) != 0)
146: ++ip;
147: if (c == 'x') {
148: r = 16;
149: if ((c = *ip) != 0)
150: ++ip;
151: }
152: }
153: n = 0;
154: while ((v=digit(c, r)) >= 0) {
155: n = r*n + v;
156: if ((c = *ip) != 0)
157: ++ip;
158: }
159: if (c=='f' || c=='b') {
160: if (n < 10) {
161: if (c == 'f')
162: tp = tsymp[n].tp_fp; else
163: tp = tsymp[n].tp_bp;
164: if (tp != NULL) {
165: esp->e_type = E_DIR;
166: esp->e_base.e_lp = tp->t_lp;
167: esp->e_addr = tp->t_addr;
168: return;
169: }
170: }
171: err('u', "undefined local symbol");
172: return;
173: }
174: if (c != 0)
175: --ip;
176: esp->e_addr = n;
177: return;
178: }
179: if (ctype[c] == LETTER) {
180: getid(id, c);
181: if ((sp=lookup(id, gflag)) != NULL) {
182: if (sp->s_kind == S_NEW) {
183: if ((sp->s_flag&S_GBL) != 0) {
184: esp->e_type = E_SYM;
185: esp->e_base.e_sp = sp;
186: return;
187: }
188: uerr(id);
189: return;
190: }
191: esp->e_type = sp->s_type;
192: esp->e_addr = sp->s_addr;
193: if (sp->s_type == E_ASEG)
194: esp->e_base.e_segn = sp->s_base.s_segn;
195: else if (sp->s_type == E_DIR)
196: esp->e_base.e_lp = sp->s_base.s_lp;
197: else if (sp->s_type==E_SYM || sp->s_type==E_SEG)
198: esp->e_base.e_sp = sp->s_base.s_sp;
199: return;
200: }
201: uerr(id);
202: return;
203: }
204: qerr("invalid symbol");
205: }
206:
207: /*
208: * Look for an optional floating point register specification
209: * and store an appropriate e_mode value through ep.
210: * No operand: store ST and return 0.
211: * One operand: store reg and return 1.
212: */
213: fp_reg(ep)
214: register struct expr *ep;
215: {
216: register c;
217: char id[NCPLN];
218: struct sym *sp;
219:
220: ep->e_mode = ST;
221: if (ctype[c=getnb()] == LETTER) {
222: getid(id, c);
223: if ((sp=lookup(id, 0)) != NULL) {
224: if ((sp->s_addr&MMASK) != ST) {
225: qerr("invalid floating-point register");
226: return(0);
227: }
228: ep->e_mode = sp->s_addr;
229: return(1);
230: }
231: uerr(id);
232: return(0);
233: }
234: unget(c);
235: return(0);
236: }
237:
238: /*
239: * Look for one or two optional floating point register operands
240: * and store appropriate e_mode values through ep1, ep2.
241: * Return a flag indicating whether any operands were supplied.
242: * No operand: store ST1, ST, return 0.
243: * One operand: store reg1, ST, return 1.
244: * Two operands: store reg1, reg2, return 1; at least one must be ST.
245: */
246: fp_reg2(ep1, ep2)
247: register struct expr *ep1, *ep2;
248: {
249: register int c;
250:
251: ep2->e_mode = ST;
252: if (fp_reg(ep1)) {
253: if ((c = getnb()) == ',') {
254: if (!fp_reg(ep2)
255: || (ep1->e_mode != ST && ep2->e_mode != ST))
256: qerr("invalid floating-point register");
257: }
258: else
259: unget(c);
260: return(1);
261: }
262: else {
263: ep1->e_mode = ST1;
264: return(0);
265: }
266: }
267:
268: digit(c, r)
269: register c, r;
270: {
271: if (r == 16) {
272: if (c>='A' && c<='F')
273: return (c-'A'+10);
274: if (c>='a' && c<='f')
275: return (c-'a'+10);
276: }
277: if (c>='0' && c<='9')
278: return (c - '0');
279: return (-1);
280: }
281:
282: abscheck(esp)
283: register struct expr *esp;
284: {
285: if (esp->e_type != E_ACON) {
286: rerr("expected constant");
287: esp->e_type = E_ACON;
288: }
289: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.