![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to asparse.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / as|
Return to asparse.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / as |
1.1 root 1: /* Copyright (c) 1979 Regents of the University of California */
2: #include <stdio.h>
3: #include <a.out.h>
4: #include "as.h"
5: #include "asexpr.h"
6: #include "asscan.h"
7: #include "assyms.h"
8:
9: extern struct exp usedot[];/*information on the dot for each seg*/
10: struct exp *dotp = &usedot[0]; /*current dot*/
11: int anyerrs;
12:
13: int passno = 1;
14:
15: FILE *tmpfil;
16: FILE *relfil; /*relocation info sent here*/
17: FILE *txtfil; /*text (for any text #) sent here*/
18:
19: int hshused; /*hash slots consumed */
20: long tsize;
21: long dsize;
22:
23: long bitfield;
24: int bitoff;
25:
26: /*
27: * The following three variables are communication between various
28: * modules to special case a number of things. They are properly
29: * categorized as hacks.
30: */
31: struct symtab *lastnam; /*last name seen by the lexical analyzer*/
32: int exprisname; /*last factor in an expression was a name*/
33: int droppedLP; /*one is analyzing an expression beginning with*/
34: /*a left parenthesis, which has already been*/
35: /*shifted. (Used to parse (<expr>)(rn)*/
36:
37: char yytext[NCPS+2];
38: static char Dotsname[32];
39:
40: struct exp *xp; /*next free expression slot, used by expr.c*/
41:
42: int yylval; /*the lexical value; sloppy typing*/
43:
44: extern ptrall tokptr; /*points to current token being eaten*/
45: extern int d124;
46:
47: int yyparse()
48: {
49: register struct exp *locxp;
50: /*
51: * loc1xp and ptrloc1xp are used in the
52: * expression lookahead
53: */
54: struct exp *loc1xp; /*must be non register*/
55: struct exp **ptrloc1xp = & loc1xp;
56: struct exp *pval; /*hacking expr:expr*/
57:
58: register struct symtab *np;
59: register int argcnt;
60:
61: register int val; /*what yylex gives*/
62: register int auxval; /*saves val*/
63:
64: register struct arg *ap; /*first free argument*/
65:
66: struct symtab *p;
67: register struct symtab *stpt;
68:
69: struct strdesc *stringp; /*handles string lists*/
70:
71: int regno; /*handles arguments*/
72: int *ptrregno = ®no;
73: int sawmul; /*saw * */
74: int sawindex; /*saw [rn]*/
75: int sawsize;
76: int seg_type; /*the kind of segment: data or text*/
77: int seg_number; /*the segment number*/
78: long space_value; /*how much .space needs*/
79:
80: int field_width; /*how wide a field is to be*/
81: int field_value; /*the value to stuff in a field*/
82: char *stabname; /*name of stab dealing with*/
83: ptrall stabstart; /*where the stab starts in the buffer*/
84:
85: xp = explist;
86: ap = arglist;
87:
88: val = yylex();
89: while (val != PARSEEOF){
90: while (INTOKSET(val, LINSTBEGIN)){
91: if (val == NL){
92: lineno++;
93: shift;
94: } else
95: if (val == SEMI)
96: shift;
97: else { /*its a name, so we have a label (hopefully*/
98: if (val != NAME){
99: ERROR("Name expected for a label");
100: }
101: np = (struct symtab *)yylval;
102: shiftover(NAME);
103: shiftover(COLON);
104: flushfield(NBPW/4);
105: if ((np->type&XTYPE)!=XUNDEF) {
106: if( (np->type&XTYPE)!=dotp->xtype
107: || np->value!=dotp->xvalue
108: || ( (passno==1)
109: &&(np->index != dotp->xloc)
110: )
111: ){
112: #ifndef DEBUG
113: if (np->name[0] != 'L')
114: #endif
115: {
116: yyerror("%.8s redefined", np->name);
117: #ifdef DEBUG
118: printf("name.value=%d, dotp->xvalue=%d\n",
119: np->value, dotp->xvalue);
120: #endif
121: }
122: }
123: }
124: np->type &= ~(XTYPE|XFORW);
125: np->type |= dotp->xtype;
126: np->value = dotp->xvalue;
127: if (passno == 1){
128: np->index = dotp-usedot;
129: if (np->name[0] == 'L'){
130: nlabels++;
131: }
132: np->tag = LABELID;
133: }
134: } /*end of this being a label*/
135: } /*end of to consuming all labels, NLs and SEMIS */
136:
137: xp = explist;
138: ap = arglist;
139:
140: /*
141: * process the INSTRUCTION body
142: */
143: switch(val){
144: default:
145: ERROR("Unrecognized instruction or directive");
146:
147: case IABORT:
148: shift;
149: sawabort();
150: /*NOTREACHED*/
151: break;
152:
153: case PARSEEOF:
154: tokptr -= sizeof(toktype);
155: *tokptr++ = VOID;
156: tokptr[1] = VOID;
157: tokptr[2] = PARSEEOF;
158: break;
159:
160: case IFILE:
161: shift;
162: stringp = (struct strdesc *)yylval;
163: shiftover(STRING);
164: dotsname = &Dotsname[0];
165: movestr(dotsname, stringp->str,
166: stringp->str_lg >= 32? 32 :stringp->str_lg);
167: dotsname[stringp->str_lg] = '\0';
168: #ifdef DEBUG
169: if (debug)
170: printf("(from parser) Now considered to be in file %s\n",
171: dotsname);
172: #endif
173: break;
174:
175: case ILINENO:
176: shift; /*over the ILINENO*/
177: expr(locxp, val);
178: lineno = locxp->xvalue;
179: #ifdef DEBUG
180: if (debug)
181: printf("Now considered to be on line number %d\n",
182: lineno);
183: #endif
184: break;
185:
186: case ISET: { /* .set <name> , <expr> */
187: shift;
188: np = (struct symtab *)yylval;
189: shiftover(NAME);
190: shiftover(CM);
191: expr(locxp, val);
192: np->type &= (XXTRN|XFORW);
193: np->type |= locxp->xtype&(XTYPE|XFORW);
194: np->value = locxp->xvalue;
195: if (passno==1)
196: np->index = locxp->xloc;
197: if ((locxp->xtype&XTYPE) == XUNDEF)
198: yyerror("Illegal set?");
199: break;
200: } /*end of case ISET*/
201:
202: case ILSYM: { /*.lsym name , expr */
203: shift;
204: np = (struct symtab *)yylval;
205: shiftover(NAME);
206: shiftover(CM);
207: expr(locxp, val);
208: /*
209: * Build the unique occurance of the
210: * symbol.
211: * The character scanner will have
212: * already entered it into the symbol
213: * table, but we should remove it
214: */
215: if (passno == 1){
216: stpt = (struct symtab *)symalloc();
217: movestr(stpt->name, np->name, NCPS);
218: np->tag = OBSOLETE; /*invalidate original */
219: nforgotten++;
220: np = stpt;
221: if (locxp->xtype != XABS)
222: ("Illegal lsym");
223: np->value=locxp->xvalue;
224: np->type=XABS;
225: np->tag = ILSYM;
226: }
227: break;
228: } /*end of case ILSYM*/
229:
230: case IGLOBAL: { /*.globl <name> */
231: shift;
232: np = (struct symtab *)yylval;
233: shiftover(NAME);
234: np->type |= XXTRN;
235: break;
236: } /*end of case IGLOBAL*/
237:
238: case IDATA: /*.data [ <expr> ] */
239: case ITEXT: { /*.text [ <expr> ] */
240: seg_type = -val;
241: shift;
242: if (INTOKSET(val, EBEGOPS+YUKKYEXPRBEG+SAFEEXPRBEG)){
243: expr(locxp, val);
244: seg_type = -seg_type; /*now, it is positive*/
245: }
246:
247: if (seg_type < 0) { /*there wasn't an associated expr*/
248: seg_number = 0;
249: seg_type = -seg_type;
250: } else {
251: if (locxp->xtype != XABS || (seg_number=locxp->xvalue) >= NLOC) {
252: yyerror("illegal location counter");
253: seg_number = 0;
254: }
255: }
256: if (seg_type == IDATA)
257: seg_number += NLOC;
258: flushfield(NBPW/4);
259: dotp = &usedot[seg_number];
260: if (passno==2) { /* go salt away in pass 2*/
261: if (usefile[seg_number] == NULL) {
262: tmpn2[TMPC] = 'a'+seg_number;
263: if ((usefile[seg_number] =
264: fopen(tmpn2, "w"))==NULL) {
265: yyerror("cannot create temp %s", tmpn2);
266: delexit();
267: }
268:
269: tmpn3[TMPC] = 'a'+seg_number;
270: if ((rusefile[seg_number] =
271: fopen(tmpn3, "w"))==NULL) {
272:
273: yyerror("cannot create temp %s",
274: tmpn3);
275: }
276: }
277: txtfil = usefile[seg_number];
278: relfil = rusefile[seg_number];
279: }
280:
281: break;
282: } /*end of case .TEXT and .DATA*/
283:
284: /*
285: * Storage filler directives:
286: *
287: * .byte [<exprlist>]
288: *
289: * exprlist: empty | exprlist outexpr
290: * outexpr: <expr> | <expr> : <expr>
291: */
292: case IBYTE: curlen = NBPW/4; goto elist;
293:
294: case IINT:
295: case ILONG: curlen = NBPW; goto elist;
296:
297: case IWORD: {
298: curlen = NBPW/2;
299: elist:
300: seg_type = val;
301: shift;
302:
303: /*
304: * This processes an expression list
305: */
306: if (INTOKSET(val, EBEGOPS+YUKKYEXPRBEG+SAFEEXPRBEG)){
307: do{
308: /*
309: * expression list consists of a list of :
310: * <expr>
311: * <expr> : <expr>
312: * (pack expr2 into expr1 bits
313: */
314: expr(locxp, val);
315: /*
316: * now, pointing at the next token
317: */
318: if (val == COLON){
319: shiftover(COLON);
320: expr(pval, val);
321: if (locxp->xtype != XABS)
322: yyerror("Width not absolute");
323: field_width = locxp->xvalue;
324: locxp = pval;
325: if (bitoff + field_width >
326: curlen)
327: flushfield(curlen);
328: if (field_width > curlen)
329: yyerror("Expression crosses field boundary");
330: } /*value being colon*/
331: else {
332: field_width = curlen;
333: flushfield(curlen);
334: }
335:
336: if ((locxp->xtype&XTYPE)!=XABS) {
337: if (bitoff)
338: yyerror("Illegal relocation in field");
339: field_width=LEN1+!PCREL;
340: if (curlen==NBPW)
341: field_width = LEN4 + !PCREL;
342: if (curlen==NBPW/2)
343: field_width = LEN2 + !PCREL;
344: /*
345: * Save relocation information for this non absolute
346: * symbol:
347: * pass 1: saves enough space for the value, and
348: * fixes dotp.
349: * pass 2: writes the address info in ld compatable
350: * format onto one of the relfiles
351: */
352: outrel(&locxp->xvalue,
353: field_width,
354: locxp->xtype,
355: locxp->xname);
356: } else {
357: field_value = locxp->xvalue & ( (1L << field_width)-1);
358: bitfield |= field_value << bitoff;
359: bitoff += field_width;
360: }
361: if ( auxval = (val == CM)) shift;
362: } while (auxval);
363: } /*existed an expression at all*/
364:
365: flushfield(curlen);
366: if ( ( curlen == NBPW/4) && bitoff)
367: dotp->xvalue ++;
368: break;
369: } /*end of case IBYTE, IWORD, ILONG, IINT*/
370:
371: case ISPACE: { /* .space <expr> */
372: shift;
373: expr(locxp, val);
374: if (locxp->xtype != XABS)
375: yyerror("Space size not absolute");
376: space_value = locxp->xvalue;
377: ospace:
378: flushfield(NBPW/4);
379: while (space_value > 96){
380: outs(strbuf[2].str, 96);
381: space_value -= 96;
382: }
383: outs(strbuf[2].str, space_value);
384: break;
385: } /*end of case ISPACE*/
386:
387: case IASCII: /* .ascii [ <stringlist> ] */
388: case IASCIZ: { /* .asciz [ <stringlist> ] */
389: auxval = val;
390: shift;
391:
392: /*
393: * Code to consume a string list
394: *
395: * stringlist: empty | STRING | stringlist STRING
396: */
397: while (val == STRING){
398: flushfield(NBPW/4);
399: if (bitoff)
400: dotp->xvalue++;
401: stringp = (struct strdesc *)yylval;
402: outs(stringp->str, stringp->str_lg);
403: shift; /*over the STRING*/
404: if (val == CM) /*could be a split string*/
405: shift;
406: }
407:
408: if (auxval == IASCIZ){
409: flushfield(NBPW/4);
410: outb(0);
411: }
412: break;
413: } /*end of case IASCII and IASIZ*/
414:
415: case IORG: { /* .org <expr> */
416: shift;
417: expr(locxp, val);
418:
419: if (locxp->xtype==XABS)
420: orgwarn++;
421: else if (locxp->xtype!=dotp->xtype)
422: yyerror("Illegal expression to set origin");
423: space_value = locxp->xvalue - dotp->xvalue;
424: if (space_value < 0)
425: yyerror("Backwards 'org'");
426: goto ospace;
427: break;
428: } /*end of case IORG*/
429:
430: /*
431: *
432: * Process stabs. Stabs are created only by the f77
433: * and the C compiler with the -g flag set.
434: * We only look at the stab ONCE, during pass 1, and
435: * virtually remove the stab from the intermediate file
436: * so it isn't seen during pass2. This makes for some
437: * hairy processing to handle labels occuring in
438: * stab entries, but since most expressions in the
439: * stab are integral we save lots of time in the second
440: * pass by not looking at the stabs.
441: * A stab that is tagged floating will be bumped during
442: * the jxxx resolution phase. A stab tagged fixed will
443: * not be be bumped.
444: *
445: * .stab: Old fashioned stabs
446: * .stabn: For stabs without names
447: * .stabs: For stabs with string names
448: * .stabd: For stabs for line numbers or bracketing,
449: * without a string name, without
450: * a final expression. The value of the
451: * final expression is taken to be the current
452: * location counter, and is patched by the 2nd pass
453: *
454: * .stab{<expr>,}*8,<expr>, <expr>, <expr>, <expr>
455: * .stabn <expr>, <expr>, <expr>, <expr>
456: * .stabs STRING, <expr>, <expr>, <expr>, <expr>
457: * .stabd <expr>, <expr>, <expr> # .
458: */
459: case ISTAB: {
460: stabname = ".stab";
461: if (passno == 2) goto errorfix;
462: stpt = (struct symtab *)yylval;
463: /*
464: * Make a pointer to the .stab slot.
465: * There is a pointer in the way (stpt), and
466: * tokptr points to the next token.
467: */
468: stabstart = tokptr;
469: (char *)stabstart -= sizeof(struct symtab *);
470: (char *)stabstart -= sizeof(toktype);
471: shift;
472: for (argcnt = 0; argcnt < 8; argcnt++){
473: expr(locxp, val);
474: stpt->name[argcnt] = locxp->xvalue;
475: shiftover(CM);
476: }
477: tailstab:
478: expr(locxp, val);
479: if (! (locxp->xvalue & STABTYPS)){
480: yyerror("Invalid type in %s",stabname);
481: goto errorfix;
482: }
483: stpt->ptype = locxp->xvalue;
484: shiftover(CM);
485: expr(locxp, val);
486: stpt->other = locxp->xvalue;
487: shiftover(CM);
488: expr(locxp, val);
489: stpt->desc = locxp->xvalue;
490: shiftover(CM);
491: exprisname = 0;
492: expr(locxp, val);
493: p = locxp->xname;
494: if (p == NULL) { /*absolute expr to begin with*/
495: stpt->value = locxp->xvalue;
496: stpt->index = dotp - usedot;
497: if (exprisname){
498: switch(stpt->ptype){
499: case N_GSYM:
500: case N_FNAME:
501: case N_RSYM:
502: case N_SSYM:
503: case N_LSYM:
504: case N_PSYM:
505: case N_BCOMM:
506: case N_ECOMM:
507: case N_LENG:
508: stpt->tag = STABFIXED;
509: break;
510: default:
511: stpt->tag = STABFLOATING;
512: break;
513: }
514: } else
515: stpt->tag = STABFIXED;
516: }
517: else { /*really have a name*/
518: stpt->dest = locxp->xname;
519: stpt->index = p->index;
520: stpt->type = p->type | STABFLAG;
521: /*
522: * We will assign a more accruate
523: * guess of locxp's location when
524: * we sort the symbol table
525: * The final value of value is
526: * given by stabfix()
527: */
528: stpt->tag = STABFLOAT;
529: #ifdef DSTAB
530: printf("FORWARD REF FOR %s...\n", stabname);
531: printf("value (xname) = %x value(value(xname) = %x\n",
532: stpt->dest,stpt->dest->value);
533: printf("name: %.8s\n\n",
534: (stpt->dest)->name);
535: #endif
536: }
537: /*
538: * tokptr now points at one token beyond
539: * the current token stored in val and yylval,
540: * which are the next tokens after the end of
541: * this .stab directive. This next token must
542: * be either a SEMI or NL, so is of width just
543: * one. Therefore, to point to the next token
544: * after the end of this stab, just back up one..
545: */
546: buildskip(stabstart, (char *)tokptr - sizeof(toktype));
547: break; /*end of the .stab*/
548: } /*end of ISTAB*/
549:
550: case ISTABDOT: {
551: stabname = ".stabd";
552: stpt = (struct symtab *)yylval;
553: /*
554: * We clobber everything after the
555: * .stabd and its pointer... we MUST
556: * be able to get back to this .stabd
557: * so that we can resolve its final value
558: */
559: stabstart = tokptr;
560: shift; /*over the ISTABDOT*/
561: if (passno == 1){
562: expr(locxp, val);
563: if (! (locxp->xvalue & STABTYPS)){
564: yyerror("Invalid type in .stabd");
565: goto errorfix;
566: }
567: stpt->ptype = locxp->xvalue;
568: shiftover(CM);
569: expr(locxp, val);
570: stpt->other = locxp->xvalue;
571: shiftover(CM);
572: expr(locxp, val);
573: stpt->desc = locxp->xvalue;
574: /*
575: *
576: * Now, clobber everything but the
577: * .stabd pseudo and the pointer
578: * to its symbol table entry
579: * tokptr points to the next token,
580: * build the skip up to this
581: */
582: buildskip(stabstart, (toktype *)tokptr - sizeof(toktype));
583: }
584: /*
585: * pass 1: Assign a good guess for its position
586: * (ensures they are sorted into right place)/
587: * pass 2: Fix the actual value
588: */
589: stpt->value = dotp->xvalue;
590: stpt->index = dotp - usedot;
591: stpt->tag = STABFLOAT; /*although it has no effect in pass 2*/
592: break;
593: } /*end of case ISTABDOT*/
594:
595: case ISTABNONE: stabname = ".stabn"; goto shortstab;
596:
597: case ISTABSTR: { stabname = ".stabs";
598: shortstab:
599: auxval = val;
600: if (passno == 2) goto errorfix;
601: stpt = (struct symtab *)yylval;
602: stabstart = tokptr;
603: (char *)stabstart -= sizeof(struct symtab *);
604: (char *)stabstart -= sizeof(toktype);
605: shift;
606: if (auxval == ISTABSTR){
607: stringp = (struct strdesc *)yylval;
608: shiftover(STRING);
609: auxval = stringp->str_lg > NCPS ? NCPS : stringp->str_lg;
610: shiftover(CM);
611: } else {
612: stringp = &(strbuf[2]);
613: auxval = NCPS;
614: }
615: movestr(stpt->name, stringp->str, auxval);
616: goto tailstab;
617: break;
618: } /*end of case ISTABSTR and ISTABN*/
619:
620: case ICOMM: /* .comm <name> , <expr> */
621: case ILCOMM: { /* .lcomm <name> , <expr> */
622: auxval = val;
623: shift;
624: np = (struct symtab *)yylval;
625: shiftover(NAME);
626: shiftover(CM);
627: expr(locxp, val);
628:
629: if (locxp->xtype != XABS)
630: yyerror("comm size not absolute");
631: if (passno==1 && (np->type&XTYPE)!=XUNDEF)
632: yyerror("Redefinition of %.8s", np->name);
633: if (passno==1) {
634: np->value = locxp->xvalue;
635: if (auxval == ICOMM)
636: np->type |= XXTRN;
637: else {
638: np->type &= ~XTYPE;
639: np->type |= XBSS;
640: }
641: }
642: break;
643: } /*end of case ICOMM and ILCOMM*/
644:
645: case IALIGN: { /* .align <expr> */
646: stpt = (struct symtab *)yylval;
647: shift;
648: expr(locxp, val);
649: jalign(locxp, stpt);
650: break;
651: } /*end of case IALIGN*/
652:
653: case INST0: { /* instructions w/o arguments*/
654: insout(yylval, 0, 0);
655: shift;
656: break;
657: } /*end of case INST0*/
658:
659: case INSTn: /* instructions with arguments*/
660: case IJXXX: { /* UNIX style jump instructions */
661: auxval = val;
662: seg_type = yylval;
663: /*
664: * Code to process an argument list
665: */
666: ap = arglist;
667: xp = explist; /*must be set before bring in the first token*/
668:
669: shift; /*and bring in the first token for the arg list*/
670:
671: for (argcnt = 1; argcnt <= 6; argcnt++, ap++){
672: /*
673: * code to process an argument proper
674: */
675: sawindex = sawmul = sawsize = 0;
676: {
677: switch(val) {
678:
679: default: {
680: disp:
681: if( !(INTOKSET(val,
682: EBEGOPS
683: +YUKKYEXPRBEG
684: +SAFEEXPRBEG)) ) {
685: ERROR("expression expected");
686: }
687: expr(ap->xp,val);
688: overdisp:
689: if ( val == LP || sawsize){
690: shiftover(LP);
691: findreg(regno);
692: shiftover(RP);
693: ap->atype = ADISP;
694: ap->areg1 = regno;
695: } else {
696: ap->atype = AEXP;
697: ap->areg1 = 0;
698: }
699: goto index;
700: } /*end of the default action*/
701:
702: case SIZESPEC: {
703: sizespec:
704: sawsize = yylval;
705: shift;
706: goto disp;
707: }
708:
709: case REG:
710: case REGOP: {
711: findreg(regno);
712: ap->atype = AREG;
713: ap->areg1 = regno;
714: break;
715: } /*end of case REG*/
716:
717: case MUL: {
718: sawmul = 1;
719: shift;
720: if (val == LP) goto base;
721: if (val == LITOP) goto imm;
722: if (val == SIZESPEC) goto sizespec;
723: if (INTOKSET(val,
724: EBEGOPS
725: +YUKKYEXPRBEG
726: +SAFEEXPRBEG)) goto disp;
727: ERROR("expression, '(' or '$' expected");
728: break;
729: } /*end of case MUL*/
730:
731: case LP: {
732: base:
733: shift; /*consume the LP*/
734: /*
735: * hack the ambiguity of
736: * movl (expr) (rn), ...
737: * note that (expr) could also
738: * be (rn) (by special hole in the
739: * grammar), which we ensure
740: * means register indirection, instead
741: * of an expression with value n
742: */
743: if (val != REG && val != REGOP){
744: droppedLP = 1;
745: val = exprparse(val, &(ap->xp));
746: droppedLP = 0;
747: goto overdisp;
748: }
749: findreg(regno);
750: shiftover(RP);
751: if (val == PLUS){
752: shift;
753: ap->atype = AINCR;
754: } else
755: ap->atype = ABASE;
756: ap->areg1 = regno;
757: goto index;
758: } /*end of case LP*/
759:
760: case LITOP: {
761: imm:
762: shift;
763: expr(locxp, val);
764: ap->atype = AIMM;
765: ap->areg1 = 0;
766: ap->xp = locxp;
767: goto index;
768: } /*end of case LITOP*/
769:
770: case MP: {
771: shift; /* -(reg) */
772: findreg(regno);
773: shiftover(RP);
774: ap->atype = ADECR;
775: ap->areg1 = regno;
776: index: /*look for [reg] */
777: if (val == LB){
778: shift;
779: findreg(regno);
780: shiftover(RB);
781: sawindex = 1;
782: ap->areg2 = regno;
783: }
784: break;
785: } /*end of case MP*/
786:
787: } /*end of the switch to process an arg*/
788: } /*end of processing an argument*/
789:
790: if (sawmul){
791: /*
792: * Make a concession for *(%r)
793: * meaning *0(%r)
794: */
795: if (ap->atype == ABASE) {
796: ap->atype = ADISP;
797: xp->xtype = XABS;
798: xp->xvalue = 0;
799: xp->xloc = 0;
800: ap->xp = xp++;
801: }
802: ap->atype |= ASTAR;
803: sawmul = 0;
804: }
805: if (sawindex){
806: ap->atype |= AINDX;
807: sawindex = 0;
808: }
809: ap->dispsize = sawsize == 0 ? d124 : sawsize;
810: if (val != CM) break;
811: shiftover(CM);
812: } /*processing all the arguments*/
813:
814: if (argcnt > 6){
815: yyerror("More than 6 arguments");
816: goto errorfix;
817: }
818:
819: insout(seg_type, arglist,
820: auxval == INSTn ? argcnt : - argcnt);
821: break;
822: } /*end of case INSTn and IJXXX*/
823:
824: case IFLOAT: curlen = 4; goto floatlist;
825:
826: case IDOUBLE: {
827: curlen = 8;
828: floatlist:
829: /*
830: * eat a list of floating point numbers
831: */
832: shift;
833: if (val == FLTNUM){
834: do{
835: if (val == CM) shift;
836: if (val != FLTNUM) {
837: ERROR("floating number expected");
838: }
839: dotp->xvalue += curlen;
840: if (passno == 2)
841: fwrite(
842: &(((struct exp *)yylval)->doubval.dvalue),
843: 1, curlen, txtfil);
844: shift;
845: } while (val == CM);
846: }
847: break;
848: } /*end of case IFLOAT and IDOUBLE*/
849:
850: } /*end of the switch for looking at each reserved word*/
851:
852: /*
853: * If got here, then one has no syntax errors!
854: */
855: continue;
856:
857: /*
858: * got here by either requesting to skip to the
859: * end of this statement, or by erroring out and
860: * wanting to apply panic mode recovery
861: */
862: errorfix: {
863: #ifdef DEBUG
864: if (debug)
865: printf("Discarding tokens from here:\n");
866: #endif
867: while ( (val != NL)
868: && (val != SEMI)
869: && (val != PARSEEOF)
870: ){
871: #ifdef DEBUG
872: if (debug)
873: printf("****>>>>\t");
874: #endif
875: shift;
876: }
877: if (val == NL)
878: lineno++;
879: #ifdef DEBUG
880: if (debug)
881: printf("To here.\n");
882: #endif
883: shift;
884: }
885:
886: } /*end of the loop to read the entire file, line by line*/
887:
888:
889: } /*end of yyparse*/
890:
891: /*
892: * Process a register declaration of the form
893: * % <expr>
894: *
895: * Note:
896: * The scanner has already processed funny registers of the form
897: * %dd[+-]*, where dd is a decimal number in the range 00 to 15 (optional
898: * preceding zero digit). If there was any space between the % and
899: * the digit, the scanner wouldn't have recognized it, so we
900: * hack it out here.
901: */
902: int funnyreg(val, regnoback) /*what the read head will sit on*/
903: int val; /*what the read head is sitting on*/
904: int *regnoback; /*call by return*/
905: {
906: register struct exp *locxp;
907: struct exp *loc1xp;
908: struct exp **ptrloc1xp = & loc1xp;
909:
910: expr(locxp, val); /*and leave the current read head with value*/
911: if ( (passno == 2) &&
912: ( locxp->xtype & XTYPE != XABS
913: || locxp->xvalue < 0
914: || locxp->xvalue >= 16
915: )
916: ){
917: yyerror("Illegal register");
918: return(0);
919: }
920: *regnoback = locxp->xvalue;
921: return(val);
922: }
923:
924: /* VARARGS 1*/
925: yyerror(s, a1, a2)
926: char *s;
927: {
928: FILE *sink;
929:
930: #ifdef DEBUG
931: sink = stdout;
932: #else
933: sink = stderr;
934: #endif
935:
936: if (anyerrs == 0 && ! silent)
937: fprintf(sink, "Assembler:\n");
938: anyerrs++;
939: if (silent) return;
940:
941: fprintf(sink, "\"%s\", line %d: ", dotsname, lineno);
942: fprintf(sink, s, a1, a2);
943: fprintf(sink, "\n");
944: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.