![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to operand.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / c2|
Return to operand.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / c2 |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)operand.c 1.1 86/02/03 Copyr 1985 Sun Micro";
3: #endif
4:
5: /*
6: * Copyright (c) 1985 by Sun Microsystems, Inc.
7: */
8:
9: #include "as.h"
10: #include <ctype.h>
11:
12: short cinfo[128] = {
13: ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR,
14: ERR, SPC, EOL, SPC, SPC, SPC, ERR, ERR,
15: ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR,
16: ERR, ERR, ERR, ERR, ERR, ERR, ERR, ERR,
17: SPC, ERR, QUO, IMM, S+T, ERR, ERR, ERR,
18: LP, RP, MUL, ADD, COM, SUB, S+T, DIV,
19: D+T, D+T, D+T, D+T, D+T, D+T, D+T, D+T,
20: D+T, D+T, COL, EOL, ERR, EQL, ERR, ERR,
21: IND, S+T, S+T, S+T, S+T, S+T, S+T, S+T,
22: S+T, S+T, S+T, S+T, S+T, S+T, S+T, S+T,
23: S+T, S+T, S+T, S+T, S+T, S+T, S+T, S+T,
24: S+T, S+T, S+T, ERR, ERR, ERR, ERR, S+T,
25: ERR, S+T, S+T, S+T, S+T, S+T, S+T, S+T,
26: S+T, S+T, S+T, S+T, S+T, S+T, S+T, S+T,
27: S+T, S+T, S+T, S+T, S+T, S+T, S+T, S+T,
28: S+T, S+T, S+T, LB, EOL, RB, NOT, S+T
29: };
30:
31: /* for local labels: ``[0-9]:'', and references ``[0-9][bh]'' */
32: #if AS
33: char *ll_format = "*%c%06d";
34: #else C2
35: char *ll_format = "LX%c%06d";
36: #endif
37:
38: int ll_val[10];
39:
40: static struct suffix {
41: int indx_sx; /* index register */
42: int scale_sx; /* index scaling */
43: long disp_sx; /* displacement */
44: struct sym_bkt *sym_sx; /* symbolic displacement */
45: unsigned flags_sx; /* see below */
46: } fix [2];
47:
48: static struct suffix zero_suffix = { 0 };
49:
50: /* flags_sx values */
51: #define SX_INDXW 1 /* word-size index specified */
52: #define SX_INDXL 2 /* long-size index specified */
53: #define SX_DISPW 4 /* word-size displacement specified */
54: #define SX_DISPL 8 /* long-size displacement specified */
55: #define SX_GOTINDEX 020 /* index register specified */
56: #define SX_GOTDISP 040 /* displacement specified */
57: #if C2
58: #define SX_CXDISP 0100 /* displacement is complex */
59: #endif
60:
61: static struct oper zero_oper = { T_NULL, 0, 0, NULL, 0, 0, 0};
62:
63: char *suffix(), *exp(), *term(), *scan_reg_or_immed();
64: char * scan_float();
65: double atof();
66:
67: /*
68: * Fetches operand value and register subfields and loads them into
69: * the operand structure. This routine will fetch only one set of value
70: * and register subfields. It will move line pointer to first untouched char.
71: */
72: char *
73: soperand(lptr,opnd)
74: register char *lptr;
75: struct oper *opnd;
76: {
77: struct oper spare_oper;
78: int v;
79:
80: *opnd = zero_oper;
81: spare_oper = zero_oper;
82:
83: if ((v=cinfo[*lptr]) == IMM) {
84: lptr = exp(++lptr,opnd);
85: if (opnd->type_o == T_REG)
86: PROG_ERROR(E_REG);
87: if (opnd->type_o == T_FLOAT)
88: /* immediate value is floating-point */
89: opnd->flags_o |= O_FLOAT;
90: opnd->type_o = T_IMMED;
91: } else if (v == IND) {
92: /* index mode, omitted base */
93: /* expecting LP next */
94: lptr += 1;
95: skipb(lptr);
96: if (cinfo[*lptr] == LP)
97: goto index_mode;
98: else
99: PROG_ERROR(E_OPERAND);
100: } else {
101: lptr = exp(lptr,opnd);
102: skipb(lptr);
103: switch (opnd->type_o){
104: case T_REG:
105: switch (cinfo[*lptr]){
106: case COL:
107: /* should be a register pair */
108: lptr = exp( ++lptr, &spare_oper);
109: if (spare_oper.type_o != T_REG)
110: PROG_ERROR(E_OPERAND);
111: #if AS
112: if (!ext_instruction_set)
113: PROG_ERROR(E_OPERAND);
114: #endif
115: opnd->type_o = T_REGPAIR;
116: opnd->reg_o = spare_oper.value_o;
117: break;
118: case IND:
119: if (!(areg(opnd->value_o)||pcreg(opnd->value_o)))
120: PROG_ERROR(E_OPERAND);
121: lptr += 1;
122: skipb(lptr);
123: switch (cinfo[*lptr]){
124: default:
125: opnd->type_o = T_DEFER;
126: break;
127: case ADD:
128: opnd->type_o = T_POSTINC;
129: lptr++;
130: break;
131: case SUB:
132: opnd->type_o = T_PREDEC;
133: lptr++;
134: break;
135: case LP:
136: /* defer or indexing coming up here */
137: index_mode:
138: lptr = suffix( lptr, &fix[0] );
139: if (cinfo[*lptr] != IND){
140: simplify1( opnd, &fix[0] );
141: } else {
142: lptr = suffix( ++lptr, &fix[1] );
143: simplify2( opnd, &fix[0], &fix[1] );
144: }
145: break;
146: case IND:
147: lptr = suffix( ++lptr, &fix[1] );
148: simplify2( opnd, &zero_suffix, &fix[1] );
149: break;
150: }
151: #if AS
152: if (opnd->type_o == T_INDEX && !ext_instruction_set)
153: if ( (opnd->flags_o&(O_BSUPRESS|O_INDIRECT|O_WDISP|O_LDISP)) ||
154: opnd->scale_o != 1 || !(opnd->flags_o&O_PREINDEX))
155: PROG_ERROR( E_OPERAND );
156: #endif
157: /* flow through */
158: default:
159: break;
160: }
161: break;
162: case T_NORMAL:
163: if (cinfo[*lptr] == COL ){
164: switch (*++lptr) {
165: case 'W':
166: case 'w': opnd->type_o = T_ABSS;
167: lptr++;
168: break;
169: case 'L':
170: case 'l': opnd->type_o = T_ABSL;
171: lptr++;
172: break;
173: }
174: }
175: if (cinfo[*lptr] == IND)
176: goto index_mode;
177: break;
178: }
179: }
180: skipb( lptr );
181: if ( cinfo[ *lptr ] == LB ) {
182: /* oh, boy, bitfields */
183: opnd->flags_o |= O_BFLD;
184: spare_oper = zero_oper;
185: lptr = scan_reg_or_immed( lptr+1, &spare_oper);
186: v = spare_oper.value_o;
187: if (spare_oper.type_o == T_REG){
188: opnd->flags_o |= O_BFOREG;
189: } else if ((spare_oper.sym_o && !(spare_oper.sym_o->attr_s&S_DEF)) || v < 0 || v > 31){
190: PROG_ERROR(E_CONSTANT);
191: }
192: opnd->bfoffset_o = v;
193: skipb( lptr );
194: if ( cinfo[ *lptr ] == COL)
195: lptr ++;
196: else
197: PROG_ERROR(E_OPERAND);
198: spare_oper = zero_oper;
199: lptr = scan_reg_or_immed( lptr, &spare_oper);
200: v = spare_oper.value_o;
201: if (spare_oper.type_o == T_REG){
202: opnd->flags_o |= O_BFWREG;
203: } else if ((spare_oper.sym_o && !(spare_oper.sym_o->attr_s&S_DEF)) || v < 0 || v > 31){
204: PROG_ERROR(E_CONSTANT);
205: }
206: opnd->bfwidth_o = v;
207: skipb( lptr );
208: if ( cinfo[ *lptr ] == RB )
209: lptr++;
210: else
211: PROG_ERROR(E_OPERAND);
212: }
213: return(lptr);
214: } /* end soperand */
215:
216: static char *
217: scan_reg_or_immed( lptr, o )
218: register char *lptr;
219: register struct oper *o;
220: {
221: skipb( lptr );
222: if (cinfo[*lptr] == IMM) {
223: lptr = exp(++lptr,o);
224: if (o->type_o == T_REG)
225: PROG_ERROR(E_REG);
226: if (o->sym_o && !(o->sym_o->attr_s&S_DEF))
227: PROG_ERROR(E_REG);
228: o->type_o = T_IMMED;
229: } else {
230: lptr = exp( lptr, o );
231: if ( o->type_o != T_REG || o->value_o > D7REG)
232: PROG_ERROR(E_OPERAND);
233: }
234: return lptr;
235: }
236:
237: static char *
238: opt_length( lptr, fp, wflag, lflag )
239: register char * lptr;
240: struct suffix * fp;
241: {
242: char * save = lptr;
243: if (cinfo[ *lptr ] == COL){
244: lptr++;
245: skipb( lptr );
246: switch ( *lptr ){
247: case 'l':
248: case 'L':
249: fp->flags_sx |= lflag;
250: lptr++;
251: break;
252: case 'w':
253: case 'W':
254: fp->flags_sx |= wflag;
255: lptr++;
256: break;
257: default: return save; /* : yes, length, no: may be scale */
258: }
259: }
260: return lptr;
261: }
262: static char *
263: opt_scale( lptr, fp )
264: char * lptr;
265: struct suffix * fp;
266: {
267: fp->scale_sx = 1;
268: if (cinfo[ *lptr ] == COL){
269: lptr++;
270: skipb( lptr );
271: switch ( *lptr ){
272: case '1':
273: case '2':
274: case '4':
275: case '8':
276: fp->scale_sx = *lptr - '0';
277: lptr++;
278: break;
279: default: PROG_ERROR(E_OPERAND);
280: }
281: }
282: return lptr;
283: }
284:
285: static char *
286: suffix( lptr, fixp )
287: register char * lptr;
288: register struct suffix * fixp;
289: {
290: /*
291: * scan for open paran. look for displacement, optional length
292: * specifier, then index register, optional length specifier, optional
293: * scale specifier.
294: * fill in suffix structure with what we find.
295: */
296: struct oper o;
297: o = zero_oper;
298: *fixp = zero_suffix;
299: skipb( lptr );
300: if (cinfo[ *lptr ] == LP )
301: lptr += 1;
302: else
303: return lptr; /* guess that null suffix might be ok */
304: lptr = exp( lptr , &o );
305: if ( o.type_o == T_NORMAL ){
306: fixp->disp_sx = o.value_o;
307: fixp->sym_sx = o.sym_o;
308: fixp->flags_sx |= SX_GOTDISP;
309: #if C2
310: if (o.flags_o&O_COMPLEX)
311: fixp->flags_sx |= SX_CXDISP;
312: #endif
313: lptr = opt_length( lptr, fixp, SX_DISPW, SX_DISPL );
314: skipb( lptr );
315: if (cinfo[ *lptr ] == COM)
316: lptr = exp( ++lptr, &o );
317: else
318: goto scan_rp;
319: }
320: /* now we're talking index */
321: if ( o.type_o != T_REG ){
322: PROG_ERROR( E_OPERAND);
323: }
324: fixp->flags_sx |= SX_GOTINDEX;
325: fixp->indx_sx = o.value_o;
326: lptr = opt_length( lptr, fixp, SX_INDXW, SX_INDXL );
327: lptr = opt_scale( lptr, fixp );
328: scan_rp:
329: skipb( lptr );
330: if (cinfo[ *lptr ] == RP)
331: lptr ++;
332: else
333: PROG_ERROR( E_OPERAND);
334: return lptr;
335: }
336:
337: static
338: simplify1( oper, fp )
339: register struct oper * oper;
340: register struct suffix *fp;
341: {
342: register bval = oper->value_o;
343: /* we have some form of deferred or indexed addressing here */
344: /* try to make the best of it. */
345: /*
346: * examples are:
347: * a0@(disp)
348: * a0@(disp,d0:w:2)
349: * a0@(d0:w:2)
350: * pc@(disp)
351: * pc@(disp,d0:w:2)
352: * pc@(d0:w:2)
353: * @(d0)
354: * @(disp,d0)
355: */
356: switch (oper->type_o){
357: case T_REG:
358: if( !(fp->flags_sx&(SX_GOTINDEX|SX_DISPL)) ){
359: /* displacement mode */
360: oper->type_o = T_DISPL;
361: oper->reg_o = bval;
362: oper->value_o = fp->disp_sx;
363: oper->sym_o = fp->sym_sx;
364: } else {
365: /* index mode */
366: imode:
367: oper->type_o = T_INDEX;
368: oper->reg_o = bval;
369: oper->disp_o = fp->disp_sx;
370: oper->sym_o = fp->sym_sx;
371: if (fp->flags_sx&SX_GOTINDEX){
372: oper->value_o = fp->indx_sx;
373: oper->scale_o = fp->scale_sx;
374: if (fp->flags_sx&SX_INDXW)
375: oper->flags_o|= O_WINDEX|O_PREINDEX;
376: else
377: oper->flags_o|= O_LINDEX|O_PREINDEX;
378: } else {
379: oper->value_o = 0;
380: oper->scale_o = 0;
381: }
382: if (fp->flags_sx & SX_DISPL)
383: oper->flags_o|= O_LDISP;
384: else if (fp->flags_sx & SX_DISPW)
385: oper->flags_o|= O_WDISP;
386: /* else short form indexing */
387: }
388: break;
389: case T_NULL:
390: /* @(disp,d0) */
391: /* @(d0) */
392: /* index mode, supressed base */
393: oper->type_o= T_INDEX;
394: oper->flags_o|= O_BSUPRESS;
395: oper->reg_o = A0REG; /* Supress THIS register */
396: oper->disp_o= fp->disp_sx;
397: oper->sym_o= fp->sym_sx;
398: if(fp->flags_sx & SX_DISPL)
399: oper->flags_o |= O_LDISP;
400: else if (fp->flags_sx & SX_DISPW)
401: oper->flags_o |= O_WDISP;
402: do_index:
403: if (fp->flags_sx & SX_GOTINDEX){
404: oper->value_o = fp->indx_sx;
405: oper->scale_o = fp->scale_sx;
406: if (fp->flags_sx & (SX_INDXW) )
407: oper->flags_o |= O_PREINDEX|O_WINDEX;
408: else
409: oper->flags_o |= O_PREINDEX|O_LINDEX;
410: } else {
411: oper->value_o = 0;
412: oper->scale_o = 0;
413: }
414: break;
415: case T_ABSS:
416: oper->flags_o = O_WDISP;
417: goto normal;
418: case T_ABSL:
419: oper->flags_o = O_LDISP;
420: goto normal;
421: case T_NORMAL:
422: /* disp@ */
423: /* disp@(d0) */
424: /* index mode, supressed base */
425: oper->flags_o = 0;
426: normal:
427: oper->type_o = T_INDEX;
428: oper->flags_o|= O_BSUPRESS;
429: oper->reg_o = A0REG; /* Supress THIS register */
430: oper->disp_o = oper->value_o;
431: if (fp->flags_sx&SX_GOTDISP)
432: PROG_ERROR(E_OPERAND);
433: goto do_index;
434: default:
435: PROG_ERROR(E_OPERAND);
436: }
437: #if C2
438: if (fp->flags_sx&SX_CXDISP)
439: oper->flags_o |= O_COMPLEX;
440: #endif
441: }
442:
443: static
444: simplify2( oper, fp, dfp )
445: register struct oper * oper;
446: struct suffix *fp;
447: register struct suffix *dfp;
448: {
449: /*
450: * we have a memory indirect operand.
451: * examples:
452: * a0@(disp:l,d0:l:4)@(disp:w)
453: * a0@(disp)@(disp,d0:l:4)
454: * a0@@
455: * @(disp,d0)@(disp)
456: * @(d0)@
457: * @(disp)@
458: * @(disp,d0)@
459: * @(disp)@(d0)
460: */
461: simplify1( oper, fp );
462: if (oper->type_o == T_DISPL){
463: oper->type_o = T_INDEX;
464: oper->disp_o = oper->value_o;
465: oper->value_o = 0;
466: }
467: /* now build on that with second suffix */
468: oper->flags_o |= O_INDIRECT;
469: oper->disp2_o = dfp->disp_sx;
470: oper->sym2_o = dfp->sym_sx;
471: if (dfp->flags_sx & SX_DISPL)
472: oper->flags_o |= O_LDISP2;
473: else if (dfp->flags_sx & SX_DISPW)
474: oper->flags_o |= O_WDISP2;
475: if (dfp->flags_sx & SX_GOTINDEX){
476: if (oper->flags_o&O_PREINDEX)
477: PROG_ERROR(E_OPERAND);
478: oper->value_o = dfp->indx_sx;
479: oper->flags_o |= O_POSTINDEX;
480: oper->scale_o = dfp->scale_sx;
481: if (dfp->flags_sx&SX_INDXW)
482: oper->flags_o |= O_WINDEX;
483: else
484: oper->flags_o |= O_LINDEX;
485: }
486:
487: #if C2
488: if (fp->flags_sx&SX_CXDISP)
489: oper->flags_o |= O_COMPLEX2;
490: #endif
491: }
492:
493: /* read expression */
494: char *
495: exp(lptr, arg1)
496: register char *lptr;
497: register struct oper *arg1;
498: {
499: struct oper arg2; /* holds value of right hand term */
500: register int i;
501: static struct oper zero_opr;
502: #if AS
503: # define MKCOMPLEX( op )
504: #endif
505: #if C2
506: # define MKCOMPLEX( op ) if (arg1->sym_o&&arg2.sym_o || \
507: arg1->flags_o&O_COMPLEX || arg2.flags_o&O_COMPLEX){ \
508: ocomplex( op, arg1, &arg2 ); continue; \
509: }
510: #endif
511:
512: skipb(lptr); /* Find the operator */
513: i = cinfo[*lptr];
514: if (i==EOL || i==COM){ /* nil operand is zero */
515: arg1->sym_o = NULL;
516: arg1->value_o = 0;
517: return(lptr);
518: }
519: lptr = term( lptr, arg1 );
520:
521: while (1) {
522: arg2 = zero_opr;
523: skipb(lptr);
524: switch (cinfo[*lptr]) {
525: case ADD: lptr = term( ++lptr, &arg2 );
526: if (arg1->type_o==T_REG || arg2.type_o==T_REG)
527: break;
528: #if AS
529: if (arg1->sym_o && arg2.sym_o)
530: if (pass==2) break;
531: #endif
532: MKCOMPLEX( ADD );
533: if (arg2.sym_o)
534: arg1->sym_o = arg2.sym_o;
535: arg1->value_o += arg2.value_o;
536: arg1->flags_o |= arg2.flags_o&O_COMPLEX;
537: continue;
538:
539: case MUL: lptr = term(++lptr,&arg2);
540: if (arg1->type_o==T_REG || arg2.type_o==T_REG)
541: break;
542: #if AS
543: if (arg1->sym_o || arg2.sym_o)
544: if (pass==2) break;
545: #endif
546: MKCOMPLEX( MUL );
547: arg1->value_o *= arg2.value_o;
548: arg1->flags_o |= arg2.flags_o&O_COMPLEX;
549: continue;
550:
551: case DIV: lptr = term( ++lptr, &arg2 );
552: if (arg1->type_o==T_REG || arg2.type_o==T_REG)
553: break;
554: #if AS
555: if (arg1->sym_o || arg2.sym_o)
556: if (pass==2) break;
557: else if (arg2.value_o == 0) arg2.value_o = 1;
558: #endif
559: MKCOMPLEX( DIV );
560: arg1->value_o /= arg2.value_o;
561: arg1->flags_o |= arg2.flags_o&O_COMPLEX;
562: continue;
563:
564: case SUB: lptr = term( ++lptr, &arg2 );
565: if (arg1->type_o==T_REG || arg2.type_o==T_REG)
566: break;
567: if (arg2.sym_o){ /* if B is relocatable, */
568: if (arg1->sym_o){ /* and A is relocatable, */
569: #if AS
570: if (arg2.sym_o->csect_s != arg1->sym_o->csect_s
571: && pass == 2){
572: break; /* break into error */
573: } else {
574: /* result is absolute (no offset) */
575: arg1->sym_o = NULL;
576: /* but not a simple address for sdi's */
577: arg1->flags_o |= O_COMPLEX;
578: }
579: #endif
580: #if C2
581: /* operand cannot be understood at this time */
582: ocomplex( SUB, arg1, &arg2 );
583: continue;
584: #endif
585: }
586: else break; /* if B rel., and A is not, */
587: /* then break into relocation error */
588: }
589: arg1->value_o -= arg2.value_o;
590: continue;
591:
592: default: return(lptr);
593: }
594: PROG_ERROR(E_RELOCATE);
595: return(lptr);
596: }
597: #undef MKCOMPLEX
598: } /* end exp <read expression> */
599:
600: /* read term: either symbol, constant, or unary minus */
601: char *
602: term( lptr, vp )
603: register char *lptr;
604: register struct oper *vp;
605: {
606: register struct sym_bkt *sbp;
607: register int base = 10;
608: register long val;
609: register char *p;
610: register int i;
611: char savechar, *t;
612: char token[50];
613:
614: skipb(lptr);
615: i = cinfo[*lptr];
616:
617: /* here for number */
618: if (i & D){
619: p = lptr;
620: val = 0;
621: if (*lptr == '0'){
622: lptr++;
623: switch( *lptr){
624: case 'x':
625: case 'X':
626: lptr++;
627: /* hexidecimal number */
628: while (1){
629: if (cinfo[*lptr] & D)
630: val = val*16 + *lptr++ - '0';
631: else if (*lptr>='A' && *lptr<='F')
632: val = val*16 + *lptr++ - 'A' + 10;
633: else if (*lptr>='a' && *lptr<='f')
634: val = val*16 + *lptr++ - 'a' + 10;
635: else break;
636: }
637: break;
638: case 'f':
639: /*
640: * be careful not to confuse the floating-point
641: * constant 0f0.0 with the local label reference * 0f .
642: * for legitimate floating constants, the next
643: * character can be a digit, a decimal point,
644: * a negative sign, or one of the letters
645: * 'n', 'N', 'i', or 'I'.
646: */
647: switch (*(lptr+1)){
648: case '0':case '1':case '2':case '3':case '4':
649: case '5': case '6':case '7':case '8':case '9':
650: case '.': case '-': case '+':
651: case 'n':case 'N': case 'i':case 'I':
652: break;
653: default:
654: val = 0;
655: goto got_a_number;
656: }
657: /* FALL THROUGH */
658: case 'F':
659: case 'R':
660: case 'r':
661: lptr = scan_float( lptr, vp );
662: return (lptr);
663: default:
664: /* octal number */
665: while (cinfo[*lptr] & D){
666: if (*lptr == '8' || *lptr == '9')
667: PROG_ERROR(E_CONSTANT);
668: val = val*8 + *lptr++ - '0';
669: }
670: }
671: } else {
672: /* decimal number */
673: while (cinfo[*lptr] & D)
674: val = val*10 + *lptr++ - '0';
675: }
676: got_a_number:
677: if (*lptr == '$')
678: { lptr = p; goto sym; }
679: if (*lptr == 'b' || *lptr == 'f'){
680: /* local label reference, of form [0-9][bh] */
681: /* single digits only */
682: if (lptr > p+1 ){
683: PROG_ERROR(E_SYMLEN);
684: }
685: val = ll_val[*p-'0'] + (*lptr++=='f');
686: if (val < 0 ) PROG_ERROR(E_SYMDEF);
687: sprintf(token, ll_format, *p, val);
688: sbp = lookup(token);
689: goto sym2;
690:
691: }
692: vp->value_o = val;
693: vp->sym_o = NULL;
694: vp->type_o = T_NORMAL;
695: return(lptr);
696: }
697:
698: /* here for symbol name */
699: if (i & S) {
700: sym: t = lptr;
701: while (cinfo[*lptr] & T)
702: lptr++;
703: savechar = *lptr;
704: *lptr = '\0';
705: sbp = lookup(t); /* find its symbol bucket */
706: *lptr = savechar;
707: sym2:
708: #if C2
709: sbp->nuse_s++;
710: #endif
711: if (sbp->attr_s & S_DEF
712: #if C2
713: && sbp->csect_s == C_UNDEF
714: #endif
715: ){
716: /* if it's defined, use its value */
717: vp->value_o = sbp->value_s;
718: } else
719: vp->value_o = 0;
720: if (sbp->attr_s & S_REG){
721: vp->type_o = T_REG;
722: vp->sym_o = NULL;
723: } else {
724: vp->sym_o = ((sbp->attr_s & S_DEF) &&
725: (sbp->csect_s == C_UNDEF )) ? 0 : sbp;
726: vp->type_o = T_NORMAL;
727: }
728: return(lptr);
729: }
730:
731: /* check for unary minus */
732: if (i == SUB) {
733: lptr = term(++lptr,vp);
734: if (vp->sym_o){
735: #if AS
736: PROG_ERROR(E_RELOCATE);
737: #endif
738: #if C2
739: if (vp->sym_o){
740: ocomplex( SUB, vp, 0);
741: return(lptr);
742: }
743: #endif
744: }
745: vp->value_o = -(vp->value_o);
746: return(lptr);
747: }
748:
749: /* check for complement */
750: if (i == NOT) {
751: lptr = term(++lptr,vp);
752: if (vp->sym_o){
753: #if AS
754: PROG_ERROR(E_RELOCATE);
755: #endif
756: #if C2
757: if (vp->sym_o){
758: ocomplex( NOT, vp, 0);
759: return(lptr);
760: }
761: #endif
762: }
763: vp->value_o = ~(vp->value_o);
764: return(lptr);
765: }
766:
767: /* here for string */
768: if (i == QUO) {
769: vp->stringval_o = lptr+1;
770: /* scan over the quoted string, being careful of \-stuff */
771: do{
772: i = *++lptr;
773: if (i=='\\')
774: switch (i = *++lptr){
775: case '"': i = '\\'; /* fake-out loop test by covering up \"*/
776: }
777: }while (i!='\n' && i!='"');
778: if (i == '\n'){
779: PROG_ERROR(E_STRING);
780: }
781: *lptr++ = 0;
782: vp->sym_o = NULL;
783: vp->type_o = T_STRING;
784: return(lptr);
785: }
786:
787: /* new, improved kluge -- parens !! */
788: if (i==LP) {
789: lptr = exp(++lptr, vp);
790: skipb(lptr);
791: if ((i=cinfo[*lptr]) == RP) {
792: lptr++;
793: } else {
794: PROG_ERROR( E_PAREN );
795: }
796: return( lptr );
797: }
798:
799: PROG_ERROR(E_TERM);
800: return(lptr);
801: } /* end term */
802:
803: char *
804: scan_float( lptr, vp )
805: register char * lptr;
806: struct oper *vp;
807: {
808: /*
809: * lptr address a string which is a 'd' or an 'f', followed
810: * by a floating-point number. The latter looks like:
811: * [+-]nan( [0-9a-f]+ )
812: * or [+-]inf
813: * or [+-][0-9]+[.[0-9]+][e[+-][0-9]+]
814: * in the latter case, we call atof to do the conversion work.
815: * We do not take great care in syntax checking the number.
816: */
817: int s=0;
818: union{ double d; float f; int x[2]; } fp;
819: unsigned nanno, nanno2;
820: register char *nbegin;
821: char c;
822:
823: lptr++; /* skip the f */
824: nbegin = lptr;
825: again:
826: switch ( *lptr++){
827: case '+': if (s) goto bad_num; s = 1; goto again;
828: case '-': if (s) goto bad_num; s = -1; goto again;
829: case 'N':
830: case 'n': /* nan */
831: if (*lptr++ != 'a') goto bad_num;
832: if (*lptr++ != 'n') goto bad_num;
833: if (*lptr++ != '(') goto bad_num;
834: nanno = nanno2 = 0;
835: while( isxdigit(c = *lptr++)){
836: if (isdigit(c)) c -= '0';
837: else if (isupper(c)) c -= 'a'-10;
838: else c -= 'A'-10;
839: nanno2 = (nanno2 << 8) | (nanno >> 24);
840: nanno = (nanno<<8) | c;
841: }
842: if (c != ')') goto bad_num;
843: goto make_indef;
844:
845: case 'I':
846: case 'i': /* inf */
847: if (*lptr++ != 'n') goto bad_num;
848: if (*lptr++ != 'f') goto bad_num;
849: if (strncmp(lptr,"inity",5) == 0)
850: lptr += 5;
851: nanno = nanno2 = 0;
852: make_indef:
853: fp.x[0] = ((s<0)?0xfff00000:0x7ff00000) | nanno2;
854: fp.x[1] = nanno;
855: break;
856: case '0': case '1': case '2': case '3': case '4':
857: case '5': case '6': case '7': case '8': case '9':
858: /* scan for more digits */
859: while( isdigit( c = *lptr++ ) )
860: continue;
861: if (c != '.' )
862: goto scan_exp;
863: /* FALL THROUGH */
864: case '.':
865: /* scan for more digits */
866: while( isdigit( c = *lptr++ ) )
867: continue;
868: scan_exp:
869: s = 0;
870: switch(c){
871: case '+':
872: case '-':
873: s = 1;
874: /* FALL THROUGH */
875: case 'e':
876: case 'E':
877: switch ( c= *lptr++ ){
878: case '+':
879: case '-':
880: if (s) goto bad_num;
881: c = *lptr++;
882: /* FALL THROUGH */
883: default:
884: s = 0; /* count chars: 0 is not ok */
885: while( isdigit(c) ){
886: c = *lptr++;
887: s++;
888: }
889: if (s == 0) goto bad_num;
890: break;
891: }
892: break;
893: }
894: fp.d = atof( nbegin );
895: lptr--;
896: break;
897: default:
898: bad_num:
899: PROG_ERROR( E_BADCHAR );
900: return lptr;
901: }
902: vp->fval_o = fp.d;
903: vp->type_o = T_FLOAT;
904: return lptr;
905: }
906:
907:
908: static void
909: printoffset( value, sym, cmplx )
910: int value;
911: struct sym_bkt *sym;
912: int cmplx;
913: {
914: register struct optree *ot;
915: register char c = '?';
916: struct oper *op;
917: if (cmplx){
918: ot = (struct optree*)sym;
919: if (ot->right_t == NULL){
920: /* unary operation */
921: switch(ot->op_t){
922: case SUB: c = '-'; break;
923: case NOT: c = '~'; break;
924: }
925: printf("%c(",c);
926: op=ot->left_t;
927: printoffset(op->value_o, op->sym_o, op->flags_o&O_COMPLEX);
928: putchar(')');
929: } else {
930: /* binary */
931: putchar('(');
932: op=ot->left_t;
933: printoffset(op->value_o, op->sym_o, op->flags_o&O_COMPLEX);
934: switch(ot->op_t){
935: case ADD: c = '+'; break;
936: case SUB: c = '-'; break;
937: case MUL: c = '*'; break;
938: case DIV: c = '/'; break;
939: }
940: printf(")%c(", c);
941: op=ot->right_t;;
942: printoffset(op->value_o, op->sym_o, op->flags_o&O_COMPLEX);
943: putchar(')');
944: }
945: return;
946: }
947: if (sym != NULL){
948: fputs(sym->name_s, stdout);
949: if (value)
950: printf("+%d", value);
951: } else {
952: printf("%d", value);
953: }
954: }
955:
956:
957: char *rnames[] = {
958: "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
959: "a0", "a1", "a2", "a3", "a4", "a5", "a6", "sp",
960: "fp0","fp1","fp2","fp3","fp4","fp5","fp6","fp7",
961: "cc", "fcc", "pc", "sr", "usp", "sfc", "dfc", "vbr",
962: "cacr", "caar", "msp", "isp", "fpc", "fps", "fpi"
963: };
964:
965: static void
966: printindex( o )
967: register struct oper *o;
968: {
969: printf("%s:%c", rnames[o->value_o], o->flags_o&O_WINDEX ? 'w' : 'l');
970: if (o->scale_o != 1) printf(":%d", o->scale_o);
971: }
972:
973: printoperand( o )
974: register struct oper *o;
975: {
976: switch (o->type_o){
977: case T_REG: printf("%s", rnames[o->value_o]); break;
978: case T_DEFER: printf("%s@", rnames[o->value_o]); break;
979: case T_POSTINC: printf("%s@+", rnames[o->value_o]); break;
980: case T_PREDEC: printf("%s@-", rnames[o->value_o]); break;
981: case T_DISPL: printf("%s@(", rnames[o->reg_o]);
982: printoffset(o->value_o, o->sym_o, o->flags_o&O_COMPLEX);
983: putchar(')');
984: break;
985: case T_INDEX:
986: if (!(o->flags_o&O_BSUPRESS)){
987: printf("%s@", rnames[o->reg_o]);
988: }
989: putchar('(');
990: printoffset(o->disp_o, o->sym_o, o->flags_o&O_COMPLEX);
991: if (o->flags_o & O_WDISP) fputs(":w", stdout);
992: else if (o->flags_o & O_LDISP) fputs(":l", stdout);
993: if (o->flags_o&O_PREINDEX){
994: putchar(',');
995: printindex( o );
996: }
997: putchar(')');
998: if (o->flags_o&O_INDIRECT){
999: putchar('@');
1000: if (o->disp2_o || o->sym2_o || o->flags_o&O_POSTINDEX){
1001: putchar('(');
1002: if (o->disp2_o || o->sym2_o ){
1003: printoffset(o->disp2_o, o->sym2_o, o->flags_o&O_COMPLEX2);
1004: if (o->flags_o&O_POSTINDEX)
1005: putchar(',');
1006: }
1007: if (o->flags_o&O_POSTINDEX){
1008: printindex( o );
1009: }
1010: putchar(')');
1011: }
1012: }
1013: break;
1014: case T_ABSS:
1015: case T_ABSL:
1016: printoffset(o->value_o, o->sym_o, o->flags_o&O_COMPLEX);
1017: fputs( (o->type_o == T_ABSS) ? ":w" : ":l", stdout);
1018: break;
1019: case T_IMMED:
1020: putchar('#');
1021: if (o->flags_o & O_FLOAT) goto float_val;
1022: /* FALL THROUGH */
1023: case T_NORMAL:
1024: printoffset(o->value_o, o->sym_o, o->flags_o&O_COMPLEX);
1025: break;
1026: case T_STRING:
1027: printf("\"%s\"", o->stringval_o);
1028: break;
1029: case T_REGPAIR: printf("%s:%s", rnames[o->value_o],rnames[o->reg_o]);
1030: break;
1031: float_val:
1032: case T_FLOAT: printf("0r%.17e", o->fval_o);
1033: break;
1034: default:
1035: printf("UNKNOWN(%d)", o->type_o);
1036: break;
1037: }
1038: if (o->flags_o&O_BFLD){
1039: /* bit field */
1040: /* first the offset part */
1041: if (o->flags_o&O_BFOREG)
1042: printf("{%s:",rnames[o->bfoffset_o]);
1043: else
1044: printf("{#%d:",o->bfoffset_o);
1045: /* then the width part */
1046: if (o->flags_o&O_BFWREG)
1047: printf("%s}",rnames[o->bfwidth_o]);
1048: else
1049: printf("#%d}",o->bfwidth_o);
1050: }
1051: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.