Quake-III-Arena

tokens.c (6800B)

---

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "cpp.h"
 
 static char wbuf[2*OBS];
 static char *wbp = wbuf;
 
 /*
  * 1 for tokens that don't need whitespace when they get inserted
  * by macro expansion
  */
 static const char wstab[] = {
 	0,	/* END */
 	0,	/* UNCLASS */
 	0,	/* NAME */
 	0,	/* NUMBER */
 	0,	/* STRING */
 	0,	/* CCON */
 	1,	/* NL */
 	0,	/* WS */
 	0,	/* DSHARP */
 	0,	/* EQ */
 	0,	/* NEQ */
 	0,	/* LEQ */
 	0,	/* GEQ */
 	0,	/* LSH */
 	0,	/* RSH */
 	0,	/* LAND */
 	0,	/* LOR */
 	0,	/* PPLUS */
 	0,	/* MMINUS */
 	0,	/* ARROW */
 	1,	/* SBRA */
 	1,	/* SKET */
 	1,	/* LP */
 	1,	/* RP */
 	0,	/* DOT */
 	0,	/* AND */
 	0,	/* STAR */
 	0,	/* PLUS */
 	0,	/* MINUS */
 	0,	/* TILDE */
 	0,	/* NOT */
 	0,	/* SLASH */
 	0,	/* PCT */
 	0,	/* LT */
 	0,	/* GT */
 	0,	/* CIRC */
 	0,	/* OR */
 	0,	/* QUEST */
 	0,	/* COLON */
 	0,	/* ASGN */
 	1,	/* COMMA */
 	0,	/* SHARP */
 	1,	/* SEMIC */
 	1,	/* CBRA */
 	1,	/* CKET */
 	0,	/* ASPLUS */
  	0,	/* ASMINUS */
  	0,	/* ASSTAR */
  	0,	/* ASSLASH */
  	0,	/* ASPCT */
  	0,	/* ASCIRC */
  	0,	/* ASLSH */
 	0,	/* ASRSH */
  	0,	/* ASOR */
  	0,	/* ASAND */
 	0,	/* ELLIPS */
 	0,	/* DSHARP1 */
 	0,	/* NAME1 */
 	0,	/* DEFINED */
 	0,	/* UMINUS */
 };
 
 void
 maketokenrow(int size, Tokenrow *trp)
 {
 	trp->max = size;
 	if (size>0)
 		trp->bp = (Token *)domalloc(size*sizeof(Token));
 	else
 		trp->bp = NULL;
 	trp->tp = trp->bp;
 	trp->lp = trp->bp;
 }
 
 Token *
 growtokenrow(Tokenrow *trp)
 {
 	int ncur = trp->tp - trp->bp;
 	int nlast = trp->lp - trp->bp;
 
 	trp->max = 3*trp->max/2 + 1;
 	trp->bp = (Token *)realloc(trp->bp, trp->max*sizeof(Token));
 	if (trp->bp == NULL)
 		error(FATAL, "Out of memory from realloc");
 	trp->lp = &trp->bp[nlast];
 	trp->tp = &trp->bp[ncur];
 	return trp->lp;
 }
 
 /*
  * Compare a row of tokens, ignoring the content of WS; return !=0 if different
  */
 int
 comparetokens(Tokenrow *tr1, Tokenrow *tr2)
 {
 	Token *tp1, *tp2;
 
 	tp1 = tr1->tp;
 	tp2 = tr2->tp;
 	if (tr1->lp-tp1 != tr2->lp-tp2)
 		return 1;
 	for (; tp1<tr1->lp ; tp1++, tp2++) {
 		if (tp1->type != tp2->type
 		 || (tp1->wslen==0) != (tp2->wslen==0)
 		 || tp1->len != tp2->len
 		 || strncmp((char*)tp1->t, (char*)tp2->t, tp1->len)!=0)
 			return 1;
 	}
 	return 0;
 }
 
 /*
  * replace ntok tokens starting at dtr->tp with the contents of str.
  * tp ends up pointing just beyond the replacement.
  * Canonical whitespace is assured on each side.
  */
 void
 insertrow(Tokenrow *dtr, int ntok, Tokenrow *str)
 {
 	int nrtok = rowlen(str);
 
 	dtr->tp += ntok;
 	adjustrow(dtr, nrtok-ntok);
 	dtr->tp -= ntok;
 	movetokenrow(dtr, str);
 	makespace(dtr);
 	dtr->tp += nrtok;
 	makespace(dtr);
 }
 
 /*
  * make sure there is WS before trp->tp, if tokens might merge in the output
  */
 void
 makespace(Tokenrow *trp)
 {
 	uchar *tt;
 	Token *tp = trp->tp;
 
 	if (tp >= trp->lp)
 		return;
 	if (tp->wslen) {
 		if (tp->flag&XPWS
 		 && (wstab[tp->type] || trp->tp>trp->bp && wstab[(tp-1)->type])) {
 			tp->wslen = 0;
 			return;
 		}
 		tp->t[-1] = ' ';
 		return;
 	}
 	if (wstab[tp->type] || trp->tp>trp->bp && wstab[(tp-1)->type])
 		return;
 	tt = newstring(tp->t, tp->len, 1);
 	*tt++ = ' ';
 	tp->t = tt;
 	tp->wslen = 1;
 	tp->flag |= XPWS;
 }
 
 /*
  * Copy an entire tokenrow into another, at tp.
  * It is assumed that there is enough space.
  *  Not strictly conforming.
  */
 void
 movetokenrow(Tokenrow *dtr, Tokenrow *str)
 {
 	int nby;
 
 	/* nby = sizeof(Token) * (str->lp - str->bp); */
 	nby = (char *)str->lp - (char *)str->bp;
 	memmove(dtr->tp, str->bp, nby);
 }
 
 /*
  * Move the tokens in a row, starting at tr->tp, rightward by nt tokens;
  * nt may be negative (left move).
  * The row may need to be grown.
  * Non-strictly conforming because of the (char *), but easily fixed
  */
 void
 adjustrow(Tokenrow *trp, int nt)
 {
 	int nby, size;
 
 	if (nt==0)
 		return;
 	size = (trp->lp - trp->bp) + nt;
 	while (size > trp->max)
 		growtokenrow(trp);
 	/* nby = sizeof(Token) * (trp->lp - trp->tp); */
 	nby = (char *)trp->lp - (char *)trp->tp;
 	if (nby)
 		memmove(trp->tp+nt, trp->tp, nby);
 	trp->lp += nt;
 }
 
 /*
  * Copy a row of tokens into the destination holder, allocating
  * the space for the contents.  Return the destination.
  */
 Tokenrow *
 copytokenrow(Tokenrow *dtr, Tokenrow *str)
 {
 	int len = rowlen(str);
 
 	maketokenrow(len, dtr);
 	movetokenrow(dtr, str);
 	dtr->lp += len;
 	return dtr;
 }
 
 /*
  * Produce a copy of a row of tokens.  Start at trp->tp.
  * The value strings are copied as well.  The first token
  * has WS available.
  */
 Tokenrow *
 normtokenrow(Tokenrow *trp)
 {
 	Token *tp;
 	Tokenrow *ntrp = new(Tokenrow);
 	int len;
 
 	len = trp->lp - trp->tp;
 	if (len<=0)
 		len = 1;
 	maketokenrow(len, ntrp);
 	for (tp=trp->tp; tp < trp->lp; tp++) {
 		*ntrp->lp = *tp;
 		if (tp->len) {
 			ntrp->lp->t = newstring(tp->t, tp->len, 1);
 			*ntrp->lp->t++ = ' ';
 			if (tp->wslen)
 				ntrp->lp->wslen = 1;
 		}
 		ntrp->lp++;
 	}
 	if (ntrp->lp > ntrp->bp)
 		ntrp->bp->wslen = 0;
 	return ntrp;
 }
 
 /*
  * Debugging
  */
 void
 peektokens(Tokenrow *trp, char *str)
 {
 	Token *tp;
 
 	tp = trp->tp;
 	flushout();
 	if (str)
 		fprintf(stderr, "%s ", str);
 	if (tp<trp->bp || tp>trp->lp)
 		fprintf(stderr, "(tp offset %d) ", tp-trp->bp);
 	for (tp=trp->bp; tp<trp->lp && tp<trp->bp+32; tp++) {
 		if (tp->type!=NL) {
 			int c = tp->t[tp->len];
 			tp->t[tp->len] = 0;
 			fprintf(stderr, "%s", tp->t);
 			tp->t[tp->len] = c;
 		}
 		if (tp->type==NAME) {
 			fprintf(stderr, tp==trp->tp?"{*":"{");
 			prhideset(tp->hideset);
 			fprintf(stderr, "} ");
 		} else
 			fprintf(stderr, tp==trp->tp?"{%x*} ":"{%x} ", tp->type);
 	}
 	fprintf(stderr, "\n");
 	fflush(stderr);
 }
 
 void
 puttokens(Tokenrow *trp)
 {
 	Token *tp;
 	int len;
 	uchar *p;
 
 	if (verbose)
 		peektokens(trp, "");
 	tp = trp->bp;
 	for (; tp<trp->lp; tp++) {
 		len = tp->len+tp->wslen;
 		p = tp->t-tp->wslen;
 		while (tp<trp->lp-1 && p+len == (tp+1)->t - (tp+1)->wslen) {
 			tp++;
 			len += tp->wslen+tp->len;
 		}
 		if (len>OBS/2) {		/* handle giant token */
 			if (wbp > wbuf)
 				write(1, wbuf, wbp-wbuf);
 			write(1, (char *)p, len);
 			wbp = wbuf;
 		} else {	
 			memcpy(wbp, p, len);
 			wbp += len;
 		}
 		if (wbp >= &wbuf[OBS]) {
 			write(1, wbuf, OBS);
 			if (wbp > &wbuf[OBS])
 				memcpy(wbuf, wbuf+OBS, wbp - &wbuf[OBS]);
 			wbp -= OBS;
 		}
 	}
 	trp->tp = tp;
 	if (cursource->fd==0)
 		flushout();
 }
 
 void
 flushout(void)
 {
 	if (wbp>wbuf) {
 		write(1, wbuf, wbp-wbuf);
 		wbp = wbuf;
 	}
 }
 
 /*
  * turn a row into just a newline
  */
 void
 setempty(Tokenrow *trp)
 {
 	trp->tp = trp->bp;
 	trp->lp = trp->bp+1;
 	*trp->bp = nltoken;
 }
 
 /*
  * generate a number
  */
 char *
 outnum(char *p, int n)
 {
 	if (n>=10)
 		p = outnum(p, n/10);
 	*p++ = n%10 + '0';
 	return p;
 }
 
 /*
  * allocate and initialize a new string from s, of length l, at offset o
  * Null terminated.
  */
 uchar *
 newstring(uchar *s, int l, int o)
 {
 	uchar *ns = (uchar *)domalloc(l+o+1);
 
 	ns[l+o] = '\0';
 	return (uchar*)strncpy((char*)ns+o, (char*)s, l) - o;
 }