[unix-history] / usr / src / old / as.tahoe / asscan2.c

/*
 *	Copyright (c) 1982 Regents of the University of California
 */
#ifndef lint
static char sccsid[] = "@(#)asscan2.c 4.14 7/6/83";
#endif not lint

#include "asscanl.h"

static	inttoktype	oval = NL;
#define	ASINBUFSIZ	4096
char	inbufunget[8];
char	inbuffer[ASINBUFSIZ];
char	*Ginbufptr = inbuffer;
int	Ginbufcnt = 0;
int	scannerhadeof;

fillinbuffer()
{
		int	nread;
		int	goal;
		int	got;

	nread = 0;
	if (scannerhadeof == 0){
		goal = sizeof(inbuffer);
		do {
			got = read(stdin->_file, inbuffer + nread, goal);
			if (got == 0)
				scannerhadeof = 1;
			if (got <= 0)
				break;
			nread += got;
			goal -= got;
		} while (goal);
	} else {
		scannerhadeof = 0;
	}
	/*
	 *	getchar assumes that Ginbufcnt and Ginbufptr
	 *	are adjusted as if one character has been removed
	 *	from the input.
	 */
	if (nread == 0){
		inbuffer[0] = EOFCHAR;
		nread = 1;
	}
	Ginbufcnt = nread - 1;
	Ginbufptr = inbuffer + 1;
}

scan_dot_s(bufferbox)
	struct tokbufdesc *bufferbox;
{
	reg	char	*inbufptr;
	reg	int	inbufcnt;
	reg	int	ryylval;	/* local copy of lexical value */
	extern	int	yylval;		/* global copy of lexical value */
	reg	int	val;		/* the value returned */
		int	i;		/* simple counter */
	reg	char	*rcp;	
		int	ch;		/* treated as a character */
		int	ch1;		/* shadow value */
		struct 	symtab	*op;
	reg	ptrall	bufptr;		/* where to stuff tokens */
		ptrall	bufub;		/* where not to stuff tokens */
		long	intval;		/* value of int */
		int	linescrossed;	/* when doing strings and comments */
		u_char	opstruct;
	reg	int	strlg;		/* the length of a string */

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

	MEMTOREGBUF;
	if (newfflag){
		newfflag = 0;
		ryylval = (int)savestr(newfname, strlen(newfname)+1, STR_BOTH);

		ptoken(bufptr, IFILE);
		ptoken(bufptr, STRING);
		pptr(bufptr, ryylval);

		ptoken(bufptr, ILINENO);
		ptoken(bufptr, INT);
		pint(bufptr,  1);
	}

	while (bufptr < bufub){
   loop:
        switch(ryylval = (type+1)[ch = getchar()]) {
	case SCANEOF:
	endoffile: ;
		inbufptr = 0;
		ptoken(bufptr, PARSEEOF);
		goto done;

	case DIV:		/*process C style comments*/
		if ( (ch = getchar()) == '*') {  /*comment prelude*/
			int	incomment;
			linescrossed = 0;
			incomment = 1;
			ch = getchar();	/*skip over the * */
			while(incomment){
				switch(ch){
				case '*':
					ch = getchar();
					incomment = (ch != '/');
					break;
				case '\n':
					scanlineno++;
					linescrossed++;
					ch = getchar();
					break;
				case EOFCHAR:
					goto endoffile;
				default:
					ch = getchar();
					break;
				}
			}
			val = ILINESKIP;
			ryylval = linescrossed;
			goto ret;
		} else {	/*just an ordinary DIV*/
			ungetc(ch);
			val = ryylval = DIV;
			goto ret;
		}
	case SH:
		if (oval == NL){
			/*
			 *	Attempt to recognize a C preprocessor
			 *	style comment '^#[ \t]*[0-9]*[ \t]*".*"
			 */
			ch = getchar();	/*bump the #*/
			while (INCHARSET(ch, SPACE))
				ch = getchar();/*bump white */
			if (INCHARSET(ch, DIGIT)){
				intval = 0;
				while(INCHARSET(ch, DIGIT)){
					intval = intval*10 + ch - '0';
					ch = getchar();
				}
				while (INCHARSET(ch, SPACE))
					ch = getchar();
				if (ch == '"' || ch == '\n'){
					ptoken(bufptr, ILINENO);
					ptoken(bufptr, INT);
					pint(bufptr, intval - 1);
					if (ch == '"')
					{
						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 ((ch != '\n') && (ch != EOFCHAR)) 
			ch = getchar();
		if (ch == EOFCHAR)
			goto endoffile;
		val = ryylval = oval = NL;
		scanlineno++;
		goto ret;

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

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

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

	case ALPH:
		ch1 = ch;
		if (INCHARSET(ch, SZSPECBEGIN)){
			if( (ch = getchar()) == '`' || ch == '^'){
				ch1 |= 0100;	/*convert to lower*/
				switch(ch1){
				case 'b':	ryylval = 1;	break;
				case 'w':	ryylval = 2;	break;
				case 'l':	ryylval = 4;	break;
				default:	ryylval = d124;	break;
				}
				val = SIZESPEC;
				goto ret;
			} else {
				ungetc(ch);
				ch = ch1;	/*restore first character*/
			}
		}
		rcp = yytext;
		do {
			if (rcp < &yytext[NCPName])
				*rcp++ = ch;
		} while (INCHARSET ( (ch = getchar()), ALPHA | DIGIT));
		*rcp = '\0';
		while (INCHARSET(ch, SPACE))
			ch = getchar();
		ungetc(ch);
	
		switch((op = *lookup(1))->s_tag){
		case 0:
		case LABELID:
			/*
			 *	Its a name... (Labels are subsets of name)
			 */
			ryylval = (int)op;
			val = NAME;
			break;
		case INST0:
		case INSTn:
		case IJXXX:
			opstruct = ( (struct instab *)op)->i_opcode;
			val = op->s_tag;
			break;
		default:
			ryylval = ( (struct instab *)op)->i_opcode;
			val = op->s_tag;
			break;
		}
		goto ret;

	case DIG:
		/*
		 *	restore local inbufptr and inbufcnt
		 */
		REGTOMEMBUF;
		val = number(ch);
		MEMTOREGBUF;
		/*
		 *	yylval or yybignum has been stuffed as a side
		 *	effect to number(); get the global yylval
		 *	into our fast local copy in case it was an INT.
		 */
		ryylval = yylval;
		goto ret;

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

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

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

	case DQ:
	   eatstr:
		linescrossed = 0;
		for (strlg = 0; /*VOID*/; strlg++){
		    switch(ch = getchar()){
		    case '"':
			goto tailDQ;
		    default:
		    stuff:
			putc(ch, strfile);
			break;
		    case '\n':
			yywarning("New line in a string constant");
			scanlineno++;
			linescrossed++;
			ch = getchar();
			switch(ch){
			case EOFCHAR:
				putc('\n', strfile);
				ungetc(EOFCHAR);
				goto tailDQ;
			default:
				ungetc(ch);
				ch = '\n';
				goto stuff;
			}
			break;

		    case '\\':
			ch = getchar();		/*skip the '\\'*/
			if ( INCHARSET(ch, BSESCAPE)){
				switch (ch){
				  case 'b':  ch = '\b'; goto stuff;
				  case 'f':  ch = '\f'; goto stuff;
				  case 'n':  ch = '\n'; goto stuff;
				  case 'r':  ch = '\r'; goto stuff;
				  case 't':  ch = '\t'; goto stuff;
				}
			}
			if ( !(INCHARSET(ch, OCTDIGIT)) ) 
				goto stuff;
			i = 0;
			intval = 0;
			while ( (i < 3) && (INCHARSET(ch, OCTDIGIT))){
				i++;
				intval <<= 3;
				intval += ch - '0';
				ch = getchar();
			}
			ungetc(ch);
			ch = (char)intval;
			goto stuff;
		    }
		}
	tailDQ: ;
		/*
		 *	account for any lines that were crossed
		 */
		if (linescrossed){
			ptoken(bufptr, ILINESKIP);
			pint(bufptr, linescrossed);
		}
		/*
		 *	Cheat: append a trailing null to the string
		 *	and then adjust the string length to ignore
		 *	the trailing null.  If any STRING client requires
		 *	the trailing null, the client can just change STRLEN
		 */
		putc(0, strfile);
		ryylval = (int)savestr((char *)0, strlg + 1, STR_FILE);
		val = STRING;
		((struct strdesc *)ryylval)->sd_strlen -= 1;
		goto ret;

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

	default:
		val = ryylval;
		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, ryylval);
				break;
		case	SIZESPEC:
				pchar(bufptr, ryylval);
				break;
		case	BFINT:	plong(bufptr, ryylval);
				break;
		case	INT:	plong(bufptr, ryylval);
				break;
		case 	BIGNUM:	pnumber(bufptr, yybignum);
				break;
		case	STRING:	pptr(bufptr, (int)(char *)ryylval);
				break;
		case	NAME:	pptr(bufptr, (int)(struct symtab *)ryylval);
				break;
		case	REG:	pchar(bufptr, ryylval);
				break;	
		case	INST0:
		case	INSTn:
				popcode(bufptr, opstruct);
				break;
		case 	IJXXX:
				popcode(bufptr, opstruct);
				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 = (bytetoktype *)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);
	REGTOMEMBUF;
}
Commit	Line	Data
f76eb4c0 KB	1	/*
	2	* Copyright (c) 1982 Regents of the University of California
	3	*/
	4	#ifndef lint
	5	static char sccsid[] = "@(#)asscan2.c 4.14 7/6/83";
	6	#endif not lint
	7
	8	#include "asscanl.h"
	9
	10	static inttoktype oval = NL;
	11	#define ASINBUFSIZ 4096
	12	char inbufunget[8];
	13	char inbuffer[ASINBUFSIZ];
	14	char *Ginbufptr = inbuffer;
	15	int Ginbufcnt = 0;
	16	int scannerhadeof;
	17
	18	fillinbuffer()
	19	{
	20	int nread;
	21	int goal;
	22	int got;
	23
	24	nread = 0;
	25	if (scannerhadeof == 0){
	26	goal = sizeof(inbuffer);
	27	do {
	28	got = read(stdin->_file, inbuffer + nread, goal);
	29	if (got == 0)
	30	scannerhadeof = 1;
	31	if (got <= 0)
	32	break;
	33	nread += got;
	34	goal -= got;
	35	} while (goal);
	36	} else {
	37	scannerhadeof = 0;
	38	}
	39	/*
	40	* getchar assumes that Ginbufcnt and Ginbufptr
	41	* are adjusted as if one character has been removed
	42	* from the input.
	43	*/
	44	if (nread == 0){
	45	inbuffer[0] = EOFCHAR;
	46	nread = 1;
	47	}
	48	Ginbufcnt = nread - 1;
	49	Ginbufptr = inbuffer + 1;
	50	}
	51
	52	scan_dot_s(bufferbox)
	53	struct tokbufdesc *bufferbox;
	54	{
	55	reg char *inbufptr;
	56	reg int inbufcnt;
	57	reg int ryylval; /* local copy of lexical value */
	58	extern int yylval; /* global copy of lexical value */
	59	reg int val; /* the value returned */
	60	int i; /* simple counter */
	61	reg char *rcp;
	62	int ch; /* treated as a character */
	63	int ch1; /* shadow value */
	64	struct symtab *op;
65	reg ptrall bufptr; /* where to stuff tokens */
66	ptrall bufub; /* where not to stuff tokens */
67	long intval; /* value of int */
68	int linescrossed; /* when doing strings and comments */
69	u_char opstruct;
70	reg int strlg; /* the length of a string */
71
72	(bytetoktype )bufptr = (bytetoktype ) & (bufferbox->toks[0]);
73	(bytetoktype *)bufub = &(bufferbox->toks[AVAILTOKS]);
74
75	MEMTOREGBUF;
76	if (newfflag){
77	newfflag = 0;
78	ryylval = (int)savestr(newfname, strlen(newfname)+1, STR_BOTH);
79
80	ptoken(bufptr, IFILE);
81	ptoken(bufptr, STRING);
82	pptr(bufptr, ryylval);
83
84	ptoken(bufptr, ILINENO);
85	ptoken(bufptr, INT);
86	pint(bufptr, 1);
87	}
88
89	while (bufptr < bufub){
90	loop:
91	switch(ryylval = (type+1)[ch = getchar()]) {
92	case SCANEOF:
93	endoffile: ;
94	inbufptr = 0;
95	ptoken(bufptr, PARSEEOF);
96	goto done;
97
98	case DIV: /process C style comments/
99	if ( (ch = getchar()) == '') { /comment prelude*/
100	int incomment;
101	linescrossed = 0;
102	incomment = 1;
103	ch = getchar(); /skip over the */
104	while(incomment){
105	switch(ch){
106	case '*':
107	ch = getchar();
108	incomment = (ch != '/');
109	break;
110	case '\n':
111	scanlineno++;
112	linescrossed++;
113	ch = getchar();
114	break;
115	case EOFCHAR:
116	goto endoffile;
117	default:
118	ch = getchar();
119	break;
120	}
121	}
122	val = ILINESKIP;
123	ryylval = linescrossed;
124	goto ret;
125	} else { /just an ordinary DIV/
126	ungetc(ch);
127	val = ryylval = DIV;
128	goto ret;
129	}
130	case SH:
131	if (oval == NL){
132	/*
133	* Attempt to recognize a C preprocessor
134	* style comment '^#[ \t][0-9][ \t]"."
135	*/
136	ch = getchar(); /bump the #/
137	while (INCHARSET(ch, SPACE))
138	ch = getchar();/bump white /
139	if (INCHARSET(ch, DIGIT)){
140	intval = 0;
141	while(INCHARSET(ch, DIGIT)){
142	intval = intval*10 + ch - '0';
143	ch = getchar();
144	}
145	while (INCHARSET(ch, SPACE))
146	ch = getchar();
147	if (ch == '"' \|\| ch == '\n'){
148	ptoken(bufptr, ILINENO);
149	ptoken(bufptr, INT);
150	pint(bufptr, intval - 1);
151	if (ch == '"')
152	{
153	ptoken(bufptr, IFILE);
154	/*
155	* The '"' has already been
156	* munched
157	*
158	* eatstr will not eat
159	* the trailing \n, so
160	* it is given to the parser
161	* and counted.
162	*/
163	goto eatstr;
164	}
165	}
166	}
167	}
168	/*
169	* Well, its just an ordinary decadent comment
170	*/
171	while ((ch != '\n') && (ch != EOFCHAR))
172	ch = getchar();
173	if (ch == EOFCHAR)
174	goto endoffile;
175	val = ryylval = oval = NL;
176	scanlineno++;
177	goto ret;
178
179	case NL:
180	scanlineno++;
181	val = ryylval;
182	goto ret;
183
184	case SP:
185	oval = SP; /invalidate ^# meta comments/
186	goto loop;
187
188	case REGOP: /* % , could be used as modulo, or register*/
189	ch = getchar();
190	if (INCHARSET(ch, DIGIT)){
191	ryylval = ch-'0';
192	if (ch=='1') {
193	if (INCHARSET( (ch = getchar()), REGDIGIT))
194	ryylval = 10+ch-'0';
195	else
196	ungetc(ch);
197	}
198	/*
199	* God only knows what the original author
200	* wanted this undocumented feature to
201	* do.
202	* %5++ is really r7
203	*/
204	while(INCHARSET( (ch = getchar()), SIGN)) {
205	if (ch=='+')
206	ryylval++;
207	else
208	ryylval--;
209	}
210	ungetc(ch);
211	val = REG;
212	} else {
213	ungetc(ch);
214	val = REGOP;
215	}
216	goto ret;
217
218	case ALPH:
219	ch1 = ch;
220	if (INCHARSET(ch, SZSPECBEGIN)){
221	if( (ch = getchar()) == '`' \|\| ch == '^'){
222	ch1 \|= 0100; /convert to lower/
223	switch(ch1){
224	case 'b': ryylval = 1; break;
225	case 'w': ryylval = 2; break;
226	case 'l': ryylval = 4; break;
227	default: ryylval = d124; break;
228	}
229	val = SIZESPEC;
230	goto ret;
231	} else {
232	ungetc(ch);
233	ch = ch1; /restore first character/
234	}
235	}
236	rcp = yytext;
237	do {
238	if (rcp < &yytext[NCPName])
239	*rcp++ = ch;
240	} while (INCHARSET ( (ch = getchar()), ALPHA \| DIGIT));
241	*rcp = '\0';
242	while (INCHARSET(ch, SPACE))
243	ch = getchar();
244	ungetc(ch);
245
246	switch((op = *lookup(1))->s_tag){
247	case 0:
248	case LABELID:
249	/*
250	* Its a name... (Labels are subsets of name)
251	*/
252	ryylval = (int)op;
253	val = NAME;
254	break;
255	case INST0:
256	case INSTn:
257	case IJXXX:
258	opstruct = ( (struct instab *)op)->i_opcode;
259	val = op->s_tag;
260	break;
261	default:
262	ryylval = ( (struct instab *)op)->i_opcode;
263	val = op->s_tag;
264	break;
265	}
266	goto ret;
267
268	case DIG:
269	/*
270	* restore local inbufptr and inbufcnt
271	*/
272	REGTOMEMBUF;
273	val = number(ch);
274	MEMTOREGBUF;
275	/*
276	* yylval or yybignum has been stuffed as a side
277	* effect to number(); get the global yylval
278	* into our fast local copy in case it was an INT.
279	*/
280	ryylval = yylval;
281	goto ret;
282
283	case LSH:
284	case RSH:
285	/*
286	* We allow the C style operators
287	* << and >>, as well as < and >
288	*/
289	if ( (ch1 = getchar()) != ch)
290	ungetc(ch1);
291	val = ryylval;
292	goto ret;
293
294	case MINUS:
295	if ( (ch = getchar()) =='(')
296	ryylval=val=MP;
297	else {
298	ungetc(ch);
299	val=MINUS;
300	}
301	goto ret;
302
303	case SQ:
304	if ((ryylval = getchar()) == '\n')
305	scanlineno++; /not entirely correct/
306	val = INT;
307	goto ret;
308
309	case DQ:
310	eatstr:
311	linescrossed = 0;
312	for (strlg = 0; /VOID/; strlg++){
313	switch(ch = getchar()){
314	case '"':
315	goto tailDQ;
316	default:
317	stuff:
318	putc(ch, strfile);
319	break;
320	case '\n':
321	yywarning("New line in a string constant");
322	scanlineno++;
323	linescrossed++;
324	ch = getchar();
325	switch(ch){
326	case EOFCHAR:
327	putc('\n', strfile);
328	ungetc(EOFCHAR);
329	goto tailDQ;
330	default:
331	ungetc(ch);
332	ch = '\n';
333	goto stuff;
334	}
335	break;
336
337	case '\\':
338	ch = getchar(); /skip the '\\'/
339	if ( INCHARSET(ch, BSESCAPE)){
340	switch (ch){
341	case 'b': ch = '\b'; goto stuff;
342	case 'f': ch = '\f'; goto stuff;
343	case 'n': ch = '\n'; goto stuff;
344	case 'r': ch = '\r'; goto stuff;
345	case 't': ch = '\t'; goto stuff;
346	}
347	}
348	if ( !(INCHARSET(ch, OCTDIGIT)) )
349	goto stuff;
350	i = 0;
351	intval = 0;
352	while ( (i < 3) && (INCHARSET(ch, OCTDIGIT))){
353	i++;
354	intval <<= 3;
355	intval += ch - '0';
356	ch = getchar();
357	}
358	ungetc(ch);
359	ch = (char)intval;
360	goto stuff;
361	}
362	}
363	tailDQ: ;
364	/*
365	* account for any lines that were crossed
366	*/
367	if (linescrossed){
368	ptoken(bufptr, ILINESKIP);
369	pint(bufptr, linescrossed);
370	}
371	/*
372	* Cheat: append a trailing null to the string
373	* and then adjust the string length to ignore
374	* the trailing null. If any STRING client requires
375	* the trailing null, the client can just change STRLEN
376	*/
377	putc(0, strfile);
378	ryylval = (int)savestr((char *)0, strlg + 1, STR_FILE);
379	val = STRING;
380	((struct strdesc *)ryylval)->sd_strlen -= 1;
381	goto ret;
382
383	case BADCHAR:
384	linescrossed = lineno;
385	lineno = scanlineno;
386	yyerror("Illegal character mapped: %d, char read:(octal) %o",
387	ryylval, ch);
388	lineno = linescrossed;
389	val = BADCHAR;
390	goto ret;
391
392	default:
393	val = ryylval;
394	goto ret;
395	} /end of the switch/
396	/*
397	* here with one token, so stuff it
398	*/
399	ret:
400	oval = val;
401	ptoken(bufptr, val);
402	switch(val){
403	case ILINESKIP:
404	pint(bufptr, ryylval);
405	break;
406	case SIZESPEC:
407	pchar(bufptr, ryylval);
408	break;
409	case BFINT: plong(bufptr, ryylval);
410	break;
411	case INT: plong(bufptr, ryylval);
412	break;
413	case BIGNUM: pnumber(bufptr, yybignum);
414	break;
415	case STRING: pptr(bufptr, (int)(char *)ryylval);
416	break;
417	case NAME: pptr(bufptr, (int)(struct symtab *)ryylval);
418	break;
419	case REG: pchar(bufptr, ryylval);
420	break;
421	case INST0:
422	case INSTn:
423	popcode(bufptr, opstruct);
424	break;
425	case IJXXX:
426	popcode(bufptr, opstruct);
427	pptr(bufptr, (int)(struct symtab *)symalloc());
428	break;
429	case ISTAB:
430	case ISTABSTR:
431	case ISTABNONE:
432	case ISTABDOT:
433	case IALIGN:
434	pptr(bufptr, (int)(struct symtab *)symalloc());
435	break;
436	/*
437	* default:
438	*/
439	}
440	builtval: ;
441	} /end of the while to stuff the buffer/
442	done:
443	bufferbox->tok_count = (bytetoktype *)bufptr - &(bufferbox->toks[0]);
444	/*
445	* This is a real kludge:
446	*
447	* We put the last token in the buffer to be a MINUS
448	* symbol. This last token will never be picked up
449	* in the normal way, but can be looked at during
450	* a peekahead look that the short circuit expression
451	* evaluator uses to see if an expression is complicated.
452	*
453	* Consider the following situation:
454	*
455	* .word 45 + 47
456	* buffer 1 \| buffer 0
457	* the peekahead would want to look across the buffer,
458	* but will look in the buffer end zone, see the minus, and
459	* fail.
460	*/
461	ptoken(bufptr, MINUS);
462	REGTOMEMBUF;
463	}