old/as.vax/asscan.c

/* Copyright (c) 1980 Regents of the University of California */
static	char sccsid[] = "@(#)asscan.c 4.1 08/13/80";
#include <stdio.h>
#include <sys/types.h>
#include "as.h"
#include "asscan.h"

/*
 *	NOTE:
 *		This version of the assembler does not use fread and fwrite
 *	for the token buffering.  The token buffers are integrals of BUFSIZ
 *	at all times, so we use direct read and write.  fread and fwrite
 *	as supplied from BTL in stdio are HORRENDOUSLY inefficient,
 *	as they use putchar for each character, nested two deep in loops.
 */
#define writeTEST(pointer, size, nelements, ioptr) \
	write(ioptr->_file, pointer, nelements * size) != nelements * size

#define readTEST(pointer, size, nelements, ioptr) \
	read(ioptr->_file, pointer, nelements * size) != nelements * size
/*
 *	Variables to manage the token buffering.
 *	We scan (lexically analyze) a large number of tokens, and
 *	then parse all of the tokens in the scan buffer.
 *	This reduces procedure call overhead when the parser
 *	demands a token, allows for an efficient reread during
 *	the second pass, and confuses the line number reporting
 *	for errors encountered in the scanner and in the parser.
 */
#define TOKDALLOP	8
struct	tokbufdesc *bufstart;	/*where the buffer list begins*/
struct	tokbufdesc *buftail;	/*last one on the list*/
struct	tokbufdesc *emptybuf;	/*the one being filled*/
/*
 *	If we are using VM, during the second pass we reclaim the used
 *	token buffers for saving the relocation information
 */
struct	tokbufdesc *tok_free;	/* free pool */
struct	tokbufdesc *tok_temp;	/* temporary for doing list manipulation */
/*
 *	Other token buffer managers
 */
int	bufno;			/*which buffer number: 0,1 for tmp file*/
struct 	tokbufdesc tokbuf[2];	/*our initial increment of buffers*/
ptrall	tokptr;			/*where the current token comes from*/
ptrall	tokub;			/*the last token in the current token buffer*/

/*
 *	Variables to manage the string buffering
 *	declared in asscan.h.
 */
int	strno;			/*the current string being filled*/
struct	strdesc	strbuf[3];	/*the string buffers; the first for nulls*/
struct	strdesc	*strptr;	/*current string buffer being filled*/

inittmpfile()
{
	if (passno == 1){
		if (useVM){
			bufstart = &tokbuf[0];
			buftail = &tokbuf[1];
			bufstart->tok_next = buftail;
			buftail->tok_next = 0;
		}
		tokbuf[0].tok_count = -1;
		tokbuf[1].tok_count = -1;
	}
	tok_temp = 0;
	tok_free = 0;
	bufno = 0;
	emptybuf = &tokbuf[bufno];
	tokptr = 0;
	tokub = 0;
}

closetmpfile()
{
	if (passno == 1){
		if (useVM){
			emptybuf->toks[emptybuf->tok_count++] = PARSEEOF;
		} else {
			/*
			 *	Clean up the buffers that haven't been
			 *	written out yet
			 */
			if (tokbuf[bufno ^ 1].tok_count >= 0){
				if (writeTEST((char *)&tokbuf[bufno ^ 1], sizeof *emptybuf, 1, tmpfil)){
				  badwrite:
					yyerror("Unexpected end of file writing the interpass tmp file");
				exit(2);
				}
			}
			/*
			 *	Ensure that we will read an End of file,
			 *	if there are more than one file names
			 *	in the argument list
			 */
			tokbuf[bufno].toks[tokbuf[bufno].tok_count++] = PARSEEOF;
			if (writeTEST((char *)&tokbuf[bufno], sizeof *emptybuf, 1, tmpfil))
				goto badwrite;
		}
	}	/*end of being pass 1*/
}

#define bstrlg(from, length) \
	*(lgtype *)from = length; \
	(char *)from += sizeof(lgtype) + length

#define bstrfromto(from,to) \
	*(lgtype *)from = (char *)to - (char *)from - sizeof(lgtype); \
	(char *)from += sizeof(lgtype) + (char *)to - (char *)from

#define eatstrlg(from) \
	(char *)from +=  sizeof(lgtype) + *(lgtype *)from

#define bskiplg(from, length) \
	*(lgtype *)from = length; \
	(char *)from += sizeof(lgtype) + length

#define bskipfromto(from, to) \
	*(lgtype *)from = (toktype *)to - (toktype *)from - sizeof(lgtype); \
	(char *)from += sizeof (lgtype) + (toktype *)to - (toktype *)from

#define eatskiplg(from) \
	(toktype *)from += sizeof(lgtype) + *(lgtype *)from

#ifdef DEBUG
	ptrall	firsttoken;
#endif DEBUG

extern	int		yylval;		/*global communication with parser*/

toktype yylex()
{
	register	ptrall	bufptr;
	register	toktype		val;
	register	struct	exp	*locxp;

	bufptr = tokptr;		/*copy in the global value*/
   top:
	if (bufptr < tokub){
		gtoken(val, bufptr);
		switch(yylval = val){
		case	PARSEEOF :
				yylval = val = PARSEEOF;
				break;
		case	BFINT:
		case	INT:
				if (xp >= &explist[NEXP])
				     yyerror("Too many expressions; try simplyfing");
				else
				    locxp = xp++;
				glong(locxp->xvalue, bufptr);
				locxp->yvalue = 0;
			  makevalue:
				locxp->xtype = XABS;
				locxp->xloc = 0;
				locxp->xname = NULL;
				yylval = (int)locxp;
				break;
		case	FLTNUM:
				if (xp >= &explist[NEXP])
				     yyerror("Too many expressions; try simplyfing");
				else
				    locxp = xp++;
				gdouble( ( (union Double *)locxp)->dvalue, bufptr);
				goto makevalue;
		case	QUAD:
				if (xp >= &explist[NEXP])
				     yyerror("Too many expressions; try simplyfing");
				else
				    locxp = xp++;
				glong(locxp->xvalue, bufptr);
				glong(locxp->yvalue, bufptr);
				yylval = val = INT;
				goto makevalue;
		case	NAME:
				gptr(yylval, bufptr);
				lastnam = (struct symtab *)yylval;
				break;
		case	SIZESPEC:
		case 	REG:
		case	INSTn:
		case	INST0:
				gchar(yylval, bufptr);
				break;
		case	IJXXX:
				gchar(yylval, bufptr);
				gptr(lastjxxx, bufptr);
				break;
		case	ILINESKIP:
				gint(yylval, bufptr);
				lineno += yylval;
				goto top;
		case	SKIP:
				eatskiplg(bufptr);
				goto top;
		case	VOID:
				goto top;
		case 	STRING:
				strptr = &strbuf[strno ^= 1];
				strptr->str_lg = *((lgtype *)bufptr);
				movestr(&strptr->str[0],
					(char *)bufptr + sizeof(lgtype),
					strptr->str_lg);
				eatstrlg(bufptr);
				yylval = (int)strptr;
				break;
		case 	ISTAB:
		case	ISTABSTR:
		case	ISTABNONE:
		case	ISTABDOT:
		case	IALIGN:
				gptr(yylval, bufptr);
				break;
		}
#ifdef DEBUG
		if (toktrace){
		char	*tok_to_name();
		printf("P: %d T#: %4d, %s ",
			passno, bufptr -  firsttoken, tok_to_name(val));
		switch(val){
		case 	INT:	printf("val %d",
					((struct exp *)yylval)->xvalue);
				break;
		case	BFINT:	printf("val %d",
					((struct exp *)yylval)->xvalue);
				break;
		case	QUAD:	printf("val[msd] = 0x%x, val[lsd] = 0x%x.",
				((struct exp *)yylval)->xvalue,
				((struct exp *)yylval)->yvalue);
				break;
		case 	FLTNUM: printf("value %20.17f",
				((union Double *)yylval)->dvalue);
				break;
		case	NAME:	printf("\"%.8s\"",
					((struct symtab *)yylval)->name);
				break;
		case	REG:	printf(" r%d",
					yylval);
				break;
		case	IJXXX:
		case	INST0:
		case	INSTn:	printf("%.8s",
					itab[0xFF &yylval]->name);
				break;
		case	STRING:	printf("length %d ",
					((struct strdesc *)yylval)->str_lg);
				printf("value\"%s\"",
					((struct strdesc *)yylval)->str);
				break;
		}  		/*end of the debug switch*/
		printf("\n");
		}
#endif DEBUG

	} else {	/* start a new buffer */
	    if (useVM){
		if (passno == 2){
			tok_temp = emptybuf->tok_next;
			emptybuf->tok_next = tok_free;
			tok_free = emptybuf;
			emptybuf = tok_temp;
		} else {
			emptybuf = emptybuf->tok_next;
		}
		bufno += 1;
		if (emptybuf == 0){
			struct	tokbufdesc *newdallop;
			int	i;
			if (passno == 2)
				goto badread;
			emptybuf = newdallop = (struct tokbufdesc *)
			  Calloc(TOKDALLOP, sizeof (struct tokbufdesc));
			for (i=0; i < TOKDALLOP; i++){
				buftail->tok_next = newdallop;
				buftail = newdallop;
				newdallop += 1;
			}
			buftail->tok_next = 0;
		}	/*end of need to get more buffers*/
		(toktype *)bufptr = &(emptybuf->toks[0]);
		if (passno == 1)
			scan_dot_s(emptybuf);
	    } else {	/*don't use VM*/
		bufno ^= 1;
		emptybuf = &tokbuf[bufno];
		((toktype *)bufptr) = &(emptybuf->toks[0]);
		if (passno == 1){
			/*
			 *	First check if there are things to write
			 *	out at all
			 */
			if (emptybuf->tok_count >= 0){
			    if (writeTEST((char *)emptybuf, sizeof *emptybuf, 1, tmpfil)){
			      badwrite:
				yyerror("Unexpected end of file writing the interpass tmp file");
				exit(2);
			    }
			}
			scan_dot_s(emptybuf);
		} else {	/*pass 2*/
		    if (readTEST((char *)emptybuf, sizeof *emptybuf, 1, tmpfil)){
			 badread:
			     yyerror("Unexpected end of file while reading the interpass tmp file");
			     exit(1);
		    }
		}
	    }	/*end of using a real live file*/
	    (char *)tokub = (char *)bufptr + emptybuf->tok_count;
#ifdef DEBUG
	    firsttoken = bufptr;
	    if (debug)
		printf("created buffernumber %d with %d tokens\n",
			bufno, emptybuf->tok_count);
#endif DEBUG
	    goto top;
	}	/*end of reading/creating a new buffer*/
	tokptr = bufptr;		/*copy back the global value*/
	return(val);
}	/*end of yylex*/


buildskip(from, to)
	register	ptrall	from, to;
{
	int	diff;
	register	int	frombufno;
	register	struct	tokbufdesc *middlebuf;
	/*
	 *	check if from and to are in the same buffer
	 *	from and to DIFFER BY AT MOST 1 buffer and to is
	 *	always ahead of from, with to being in the buffer emptybuf
	 *	points to.
	 *	The hard part here is accounting for the case where the
	 *	skip is to cross a buffer boundary; we must construct
	 *	two skips.
	 *
	 *	Figure out where the buffer boundary between from and to is
	 *	It's easy in VM, as buffers increase to high memory, but
	 *	w/o VM, we alternate between two buffers, and want
	 *	to look at the exact middle of the contiguous buffer region.
	 */
	middlebuf = useVM ? emptybuf : &tokbuf[1];
	if (  ( (toktype *)from > (toktype *)middlebuf)
	    ^ ( (toktype *)to > (toktype *)middlebuf)
	   ){	/*split across a buffer boundary*/
		ptoken(from, SKIP);
		/*
		 *	Set the skip so it lands someplace beyond
		 *	the end of this buffer.
		 *	When we pull this skip out in the second pass,
		 *	we will temporarily move the current pointer
		 *	out beyond the end of the buffer, but immediately
		 *	do a compare and fail the compare, and then reset
		 *	all the pointers correctly to point into the next buffer.
		 */
		bskiplg(from,  TOKBUFLG + 1);
		/*
		 *	Now, force from to be in the same buffer as to
		 */
		(toktype *)from = (toktype *)&(emptybuf->toks[0]);
	}
	/*
	 *	Now, to and from are in the same buffer
	 */
	if (from > to)
		yyerror("Internal error: bad skip construction");
	else {
		if ( (diff = (toktype *)to - (toktype *)from) >=
			(sizeof(toktype) + sizeof(lgtype) + 1)) {
				ptoken(from, SKIP);
				bskipfromto(from, to);
		} else {
			for ( ; diff > 0; --diff)
				ptoken(from, VOID);
		}
	}
}

movestr(to, from, lg)
	register	char	*to, *from;
	register	int	lg;
{
	if (lg <= 0) return;
	do
		*to++ = *from++;
	while (--lg);
}
static	int	newfflag = 0;
static	char	*newfname;
int	scanlineno;		/*the scanner's linenumber*/

new_dot_s(namep)
	char	*namep;
{
	newfflag = 1;
	newfname = namep;
	dotsname = namep;
	lineno = 1;
	scanlineno = 1;
}

/*
 *	Maps characters to their use in assembly language
 */
#define EOFCHAR	(-1)
#define	NEEDCHAR (-2)

readonly short type[] = {
	NEEDSBUF,		/*fill up the input buffer*/
	SCANEOF,		/*hit the hard end of file*/
	SP,	BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,   /*\0..^G*/
	BADCHAR,SP,	NL,	BADCHAR,BADCHAR,SP,	BADCHAR,BADCHAR,   /*BS..SI*/
	BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,   /*DLE..ETB*/
	BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,   /*CAN..US*/
	SP,	ORNOT,	DQ,	SH,	LITOP,	REGOP,	AND,	SQ,  /*sp .. '*/
	LP,	RP,	MUL,	PLUS,	CM,	MINUS,	ALPH,	DIV, /*( .. /*/
	DIG,	DIG,	DIG,	DIG,	DIG,	DIG,	DIG,	DIG, /*0 .. 7*/
	DIG,	DIG,	COLON,	SEMI,	LSH,	BADCHAR,RSH,	BADCHAR, /*8 .. ?*/
	BADCHAR,ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,/*@ .. G*/
	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,/*H .. BADCHAR*/
	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,/*P .. V*/
	ALPH,	ALPH,	ALPH,	LB,	BADCHAR,RB,	XOR,	ALPH,/*W .. _*/
	SIZEQUOTE,ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,/*` .. g*/
	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,/*h .. o*/
	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,	ALPH,/*p .. v*/
	ALPH,	ALPH,	ALPH,	BADCHAR,IOR,	BADCHAR,TILDE,	BADCHAR,/*x .. del*/
};

/*
 *	The table of possible uses for each character to test set inclusion.
 *	Different than the above table, which knows about tokens yylex
 *	is to return.
 */
#define	HEXFLAG		01		/* 'x' or 'X' */
#define	HEXLDIGIT	02		/* 'a' .. 'f' */
#define HEXUDIGIT	04		/* 'A' .. 'F' */
#define	ALPHA		010		/* 'A' .. 'Z', 'a' .. 'z', '_'*/
#define DIGIT		020		/* '0' .. '9' */
#define	FLOATEXP	040		/* 'd' 'e' 'D' 'E' */
						/*exponent field*/
#define SIGN		0100		/* '+' .. '-'*/
#define REGDIGIT	0200		/* '0' .. '5' */
#define SZSPECBEGIN	0400		/* 'b', 'B', 'l', 'L', 'w', 'W' */
#define POINT		01000		/* '.' */
#define SPACE		02000		/* '\t' or ' ' */
#define BSESCAPE	04000		/* bnrtf */
#define STRESCAPE	010000		/* '"', '\\', '\n' */
#define OCTDIGIT	020000		/* '0' .. '7' */
#define	FLOATFLAG	040000		/* 'd', 'D', 'f', 'F' */
						/*after leading 0*/

readonly short charsets[] = {
	0,	0,	0,	0,	0,	0,	0,	0,   /*\0..^G*/
	0,	SPACE,	STRESCAPE,0,	0,	0,	0,	0,   /*BS..SI*/
	0,	0,	0,	0,	0,	0,	0,	0,   /*DLE..ETB*/
	0,	0,	0,	0,	0,	0,	0,	0,   /*CAN..US*/
/* dollar is an alpha character */
	SPACE,	0,	STRESCAPE,0,	ALPHA,	0,	0,	0,   /*sp.. '*/
	0,	0,	0,	SIGN,	0,	SIGN,	POINT+ALPHA,0, /*( .. /*/
	DIGIT+REGDIGIT+OCTDIGIT,	DIGIT+REGDIGIT+OCTDIGIT,     /*0..1*/
	DIGIT+REGDIGIT+OCTDIGIT,	DIGIT+REGDIGIT+OCTDIGIT,     /*2..3*/
	DIGIT+REGDIGIT+OCTDIGIT,	DIGIT+REGDIGIT+OCTDIGIT,     /*4..5*/
	DIGIT+OCTDIGIT,			DIGIT+OCTDIGIT,		     /*6..7*/
	DIGIT,	DIGIT,	0,	0,	0,	0,	0,	0,   /*8..?*/
	0,							     /*@*/
	ALPHA+HEXUDIGIT,ALPHA+HEXUDIGIT+SZSPECBEGIN,		     /*A..B*/
	ALPHA+HEXUDIGIT,ALPHA+HEXUDIGIT+FLOATEXP+FLOATFLAG,	     /*C..D*/
	ALPHA+HEXUDIGIT+FLOATEXP,ALPHA+HEXUDIGIT+FLOATFLAG,	     /*E..F*/
	ALPHA,							     /*G*/
	ALPHA,			ALPHA,	ALPHA, 	ALPHA,		     /*H..K*/
	ALPHA+SZSPECBEGIN, 	ALPHA,	ALPHA,	ALPHA,		     /*L..O*/
	ALPHA,			ALPHA,	ALPHA,	ALPHA,		     /*P..S*/
	ALPHA,			ALPHA,	ALPHA,	ALPHA+SZSPECBEGIN,   /*T..W*/
	ALPHA+HEXFLAG,	ALPHA,	ALPHA,	0,STRESCAPE,0,	0,	ALPHA,/*X.._*/

	0,
	ALPHA+HEXLDIGIT,ALPHA+HEXLDIGIT+BSESCAPE+SZSPECBEGIN,	      /*a..b*/
	ALPHA+HEXLDIGIT,ALPHA+HEXLDIGIT+FLOATEXP+FLOATFLAG,	      /*c..d*/
	ALPHA+HEXLDIGIT+FLOATEXP,ALPHA+HEXLDIGIT+BSESCAPE+FLOATFLAG,  /*e..f*/
	ALPHA,							      /*g*/
	ALPHA,			ALPHA,	ALPHA,		ALPHA,	      /*h..k*/
	ALPHA+SZSPECBEGIN,	ALPHA,	ALPHA+BSESCAPE,	ALPHA,	      /*l..o*/
	ALPHA,			ALPHA,	ALPHA+BSESCAPE,	ALPHA,	      /*p..s*/
	ALPHA+BSESCAPE,		ALPHA,	ALPHA,		ALPHA+SZSPECBEGIN,/*t..w*/
	ALPHA+HEXFLAG,	ALPHA,	ALPHA,	0,0,	0,	0,	0,    /*x..del*/
0};

#define INCHARSET(val, kind) (charsets[val] & (kind) )
static	toktype	oval = NL;

#define	NINBUFFERS	2
#define	INBUFLG		NINBUFFERS*BUFSIZ + 2
	/*
	 *	We have two input buffers; the first one is reserved
	 *	for catching the tail of a line split across a buffer
	 *	boundary; the other one are used for snarfing a buffer
	 *	worth of .s source.
	 */
static	char	inbuffer[INBUFLG];
static	char	*InBufPtr = 0;

#ifdef  getchar
#undef	getchar
#endif
#define getchar() *inbufptr++

#ifdef  ungetc
#undef	ungetc
#endif
#define	ungetc(char) *--inbufptr = char

/*
 *	fill the inbuffer from the standard input.
 *	Assert: there are always n COMPLETE! lines in the buffer area.
 *	Assert: there is always a \n terminating the last line
 *		in the buffer area.
 *	Assert: after the \n, there is an EOFCHAR (hard end of file)
 *		or a NEEDCHAR (end of buffer)
 *	Assert:	fgets always null pads the string it reads.
 *	Assert:	no ungetc's are done at the end of a line or at the
 *		beginning of a line.
 *
 *	We read a complete buffer of characters in one single read.
 *	We then back scan within this buffer to find the end of the
 *	last complete line, and force the assertions, and save a pointer
 *	to the incomplete line.
 *	The next call to fillinbuffer will move the unread characters
 *	to the end of the first buffer, and then read another two buffers,
 *	completing the cycle.
 */

static	char	p_swapped = '\0';
static	char	*p_start = &inbuffer[NINBUFFERS * BUFSIZ];
static	char	*p_stop = &inbuffer[NINBUFFERS * BUFSIZ];
char *fillinbuffer()
{
	register	char	*to;
	register	char	*from;
			char	*inbufptr;
	int		nread;

	*p_start = p_swapped;
	inbufptr = &inbuffer[1*BUFSIZ] - (p_stop - p_start);

	for (to = inbufptr, from = p_start; from < p_stop;)
		*to++ = *from++;
	/*
	 *	Now, go read two full buffers (hopefully)
	 */
	nread = read(stdin->_file, &inbuffer[1*BUFSIZ], (NINBUFFERS - 1)*BUFSIZ);
	if (nread == 0)
		return(0);
	p_stop = from = &inbuffer[1*BUFSIZ + nread];
	*from = '\0';
	while (*--from != '\n')		/* back over the partial line */
		continue;
	from++;				/* first char of partial line */
	p_start = from;
	p_swapped = *p_start;
	*p_start = NEEDCHAR;		/* force assertion */
	return(inbufptr);
}

scan_dot_s(bufferbox)
	struct tokbufdesc *bufferbox;
{
	register int		yylval;/*lexical value*/
	register toktype	val;	/*the value returned; the character read*/
	register int	base;		/*the base of the number also counter*/
	register	char	*cp;
	register	char	*inbufptr;
	register	struct 		symtab	*op;
	register	unsigned	char	tag;
	int		forb;

	register	ptrall	bufptr;		/*where to stuff tokens*/
			ptrall	lgbackpatch;	/*where to stuff a string length*/
			ptrall	bufub;		/*where not to stuff tokens*/
	register	int	maxstrlg;	/*how long a string can be*/
			long	intval;		/*value of int*/
			char	fltchr[64];	/*buffer for floating values*/
		union	Double	fltval;		/*floating value returned*/
		struct	Quad	quadval;	/*quad returned from immediate constant */
			int	linescrossed;	/*when doing strings and comments*/

	(toktype *)bufptr = (toktype *) & (bufferbox->toks[0]);
	(toktype *)bufub = &(bufferbox->toks[AVAILTOKS]);

	inbufptr = InBufPtr;
	if (inbufptr == 0){
		inbufptr = fillinbuffer();
		if (inbufptr == 0){	/*end of file*/
   		  endoffile:
			inbufptr = 0;
			ptoken(bufptr, PARSEEOF);
			goto done;
		}
	}

	if (newfflag){
		ptoken(bufptr, IFILE);
		ptoken(bufptr, STRING);
		val = strlen(newfname) + 1;
		movestr( (char *)&( ( (lgtype *)bufptr)[1]), newfname, val);
		bstrlg(bufptr, val);

		ptoken(bufptr, ILINENO);
		ptoken(bufptr, INT);
		pint(bufptr,  1);
		newfflag = 0;
	}

	while (bufptr < bufub){
   loop:
        switch(yylval = (type+2)[val = getchar()]) {
	case SCANEOF:
		inbufptr = 0;
		goto endoffile;

	case NEEDSBUF:
		inbufptr = fillinbuffer();
		if (inbufptr == 0)
			goto endoffile;
		goto loop;

	case DIV:		/*process C style comments*/
		if ( (val = getchar()) == '*') {  /*comment prelude*/
			int	incomment;
			linescrossed = 0;
			incomment = 1;
			val = getchar();	/*skip over the * */
			do{
				while ( (val != '*') &&
					(val != '\n') &&
					(val != EOFCHAR) &&
					(val != NEEDCHAR))
						val = getchar();
				if (val == '\n'){
					scanlineno++;
					linescrossed++;
				} else
				if (val == EOFCHAR)
					goto endoffile;
				if (val == NEEDCHAR){
					inbufptr = fillinbuffer();
					if (inbufptr == 0)
						goto endoffile;
					lineno++;
					incomment = 1;
					val = getchar(); /*pull in the new char*/
				} else { 	/*its a star */
					val = getchar();
					incomment = val != '/';
				}
			} while (incomment);
			val = ILINESKIP;
			yylval = linescrossed;
			goto ret;
		} else {	/*just an ordinary DIV*/
			ungetc(val);
			val = yylval = DIV;
			goto ret;
		}
	case SH:
		if (oval == NL){
			/*
			 *	Attempt to recognize a C preprocessor
			 *	style comment '^#[ \t]*[0-9]*[ \t]*".*"
			 */
			val = getchar();	/*bump the #*/
			while (INCHARSET(val, SPACE))
				val = getchar();/*bump white */
			if (INCHARSET(val, DIGIT)){
				intval = 0;
				while(INCHARSET(val, DIGIT)){
					intval = intval *10 + val - '0';
					val = getchar();
				}
				while (INCHARSET(val, SPACE))
					val = getchar();
				if (val == '"'){
					ptoken(bufptr, ILINENO);
					ptoken(bufptr, INT);
					pint(bufptr, intval - 1);
					ptoken(bufptr, IFILE);
					/*
					 *	The '"' has already been
					 *	munched
					 *
					 *	eatstr will not eat
					 *	the trailing \n, so
					 *	it is given to the parser
					 *	and counted.
					 */
					goto eatstr;
				}
			}
		}
		/*
		 *	Well, its just an ordinary decadent comment
		 */
		while ((val != '\n') && (val != EOFCHAR))
			val = getchar();
		if (val == EOFCHAR)
			goto endoffile;
		val = yylval = oval = NL;
		scanlineno++;
		goto ret;

	case NL:
		scanlineno++;
		val = yylval;
		goto ret;

	case SP:
		oval = SP;	/*invalidate ^# meta comments*/
		goto loop;

	case REGOP:		/* % , could be used as modulo, or register*/
		val = getchar();
		if (INCHARSET(val, DIGIT)){
			yylval = val-'0';
			if (val=='1') {
				if (INCHARSET( (val = getchar()), REGDIGIT))
					yylval = 10+val-'0';
				else
					ungetc(val);
			}
			/*
			 *	God only knows what the original author
			 *	wanted this undocumented feature to
			 *	do.
			 *		%5++ is really  r7
			 */
			while(INCHARSET( (val = getchar()), SIGN)) {
				if (val=='+')
					yylval++;
				else
					yylval--;
			}
			ungetc(val);
			val = REG;
		} else {
			ungetc(val);
			val = REGOP;
		}
		goto ret;

	case ALPH:
		yylval = val;
		if (INCHARSET(val, SZSPECBEGIN)){
			if( (val = getchar()) == '`' || val == '^'){
				yylval |= 0100;	/*convert to lower*/
				if (yylval == 'b') yylval = 1;
				else if (yylval == 'w') yylval = 2;
				else if (yylval == 'l') yylval = 4;
				else			yylval = d124;
				val = SIZESPEC;
				goto ret;
			} else {
				ungetc(val);
				val = yylval;	/*restore first character*/
			}
		}
		cp = yytext;
		do {
			if (cp < &yytext[NCPS])
				*cp++ = val;
		} while (INCHARSET ( (val = getchar()), ALPHA | DIGIT));
		*cp = '\0';
		while (INCHARSET(val, SPACE))
			val = getchar();
		ungetc(val);
	doit:
		tag = (op = *lookup(1))->tag;
		if (tag && tag != LABELID){
			yylval = ( (struct instab *)op)->opcode;
			val = op->tag ;
			goto ret;
		} else {
			/*
			 *	Its a name... (Labels are subsets ofname)
			 */
			yylval = (int)op;
			val = NAME;
			goto ret;
		}

	case DIG:
		base = 10;
		cp = fltchr;
		intval = 0;
		if (val=='0') {
			val = getchar();
			if (val == 'b') {
				yylval = -1;
				val = BFINT;
				goto ret;
			}
			if (INCHARSET(val, HEXFLAG)){
				base = 16;
			} else
			if (INCHARSET(val, FLOATFLAG)){
				double atof();
				while ( (cp < &fltchr[63]) &&
				        INCHARSET(
						(val=getchar()),
						(DIGIT|SIGN|FLOATEXP|POINT)
					      )
				      ) *cp++ = val;
				if (cp == fltchr) {
					yylval = 1;
					val = BFINT;
					goto ret;
				}
				ungetc(val);
				*cp++ = '\0';
				fltval.dvalue = atof(fltchr);
				val = FLTNUM;
				goto ret;
			} else {
				ungetc(val);
				base = 8;
			}
		} else {
			forb = getchar();
			if (forb == 'f' || forb == 'b') {
				yylval = val - '0' + 1;
				if (forb == 'b')
					yylval = -yylval;
				val = BFINT;
				goto ret;
			}
			ungetc(forb);	/* put back non zero */
			goto middle;
		}
		while ( (val = getchar()) == '0')
			continue;
		ungetc(val);
		while ( INCHARSET( (val = getchar()), DIGIT) ||
		    	(base==16 && (INCHARSET(val, HEXLDIGIT|HEXUDIGIT) )
		      	   )
		      ){
			if (base==8)
				intval <<= 3;
			else if (base==10)
				intval *= 10;
			else {
				intval <<= 4;
				if (INCHARSET(val, HEXLDIGIT))
					val -= 'a' - 10 - '0';
				else if (INCHARSET(val, HEXUDIGIT))
					val -= 'A' - 10 - '0';
			}
middle:
			*cp++ = (val -= '0');
			intval += val;
		}
		ungetc(val);
		*cp = 0;
		maxstrlg = cp - fltchr;
		if (   (maxstrlg > 8)
		    && (   (   (base == 8)
			    && (   (maxstrlg>11)
				|| (   (maxstrlg == 11)
				    && (*fltchr > 3)
				   )
				)
			   )
			|| (   (base == 16)
			    && (maxstrlg > 8)
			   )
			|| (   (base == 10)
			    && (maxstrlg >= 10)
			   )
			)
		) {
			val = QUAD;
			get_quad(base, fltchr, cp, &quadval);
		} else
			val = INT;
		goto ret;

	case LSH:
	case RSH:
		/*
		 *	We allow the C style operators
		 *	<< and >>, as well as < and >
		 */
		if ( (base = getchar()) != val)
			ungetc(base);
		val = yylval;
		goto ret;

	case MINUS:
		if ( (val = getchar()) =='(')
			yylval=val=MP;
		else {
			ungetc(val);
			val=MINUS;
		}
		goto ret;

	case SQ:
		if ((yylval = getchar()) == '\n')
			scanlineno++;		/*not entirely correct*/
		intval = yylval;
		val = INT;
		goto ret;

	case DQ:
	   eatstr:
		linescrossed = 0;
		maxstrlg = (char *)bufub - (char *)bufptr;

		if (maxstrlg < MAXSTRLG) {
			ungetc('"');
			*(toktype *)bufptr = VOID ;
			bufub = bufptr;
			goto done;
		}
		if (maxstrlg > MAXSTRLG)
			maxstrlg = MAXSTRLG;

		ptoken(bufptr, STRING);
		lgbackpatch = bufptr;	/*this is where the size goes*/
		bufptr += sizeof(lgtype);
		/*
		 *	bufptr is now set to
		 *	be stuffed with characters from
		 *	the input
		 */

		while (   (maxstrlg > 0)
		       && !(INCHARSET( (val = getchar()), STRESCAPE))
		      ){
			stuff:
				maxstrlg-= 1;
				pchar(bufptr, val);
			}
		if (maxstrlg <= 0){	/*enough characters to fill a string buffer*/
			ungetc('"');		/*will read it next*/
		}
		else if (val == '"');		/*done*/
		else if (val == '\n'){
			scanlineno++;
			linescrossed++;
			val = getchar();
			if (val == EOFCHAR){
			  do_eof:
				pchar(bufptr, '\n');
				ungetc(EOFCHAR);
			} else
			if (val == NEEDCHAR){
				if ( (inbufptr = fillinbuffer()) == 0)
					goto do_eof;
				val = '\n';
				goto stuff;
			} else {	/* simple case */
				ungetc(val);
				val = '\n';
				goto stuff;
			}
		} else {
			val = getchar();		/*skip the '\\'*/
			if ( INCHARSET(val, BSESCAPE)){
				switch (val){
				  case 'b':  val = '\b'; goto stuff;
				  case 'f':  val = '\f'; goto stuff;
				  case 'n':  val = '\n'; goto stuff;
				  case 'r':  val = '\r'; goto stuff;
				  case 't':  val = '\t'; goto stuff;
				}
			}
			if ( !(INCHARSET(val,OCTDIGIT)) )  goto stuff;
			base = 0;
			intval = 0;
			while ( (base < 3) && (INCHARSET(val, OCTDIGIT))){
				base++;intval <<= 3;intval += val - '0';
				val = getchar();
			}
			ungetc(val);
			val = (char)intval;
			goto stuff;
		}
		/*
		 *	bufptr now points at the next free slot
		 */
		bstrfromto(lgbackpatch, bufptr);
		if (linescrossed){
			val = ILINESKIP;
			yylval = linescrossed;
			goto ret;
		} else
			goto builtval;

	case BADCHAR:
		linescrossed = lineno;
		lineno = scanlineno;
		yyerror("Illegal character mapped: %d, char read:(octal) %o",
			yylval, val);
		lineno = linescrossed;
		val = BADCHAR;
		goto ret;

	default:
		val = yylval;
		goto ret;
	}	/*end of the switch*/
	/*
	 *	here with one token, so stuff it
	 */
	ret:
	oval = val;
	ptoken(bufptr, val);
	switch(val){
		case	ILINESKIP:
				pint(bufptr, yylval);
				break;
		case	SIZESPEC:
				pchar(bufptr, yylval);
				break;
		case	BFINT:	plong(bufptr, yylval);
				break;
		case	INT:	plong(bufptr, intval);
				break;
		case	QUAD:	plong(bufptr, quadval.quad_low_long);
				plong(bufptr, quadval.quad_high_long);
				break;
		case 	FLTNUM:	pdouble(bufptr, fltval.dvalue);
				break;
		case	NAME:	pptr(bufptr, (int)(struct symtab *)yylval);
				break;
		case	REG:	pchar(bufptr, yylval);
				break;
		case	INST0:
		case	INSTn:
				pchar(bufptr, yylval);
				break;
		case 	IJXXX:
				pchar(bufptr, yylval);
				pptr(bufptr, (int)(struct symtab *)symalloc());
				break;
		case	ISTAB:
		case	ISTABSTR:
		case	ISTABNONE:
		case	ISTABDOT:
		case	IALIGN:
				pptr(bufptr, (int)(struct symtab *)symalloc());
				break;
	/*
	 *	default:
	 */
	 }
	 builtval: ;
   }			/*end of the while to stuff the buffer*/
   done:
	bufferbox->tok_count = (toktype *)bufptr - &(bufferbox->toks[0]);

	/*
	 *	This is a real kludge:
	 *
	 *	We put the last token in the buffer to be  a MINUS
	 *	symbol.  This last token will never be picked up
	 *	in the normal way, but can be looked at during
	 *	a peekahead look that the short circuit expression
	 *	evaluator uses to see if an expression is complicated.
	 *
	 *	Consider the following situation:
	 *
	 *	.word	45		+	47
	 *        buffer 1      |  buffer 0
	 *	the peekahead would want to look across the buffer,
	 *	but will look in the buffer end zone, see the minus, and
	 *	fail.
	 */
	ptoken(bufptr, MINUS);
	InBufPtr = inbufptr;		/*copy this back*/
}

struct	Quad _quadtemp;
get_quad(radix, cp_start, cp_end, quadptr)
	int	radix;
	char	*cp_start, *cp_end;
	struct	Quad *quadptr;
{
	register		char	*cp = cp_start;	/* r11 */
	register	struct	Quad	*qp = quadptr;	/* r10 */
	register	long	temp;			/* r9 */

	asm("clrq (r10)");
	for (; cp < cp_end; cp++){
		switch (radix) {
			case 8:
				asm ("ashq $3, (r10), (r10)");
				break;
			case 16:
				asm ("ashq $4, (r10), (r10)");
				break;
			case 10:
				asm ("ashq	$1, (r10), __quadtemp");
				asm ("ashq	$3, (r10), (r10)");
				asm ("addl2	__quadtemp, (r10)");
				asm ("adwc	__quadtemp+4, 4(r10)");
				break;
		}
		asm ("cvtbl	(r11), r9");
		asm ("addl2	r9, (r10)");
		asm ("adwc	$0, 4(r10)");
	}
}