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