macro.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "cpp.h"

Include dependency graph for macro.c:

Go to the source code of this file.

Defines
#define	STRLEN   512
Functions
void	builtin (Tokenrow *trp, int biname)
void	doadefine (Tokenrow *trp, int type)
void	doconcat (Tokenrow *trp)
void	dodefine (Tokenrow *trp)
void	expand (Tokenrow *trp, Nlist *np)
void	expandrow (Tokenrow *trp, char *flag)
int	gatherargs (Tokenrow *trp, Tokenrow **atr, int *narg)
int	lookuparg (Nlist *mac, Token *tp)
Tokenrow *	stringify (Tokenrow *vp)
void	substargs (Nlist *np, Tokenrow *rtr, Tokenrow **atr)

---

Define Documentation

#define STRLEN   512

Definition at line 419 of file macro.c. Referenced by stringify().

---

Function Documentation

void builtin (  Tokenrow *  trp, int  biname )

Definition at line 457 of file macro.c. References curtime, ERROR, error(), source::fd, source::filename, KDATE, KFILE, KLINENO, KTIME, token::len, source::line, source::next, op, outnum(), outp, s, Source, src, strncpy(), token::t, Token, Tokenrow, tokenrow::tp, token::type, uchar, and token::wslen. Referenced by expandrow(), and PC_AddBuiltinDefines(). { char *op; Token *tp; Source *s; tp = trp->tp; trp->tp++; /* need to find the real source */ s = cursource; while (s && s->fd==-1) s = s->next; if (s==NULL) s = cursource; /* most are strings */ tp->type = STRING; if (tp->wslen) { *outp++ = ' '; tp->wslen = 1; } op = outp; *op++ = '"'; switch (biname) { case KLINENO: tp->type = NUMBER; op = outnum(op-1, s->line); break; case KFILE: { char *src = s->filename; while ((*op++ = *src++) != 0) if (src[-1] == '\\') *op++ = '\\'; op--; break; } case KDATE: strncpy(op, curtime+4, 7); strncpy(op+7, curtime+20, 4); op += 11; break; case KTIME: strncpy(op, curtime+11, 8); op += 8; break; default: error(ERROR, "cpp botch: unknown internal macro"); return; } if (tp->type==STRING) *op++ = '"'; tp->t = (uchar*)outp; tp->len = op - outp; outp = op; }

Here is the call graph for this function:

void doadefine (  Tokenrow *  trp, int  type )

Definition at line 92 of file macro.c. References tokenrow::bp, error(), FATAL, nlist::flag, lookup(), tokenrow::lp, Nlist, normtokenrow(), np, Token, Tokenrow, tokenrow::tp, token::type, type, uchar, and nlist::vp. Referenced by setup(). { Nlist *np; static Token onetoken[1] = {{ NUMBER, 0, 0, 0, 1, (uchar*)"1" }}; static Tokenrow onetr = { onetoken, onetoken, onetoken+1, 1 }; trp->tp = trp->bp; if (type=='U') { if (trp->lp-trp->tp != 2 || trp->tp->type!=NAME) goto syntax; if ((np = lookup(trp->tp, 0)) == NULL) return; np->flag &= ~ISDEFINED; return; } if (trp->tp >= trp->lp || trp->tp->type!=NAME) goto syntax; np = lookup(trp->tp, 1); np->flag |= ISDEFINED; trp->tp += 1; if (trp->tp >= trp->lp || trp->tp->type==END) { np->vp = &onetr; return; } if (trp->tp->type!=ASGN) goto syntax; trp->tp += 1; if ((trp->lp-1)->type == END) trp->lp -= 1; np->vp = normtokenrow(trp); return; syntax: error(FATAL, "Illegal -D or -U argument %r", trp); }

Here is the call graph for this function:

void doconcat (  Tokenrow *  trp  )

Definition at line 360 of file macro.c. References tokenrow::bp, dofree(), ERROR, error(), gettokens(), insertrow(), token::len, tokenrow::lp, makespace(), maketokenrow(), setsource(), strncpy(), token::t, Token, Tokenrow, tokenrow::tp, token::type, unsetsource(), and WARNING. Referenced by expand(). { Token *ltp, *ntp; Tokenrow ntr; int len; for (trp->tp=trp->bp; trp->tp<trp->lp; trp->tp++) { if (trp->tp->type==DSHARP1) trp->tp->type = DSHARP; else if (trp->tp->type==DSHARP) { char tt[128]; ltp = trp->tp-1; ntp = trp->tp+1; if (ltp<trp->bp || ntp>=trp->lp) { error(ERROR, "## occurs at border of replacement"); continue; } len = ltp->len + ntp->len; strncpy((char*)tt, (char*)ltp->t, ltp->len); strncpy((char*)tt+ltp->len, (char*)ntp->t, ntp->len); tt[len] = '\0'; setsource("<##>", -1, tt); maketokenrow(3, &ntr); gettokens(&ntr, 1); unsetsource(); if (ntr.lp-ntr.bp!=2 || ntr.bp->type==UNCLASS) error(WARNING, "Bad token %r produced by ##", &ntr); ntr.lp = ntr.bp+1; trp->tp = ltp; makespace(&ntr); insertrow(trp, (ntp-ltp)+1, &ntr); dofree(ntr.bp); trp->tp--; } } }

Here is the call graph for this function:

void dodefine (  Tokenrow *  trp  )

Definition at line 10 of file macro.c. References nlist::ap, tokenrow::bp, comparetokens(), dofree(), err(), ERROR, error(), nlist::flag, growtokenrow(), token::len, lookup(), LP, tokenrow::lp, maketokenrow(), tokenrow::max, Nlist, normtokenrow(), np, strncmp(), token::t, Token, Tokenrow, tokenrow::tp, token::type, nlist::vp, and token::wslen. Referenced by control(). { Token *tp; Nlist *np; Tokenrow *def, *args; tp = trp->tp+1; if (tp>=trp->lp || tp->type!=NAME) { error(ERROR, "#defined token is not a name"); return; } np = lookup(tp, 1); if (np->flag&ISUNCHANGE) { error(ERROR, "#defined token %t can't be redefined", tp); return; } /* collect arguments */ tp += 1; args = NULL; if (tp<trp->lp && tp->type==LP && tp->wslen==0) { /* macro with args */ int narg = 0; tp += 1; args = new(Tokenrow); maketokenrow(2, args); if (tp->type!=RP) { int err = 0; for (;;) { Token *atp; if (tp->type!=NAME) { err++; break; } if (narg>=args->max) growtokenrow(args); for (atp=args->bp; atp<args->lp; atp++) if (atp->len==tp->len && strncmp((char*)atp->t, (char*)tp->t, tp->len)==0) error(ERROR, "Duplicate macro argument"); *args->lp++ = *tp; narg++; tp += 1; if (tp->type==RP) break; if (tp->type!=COMMA) { err++; break; } tp += 1; } if (err) { error(ERROR, "Syntax error in macro parameters"); return; } } tp += 1; } trp->tp = tp; if (((trp->lp)-1)->type==NL) trp->lp -= 1; def = normtokenrow(trp); if (np->flag&ISDEFINED) { if (comparetokens(def, np->vp) || (np->ap==NULL) != (args==NULL) || np->ap && comparetokens(args, np->ap)) error(ERROR, "Macro redefinition of %t", trp->bp+2); } if (args) { Tokenrow *tap; tap = normtokenrow(args); dofree(args->bp); args = tap; } np->ap = args; np->vp = def; np->flag |= ISDEFINED; }

Here is the call graph for this function:

void expand (  Tokenrow *  trp, Nlist *  np )

Definition at line 178 of file macro.c. References nlist::ap, tokenrow::bp, copytokenrow(), doconcat(), dofree(), ERROR, error(), gatherargs(), token::hideset, i, insertrow(), tokenrow::lp, NARG, newhideset(), Nlist, np, rowlen, substargs(), Token, Tokenrow, tokenrow::tp, token::type, unionhideset(), and nlist::vp. Referenced by expandrow(), RemoveLinearMeshColumnsRows(), SubdivideMesh(), and SubdivideMeshQuads(). { Tokenrow ntr; int ntokc, narg, i; Token *tp; Tokenrow *atr[NARG+1]; int hs; copytokenrow(&ntr, np->vp); /* copy macro value */ if (np->ap==NULL) /* parameterless */ ntokc = 1; else { ntokc = gatherargs(trp, atr, &narg); if (narg<0) { /* not actually a call (no '(') */ trp->tp++; return; } if (narg != rowlen(np->ap)) { error(ERROR, "Disagreement in number of macro arguments"); trp->tp->hideset = newhideset(trp->tp->hideset, np); trp->tp += ntokc; return; } substargs(np, &ntr, atr); /* put args into replacement */ for (i=0; i<narg; i++) { dofree(atr[i]->bp); dofree(atr[i]); } } doconcat(&ntr); /* execute ## operators */ hs = newhideset(trp->tp->hideset, np); for (tp=ntr.bp; tp<ntr.lp; tp++) { /* distribute hidesets */ if (tp->type==NAME) { if (tp->hideset==0) tp->hideset = hs; else tp->hideset = unionhideset(tp->hideset, hs); } } ntr.tp = ntr.bp; insertrow(trp, ntokc, &ntr); trp->tp -= rowlen(&ntr); dofree(ntr.bp); return; }

Here is the call graph for this function:

void expandrow (  Tokenrow *  trp, char *  flag )

Definition at line 132 of file macro.c. References builtin(), checkhideset(), ERROR, error(), expand(), nlist::flag, token::hideset, ISDEFINED, token::len, lookup(), LP, tokenrow::lp, NAME, Nlist, np, NULL, quicklook, setsource(), token::t, Token, Tokenrow, tokenrow::tp, token::type, unsetsource(), and nlist::val. Referenced by control(), doinclude(), eval(), process(), and substargs(). { Token *tp; Nlist *np; if (flag) setsource(flag, -1, ""); for (tp = trp->tp; tp<trp->lp; ) { if (tp->type!=NAME || quicklook(tp->t[0], tp->len>1?tp->t[1]:0)==0 || (np = lookup(tp, 0))==NULL || (np->flag&(ISDEFINED|ISMAC))==0 || tp->hideset && checkhideset(tp->hideset, np)) { tp++; continue; } trp->tp = tp; if (np->val==KDEFINED) { tp->type = DEFINED; if ((tp+1)<trp->lp && (tp+1)->type==NAME) (tp+1)->type = NAME1; else if ((tp+3)<trp->lp && (tp+1)->type==LP && (tp+2)->type==NAME && (tp+3)->type==RP) (tp+2)->type = NAME1; else error(ERROR, "Incorrect syntax for `defined'"); tp++; continue; } if (np->flag&ISMAC) builtin(trp, np->val); else { expand(trp, np); } tp = trp->tp; } if (flag) unsetsource(); }

Here is the call graph for this function:

int gatherargs (  Tokenrow *  trp, Tokenrow **  atr, int *  narg )

Definition at line 230 of file macro.c. References adjustrow(), tokenrow::bp, COMMA, ERROR, error(), FATAL, gettokens(), tokenrow::lp, makespace(), NARG, normtokenrow(), Token, Tokenrow, tokenrow::tp, and token::type. Referenced by expand(). { int parens = 1; int ntok = 0; Token *bp, *lp; Tokenrow ttr; int ntokp; int needspace; *narg = -1; /* means that there is no macro call */ /* look for the ( */ for (;;) { trp->tp++; ntok++; if (trp->tp >= trp->lp) { gettokens(trp, 0); if ((trp->lp-1)->type==END) { trp->lp -= 1; trp->tp -= ntok; return ntok; } } if (trp->tp->type==LP) break; if (trp->tp->type!=NL) return ntok; } *narg = 0; ntok++; ntokp = ntok; trp->tp++; /* search for the terminating ), possibly extending the row */ needspace = 0; while (parens>0) { if (trp->tp >= trp->lp) gettokens(trp, 0); if (needspace) { needspace = 0; makespace(trp); } if (trp->tp->type==END) { trp->lp -= 1; trp->tp -= ntok; error(ERROR, "EOF in macro arglist"); return ntok; } if (trp->tp->type==NL) { trp->tp += 1; adjustrow(trp, -1); trp->tp -= 1; makespace(trp); needspace = 1; continue; } if (trp->tp->type==LP) parens++; else if (trp->tp->type==RP) parens--; trp->tp++; ntok++; } trp->tp -= ntok; /* Now trp->tp won't move underneath us */ lp = bp = trp->tp+ntokp; for (; parens>=0; lp++) { if (lp->type == LP) { parens++; continue; } if (lp->type==RP) parens--; if (lp->type==DSHARP) lp->type = DSHARP1; /* ## not special in arg */ if (lp->type==COMMA && parens==0 || parens<0 && (lp-1)->type!=LP) { if (*narg>=NARG-1) error(FATAL, "Sorry, too many macro arguments"); ttr.bp = ttr.tp = bp; ttr.lp = lp; atr[(*narg)++] = normtokenrow(&ttr); bp = lp+1; } } return ntok; }

Here is the call graph for this function:

int lookuparg (  Nlist *  mac, Token *  tp )

Definition at line 403 of file macro.c. References nlist::ap, tokenrow::bp, token::len, tokenrow::lp, NAME, Nlist, strncmp(), token::t, Token, and token::type. Referenced by substargs(). { Token *ap; if (tp->type!=NAME || mac->ap==NULL) return -1; for (ap=mac->ap->bp; ap<mac->ap->lp; ap++) { if (ap->len==tp->len && strncmp((char*)ap->t,(char*)tp->t,ap->len)==0) return ap - mac->ap->bp; } return -1; }

Here is the call graph for this function:

Tokenrow* stringify (  Tokenrow *  vp  )

Definition at line 421 of file macro.c. References cp, ERROR, error(), token::flag, i, token::len, newstring(), s, STRING, strlen(), STRLEN, token::t, t, Token, Tokenrow, tr, token::type, uchar, vp, and token::wslen. Referenced by substargs(). { static Token t = { STRING }; static Tokenrow tr = { &t, &t, &t+1, 1 }; Token *tp; uchar s[STRLEN]; uchar *sp = s, *cp; int i, instring; *sp++ = '"'; for (tp = vp->bp; tp < vp->lp; tp++) { instring = tp->type==STRING || tp->type==CCON; if (sp+2*tp->len >= &s[STRLEN-10]) { error(ERROR, "Stringified macro arg is too long"); break; } if (tp->wslen && (tp->flag&XPWS)==0) *sp++ = ' '; for (i=0, cp=tp->t; i<tp->len; i++) { if (instring && (*cp=='"' || *cp=='\\')) *sp++ = '\\'; *sp++ = *cp++; } } *sp++ = '"'; *sp = '\0'; sp = s; t.len = strlen((char*)sp); t.t = newstring(sp, t.len, 0); return &tr; }

Here is the call graph for this function:

void substargs (  Nlist *  np, Tokenrow *  rtr, Tokenrow **  atr )

Definition at line 320 of file macro.c. References tokenrow::bp, copytokenrow(), dofree(), DSHARP, ERROR, error(), expandrow(), insertrow(), lookuparg(), tokenrow::lp, NAME, Nlist, np, stringify(), Token, Tokenrow, tokenrow::tp, and token::type. Referenced by expand(). { Tokenrow tatr; Token *tp; int ntok, argno; for (rtr->tp=rtr->bp; rtr->tp<rtr->lp; ) { if (rtr->tp->type==SHARP) { /* string operator */ tp = rtr->tp; rtr->tp += 1; if ((argno = lookuparg(np, rtr->tp))<0) { error(ERROR, "# not followed by macro parameter"); continue; } ntok = 1 + (rtr->tp - tp); rtr->tp = tp; insertrow(rtr, ntok, stringify(atr[argno])); continue; } if (rtr->tp->type==NAME && (argno = lookuparg(np, rtr->tp)) >= 0) { if ((rtr->tp+1)->type==DSHARP || rtr->tp!=rtr->bp && (rtr->tp-1)->type==DSHARP) insertrow(rtr, 1, atr[argno]); else { copytokenrow(&tatr, atr[argno]); expandrow(&tatr, "<macro>"); insertrow(rtr, 1, &tatr); dofree(tatr.bp); } continue; } rtr->tp++; } }

Here is the call graph for this function:

---