diff options
Diffstat (limited to 'usr/src/lib/libpp/common/pplib.h')
| -rw-r--r-- | usr/src/lib/libpp/common/pplib.h | 863 |
1 files changed, 863 insertions, 0 deletions
diff --git a/usr/src/lib/libpp/common/pplib.h b/usr/src/lib/libpp/common/pplib.h new file mode 100644 index 0000000000..3428b4d55f --- /dev/null +++ b/usr/src/lib/libpp/common/pplib.h @@ -0,0 +1,863 @@ +/*********************************************************************** +* * +* This software is part of the ast package * +* Copyright (c) 1986-2007 AT&T Knowledge Ventures * +* and is licensed under the * +* Common Public License, Version 1.0 * +* by AT&T Knowledge Ventures * +* * +* A copy of the License is available at * +* http://www.opensource.org/licenses/cpl1.0.txt * +* (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) * +* * +* Information and Software Systems Research * +* AT&T Research * +* Florham Park NJ * +* * +* Glenn Fowler <gsf@research.att.com> * +* * +***********************************************************************/ +#pragma prototyped +/* + * Glenn Fowler + * AT&T Research + * + * preprocessor library private definitions + */ + +#ifndef _PPLIB_H +#define _PPLIB_H + +/* + * the first definitions control optional code -- 0 disables + */ + +#ifndef ARCHIVE +#define ARCHIVE 1 /* -I can specify header archives */ +#endif +#ifndef CATSTRINGS +#define CATSTRINGS 1 /* concatenate adjacent strings */ +#endif +#ifndef CHECKPOINT +#define CHECKPOINT 1 /* checkpoint preprocessed files */ +#endif +#ifndef COMPATIBLE +#define COMPATIBLE 1 /* enable COMPATIBILITY related code */ +#endif +#ifndef MACKEYARGS +#define MACKEYARGS _BLD_DEBUG /* name=value macro formals and actuals */ +#endif +#ifndef POOL +#define POOL 1 /* enable loop on input,output,error */ +#endif +#ifndef PROTOTYPE +#define PROTOTYPE 1 /* enable ppproto code */ +#endif + +#define TRUNCLENGTH 8 /* default TRUNCATE length */ + +#if _BLD_DEBUG +#undef DEBUG +#define DEBUG (TRACE_message|TRACE_count|TRACE_debug) +#else +#ifndef DEBUG +#define DEBUG (TRACE_message) +#endif +#endif + +/* + * the lower tests are transient + */ + +#define TEST_count (1L<<24) +#define TEST_hashcount (1L<<25) +#define TEST_hashdump (1L<<26) +#define TEST_hit (1L<<27) +#define TEST_noinit (1L<<28) +#define TEST_nonoise (1L<<29) +#define TEST_noproto (1L<<30) + +#define TEST_INVERT (1L<<31) + +#define PROTO_CLASSIC (1<<0) /* classic to prototyped */ +#define PROTO_DISABLE (1<<1) /* disable conversion */ +#define PROTO_EXTERNALIZE (1<<2) /* static fun() => extern fun() */ +#define PROTO_FORCE (1<<3) /* force even if no magic */ +#define PROTO_HEADER (1<<4) /* header defines too */ +#define PROTO_INCLUDE (1<<5) /* <prototyped.h> instead */ +#define PROTO_INITIALIZED (1<<6) /* internal initialization */ +#define PROTO_LINESYNC (1<<7) /* force standalone line syncs */ +#define PROTO_NOPRAGMA (1<<8) /* delete pragma prototyped */ +#define PROTO_PASS (1<<9) /* pass blocks if no magic */ +#define PROTO_PLUSPLUS (1<<10) /* extern () -> extern (...) */ +#define PROTO_RETAIN (1<<11) /* defines retained after close */ +#define PROTO_TEST (1<<12) /* enable test code */ + +#define PROTO_USER (1<<13) /* first user flag */ + +#define SEARCH_EXISTS 0 /* ppsearch for existence */ +#define SEARCH_HOSTED (1<<0) /* search hosted dirs only */ +#define SEARCH_IGNORE (1<<1) /* ignore if not found */ +#define SEARCH_INCLUDE (1<<2) /* ppsearch for include */ +#define SEARCH_VENDOR (1<<3) /* search vendor dirs only */ +#define SEARCH_USER (1<<4) /* first user flag */ + +#define STYLE_gnu (1<<0) /* gnu style args */ + +#define IN_c (1<<0) /* C language file */ +#define IN_defguard (1<<1) /* did multiple include check */ +#define IN_disable (1<<2) /* saved state&DISABLE */ +#define IN_endguard (1<<3) /* did multiple include check */ +#define IN_eof (1<<4) /* reached EOF */ +#define IN_expand (1<<5) /* ppexpand buffer */ +#define IN_flush (1<<6) /* flush stdout on file_refill()*/ +#define IN_hosted (1<<7) /* saved mode&HOSTED */ +#define IN_ignoreline (1<<8) /* ignore #line until file */ +#define IN_newline (1<<9) /* newline at end of last fill */ +#define IN_noguard (1<<10) /* no multiple include guard */ +#define IN_prototype (1<<11) /* ppproto() input */ +#define IN_regular (1<<12) /* regular input file */ +#define IN_static (1<<13) /* static buffer - don't free */ +#define IN_sync (1<<14) /* line sync required on pop */ +#define IN_tokens (1L<<15)/* non-space tokens encountered */ + +#define OPT_GLOBAL (1<<0) /* pp: pass optional */ +#define OPT_PASS (1<<1) /* pass on */ + +struct ppsymbol; +struct ppindex; + +typedef char* (*PPBUILTIN)(char*, const char*, const char*); +typedef void (*PPCOMMENT)(const char*, const char*, const char*, int); +typedef void (*PPINCREF)(const char*, const char*, int, int); +typedef void (*PPLINESYNC)(int, const char*); +typedef void (*PPMACREF)(struct ppsymbol*, const char*, int, int, unsigned long); +typedef int (*PPOPTARG)(int, int, const char*); +typedef void (*PPPRAGMA)(const char*, const char*, const char*, const char*, int); + +struct ppinstk /* input stream stack frame */ +{ + char* nextchr; /* next input char (first elt) */ + struct ppinstk* next; /* next frame (for allocation) */ + struct ppinstk* prev; /* previous frame */ + long* control; /* control block level */ + char* buffer; /* buffer base pointer */ + char* file; /* saved file name */ + char* prefix; /* directory prefix */ + struct ppsymbol* symbol; /* macro info */ +#if CHECKPOINT + struct ppindex* index; /* checkpoint include index */ + int buflen; /* buffer count */ +#endif + int line; /* saved line number */ + int vendor; /* saved pp.vendor */ + short fd; /* file descriptor */ + short hide; /* hide index (from pp.hide) */ + short flags; /* IN_[a-z]* flags */ + char type; /* input type */ +}; + +#if MACKEYARGS +struct ppkeyarg /* pp macro keyword arg info */ +{ + char* name; /* keyword arg name */ + char* value; /* keyword arg value */ +}; +#endif + +struct pplist /* string list */ +{ + char* value; /* string value */ + struct pplist* next; /* next in list */ +}; + +struct oplist /* queue op until PP_INIT */ +{ + int op; /* PP_* op */ + char* value; /* op value */ + struct oplist* next; /* next op */ +}; + +struct pphide /* hidden symbol info */ +{ + struct ppmacro* macro; /* saved macro info */ + unsigned long flags; /* saved symbol flags if macro */ + int level; /* nesting level */ +}; + +struct ppmacstk /* macro invocation stack frame */ +{ + struct ppmacstk* next; /* next frame (for allocation) */ + struct ppmacstk* prev; /* previous frame */ + int line; /* line number of first arg */ + char* arg[1]; /* arg text pointers */ +}; + +struct ppmember /* archive member pun on ppfile */ +{ + struct ppdirs* archive; /* archive holding file */ + unsigned long offset; /* data offset */ + unsigned long size; /* data size */ +}; + +struct counter /* monitoring counters */ +{ + int candidate; /* macro candidates */ + int function; /* function macros */ + int macro; /* macro hits */ + int pplex; /* pplex() calls */ + int push; /* input stream pushes */ + int terminal; /* terminal states */ + int token; /* emitted tokens */ +}; + +struct pptuple /* tuple macro */ +{ + struct pptuple* nomatch; /* nomatch tuple */ + struct pptuple* match; /* match tuple */ + char token[1]; /* matching token */ +}; + +struct ppfileid /* physical file id */ +{ + unsigned long st_dev; /* dev */ + unsigned long st_ino; /* ino */ +}; + +struct pathid /* physical file name and id */ +{ + char* path; /* file path */ + struct ppfileid id; /* file id */ +}; + +#define SAMEID(a,b) ((a)->st_ino==(unsigned long)(b)->st_ino&&(a)->st_dev==(unsigned long)(b)->st_dev) +#define SAVEID(a,b) ((a)->st_ino=(unsigned long)(b)->st_ino,(a)->st_dev=(unsigned long)(b)->st_dev) + +#define _PP_CONTEXT_PRIVATE_ /* ppglobals private context */ \ + struct ppcontext* context; /* current context */ \ + long state; /* pp state flags */ \ + long mode; /* uncoupled pp state flags */ \ + long option; /* option flags */ \ + long test; /* implementation tests */ \ + struct \ + { \ + Sfio_t* sp; /* FILEDEPS output stream */ \ + long flags; /* PP_FILEDEPS flags */ \ + } filedeps; /* FILEDEPS info */ \ + struct ppdirs* firstdir; /* first include dir */ \ + struct ppdirs* lastdir; /* last include dir */ \ + int hide; /* current include hide index */ \ + int column; /* FILEDEPS column */ \ + int pending; /* ppline() pending output */ \ + char* firstfile; /* ppline() first file */ \ + char* lastfile; /* ppline() most recent file */ \ + char* ignore; /* include ignore list file */ \ + char* probe; /* ppdefault probe key */ \ + Hash_table_t* filtab; /* file name hash table */ \ + Hash_table_t* prdtab; /* predicate hash table */ \ + char* date; /* start date string */ \ + char* time; /* start time string */ \ + char* maps; /* directive maps */ \ + long ro_state; /* readonly state */ \ + long ro_mode; /* readonly mode */ \ + long ro_option; /* readonly option */ \ + struct pathid cdir; /* arg C dir */ \ + struct pathid hostdir; /* arg host dir */ \ + char* ppdefault; /* arg default info file */ \ + struct ppindex* firstindex; /* first include index entry */ \ + struct ppindex* lastindex; /* last include index entry */ \ + struct oplist* firstop; /* first arg op */ \ + struct oplist* lastop; /* last arg op */ \ + struct oplist* firsttx; /* first text file */ \ + struct oplist* lasttx; /* last text file */ \ + unsigned char arg_file; /* arg file index */ \ + unsigned char arg_mode; /* arg mode */ \ + unsigned char arg_style; /* arg style */ \ + unsigned char c; /* arg C state */ \ + unsigned char hosted; /* arg hosted state */ \ + unsigned char ignoresrc; /* arg ignore source state */ \ + unsigned char initialized; /* arg initialized state */ \ + unsigned char standalone; /* arg standalone state */ \ + unsigned char spare_1; /* padding spare */ + +#define _PP_GLOBALS_PRIVATE_ /* ppglobals private additions */ \ + char* checkpoint; /* checkpoint version */ \ + int constack; /* pp.control size */ \ + struct ppinstk* in; /* input stream stack pointer */ \ + char* addp; /* addbuf pointer */ \ + char* args; /* predicate args */ \ + char* addbuf; /* ADD buffer */ \ + char* catbuf; /* catenation buffer */ \ + char* hdrbuf; /* HEADEREXPAND buffer */ \ + char* hidebuf; /* pp:hide buffer */ \ + char* path; /* full path of last #include */ \ + char* tmpbuf; /* very temporary buffer */ \ + char* valbuf; /* builtin macro value buffer */ \ + char* optflags; /* OPT_* flags indexed by X_* */ \ + int lastout; /* last output char */ \ + /* the rest are implicitly initialized */ \ + char* include; /* saved path of last #include */ \ + char* prefix; /* current directory prefix */ \ + struct ppmember* member; /* include archive member data */ \ + int hidden; /* hidden newline count */ \ + int hiding; /* number of symbols in hiding */ \ + int level; /* pplex() recursion level */ \ + struct \ + { \ + int input; /* pool input */ \ + int output; /* pool output */ \ + } pool; /* loop on input,output,error */ \ + struct \ + { \ + long ro_state; /* original pp.ro_state */ \ + long ro_mode; /* original pp.ro_mode */ \ + long ro_option; /* original pp.ro_option */ \ + int on; /* PP_RESET enabled */ \ + Hash_table_t* symtab; /* original pp.symtab scope */ \ + } reset; /* PP_RESET state */ \ + int truncate; /* identifier truncation length */ \ + struct ppmacstk* macp; /* top of macro actual stack */ \ + char* maxmac; /* maximum size of macro stack */ \ + char* mactop; /* top of current macro frame */ \ + char* toknxt; /* '\0' of pp.token */ \ + long* control; /* control block flags pointer */ \ + long* maxcon; /* max control block frame */ \ + struct oplist* chop; /* include prefix chop list */ \ + struct ppfile* insert; /* inserted line sync file */ \ + struct ppfile* original; /* original include name */ \ + struct ppdirs* found; /* last successful ppsearch dir */ \ + int vendor; /* vendor includes only */ \ + Hash_table_t* dirtab; /* directive hash table */ \ + Hash_table_t* strtab; /* string hash table */ \ + PPBUILTIN builtin; /* builtin macro handler */ \ + PPCOMMENT comment; /* pass along comments */ \ + PPINCREF incref; /* include file push/return */ \ + PPLINESYNC linesync; /* pass along line sync info */ \ + PPLINESYNC olinesync; /* original linesync value */ \ + PPMACREF macref; /* called on macro def/ref */ \ + PPOPTARG optarg; /* unknown option arg handler */ \ + PPPRAGMA pragma; /* pass along unknown pragmas */ \ + struct counter counter; /* monitoring counters */ \ + char funbuf[256]; /* last __FUNCTION__ */ + +#define _PP_SYMBOL_PRIVATE_ /* ppsymbol private additions */ \ + struct pphide* hidden; /* hidden symbol info */ + +#if MACKEYARGS +#define _PP_MACRO_PRIVATE_ /* ppmacro private additions */ \ + struct pptuple* tuple; /* tuple macro */ \ + union \ + { \ + char* formal; /* normal formals list */ \ + struct ppkeyarg* key; /* keyword formals table */ \ + } args; /* macro args info */ \ + int size; /* body size */ +#define formals args.formal /* formal argument list */ +#define formkeys args.key /* formal keyword argument list */ +#else +#define _PP_MACRO_PRIVATE_ /* ppmacro private additions */ \ + struct pptuple* tuple; /* tuple macro */ \ + char* formals; /* formal argument list */ \ + int size; /* body size */ +#endif + +#define _PP_DIRS_PRIVATE_ /* ppdirs private additions */ \ + unsigned char c; /* files here are C language */ \ + unsigned char index; /* prefix,local,standard index */ \ + unsigned char type; /* dir type */ \ + union \ + { \ + char* buffer; /* TYPE_BUFFER buffer */ \ + Sfio_t* sp; /* archive stream */ \ + struct ppdirs* subdir; /* subdir list */ \ + } info; /* type info */ \ + struct ppfileid id; /* directory id */ \ + +#if !PROTOMAIN +#include <ast.h> +#include <error.h> +#endif + +#undef newof +#define newof(p,t,n,x) ((p)?(t*)realloc((char*)(p),sizeof(t)*(n)+(x)):(t*)calloc(1,sizeof(t)*(n)+(x))) + +#include "pp.h" +#include "ppdef.h" +#include "ppkey.h" + +#undef setstate /* random clash! */ + +/* + * DEBUG is encoded with the following bits + */ + +#define TRACE_message 01 +#define TRACE_count 02 +#define TRACE_debug 04 + +#if DEBUG && !lint +#define PANIC (ERROR_PANIC|ERROR_SOURCE|ERROR_SYSTEM),__FILE__,__LINE__ +#else +#define PANIC ERROR_PANIC +#endif + +#if DEBUG & TRACE_count +#define count(x) pp.counter.x++ +#else +#define count(x) +#endif + +#if DEBUG & TRACE_message +#define message(x) do { if (tracing) error x; } while (0) +#else +#define message(x) +#endif + +#if DEBUG & TRACE_debug +#define debug(x) do { if (tracing) error x; } while (0) +#else +#define debug(x) +#endif + +/* + * note that MEMCPY advances the associated pointers + */ + +#define MEMCPY(to,fr,n) \ + do switch(n) \ + { default : memcpy(to,fr,n); to += n; fr += n; break; \ + case 7 : *to++ = *fr++; \ + case 6 : *to++ = *fr++; \ + case 5 : *to++ = *fr++; \ + case 4 : *to++ = *fr++; \ + case 3 : *to++ = *fr++; \ + case 2 : *to++ = *fr++; \ + case 1 : *to++ = *fr++; \ + case 0 : break; \ + } while (0) + +#define NEWDIRECTIVE (-1) + +#undef dirname +#undef error + +#define dirname(x) ppkeyname(x,1) +#define error pperror +#define keyname(x) ppkeyname(x,0) +#define nextframe(m,p) (m->next=m+(p-(char*)m+sizeof(struct ppmacstk)-1)/sizeof(struct ppmacstk)+1) +#define popframe(m) (m=m->prev) +#define pptokchr(c) pptokstr(NiL,(c)) +#define pushcontrol() do { if (pp.control++ >= pp.maxcon) ppnest(); } while (0) +#define pushframe(m) (m->next->prev=m,m=m->next) +#define setmode(m,v) ((v)?(pp.mode|=(m)):(pp.mode&=~(m))) +#define setoption(m,v) ((v)?(pp.option|=(m)):(pp.option&=~(m))) +#define setstate(s,v) ((v)?(pp.state|=(s)):(pp.state&=~(s))) +#define tracing (error_info.trace<0) + +#define ppgetfile(x) ((struct ppfile*)hashlook(pp.filtab,x,HASH_LOOKUP,NiL)) +#define ppsetfile(x) ((struct ppfile*)hashlook(pp.filtab,x,HASH_CREATE|HASH_SIZE(sizeof(struct ppfile)),NiL)) + +#define ppkeyget(t,n) (struct ppsymkey*)hashlook(t,n,HASH_LOOKUP,NiL) +#define ppkeyref(t,n) (struct ppsymkey*)hashlook(t,n,HASH_LOOKUP|HASH_INTERNAL,NiL) +#define ppkeyset(t,n) (struct ppsymkey*)hashlook(t,n,HASH_CREATE|HASH_SIZE(sizeof(struct ppsymkey)),NiL) + +#define MARK '@' /* internal mark */ +#define ARGOFFSET '1' /* macro arg mark offset */ + +#define STRAPP(p,v,r) do{r=(v);while((*p++)=(*r++));}while(0) +#define STRCOPY(p,v,r) do{r=(v);while((*p++)=(*r++));p--;}while(0) +#define STRCOPY2(p,r) do{while((*p++)=(*r++));p--;}while(0) + +#define SETFILE(p,v) (p+=sfsprintf(p,16,"%c%c%lx%c",MARK,'F',(long)v,MARK)) +#define SETLINE(p,v) (p+=sfsprintf(p,16,"%c%c%lx%c",MARK,'L',(long)v,MARK)) + +#define peekchr() (*pp.in->nextchr) +#define ungetchr(c) (*--pp.in->nextchr=(c)) + +#define MAXID 255 /* maximum identifier size */ +#define MAXTOKEN PPTOKSIZ /* maximum token size */ +#define MAXFORMALS 64 /* maximum number macro formals */ +#define MAXHIDDEN 8 /* ppline if hidden>=MAXHIDDEN */ +#define DEFMACSTACK (MAXFORMALS*32*32)/* default macstack size */ + +#define FSM_COMPATIBILITY 1 /* compatibility mode */ +#define FSM_IDADD 2 /* add to identifer set */ +#define FSM_IDDEL 3 /* delete from identifer set */ +#define FSM_INIT 4 /* initilize */ +#define FSM_MACRO 5 /* add new macro */ +#define FSM_OPSPACE 6 /* handle <binop><space>= */ +#define FSM_PLUSPLUS 7 /* C++ lexical analysis */ +#define FSM_QUOTADD 8 /* add to quote set */ +#define FSM_QUOTDEL 9 /* delete from quote set */ + +#define IN_TOP 01 /* top level -- directives ok */ + +#define IN_BUFFER (2|IN_TOP) /* buffer of lines */ +#define IN_COPY 2 /* macro arg (copied) */ +#define IN_EXPAND 4 /* macro arg (expanded) */ +#define IN_FILE (4|IN_TOP) /* file */ +#define IN_INIT (6|IN_TOP) /* initialization IN_BUFFER */ +#define IN_MACRO 8 /* macro text */ +#define IN_MULTILINE (8|IN_TOP) /* multi-line macro text */ +#define IN_QUOTE 10 /* "..." macro arg (copied) */ +#define IN_RESCAN (10|IN_TOP) /* directive rescan buffer */ +#define IN_SQUOTE 12 /* '...' macro arg (copied) */ +#define IN_STRING 14 /* string */ + +#define INC_CLEAR ((struct ppsymbol*)0) +#define INC_IGNORE ((struct ppsymbol*)pp.addbuf) +#define INC_TEST ((struct ppsymbol*)pp.catbuf) + +#define INC_BOUND(n) (1<<(n)) +#define INC_MEMBER(n) (1<<((n)+INC_MAX)) +#define INC_PREFIX 0 +#define INC_LOCAL 1 +#define INC_STANDARD 2 +#define INC_VENDOR 3 +#define INC_MAX 4 +#define INC_SELF (1<<(2*INC_MAX+0)) +#define INC_EXISTS (1<<(2*INC_MAX+1)) +#define INC_LISTED (1<<(2*INC_MAX+2)) +#define INC_MAPALL (1<<(2*INC_MAX+3)) +#define INC_MAPHOSTED (1<<(2*INC_MAX+4)) +#define INC_MAPNOHOSTED (1<<(2*INC_MAX+5)) +#define INC_MAPNOLOCAL (1<<(2*INC_MAX+6)) +#define INC_HOSTED (1<<(2*INC_MAX+7)) + +#define TYPE_ARCHIVE (1<<0) +#define TYPE_BUFFER (1<<1) +#define TYPE_CHECKPOINT (1<<2) +#define TYPE_DIRECTORY (1<<3) +#define TYPE_HOSTED (1<<4) +#define TYPE_INCLUDE (1<<5) +#define TYPE_VENDOR (1<<6) + +#define TOK_BUILTIN (1<<0) /* last token was #( */ +#define TOK_FORMAL (1<<1) /* last token was arg formal id */ +#define TOK_ID (1<<2) /* last token was identifier */ +#define TOK_TOKCAT (1<<3) /* last token was ## */ + +#define HADELSE (1<<0) /* already had else part */ +#define KEPT (1<<1) /* already kept part of block */ +#define SKIP (1<<2) /* skip this block */ +#define BLOCKBITS 3 /* block flag bits */ + +#define SETIFBLOCK(p) (*(p)=(*((p)-1)&SKIP)|((long)error_info.line<<BLOCKBITS)) +#define GETIFLINE(p) ((*(p)>>BLOCKBITS)&((1L<<(sizeof(long)*CHAR_BIT-BLOCKBITS))-1)) + +#define PUSH(t,p) \ + do \ + { \ + count(push); \ + if (!pp.in->next) \ + { \ + pp.in->next = newof(0, struct ppinstk, 1, 0); \ + pp.in->next->prev = pp.in; \ + } \ + p = pp.in = pp.in->next; \ + p->type = t; \ + p->flags = 0; \ + } while (0) + +#define PUSH_BUFFER(f,p,n) \ + pppush(IN_BUFFER,f,p,n) + +#define PUSH_COPY(p,n) \ + do \ + { \ + register struct ppinstk* cur; \ + PUSH(IN_COPY, cur); \ + cur->line = error_info.line; \ + error_info.line = n; \ + cur->nextchr = p; \ + cur->prev->symbol->flags &= ~SYM_DISABLED; \ + debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ + } while (0) + +#define PUSH_EXPAND(p,n) \ + do \ + { \ + register struct ppinstk* cur; \ + PUSH(IN_EXPAND, cur); \ + cur->line = error_info.line; \ + error_info.line = n; \ + cur->prev->symbol->flags &= ~SYM_DISABLED; \ + cur->buffer = cur->nextchr = ppexpand(p); \ + if (!(cur->prev->symbol->flags & SYM_MULTILINE)) \ + cur->prev->symbol->flags |= SYM_DISABLED; \ + debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ + } while (0) + +#define PUSH_FILE(f,d) \ + pppush(IN_FILE,f,NiL,d) + +#define PUSH_INIT(f,p) \ + pppush(IN_INIT,f,p,1) + +#define PUSH_MACRO(p) \ + do \ + { \ + register struct ppinstk* cur; \ + PUSH(IN_MACRO, cur); \ + cur->symbol = p; \ + cur->nextchr = p->macro->value; \ + p->flags |= SYM_DISABLED; \ + if (p->flags & SYM_FUNCTION) pushframe(pp.macp); \ + pp.state &= ~NEWLINE; \ + debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ + } while (0) + +#define PUSH_TUPLE(p,v) \ + do \ + { \ + register struct ppinstk* cur; \ + PUSH(IN_MACRO, cur); \ + cur->symbol = p; \ + cur->nextchr = v; \ + p->flags |= SYM_DISABLED; \ + pp.state &= ~NEWLINE; \ + debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ + } while (0) + +#define PUSH_MULTILINE(p) \ + do \ + { \ + register struct ppinstk* cur; \ + register int n; \ + PUSH(IN_MULTILINE, cur); \ + cur->symbol = p; \ + cur->flags |= IN_defguard|IN_endguard|IN_noguard; \ + pushcontrol(); \ + cur->control = pp.control; \ + *pp.control = 0; \ + cur->file = error_info.file; \ + n = strlen(error_info.file) + strlen(((struct ppsymbol*)p)->name) + 24; \ + error_info.file = cur->buffer = newof(0, char, n, 0); \ + sfsprintf(error_info.file, n, "%s:%s,%d", cur->file, p->name, error_info.line); \ + cur->line = error_info.line; \ + error_info.line = 1; \ + cur->nextchr = p->macro->value; \ + if (p->flags & SYM_FUNCTION) pushframe(pp.macp); \ + pp.state &= ~NEWLINE; \ + debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ + } while (0) + +#define PUSH_QUOTE(p,n) \ + do \ + { \ + register struct ppinstk* cur; \ + PUSH(IN_QUOTE, cur); \ + cur->nextchr = p; \ + pp.state |= QUOTE; \ + cur->line = error_info.line; \ + error_info.line = n; \ + debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ + } while (0) + +#define PUSH_RESCAN(p) \ + pppush(IN_RESCAN,NiL,p,0) + +#define PUSH_SQUOTE(p,n) \ + do \ + { \ + register struct ppinstk* cur; \ + PUSH(IN_SQUOTE, cur); \ + cur->nextchr = p; \ + pp.state |= SQUOTE; \ + cur->line = error_info.line; \ + error_info.line = n; \ + debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ + } while (0) + +#define PUSH_STRING(p) \ + do \ + { \ + register struct ppinstk* cur; \ + PUSH(IN_STRING, cur); \ + cur->nextchr = p; \ + if (pp.state & DISABLE) cur->flags |= IN_disable; \ + debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ + } while (0) + +#define PUSH_LINE(p) \ + do \ + { \ + register struct ppinstk* cur; \ + PUSH(IN_STRING, cur); \ + cur->nextchr = p; \ + pp.state |= DISABLE|NOSPACE|PASSEOF|STRIP; \ + debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ + } while (0) + +#define POP_LINE() \ + do \ + { \ + debug((-7, "POP in=%s", ppinstr(pp.in))); \ + pp.in = pp.in->prev; \ + pp.state &= ~(DISABLE|NOSPACE|PASSEOF|STRIP); \ + } while (0) + +struct ppcontext /* pp context */ +{ + _PP_CONTEXT_PUBLIC_ + _PP_CONTEXT_PRIVATE_ +}; + +struct ppfile /* include file info */ +{ + HASH_HEADER; /* this is a hash bucket too */ + struct ppsymbol* guard; /* guard symbol */ + struct ppfile* bound[INC_MAX]; /* include bindings */ + int flags; /* INC_* flags */ +}; + +#if CHECKPOINT + +struct ppindex /* checkpoint include index */ +{ + struct ppindex* next; /* next in list */ + struct ppfile* file; /* include file */ + unsigned long begin; /* beginning output offset */ + unsigned long end; /* ending output offset */ +}; + +#endif + +struct ppsymkey /* pun for SYM_KEYWORD lex val */ +{ + struct ppsymbol sym; /* symbol as usual */ + int lex; /* lex value for SYM_KEYWORD */ +}; + +#if PROTOMAIN && PROTO_STANDALONE + +#if defined(__STDC__) || defined(__cplusplus) || defined(c_plusplus) +#define NiL 0 +#define NoP(x) (&x,1) +#else +#define NiL ((char*)0) +#define NoP(x) +#endif + +#define newof(p,t,n,x) ((p)?(t*)realloc((char*)(p),sizeof(t)*(n)+(x)):(t*)calloc(1,sizeof(t)*(n)+(x))) + +#define _PP_DELAY_ # + +_PP_DELAY_ ifdef __STDC__ + +_PP_DELAY_ include <stdlib.h> +_PP_DELAY_ include <unistd.h> +_PP_DELAY_ include <time.h> +_PP_DELAY_ include <string.h> + +_PP_DELAY_ else + +_PP_DELAY_ define size_t int + +extern void* realloc(void*, size_t); +extern void* calloc(size_t, size_t); +extern char* ctime(time_t*); +extern void free(void*); + +_PP_DELAY_ ifndef O_RDONLY + +extern int access(const char*, int); +extern int close(int); +extern int creat(const char*, int); +extern void exit(int); +extern int link(const char*, const char*); +extern int open(const char*, int, ...); +extern int read(int, void*, int); +extern time_t time(time_t*); +extern int unlink(const char*); +extern int write(int, const void*, int); + +_PP_DELAY_ endif + +_PP_DELAY_ endif + +#else + +/* + * library implementation globals + */ + +#define ppassert _pp_assert +#define ppbuiltin _pp_builtin +#define ppcall _pp_call +#define ppcontrol _pp_control +#define ppdump _pp_dump +#define ppexpand _pp_expand +#define ppexpr _pp_expr +#define ppfsm _pp_fsm +#define ppinmap _pp_inmap +#define ppinstr _pp_instr +#define ppkeyname _pp_keyname +#define pplexmap _pp_lexmap +#define pplexstr _pp_lexstr +#define ppload _pp_load +#define ppmodestr _pp_modestr +#define ppmultiple _pp_multiple +#define ppnest _pp_nest +#define ppoption _pp_option +#define ppoptionstr _pp_optionstr +#define pppclose _pp_pclose +#define pppdrop _pp_pdrop +#define pppopen _pp_popen +#define pppread _pp_pread +#define pppredargs _pp_predargs +#define pppush _pp_push +#define pprefmac _pp_refmac +#define ppsearch _pp_search +#define ppstatestr _pp_statestr +#define pptokstr _pp_tokstr +#define pptrace _pp_trace + +#endif + +extern void ppassert(int, char*, char*); +extern void ppbuiltin(void); +extern int ppcall(struct ppsymbol*, int); +extern int ppcontrol(void); +extern void ppdump(void); +extern char* ppexpand(char*); +extern long ppexpr(int*); +extern void ppfsm(int, char*); +extern char* ppinstr(struct ppinstk*); +extern char* ppkeyname(int, int); +extern char* pplexstr(int); +extern void ppload(char*); +extern void ppmapinclude(char*, char*); +extern char* ppmodestr(long); +extern int ppmultiple(struct ppfile*, struct ppsymbol*); +extern void ppnest(void); +extern int ppoption(char*); +extern char* ppoptionstr(long); +extern void pppclose(char*); +extern int pppdrop(char*); +extern char* pppopen(char*, int, char*, char*, char*, char*, int); +extern int pppread(char*); +extern int pppredargs(void); +extern void pppush(int, char*, char*, int); +extern struct ppsymbol* pprefmac(char*, int); +extern int ppsearch(char*, int, int); +extern char* ppstatestr(long); +extern char* pptokstr(char*, int); +extern void pptrace(int); + +#if _std_malloc + +#include <vmalloc.h> + +#undef free +#define free(p) vmfree(Vmregion,(void*)p) +#undef newof +#define newof(p,t,n,x) vmnewof(Vmregion,p,t,n,x) +#undef oldof +#define oldof(p,t,n,x) vmoldof(Vmregion,p,t,n,x) +#undef strdup +#define strdup(s) vmstrdup(Vmregion,s) + +#endif + +#endif |