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