![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to asscan.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 asscan.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[] = "@(#)asscan.c 4.6 9/8/80";
3: #include <stdio.h>
4: #include "as.h"
5: #include "asscan.h"
6:
7: /*
8: * NOTE:
9: * This version of the assembler does not use fread and fwrite
10: * for the token buffering. The token buffers are integrals of BUFSIZ
11: * at all times, so we use direct read and write. fread and fwrite
12: * as supplied from BTL in stdio are HORRENDOUSLY inefficient,
13: * as they use putchar for each character, nested two deep in loops.
14: */
15: #define writeTEST(pointer, size, nelements, ioptr) \
16: write(ioptr->_file, pointer, nelements * size) != nelements * size
17:
18: #define readTEST(pointer, size, nelements, ioptr) \
19: read(ioptr->_file, pointer, nelements * size) != nelements * size
20: /*
21: * Variables to manage the token buffering.
22: * We scan (lexically analyze) a large number of tokens, and
23: * then parse all of the tokens in the scan buffer.
24: * This reduces procedure call overhead when the parser
25: * demands a token, allows for an efficient reread during
26: * the second pass, and confuses the line number reporting
27: * for errors encountered in the scanner and in the parser.
28: */
29: #define TOKDALLOP 8
30: struct tokbufdesc *bufstart; /*where the buffer list begins*/
31: struct tokbufdesc *buftail; /*last one on the list*/
32: struct tokbufdesc *emptybuf; /*the one being filled*/
33: /*
34: * If we are using VM, during the second pass we reclaim the used
35: * token buffers for saving the relocation information
36: */
37: struct tokbufdesc *tok_free; /* free pool */
38: struct tokbufdesc *tok_temp; /* temporary for doing list manipulation */
39: /*
40: * Other token buffer managers
41: */
42: int bufno; /*which buffer number: 0,1 for tmp file*/
43: struct tokbufdesc tokbuf[2]; /*our initial increment of buffers*/
44: ptrall tokptr; /*where the current token comes from*/
45: ptrall tokub; /*the last token in the current token buffer*/
46:
47: /*
48: * Variables to manage the string buffering
49: * declared in asscan.h.
50: */
51: int strno; /*the current string being filled*/
52: struct strdesc strbuf[3]; /*the string buffers; the first for nulls*/
53: struct strdesc *strptr; /*current string buffer being filled*/
54:
55: inittmpfile()
56: {
57: if (passno == 1){
58: if (useVM){
59: bufstart = &tokbuf[0];
60: buftail = &tokbuf[1];
61: bufstart->tok_next = buftail;
62: buftail->tok_next = 0;
63: }
64: tokbuf[0].tok_count = -1;
65: tokbuf[1].tok_count = -1;
66: }
67: tok_temp = 0;
68: tok_free = 0;
69: bufno = 0;
70: emptybuf = &tokbuf[bufno];
71: tokptr = 0;
72: tokub = 0;
73: }
74:
75: closetmpfile()
76: {
77: if (passno == 1){
78: if (useVM){
79: emptybuf->toks[emptybuf->tok_count++] = PARSEEOF;
80: } else {
81: /*
82: * Clean up the buffers that haven't been
83: * written out yet
84: */
85: if (tokbuf[bufno ^ 1].tok_count >= 0){
86: if (writeTEST((char *)&tokbuf[bufno ^ 1], sizeof *emptybuf, 1, tmpfil)){
87: badwrite:
88: yyerror("Unexpected end of file writing the interpass tmp file");
89: exit(2);
90: }
91: }
92: /*
93: * Ensure that we will read an End of file,
94: * if there are more than one file names
95: * in the argument list
96: */
97: tokbuf[bufno].toks[tokbuf[bufno].tok_count++] = PARSEEOF;
98: if (writeTEST((char *)&tokbuf[bufno], sizeof *emptybuf, 1, tmpfil))
99: goto badwrite;
100: }
101: } /*end of being pass 1*/
102: }
103:
104: #define bstrlg(from, length) \
105: *(lgtype *)from = length; \
106: (char *)from += sizeof(lgtype) + length
107:
108: #define bstrfromto(from,to) \
109: *(lgtype *)from = (char *)to - (char *)from - sizeof(lgtype); \
110: (char *)from += sizeof(lgtype) + (char *)to - (char *)from
111:
112: #define eatstrlg(from) \
113: (char *)from += sizeof(lgtype) + *(lgtype *)from
114:
115: #define bskiplg(from, length) \
116: *(lgtype *)from = length; \
117: (char *)from += sizeof(lgtype) + length
118:
119: #define bskipfromto(from, to) \
120: *(lgtype *)from = (toktype *)to - (toktype *)from - sizeof(lgtype); \
121: (char *)from += sizeof (lgtype) + (toktype *)to - (toktype *)from
122:
123: #define eatskiplg(from) \
124: (toktype *)from += sizeof(lgtype) + *(lgtype *)from
125:
126: #ifdef DEBUG
127: ptrall firsttoken;
128: #endif DEBUG
129:
130: extern int yylval; /*global communication with parser*/
131: static int Lastjxxx; /*this ONLY shuts up cc; see below*/
132:
133: toktype yylex()
134: {
135: register ptrall bufptr;
136: register toktype val;
137: register struct exp *locxp;
138:
139: bufptr = tokptr; /*copy in the global value*/
140: top:
141: if (bufptr < tokub){
142: gtoken(val, bufptr);
143: switch(yylval = val){
144: case PARSEEOF :
145: yylval = val = PARSEEOF;
146: break;
147: case BFINT:
148: case INT:
149: if (xp >= &explist[NEXP])
150: yyerror("Too many expressions; try simplyfing");
151: else
152: locxp = xp++;
153: glong(locxp->e_xvalue, bufptr);
154: locxp->e_yvalue = 0;
155: makevalue:
156: locxp->e_xtype = XABS;
157: locxp->e_xloc = 0;
158: locxp->e_xname = NULL;
159: yylval = (int)locxp;
160: break;
161: case FLTNUM:
162: if (xp >= &explist[NEXP])
163: yyerror("Too many expressions; try simplyfing");
164: else
165: locxp = xp++;
166: gdouble( ( (union Double *)locxp)->dvalue, bufptr);
167: goto makevalue;
168: case QUAD:
169: if (xp >= &explist[NEXP])
170: yyerror("Too many expressions; try simplyfing");
171: else
172: locxp = xp++;
173: glong(locxp->e_xvalue, bufptr);
174: glong(locxp->e_yvalue, bufptr);
175: yylval = val = INT;
176: goto makevalue;
177: case NAME:
178: gptr(yylval, bufptr);
179: lastnam = (struct symtab *)yylval;
180: break;
181: case SIZESPEC:
182: case REG:
183: case INSTn:
184: case INST0:
185: gchar(yylval, bufptr);
186: break;
187: case IJXXX:
188: gchar(yylval, bufptr);
189: /* We can't cast Lastjxxx into (int *) here.. */
190: gptr(Lastjxxx, bufptr);
191: lastjxxx = (struct symtab *)Lastjxxx;
192: break;
193: case ILINESKIP:
194: gint(yylval, bufptr);
195: lineno += yylval;
196: goto top;
197: case SKIP:
198: eatskiplg(bufptr);
199: goto top;
200: case VOID:
201: goto top;
202: case STRING:
203: strptr = &strbuf[strno ^= 1];
204: strptr->str_lg = *((lgtype *)bufptr);
205: movestr(&strptr->str[0],
206: (char *)bufptr + sizeof(lgtype),
207: strptr->str_lg);
208: eatstrlg(bufptr);
209: yylval = (int)strptr;
210: break;
211: case ISTAB:
212: case ISTABSTR:
213: case ISTABNONE:
214: case ISTABDOT:
215: case IALIGN:
216: gptr(yylval, bufptr);
217: break;
218: }
219: #ifdef DEBUG
220: if (toktrace){
221: char *tok_to_name();
222: printf("P: %d T#: %4d, %s ",
223: passno, bufptr - firsttoken, tok_to_name(val));
224: switch(val){
225: case INT: printf("val %d",
226: ((struct exp *)yylval)->e_xvalue);
227: break;
228: case BFINT: printf("val %d",
229: ((struct exp *)yylval)->e_xvalue);
230: break;
231: case QUAD: printf("val[msd] = 0x%x, val[lsd] = 0x%x.",
232: ((struct exp *)yylval)->e_xvalue,
233: ((struct exp *)yylval)->e_yvalue);
234: break;
235: case FLTNUM: printf("value %20.17f",
236: ((union Double *)yylval)->dvalue);
237: break;
238: case NAME: printf("\"%.8s\"",
239: ((struct symtab *)yylval)->s_name);
240: break;
241: case REG: printf(" r%d",
242: yylval);
243: break;
244: case IJXXX:
245: case INST0:
246: case INSTn: printf("%.8s",
247: itab[0xFF &yylval]->s_name);
248: break;
249: case STRING: printf("length %d ",
250: ((struct strdesc *)yylval)->str_lg);
251: printf("value\"%s\"",
252: ((struct strdesc *)yylval)->str);
253: break;
254: } /*end of the debug switch*/
255: printf("\n");
256: }
257: #endif DEBUG
258:
259: } else { /* start a new buffer */
260: if (useVM){
261: if (passno == 2){
262: tok_temp = emptybuf->tok_next;
263: emptybuf->tok_next = tok_free;
264: tok_free = emptybuf;
265: emptybuf = tok_temp;
266: } else {
267: emptybuf = emptybuf->tok_next;
268: }
269: bufno += 1;
270: if (emptybuf == 0){
271: struct tokbufdesc *newdallop;
272: int i;
273: if (passno == 2)
274: goto badread;
275: emptybuf = newdallop = (struct tokbufdesc *)
276: Calloc(TOKDALLOP, sizeof (struct tokbufdesc));
277: for (i=0; i < TOKDALLOP; i++){
278: buftail->tok_next = newdallop;
279: buftail = newdallop;
280: newdallop += 1;
281: }
282: buftail->tok_next = 0;
283: } /*end of need to get more buffers*/
284: (toktype *)bufptr = &(emptybuf->toks[0]);
285: if (passno == 1)
286: scan_dot_s(emptybuf);
287: } else { /*don't use VM*/
288: bufno ^= 1;
289: emptybuf = &tokbuf[bufno];
290: ((toktype *)bufptr) = &(emptybuf->toks[0]);
291: if (passno == 1){
292: /*
293: * First check if there are things to write
294: * out at all
295: */
296: if (emptybuf->tok_count >= 0){
297: if (writeTEST((char *)emptybuf, sizeof *emptybuf, 1, tmpfil)){
298: badwrite:
299: yyerror("Unexpected end of file writing the interpass tmp file");
300: exit(2);
301: }
302: }
303: scan_dot_s(emptybuf);
304: } else { /*pass 2*/
305: if (readTEST((char *)emptybuf, sizeof *emptybuf, 1, tmpfil)){
306: badread:
307: yyerror("Unexpected end of file while reading the interpass tmp file");
308: exit(1);
309: }
310: }
311: } /*end of using a real live file*/
312: (char *)tokub = (char *)bufptr + emptybuf->tok_count;
313: #ifdef DEBUG
314: firsttoken = bufptr;
315: if (debug)
316: printf("created buffernumber %d with %d tokens\n",
317: bufno, emptybuf->tok_count);
318: #endif DEBUG
319: goto top;
320: } /*end of reading/creating a new buffer*/
321: tokptr = bufptr; /*copy back the global value*/
322: return(val);
323: } /*end of yylex*/
324:
325:
326: buildskip(from, to)
327: register ptrall from, to;
328: {
329: int diff;
330: register int frombufno;
331: register struct tokbufdesc *middlebuf;
332: /*
333: * check if from and to are in the same buffer
334: * from and to DIFFER BY AT MOST 1 buffer and to is
335: * always ahead of from, with to being in the buffer emptybuf
336: * points to.
337: * The hard part here is accounting for the case where the
338: * skip is to cross a buffer boundary; we must construct
339: * two skips.
340: *
341: * Figure out where the buffer boundary between from and to is
342: * It's easy in VM, as buffers increase to high memory, but
343: * w/o VM, we alternate between two buffers, and want
344: * to look at the exact middle of the contiguous buffer region.
345: */
346: middlebuf = useVM ? emptybuf : &tokbuf[1];
347: if ( ( (toktype *)from > (toktype *)middlebuf)
348: ^ ( (toktype *)to > (toktype *)middlebuf)
349: ){ /*split across a buffer boundary*/
350: ptoken(from, SKIP);
351: /*
352: * Set the skip so it lands someplace beyond
353: * the end of this buffer.
354: * When we pull this skip out in the second pass,
355: * we will temporarily move the current pointer
356: * out beyond the end of the buffer, but immediately
357: * do a compare and fail the compare, and then reset
358: * all the pointers correctly to point into the next buffer.
359: */
360: bskiplg(from, TOKBUFLG + 1);
361: /*
362: * Now, force from to be in the same buffer as to
363: */
364: (toktype *)from = (toktype *)&(emptybuf->toks[0]);
365: }
366: /*
367: * Now, to and from are in the same buffer
368: */
369: if (from > to)
370: yyerror("Internal error: bad skip construction");
371: else {
372: if ( (diff = (toktype *)to - (toktype *)from) >=
373: (sizeof(toktype) + sizeof(lgtype) + 1)) {
374: ptoken(from, SKIP);
375: bskipfromto(from, to);
376: } else {
377: for ( ; diff > 0; --diff)
378: ptoken(from, VOID);
379: }
380: }
381: }
382:
383: movestr(to, from, lg)
384: register char *to, *from;
385: register int lg;
386: {
387: if (lg <= 0) return;
388: do
389: *to++ = *from++;
390: while (--lg);
391: }
392: static int newfflag = 0;
393: static char *newfname;
394: int scanlineno; /*the scanner's linenumber*/
395:
396: new_dot_s(namep)
397: char *namep;
398: {
399: newfflag = 1;
400: newfname = namep;
401: dotsname = namep;
402: lineno = 1;
403: scanlineno = 1;
404: }
405:
406: /*
407: * Maps characters to their use in assembly language
408: */
409: #define EOFCHAR (-1)
410: #define NEEDCHAR (-2)
411:
412: readonly short type[] = {
413: NEEDSBUF, /*fill up the input buffer*/
414: SCANEOF, /*hit the hard end of file*/
415: SP, BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR, /*\0..^G*/
416: BADCHAR,SP, NL, BADCHAR,BADCHAR,SP, BADCHAR,BADCHAR, /*BS..SI*/
417: BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR, /*DLE..ETB*/
418: BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR, /*CAN..US*/
419: SP, ORNOT, DQ, SH, LITOP, REGOP, AND, SQ, /*sp .. '*/
420: LP, RP, MUL, PLUS, CM, MINUS, ALPH, DIV, /*( .. /*/
421: DIG, DIG, DIG, DIG, DIG, DIG, DIG, DIG, /*0 .. 7*/
422: DIG, DIG, COLON, SEMI, LSH, BADCHAR,RSH, BADCHAR, /*8 .. ?*/
423: BADCHAR,ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*@ .. G*/
424: ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*H .. BADCHAR*/
425: ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*P .. V*/
426: ALPH, ALPH, ALPH, LB, BADCHAR,RB, XOR, ALPH,/*W .. _*/
427: SIZEQUOTE,ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*` .. g*/
428: ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*h .. o*/
429: ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*p .. v*/
430: ALPH, ALPH, ALPH, BADCHAR,IOR, BADCHAR,TILDE, BADCHAR,/*x .. del*/
431: };
432:
433: /*
434: * The table of possible uses for each character to test set inclusion.
435: * Different than the above table, which knows about tokens yylex
436: * is to return.
437: */
438: #define HEXFLAG 01 /* 'x' or 'X' */
439: #define HEXLDIGIT 02 /* 'a' .. 'f' */
440: #define HEXUDIGIT 04 /* 'A' .. 'F' */
441: #define ALPHA 010 /* 'A' .. 'Z', 'a' .. 'z', '_'*/
442: #define DIGIT 020 /* '0' .. '9' */
443: #define FLOATEXP 040 /* 'd' 'e' 'D' 'E' */
444: #define SIGN 0100 /* '+' .. '-'*/
445: #define REGDIGIT 0200 /* '0' .. '5' */
446: #define SZSPECBEGIN 0400 /* 'b', 'B', 'l', 'L', 'w', 'W' */
447: #define POINT 01000 /* '.' */
448: #define SPACE 02000 /* '\t' or ' ' */
449: #define BSESCAPE 04000 /* bnrtf */
450: #define STRESCAPE 010000 /* '"', '\\', '\n' */
451: #define OCTDIGIT 020000 /* '0' .. '7' */
452: #define FLOATFLAG 040000 /* 'd', 'D', 'f', 'F' */
453: /*after leading 0*/
454:
455: readonly short charsets[] = {
456: 0, 0, 0, 0, 0, 0, 0, 0, /*\0..^G*/
457: 0, SPACE, STRESCAPE,0, 0, 0, 0, 0, /*BS..SI*/
458: 0, 0, 0, 0, 0, 0, 0, 0, /*DLE..ETB*/
459: 0, 0, 0, 0, 0, 0, 0, 0, /*CAN..US*/
460: /* dollar is an alpha character */
461: SPACE, 0, STRESCAPE,0, ALPHA, 0, 0, 0, /*sp.. '*/
462: 0, 0, 0, SIGN, 0, SIGN, POINT+ALPHA,0, /*( .. /*/
463: DIGIT+REGDIGIT+OCTDIGIT, DIGIT+REGDIGIT+OCTDIGIT, /*0..1*/
464: DIGIT+REGDIGIT+OCTDIGIT, DIGIT+REGDIGIT+OCTDIGIT, /*2..3*/
465: DIGIT+REGDIGIT+OCTDIGIT, DIGIT+REGDIGIT+OCTDIGIT, /*4..5*/
466: DIGIT+OCTDIGIT, DIGIT+OCTDIGIT, /*6..7*/
467: DIGIT, DIGIT, 0, 0, 0, 0, 0, 0, /*8..?*/
468: 0, /*@*/
469: ALPHA+HEXUDIGIT,ALPHA+HEXUDIGIT+SZSPECBEGIN, /*A..B*/
470: ALPHA+HEXUDIGIT,ALPHA+HEXUDIGIT+FLOATEXP+FLOATFLAG, /*C..D*/
471: ALPHA+HEXUDIGIT+FLOATEXP,ALPHA+HEXUDIGIT+FLOATFLAG, /*E..F*/
472: ALPHA, /*G*/
473: ALPHA, ALPHA, ALPHA, ALPHA, /*H..K*/
474: ALPHA+SZSPECBEGIN, ALPHA, ALPHA, ALPHA, /*L..O*/
475: ALPHA, ALPHA, ALPHA, ALPHA, /*P..S*/
476: ALPHA, ALPHA, ALPHA, ALPHA+SZSPECBEGIN, /*T..W*/
477: ALPHA+HEXFLAG, ALPHA, ALPHA, 0,STRESCAPE,0, 0, ALPHA,/*X.._*/
478:
479: 0,
480: ALPHA+HEXLDIGIT,ALPHA+HEXLDIGIT+BSESCAPE+SZSPECBEGIN, /*a..b*/
481: ALPHA+HEXLDIGIT,ALPHA+HEXLDIGIT+FLOATEXP+FLOATFLAG, /*c..d*/
482: ALPHA+HEXLDIGIT+FLOATEXP,ALPHA+HEXLDIGIT+BSESCAPE+FLOATFLAG, /*e..f*/
483: ALPHA, /*g*/
484: ALPHA, ALPHA, ALPHA, ALPHA, /*h..k*/
485: ALPHA+SZSPECBEGIN, ALPHA, ALPHA+BSESCAPE, ALPHA, /*l..o*/
486: ALPHA, ALPHA, ALPHA+BSESCAPE, ALPHA, /*p..s*/
487: ALPHA+BSESCAPE, ALPHA, ALPHA, ALPHA+SZSPECBEGIN,/*t..w*/
488: ALPHA+HEXFLAG, ALPHA, ALPHA, 0,0, 0, 0, 0, /*x..del*/
489: 0};
490:
491: #define INCHARSET(val, kind) (charsets[val] & (kind) )
492: static toktype oval = NL;
493:
494: #define NINBUFFERS 2
495: #define INBUFLG NINBUFFERS*BUFSIZ + 2
496: /*
497: * We have two input buffers; the first one is reserved
498: * for catching the tail of a line split across a buffer
499: * boundary; the other one are used for snarfing a buffer
500: * worth of .s source.
501: */
502: static char inbuffer[INBUFLG];
503: static char *InBufPtr = 0;
504:
505: #ifdef getchar
506: #undef getchar
507: #endif
508: #define getchar() *inbufptr++
509:
510: #ifdef ungetc
511: #undef ungetc
512: #endif
513: #define ungetc(char) *--inbufptr = char
514:
515: /*
516: * fill the inbuffer from the standard input.
517: * Assert: there are always n COMPLETE! lines in the buffer area.
518: * Assert: there is always a \n terminating the last line
519: * in the buffer area.
520: * Assert: after the \n, there is an EOFCHAR (hard end of file)
521: * or a NEEDCHAR (end of buffer)
522: * Assert: fgets always null pads the string it reads.
523: * Assert: no ungetc's are done at the end of a line or at the
524: * beginning of a line.
525: *
526: * We read a complete buffer of characters in one single read.
527: * We then back scan within this buffer to find the end of the
528: * last complete line, and force the assertions, and save a pointer
529: * to the incomplete line.
530: * The next call to fillinbuffer will move the unread characters
531: * to the end of the first buffer, and then read another two buffers,
532: * completing the cycle.
533: */
534:
535: static char p_swapped = '\0';
536: static char *p_start = &inbuffer[NINBUFFERS * BUFSIZ];
537: static char *p_stop = &inbuffer[NINBUFFERS * BUFSIZ];
538: char *fillinbuffer()
539: {
540: register char *to;
541: register char *from;
542: char *inbufptr;
543: int nread;
544:
545: *p_start = p_swapped;
546: inbufptr = &inbuffer[1*BUFSIZ] - (p_stop - p_start);
547:
548: for (to = inbufptr, from = p_start; from < p_stop;)
549: *to++ = *from++;
550: /*
551: * Now, go read two full buffers (hopefully)
552: */
553: nread = read(stdin->_file, &inbuffer[1*BUFSIZ], (NINBUFFERS - 1)*BUFSIZ);
554: if (nread == 0)
555: return(0);
556: p_stop = from = &inbuffer[1*BUFSIZ + nread];
557: *from = '\0';
558: while (*--from != '\n') /* back over the partial line */
559: continue;
560: from++; /* first char of partial line */
561: p_start = from;
562: p_swapped = *p_start;
563: *p_start = NEEDCHAR; /* force assertion */
564: return(inbufptr);
565: }
566:
567: scan_dot_s(bufferbox)
568: struct tokbufdesc *bufferbox;
569: {
570: register int yylval;/*lexical value*/
571: register toktype val; /*the value returned; the character read*/
572: register int base; /*the base of the number also counter*/
573: register char *cp;
574: register char *inbufptr;
575: register struct symtab *op;
576: register unsigned char tag;
577: int forb;
578:
579: register ptrall bufptr; /*where to stuff tokens*/
580: ptrall lgbackpatch; /*where to stuff a string length*/
581: ptrall bufub; /*where not to stuff tokens*/
582: register int maxstrlg; /*how long a string can be*/
583: long intval; /*value of int*/
584: char fltchr[64]; /*buffer for floating values*/
585: union Double fltval; /*floating value returned*/
586: struct Quad quadval; /*quad returned from immediate constant */
587: int linescrossed; /*when doing strings and comments*/
588:
589: (toktype *)bufptr = (toktype *) & (bufferbox->toks[0]);
590: (toktype *)bufub = &(bufferbox->toks[AVAILTOKS]);
591:
592: inbufptr = InBufPtr;
593: if (inbufptr == 0){
594: inbufptr = fillinbuffer();
595: if (inbufptr == 0){ /*end of file*/
596: endoffile:
597: inbufptr = 0;
598: ptoken(bufptr, PARSEEOF);
599: goto done;
600: }
601: }
602:
603: if (newfflag){
604: ptoken(bufptr, IFILE);
605: ptoken(bufptr, STRING);
606: val = strlen(newfname) + 1;
607: movestr( (char *)&( ( (lgtype *)bufptr)[1]), newfname, val);
608: bstrlg(bufptr, val);
609:
610: ptoken(bufptr, ILINENO);
611: ptoken(bufptr, INT);
612: pint(bufptr, 1);
613: newfflag = 0;
614: }
615:
616: while (bufptr < bufub){
617: loop:
618: switch(yylval = (type+2)[val = getchar()]) {
619: case SCANEOF:
620: inbufptr = 0;
621: goto endoffile;
622:
623: case NEEDSBUF:
624: inbufptr = fillinbuffer();
625: if (inbufptr == 0)
626: goto endoffile;
627: goto loop;
628:
629: case DIV: /*process C style comments*/
630: if ( (val = getchar()) == '*') { /*comment prelude*/
631: int incomment;
632: linescrossed = 0;
633: incomment = 1;
634: val = getchar(); /*skip over the * */
635: do{
636: while ( (val != '*') &&
637: (val != '\n') &&
638: (val != EOFCHAR) &&
639: (val != NEEDCHAR))
640: val = getchar();
641: if (val == '\n'){
642: scanlineno++;
643: linescrossed++;
644: } else
645: if (val == EOFCHAR)
646: goto endoffile;
647: if (val == NEEDCHAR){
648: inbufptr = fillinbuffer();
649: if (inbufptr == 0)
650: goto endoffile;
651: lineno++;
652: incomment = 1;
653: val = getchar(); /*pull in the new char*/
654: } else { /*its a star */
655: val = getchar();
656: incomment = val != '/';
657: }
658: } while (incomment);
659: val = ILINESKIP;
660: yylval = linescrossed;
661: goto ret;
662: } else { /*just an ordinary DIV*/
663: ungetc(val);
664: val = yylval = DIV;
665: goto ret;
666: }
667: case SH:
668: if (oval == NL){
669: /*
670: * Attempt to recognize a C preprocessor
671: * style comment '^#[ \t]*[0-9]*[ \t]*".*"
672: */
673: val = getchar(); /*bump the #*/
674: while (INCHARSET(val, SPACE))
675: val = getchar();/*bump white */
676: if (INCHARSET(val, DIGIT)){
677: intval = 0;
678: while(INCHARSET(val, DIGIT)){
679: intval = intval *10 + val - '0';
680: val = getchar();
681: }
682: while (INCHARSET(val, SPACE))
683: val = getchar();
684: if (val == '"'){
685: ptoken(bufptr, ILINENO);
686: ptoken(bufptr, INT);
687: pint(bufptr, intval - 1);
688: ptoken(bufptr, IFILE);
689: /*
690: * The '"' has already been
691: * munched
692: *
693: * eatstr will not eat
694: * the trailing \n, so
695: * it is given to the parser
696: * and counted.
697: */
698: goto eatstr;
699: }
700: }
701: }
702: /*
703: * Well, its just an ordinary decadent comment
704: */
705: while ((val != '\n') && (val != EOFCHAR))
706: val = getchar();
707: if (val == EOFCHAR)
708: goto endoffile;
709: val = yylval = oval = NL;
710: scanlineno++;
711: goto ret;
712:
713: case NL:
714: scanlineno++;
715: val = yylval;
716: goto ret;
717:
718: case SP:
719: oval = SP; /*invalidate ^# meta comments*/
720: goto loop;
721:
722: case REGOP: /* % , could be used as modulo, or register*/
723: val = getchar();
724: if (INCHARSET(val, DIGIT)){
725: yylval = val-'0';
726: if (val=='1') {
727: if (INCHARSET( (val = getchar()), REGDIGIT))
728: yylval = 10+val-'0';
729: else
730: ungetc(val);
731: }
732: /*
733: * God only knows what the original author
734: * wanted this undocumented feature to
735: * do.
736: * %5++ is really r7
737: */
738: while(INCHARSET( (val = getchar()), SIGN)) {
739: if (val=='+')
740: yylval++;
741: else
742: yylval--;
743: }
744: ungetc(val);
745: val = REG;
746: } else {
747: ungetc(val);
748: val = REGOP;
749: }
750: goto ret;
751:
752: case ALPH:
753: yylval = val;
754: if (INCHARSET(val, SZSPECBEGIN)){
755: if( (val = getchar()) == '`' || val == '^'){
756: yylval |= 0100; /*convert to lower*/
757: if (yylval == 'b') yylval = 1;
758: else if (yylval == 'w') yylval = 2;
759: else if (yylval == 'l') yylval = 4;
760: else yylval = d124;
761: val = SIZESPEC;
762: goto ret;
763: } else {
764: ungetc(val);
765: val = yylval; /*restore first character*/
766: }
767: }
768: cp = yytext;
769: do {
770: if (cp < &yytext[NCPS])
771: *cp++ = val;
772: } while (INCHARSET ( (val = getchar()), ALPHA | DIGIT));
773: *cp = '\0';
774: while (INCHARSET(val, SPACE))
775: val = getchar();
776: ungetc(val);
777: doit:
778: tag = (op = *lookup(1))->s_tag;
779: if (tag && tag != LABELID){
780: yylval = ( (struct instab *)op)->i_opcode;
781: val = op->s_tag ;
782: goto ret;
783: } else {
784: /*
785: * Its a name... (Labels are subsets ofname)
786: */
787: yylval = (int)op;
788: val = NAME;
789: goto ret;
790: }
791:
792: case DIG:
793: base = 10;
794: cp = fltchr;
795: intval = 0;
796: if (val=='0') {
797: val = getchar();
798: if (val == 'b') {
799: yylval = -1;
800: val = BFINT;
801: goto ret;
802: }
803: if (val == 'f') {
804: /*
805: * Well, it appears to be a local label
806: * reference, but check to see if
807: * the next character makes it a floating
808: * point constant.
809: */
810: forb = getchar();
811: ungetc(forb);
812: if (!(INCHARSET(forb,(DIGIT|SIGN|FLOATEXP|POINT)))){
813: yylval = 1;
814: val = BFINT;
815: goto ret;
816: }
817: }
818: if (INCHARSET(val, HEXFLAG)){
819: base = 16;
820: } else
821: if (INCHARSET(val, FLOATFLAG)){
822: double atof();
823: while ( (cp < &fltchr[63]) &&
824: INCHARSET(
825: (val=getchar()),
826: (DIGIT|SIGN|FLOATEXP|POINT)
827: )
828: ) *cp++ = val;
829: if (cp == fltchr) {
830: yylval = 1;
831: val = BFINT;
832: goto ret;
833: }
834: ungetc(val);
835: *cp++ = '\0';
836: fltval.dvalue = atof(fltchr);
837: val = FLTNUM;
838: goto ret;
839: } else {
840: ungetc(val);
841: base = 8;
842: }
843: } else {
844: forb = getchar();
845: if (forb == 'f' || forb == 'b') {
846: yylval = val - '0' + 1;
847: if (forb == 'b')
848: yylval = -yylval;
849: val = BFINT;
850: goto ret;
851: }
852: ungetc(forb); /* put back non zero */
853: goto middle;
854: }
855: while ( (val = getchar()) == '0')
856: continue;
857: ungetc(val);
858: while ( INCHARSET( (val = getchar()), DIGIT) ||
859: (base==16 && (INCHARSET(val, HEXLDIGIT|HEXUDIGIT) )
860: )
861: ){
862: if (base==8)
863: intval <<= 3;
864: else if (base==10)
865: intval *= 10;
866: else {
867: intval <<= 4;
868: if (INCHARSET(val, HEXLDIGIT))
869: val -= 'a' - 10 - '0';
870: else if (INCHARSET(val, HEXUDIGIT))
871: val -= 'A' - 10 - '0';
872: }
873: middle:
874: *cp++ = (val -= '0');
875: intval += val;
876: }
877: ungetc(val);
878: *cp = 0;
879: maxstrlg = cp - fltchr;
880: if ( (maxstrlg > 8)
881: && ( ( (base == 8)
882: && ( (maxstrlg>11)
883: || ( (maxstrlg == 11)
884: && (*fltchr > 3)
885: )
886: )
887: )
888: || ( (base == 16)
889: && (maxstrlg > 8)
890: )
891: || ( (base == 10)
892: && (maxstrlg >= 10)
893: )
894: )
895: ) {
896: val = QUAD;
897: get_quad(base, fltchr, cp, &quadval);
898: } else
899: val = INT;
900: goto ret;
901:
902: case LSH:
903: case RSH:
904: /*
905: * We allow the C style operators
906: * << and >>, as well as < and >
907: */
908: if ( (base = getchar()) != val)
909: ungetc(base);
910: val = yylval;
911: goto ret;
912:
913: case MINUS:
914: if ( (val = getchar()) =='(')
915: yylval=val=MP;
916: else {
917: ungetc(val);
918: val=MINUS;
919: }
920: goto ret;
921:
922: case SQ:
923: if ((yylval = getchar()) == '\n')
924: scanlineno++; /*not entirely correct*/
925: intval = yylval;
926: val = INT;
927: goto ret;
928:
929: case DQ:
930: eatstr:
931: linescrossed = 0;
932: maxstrlg = (char *)bufub - (char *)bufptr;
933:
934: if (maxstrlg < MAXSTRLG) {
935: ungetc('"');
936: *(toktype *)bufptr = VOID ;
937: bufub = bufptr;
938: goto done;
939: }
940: if (maxstrlg > MAXSTRLG)
941: maxstrlg = MAXSTRLG;
942:
943: ptoken(bufptr, STRING);
944: lgbackpatch = bufptr; /*this is where the size goes*/
945: bufptr += sizeof(lgtype);
946: /*
947: * bufptr is now set to
948: * be stuffed with characters from
949: * the input
950: */
951:
952: while ( (maxstrlg > 0)
953: && !(INCHARSET( (val = getchar()), STRESCAPE))
954: ){
955: stuff:
956: maxstrlg-= 1;
957: pchar(bufptr, val);
958: }
959: if (maxstrlg <= 0){ /*enough characters to fill a string buffer*/
960: ungetc('"'); /*will read it next*/
961: }
962: else if (val == '"'); /*done*/
963: else if (val == '\n'){
964: yywarning("New line embedded in a string constant.");
965: scanlineno++;
966: linescrossed++;
967: val = getchar();
968: if (val == EOFCHAR){
969: do_eof:
970: pchar(bufptr, '\n');
971: ungetc(EOFCHAR);
972: } else
973: if (val == NEEDCHAR){
974: if ( (inbufptr = fillinbuffer()) == 0)
975: goto do_eof;
976: val = '\n';
977: goto stuff;
978: } else { /* simple case */
979: ungetc(val);
980: val = '\n';
981: goto stuff;
982: }
983: } else {
984: val = getchar(); /*skip the '\\'*/
985: if ( INCHARSET(val, BSESCAPE)){
986: switch (val){
987: case 'b': val = '\b'; goto stuff;
988: case 'f': val = '\f'; goto stuff;
989: case 'n': val = '\n'; goto stuff;
990: case 'r': val = '\r'; goto stuff;
991: case 't': val = '\t'; goto stuff;
992: }
993: }
994: if ( !(INCHARSET(val,OCTDIGIT)) ) goto stuff;
995: base = 0;
996: intval = 0;
997: while ( (base < 3) && (INCHARSET(val, OCTDIGIT))){
998: base++;intval <<= 3;intval += val - '0';
999: val = getchar();
1000: }
1001: ungetc(val);
1002: val = (char)intval;
1003: goto stuff;
1004: }
1005: /*
1006: * bufptr now points at the next free slot
1007: */
1008: bstrfromto(lgbackpatch, bufptr);
1009: if (linescrossed){
1010: val = ILINESKIP;
1011: yylval = linescrossed;
1012: goto ret;
1013: } else
1014: goto builtval;
1015:
1016: case BADCHAR:
1017: linescrossed = lineno;
1018: lineno = scanlineno;
1019: yyerror("Illegal character mapped: %d, char read:(octal) %o",
1020: yylval, val);
1021: lineno = linescrossed;
1022: val = BADCHAR;
1023: goto ret;
1024:
1025: default:
1026: val = yylval;
1027: goto ret;
1028: } /*end of the switch*/
1029: /*
1030: * here with one token, so stuff it
1031: */
1032: ret:
1033: oval = val;
1034: ptoken(bufptr, val);
1035: switch(val){
1036: case ILINESKIP:
1037: pint(bufptr, yylval);
1038: break;
1039: case SIZESPEC:
1040: pchar(bufptr, yylval);
1041: break;
1042: case BFINT: plong(bufptr, yylval);
1043: break;
1044: case INT: plong(bufptr, intval);
1045: break;
1046: case QUAD: plong(bufptr, quadval.quad_low_long);
1047: plong(bufptr, quadval.quad_high_long);
1048: break;
1049: case FLTNUM: pdouble(bufptr, fltval.dvalue);
1050: break;
1051: case NAME: pptr(bufptr, (int)(struct symtab *)yylval);
1052: break;
1053: case REG: pchar(bufptr, yylval);
1054: break;
1055: case INST0:
1056: case INSTn:
1057: pchar(bufptr, yylval);
1058: break;
1059: case IJXXX:
1060: pchar(bufptr, yylval);
1061: pptr(bufptr, (int)(struct symtab *)symalloc());
1062: break;
1063: case ISTAB:
1064: case ISTABSTR:
1065: case ISTABNONE:
1066: case ISTABDOT:
1067: case IALIGN:
1068: pptr(bufptr, (int)(struct symtab *)symalloc());
1069: break;
1070: /*
1071: * default:
1072: */
1073: }
1074: builtval: ;
1075: } /*end of the while to stuff the buffer*/
1076: done:
1077: bufferbox->tok_count = (toktype *)bufptr - &(bufferbox->toks[0]);
1078:
1079: /*
1080: * This is a real kludge:
1081: *
1082: * We put the last token in the buffer to be a MINUS
1083: * symbol. This last token will never be picked up
1084: * in the normal way, but can be looked at during
1085: * a peekahead look that the short circuit expression
1086: * evaluator uses to see if an expression is complicated.
1087: *
1088: * Consider the following situation:
1089: *
1090: * .word 45 + 47
1091: * buffer 1 | buffer 0
1092: * the peekahead would want to look across the buffer,
1093: * but will look in the buffer end zone, see the minus, and
1094: * fail.
1095: */
1096: ptoken(bufptr, MINUS);
1097: InBufPtr = inbufptr; /*copy this back*/
1098: }
1099:
1100: struct Quad _quadtemp;
1101: get_quad(radix, cp_start, cp_end, quadptr)
1102: int radix;
1103: char *cp_start, *cp_end;
1104: struct Quad *quadptr;
1105: {
1106: register char *cp = cp_start; /* r11 */
1107: register struct Quad *qp = quadptr; /* r10 */
1108: register long temp; /* r9 */
1109:
1110: asm("clrq (r10)");
1111: for (; cp < cp_end; cp++){
1112: switch (radix) {
1113: case 8:
1114: asm ("ashq $3, (r10), (r10)");
1115: break;
1116: case 16:
1117: asm ("ashq $4, (r10), (r10)");
1118: break;
1119: case 10:
1120: asm ("ashq $1, (r10), __quadtemp");
1121: asm ("ashq $3, (r10), (r10)");
1122: asm ("addl2 __quadtemp, (r10)");
1123: asm ("adwc __quadtemp+4, 4(r10)");
1124: break;
1125: }
1126: asm ("cvtbl (r11), r9");
1127: asm ("addl2 r9, (r10)");
1128: asm ("adwc $0, 4(r10)");
1129: }
1130: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.