![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to asscan1.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / bin / as|
Return to asscan1.c CVS log | Up to [CSRG BSD Unix] / 43BSD / bin / as |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: static char sccsid[] = "@(#)asscan1.c 5.1 (Berkeley) 4/30/85"; ! 9: #endif not lint ! 10: ! 11: #include "asscanl.h" ! 12: ! 13: inittokfile() ! 14: { ! 15: if (passno == 1){ ! 16: if (useVM){ ! 17: bufstart = &tokbuf[0]; ! 18: buftail = &tokbuf[1]; ! 19: bufstart->tok_next = buftail; ! 20: buftail->tok_next = 0; ! 21: } ! 22: tokbuf[0].tok_count = -1; ! 23: tokbuf[1].tok_count = -1; ! 24: } ! 25: tok_temp = 0; ! 26: tok_free = 0; ! 27: bufno = 0; ! 28: emptybuf = &tokbuf[bufno]; ! 29: tokptr = 0; ! 30: tokub = 0; ! 31: } ! 32: ! 33: closetokfile() ! 34: { ! 35: if (passno == 1){ ! 36: if (useVM){ ! 37: emptybuf->toks[emptybuf->tok_count++] = PARSEEOF; ! 38: } else { ! 39: /* ! 40: * Clean up the buffers that haven't been ! 41: * written out yet ! 42: */ ! 43: if (tokbuf[bufno ^ 1].tok_count >= 0){ ! 44: if (writeTEST((char *)&tokbuf[bufno ^ 1], sizeof *emptybuf, 1, tokfile)){ ! 45: badwrite: ! 46: yyerror("Unexpected end of file writing the interpass tmp file"); ! 47: exit(2); ! 48: } ! 49: } ! 50: /* ! 51: * Ensure that we will read an End of file, ! 52: * if there are more than one file names ! 53: * in the argument list ! 54: */ ! 55: tokbuf[bufno].toks[tokbuf[bufno].tok_count++] = PARSEEOF; ! 56: if (writeTEST((char *)&tokbuf[bufno], sizeof *emptybuf, 1, tokfile)) ! 57: goto badwrite; ! 58: } ! 59: } /*end of being pass 1*/ ! 60: } ! 61: ! 62: inttoktype yylex() ! 63: { ! 64: register ptrall bufptr; ! 65: register inttoktype val; ! 66: register struct exp *locxp; ! 67: /* ! 68: * No local variables to be allocated; this saves ! 69: * one piddling instruction.. ! 70: */ ! 71: static int Lastjxxx; ! 72: ! 73: bufptr = tokptr; /*copy in the global value*/ ! 74: top: ! 75: if (bufptr < tokub){ ! 76: gtoken(val, bufptr); ! 77: switch(yylval = val){ ! 78: case PARSEEOF: ! 79: yylval = val = PARSEEOF; ! 80: break; ! 81: case BFINT: ! 82: case INT: ! 83: if (xp >= &explist[NEXP]) ! 84: yyerror("Too many expressions; try simplyfing"); ! 85: else ! 86: locxp = xp++; ! 87: locxp->e_number = Znumber; ! 88: locxp->e_number.num_tag = TYPL; ! 89: glong(locxp->e_xvalue, bufptr); ! 90: makevalue: ! 91: locxp->e_xtype = XABS; ! 92: locxp->e_xloc = 0; ! 93: locxp->e_xname = NULL; ! 94: yylval = (int)locxp; ! 95: break; ! 96: case BIGNUM: ! 97: if (xp >= &explist[NEXP]) ! 98: yyerror("Too many expressions; try simplyfing"); ! 99: else ! 100: locxp = xp++; ! 101: gnumber(locxp->e_number, bufptr); ! 102: goto makevalue; ! 103: case NAME: ! 104: gptr(yylval, bufptr); ! 105: lastnam = (struct symtab *)yylval; ! 106: break; ! 107: case SIZESPEC: ! 108: case REG: ! 109: gchar(yylval, bufptr); ! 110: break; ! 111: case INSTn: ! 112: case INST0: ! 113: gopcode(yyopcode, bufptr); ! 114: break; ! 115: case IJXXX: ! 116: gopcode(yyopcode, bufptr); ! 117: /* We can't cast Lastjxxx into (int *) here.. */ ! 118: gptr(Lastjxxx, bufptr); ! 119: lastjxxx = (struct symtab *)Lastjxxx; ! 120: break; ! 121: case ILINESKIP: ! 122: gint(yylval, bufptr); ! 123: lineno += yylval; ! 124: goto top; ! 125: case SKIP: ! 126: eatskiplg(bufptr); ! 127: goto top; ! 128: case VOID: ! 129: goto top; ! 130: case STRING: ! 131: case ISTAB: ! 132: case ISTABSTR: ! 133: case ISTABNONE: ! 134: case ISTABDOT: ! 135: case IALIGN: ! 136: gptr(yylval, bufptr); ! 137: break; ! 138: } ! 139: #ifdef DEBUG ! 140: if (toktrace){ ! 141: char *tok_to_name(); ! 142: printf("P: %d T#: %4d, %s ", ! 143: passno, bufptr - firsttoken, tok_to_name(val)); ! 144: switch(val){ ! 145: case INT: printf("val %d", ! 146: ((struct exp *)yylval)->e_xvalue); ! 147: break; ! 148: case BFINT: printf("val %d", ! 149: ((struct exp *)yylval)->e_xvalue); ! 150: break; ! 151: case BIGNUM: bignumprint(((struct exp*)yylval)->e_number); ! 152: break; ! 153: case NAME: printf("\"%.8s\"", ! 154: FETCHNAME((struct symtab *)yylval)); ! 155: break; ! 156: case REG: printf(" r%d", ! 157: yylval); ! 158: break; ! 159: case IJXXX: ! 160: case INST0: ! 161: case INSTn: if (ITABCHECK(yyopcode)) ! 162: printf("%.8s", ! 163: FETCHNAME(ITABFETCH(yyopcode))); ! 164: else ! 165: printf("IJXXX or INST0 or INSTn can't get into the itab\n"); ! 166: break; ! 167: case STRING: ! 168: printf("length %d, seekoffset %d, place 0%o ", ! 169: ((struct strdesc *)yylval)->sd_strlen, ! 170: ((struct strdesc *)yylval)->sd_stroff, ! 171: ((struct strdesc *)yylval)->sd_place ! 172: ); ! 173: if (((struct strdesc *)yylval)->sd_place & STR_CORE) ! 174: printf("value\"%*s\"", ! 175: ((struct strdesc *)yylval)->sd_strlen, ! 176: ((struct strdesc *)yylval)->sd_string); ! 177: break; ! 178: } /*end of the debug switch*/ ! 179: printf("\n"); ! 180: } ! 181: #endif DEBUG ! 182: ! 183: } else { /* start a new buffer */ ! 184: if (useVM){ ! 185: if (passno == 2){ ! 186: tok_temp = emptybuf->tok_next; ! 187: emptybuf->tok_next = tok_free; ! 188: tok_free = emptybuf; ! 189: emptybuf = tok_temp; ! 190: } else { ! 191: emptybuf = emptybuf->tok_next; ! 192: } ! 193: bufno += 1; ! 194: if (emptybuf == 0){ ! 195: struct tokbufdesc *newdallop; ! 196: int i; ! 197: if (passno == 2) ! 198: goto badread; ! 199: emptybuf = newdallop = (struct tokbufdesc *) ! 200: Calloc(TOKDALLOP, sizeof (struct tokbufdesc)); ! 201: for (i=0; i < TOKDALLOP; i++){ ! 202: buftail->tok_next = newdallop; ! 203: buftail = newdallop; ! 204: newdallop += 1; ! 205: } ! 206: buftail->tok_next = 0; ! 207: } /*end of need to get more buffers*/ ! 208: (bytetoktype *)bufptr = &(emptybuf->toks[0]); ! 209: if (passno == 1) ! 210: scan_dot_s(emptybuf); ! 211: } else { /*don't use VM*/ ! 212: bufno ^= 1; ! 213: emptybuf = &tokbuf[bufno]; ! 214: ((bytetoktype *)bufptr) = &(emptybuf->toks[0]); ! 215: if (passno == 1){ ! 216: /* ! 217: * First check if there are things to write ! 218: * out at all ! 219: */ ! 220: if (emptybuf->tok_count >= 0){ ! 221: if (writeTEST((char *)emptybuf, sizeof *emptybuf, 1, tokfile)){ ! 222: yyerror("Unexpected end of file writing the interpass tmp file"); ! 223: exit(2); ! 224: } ! 225: } ! 226: scan_dot_s(emptybuf); ! 227: } else { /*pass 2*/ ! 228: if (readTEST((char *)emptybuf, sizeof *emptybuf, 1, tokfile)){ ! 229: badread: ! 230: yyerror("Unexpected end of file while reading the interpass tmp file"); ! 231: exit(1); ! 232: } ! 233: } ! 234: } /*end of using a real live file*/ ! 235: (char *)tokub = (char *)bufptr + emptybuf->tok_count; ! 236: #ifdef DEBUG ! 237: firsttoken = bufptr; ! 238: if (debug) ! 239: printf("created buffernumber %d with %d tokens\n", ! 240: bufno, emptybuf->tok_count); ! 241: #endif DEBUG ! 242: goto top; ! 243: } /*end of reading/creating a new buffer*/ ! 244: tokptr = bufptr; /*copy back the global value*/ ! 245: return(val); ! 246: } /*end of yylex*/ ! 247: ! 248: ! 249: buildskip(from, to) ! 250: register ptrall from, to; ! 251: { ! 252: int diff; ! 253: register struct tokbufdesc *middlebuf; ! 254: /* ! 255: * check if from and to are in the same buffer ! 256: * from and to DIFFER BY AT MOST 1 buffer and to is ! 257: * always ahead of from, with to being in the buffer emptybuf ! 258: * points to. ! 259: * The hard part here is accounting for the case where the ! 260: * skip is to cross a buffer boundary; we must construct ! 261: * two skips. ! 262: * ! 263: * Figure out where the buffer boundary between from and to is ! 264: * It's easy in VM, as buffers increase to high memory, but ! 265: * w/o VM, we alternate between two buffers, and want ! 266: * to look at the exact middle of the contiguous buffer region. ! 267: */ ! 268: middlebuf = useVM ? emptybuf : &tokbuf[1]; ! 269: if ( ( (bytetoktype *)from > (bytetoktype *)middlebuf) ! 270: ^ ( (bytetoktype *)to > (bytetoktype *)middlebuf) ! 271: ){ /*split across a buffer boundary*/ ! 272: ptoken(from, SKIP); ! 273: /* ! 274: * Set the skip so it lands someplace beyond ! 275: * the end of this buffer. ! 276: * When we pull this skip out in the second pass, ! 277: * we will temporarily move the current pointer ! 278: * out beyond the end of the buffer, but immediately ! 279: * do a compare and fail the compare, and then reset ! 280: * all the pointers correctly to point into the next buffer. ! 281: */ ! 282: bskiplg(from, TOKBUFLG + 1); ! 283: /* ! 284: * Now, force from to be in the same buffer as to ! 285: */ ! 286: (bytetoktype *)from = (bytetoktype *)&(emptybuf->toks[0]); ! 287: } ! 288: /* ! 289: * Now, to and from are in the same buffer ! 290: */ ! 291: if (from > to) ! 292: yyerror("Internal error: bad skip construction"); ! 293: else { ! 294: if ( (diff = (bytetoktype *)to - (bytetoktype *)from) >= ! 295: (sizeof(bytetoktype) + sizeof(lgtype) + 1)) { ! 296: ptoken(from, SKIP); ! 297: bskipfromto(from, to); ! 298: } else { ! 299: for ( ; diff > 0; --diff) ! 300: ptoken(from, VOID); ! 301: } ! 302: } ! 303: } ! 304: ! 305: movestr(to, from, lg) ! 306: char *to; /* 4(ap) */ ! 307: char *from; /* 8(ap) */ ! 308: int lg; /* 12(ap) */ ! 309: { ! 310: if (lg <= 0) ! 311: return; ! 312: ; ! 313: asm("movc3 12(ap),*8(ap),*4(ap)"); ! 314: ; ! 315: } ! 316: ! 317: new_dot_s(namep) ! 318: char *namep; ! 319: { ! 320: newfflag = 1; ! 321: newfname = namep; ! 322: dotsname = namep; ! 323: lineno = 1; ! 324: scanlineno = 1; ! 325: } ! 326: ! 327: min(a, b) ! 328: { ! 329: return(a < b ? a : b); ! 330: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.