1da2e3ebdSchin /*********************************************************************** 2da2e3ebdSchin * * 3da2e3ebdSchin * This software is part of the ast package * 4*34f9b3eeSRoland Mainz * Copyright (c) 1986-2009 AT&T Intellectual Property * 5da2e3ebdSchin * and is licensed under the * 6da2e3ebdSchin * Common Public License, Version 1.0 * 77c2fbfb3SApril Chin * by AT&T Intellectual Property * 8da2e3ebdSchin * * 9da2e3ebdSchin * A copy of the License is available at * 10da2e3ebdSchin * http://www.opensource.org/licenses/cpl1.0.txt * 11da2e3ebdSchin * (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) * 12da2e3ebdSchin * * 13da2e3ebdSchin * Information and Software Systems Research * 14da2e3ebdSchin * AT&T Research * 15da2e3ebdSchin * Florham Park NJ * 16da2e3ebdSchin * * 17da2e3ebdSchin * Glenn Fowler <gsf@research.att.com> * 18da2e3ebdSchin * * 19da2e3ebdSchin ***********************************************************************/ 20da2e3ebdSchin #pragma prototyped 21da2e3ebdSchin /* 22da2e3ebdSchin * Glenn Fowler 23da2e3ebdSchin * AT&T Research 24da2e3ebdSchin * 25da2e3ebdSchin * preprocessor library private definitions 26da2e3ebdSchin */ 27da2e3ebdSchin 28da2e3ebdSchin #ifndef _PPLIB_H 29da2e3ebdSchin #define _PPLIB_H 30da2e3ebdSchin 31da2e3ebdSchin /* 32da2e3ebdSchin * the first definitions control optional code -- 0 disables 33da2e3ebdSchin */ 34da2e3ebdSchin 35da2e3ebdSchin #ifndef ARCHIVE 36da2e3ebdSchin #define ARCHIVE 1 /* -I can specify header archives */ 37da2e3ebdSchin #endif 38da2e3ebdSchin #ifndef CATSTRINGS 39da2e3ebdSchin #define CATSTRINGS 1 /* concatenate adjacent strings */ 40da2e3ebdSchin #endif 41da2e3ebdSchin #ifndef CHECKPOINT 42da2e3ebdSchin #define CHECKPOINT 1 /* checkpoint preprocessed files */ 43da2e3ebdSchin #endif 44da2e3ebdSchin #ifndef COMPATIBLE 45da2e3ebdSchin #define COMPATIBLE 1 /* enable COMPATIBILITY related code */ 46da2e3ebdSchin #endif 47da2e3ebdSchin #ifndef MACKEYARGS 48da2e3ebdSchin #define MACKEYARGS _BLD_DEBUG /* name=value macro formals and actuals */ 49da2e3ebdSchin #endif 50da2e3ebdSchin #ifndef POOL 51da2e3ebdSchin #define POOL 1 /* enable loop on input,output,error */ 52da2e3ebdSchin #endif 53da2e3ebdSchin #ifndef PROTOTYPE 54da2e3ebdSchin #define PROTOTYPE 1 /* enable ppproto code */ 55da2e3ebdSchin #endif 56da2e3ebdSchin 57da2e3ebdSchin #define TRUNCLENGTH 8 /* default TRUNCATE length */ 58da2e3ebdSchin 59da2e3ebdSchin #if _BLD_DEBUG 60da2e3ebdSchin #undef DEBUG 61da2e3ebdSchin #define DEBUG (TRACE_message|TRACE_count|TRACE_debug) 62da2e3ebdSchin #else 63da2e3ebdSchin #ifndef DEBUG 64da2e3ebdSchin #define DEBUG (TRACE_message) 65da2e3ebdSchin #endif 66da2e3ebdSchin #endif 67da2e3ebdSchin 68da2e3ebdSchin /* 69da2e3ebdSchin * the lower tests are transient 70da2e3ebdSchin */ 71da2e3ebdSchin 72da2e3ebdSchin #define TEST_count (1L<<24) 73da2e3ebdSchin #define TEST_hashcount (1L<<25) 74da2e3ebdSchin #define TEST_hashdump (1L<<26) 75da2e3ebdSchin #define TEST_hit (1L<<27) 76da2e3ebdSchin #define TEST_noinit (1L<<28) 77da2e3ebdSchin #define TEST_nonoise (1L<<29) 78da2e3ebdSchin #define TEST_noproto (1L<<30) 79da2e3ebdSchin 80da2e3ebdSchin #define TEST_INVERT (1L<<31) 81da2e3ebdSchin 82da2e3ebdSchin #define PROTO_CLASSIC (1<<0) /* classic to prototyped */ 83da2e3ebdSchin #define PROTO_DISABLE (1<<1) /* disable conversion */ 84da2e3ebdSchin #define PROTO_EXTERNALIZE (1<<2) /* static fun() => extern fun() */ 85da2e3ebdSchin #define PROTO_FORCE (1<<3) /* force even if no magic */ 86da2e3ebdSchin #define PROTO_HEADER (1<<4) /* header defines too */ 87da2e3ebdSchin #define PROTO_INCLUDE (1<<5) /* <prototyped.h> instead */ 88da2e3ebdSchin #define PROTO_INITIALIZED (1<<6) /* internal initialization */ 89da2e3ebdSchin #define PROTO_LINESYNC (1<<7) /* force standalone line syncs */ 90da2e3ebdSchin #define PROTO_NOPRAGMA (1<<8) /* delete pragma prototyped */ 91da2e3ebdSchin #define PROTO_PASS (1<<9) /* pass blocks if no magic */ 92da2e3ebdSchin #define PROTO_PLUSPLUS (1<<10) /* extern () -> extern (...) */ 93da2e3ebdSchin #define PROTO_RETAIN (1<<11) /* defines retained after close */ 94da2e3ebdSchin #define PROTO_TEST (1<<12) /* enable test code */ 95da2e3ebdSchin 96da2e3ebdSchin #define PROTO_USER (1<<13) /* first user flag */ 97da2e3ebdSchin 98da2e3ebdSchin #define SEARCH_EXISTS 0 /* ppsearch for existence */ 99da2e3ebdSchin #define SEARCH_HOSTED (1<<0) /* search hosted dirs only */ 100da2e3ebdSchin #define SEARCH_IGNORE (1<<1) /* ignore if not found */ 101da2e3ebdSchin #define SEARCH_INCLUDE (1<<2) /* ppsearch for include */ 102da2e3ebdSchin #define SEARCH_VENDOR (1<<3) /* search vendor dirs only */ 103da2e3ebdSchin #define SEARCH_USER (1<<4) /* first user flag */ 104da2e3ebdSchin 105da2e3ebdSchin #define STYLE_gnu (1<<0) /* gnu style args */ 106da2e3ebdSchin 107da2e3ebdSchin #define IN_c (1<<0) /* C language file */ 108da2e3ebdSchin #define IN_defguard (1<<1) /* did multiple include check */ 109da2e3ebdSchin #define IN_disable (1<<2) /* saved state&DISABLE */ 110da2e3ebdSchin #define IN_endguard (1<<3) /* did multiple include check */ 111da2e3ebdSchin #define IN_eof (1<<4) /* reached EOF */ 112da2e3ebdSchin #define IN_expand (1<<5) /* ppexpand buffer */ 113da2e3ebdSchin #define IN_flush (1<<6) /* flush stdout on file_refill()*/ 114da2e3ebdSchin #define IN_hosted (1<<7) /* saved mode&HOSTED */ 115da2e3ebdSchin #define IN_ignoreline (1<<8) /* ignore #line until file */ 116da2e3ebdSchin #define IN_newline (1<<9) /* newline at end of last fill */ 117da2e3ebdSchin #define IN_noguard (1<<10) /* no multiple include guard */ 118da2e3ebdSchin #define IN_prototype (1<<11) /* ppproto() input */ 119da2e3ebdSchin #define IN_regular (1<<12) /* regular input file */ 120da2e3ebdSchin #define IN_static (1<<13) /* static buffer - don't free */ 121da2e3ebdSchin #define IN_sync (1<<14) /* line sync required on pop */ 122da2e3ebdSchin #define IN_tokens (1L<<15)/* non-space tokens encountered */ 123da2e3ebdSchin 124da2e3ebdSchin #define OPT_GLOBAL (1<<0) /* pp: pass optional */ 125da2e3ebdSchin #define OPT_PASS (1<<1) /* pass on */ 126da2e3ebdSchin 127da2e3ebdSchin struct ppsymbol; 128da2e3ebdSchin struct ppindex; 129da2e3ebdSchin 130da2e3ebdSchin typedef char* (*PPBUILTIN)(char*, const char*, const char*); 131da2e3ebdSchin typedef void (*PPCOMMENT)(const char*, const char*, const char*, int); 132da2e3ebdSchin typedef void (*PPINCREF)(const char*, const char*, int, int); 133da2e3ebdSchin typedef void (*PPLINESYNC)(int, const char*); 134da2e3ebdSchin typedef void (*PPMACREF)(struct ppsymbol*, const char*, int, int, unsigned long); 135da2e3ebdSchin typedef int (*PPOPTARG)(int, int, const char*); 136da2e3ebdSchin typedef void (*PPPRAGMA)(const char*, const char*, const char*, const char*, int); 137da2e3ebdSchin 138da2e3ebdSchin struct ppinstk /* input stream stack frame */ 139da2e3ebdSchin { 140da2e3ebdSchin char* nextchr; /* next input char (first elt) */ 141da2e3ebdSchin struct ppinstk* next; /* next frame (for allocation) */ 142da2e3ebdSchin struct ppinstk* prev; /* previous frame */ 143da2e3ebdSchin long* control; /* control block level */ 144da2e3ebdSchin char* buffer; /* buffer base pointer */ 145da2e3ebdSchin char* file; /* saved file name */ 146da2e3ebdSchin char* prefix; /* directory prefix */ 147da2e3ebdSchin struct ppsymbol* symbol; /* macro info */ 148da2e3ebdSchin #if CHECKPOINT 149da2e3ebdSchin struct ppindex* index; /* checkpoint include index */ 150da2e3ebdSchin int buflen; /* buffer count */ 151da2e3ebdSchin #endif 152da2e3ebdSchin int line; /* saved line number */ 153da2e3ebdSchin int vendor; /* saved pp.vendor */ 154da2e3ebdSchin short fd; /* file descriptor */ 155da2e3ebdSchin short hide; /* hide index (from pp.hide) */ 156da2e3ebdSchin short flags; /* IN_[a-z]* flags */ 157da2e3ebdSchin char type; /* input type */ 158da2e3ebdSchin }; 159da2e3ebdSchin 160da2e3ebdSchin #if MACKEYARGS 161da2e3ebdSchin struct ppkeyarg /* pp macro keyword arg info */ 162da2e3ebdSchin { 163da2e3ebdSchin char* name; /* keyword arg name */ 164da2e3ebdSchin char* value; /* keyword arg value */ 165da2e3ebdSchin }; 166da2e3ebdSchin #endif 167da2e3ebdSchin 168da2e3ebdSchin struct pplist /* string list */ 169da2e3ebdSchin { 170da2e3ebdSchin char* value; /* string value */ 171da2e3ebdSchin struct pplist* next; /* next in list */ 172da2e3ebdSchin }; 173da2e3ebdSchin 174da2e3ebdSchin struct oplist /* queue op until PP_INIT */ 175da2e3ebdSchin { 176da2e3ebdSchin int op; /* PP_* op */ 177da2e3ebdSchin char* value; /* op value */ 178da2e3ebdSchin struct oplist* next; /* next op */ 179da2e3ebdSchin }; 180da2e3ebdSchin 181da2e3ebdSchin struct pphide /* hidden symbol info */ 182da2e3ebdSchin { 183da2e3ebdSchin struct ppmacro* macro; /* saved macro info */ 184da2e3ebdSchin unsigned long flags; /* saved symbol flags if macro */ 185da2e3ebdSchin int level; /* nesting level */ 186da2e3ebdSchin }; 187da2e3ebdSchin 188da2e3ebdSchin struct ppmacstk /* macro invocation stack frame */ 189da2e3ebdSchin { 190da2e3ebdSchin struct ppmacstk* next; /* next frame (for allocation) */ 191da2e3ebdSchin struct ppmacstk* prev; /* previous frame */ 192da2e3ebdSchin int line; /* line number of first arg */ 193da2e3ebdSchin char* arg[1]; /* arg text pointers */ 194da2e3ebdSchin }; 195da2e3ebdSchin 196da2e3ebdSchin struct ppmember /* archive member pun on ppfile */ 197da2e3ebdSchin { 198da2e3ebdSchin struct ppdirs* archive; /* archive holding file */ 199da2e3ebdSchin unsigned long offset; /* data offset */ 200da2e3ebdSchin unsigned long size; /* data size */ 201da2e3ebdSchin }; 202da2e3ebdSchin 203da2e3ebdSchin struct counter /* monitoring counters */ 204da2e3ebdSchin { 205da2e3ebdSchin int candidate; /* macro candidates */ 206da2e3ebdSchin int function; /* function macros */ 207da2e3ebdSchin int macro; /* macro hits */ 208da2e3ebdSchin int pplex; /* pplex() calls */ 209da2e3ebdSchin int push; /* input stream pushes */ 210da2e3ebdSchin int terminal; /* terminal states */ 211da2e3ebdSchin int token; /* emitted tokens */ 212da2e3ebdSchin }; 213da2e3ebdSchin 214da2e3ebdSchin struct pptuple /* tuple macro */ 215da2e3ebdSchin { 216da2e3ebdSchin struct pptuple* nomatch; /* nomatch tuple */ 217da2e3ebdSchin struct pptuple* match; /* match tuple */ 218da2e3ebdSchin char token[1]; /* matching token */ 219da2e3ebdSchin }; 220da2e3ebdSchin 221da2e3ebdSchin struct ppfileid /* physical file id */ 222da2e3ebdSchin { 223da2e3ebdSchin unsigned long st_dev; /* dev */ 224da2e3ebdSchin unsigned long st_ino; /* ino */ 225da2e3ebdSchin }; 226da2e3ebdSchin 227da2e3ebdSchin struct pathid /* physical file name and id */ 228da2e3ebdSchin { 229da2e3ebdSchin char* path; /* file path */ 230da2e3ebdSchin struct ppfileid id; /* file id */ 231da2e3ebdSchin }; 232da2e3ebdSchin 233da2e3ebdSchin #define SAMEID(a,b) ((a)->st_ino==(unsigned long)(b)->st_ino&&(a)->st_dev==(unsigned long)(b)->st_dev) 234da2e3ebdSchin #define SAVEID(a,b) ((a)->st_ino=(unsigned long)(b)->st_ino,(a)->st_dev=(unsigned long)(b)->st_dev) 235da2e3ebdSchin 236da2e3ebdSchin #define _PP_CONTEXT_PRIVATE_ /* ppglobals private context */ \ 237da2e3ebdSchin struct ppcontext* context; /* current context */ \ 238da2e3ebdSchin long state; /* pp state flags */ \ 239da2e3ebdSchin long mode; /* uncoupled pp state flags */ \ 240da2e3ebdSchin long option; /* option flags */ \ 241da2e3ebdSchin long test; /* implementation tests */ \ 242da2e3ebdSchin struct \ 243da2e3ebdSchin { \ 244da2e3ebdSchin Sfio_t* sp; /* FILEDEPS output stream */ \ 245da2e3ebdSchin long flags; /* PP_FILEDEPS flags */ \ 246da2e3ebdSchin } filedeps; /* FILEDEPS info */ \ 247da2e3ebdSchin struct ppdirs* firstdir; /* first include dir */ \ 248da2e3ebdSchin struct ppdirs* lastdir; /* last include dir */ \ 249da2e3ebdSchin int hide; /* current include hide index */ \ 250da2e3ebdSchin int column; /* FILEDEPS column */ \ 251da2e3ebdSchin int pending; /* ppline() pending output */ \ 252da2e3ebdSchin char* firstfile; /* ppline() first file */ \ 253da2e3ebdSchin char* lastfile; /* ppline() most recent file */ \ 254da2e3ebdSchin char* ignore; /* include ignore list file */ \ 255da2e3ebdSchin char* probe; /* ppdefault probe key */ \ 256da2e3ebdSchin Hash_table_t* filtab; /* file name hash table */ \ 257da2e3ebdSchin Hash_table_t* prdtab; /* predicate hash table */ \ 258da2e3ebdSchin char* date; /* start date string */ \ 259da2e3ebdSchin char* time; /* start time string */ \ 260da2e3ebdSchin char* maps; /* directive maps */ \ 261da2e3ebdSchin long ro_state; /* readonly state */ \ 262da2e3ebdSchin long ro_mode; /* readonly mode */ \ 263da2e3ebdSchin long ro_option; /* readonly option */ \ 264da2e3ebdSchin struct pathid cdir; /* arg C dir */ \ 265da2e3ebdSchin struct pathid hostdir; /* arg host dir */ \ 266da2e3ebdSchin char* ppdefault; /* arg default info file */ \ 267da2e3ebdSchin struct ppindex* firstindex; /* first include index entry */ \ 268da2e3ebdSchin struct ppindex* lastindex; /* last include index entry */ \ 269da2e3ebdSchin struct oplist* firstop; /* first arg op */ \ 270da2e3ebdSchin struct oplist* lastop; /* last arg op */ \ 271da2e3ebdSchin struct oplist* firsttx; /* first text file */ \ 272da2e3ebdSchin struct oplist* lasttx; /* last text file */ \ 273da2e3ebdSchin unsigned char arg_file; /* arg file index */ \ 274da2e3ebdSchin unsigned char arg_mode; /* arg mode */ \ 275da2e3ebdSchin unsigned char arg_style; /* arg style */ \ 276da2e3ebdSchin unsigned char c; /* arg C state */ \ 277da2e3ebdSchin unsigned char hosted; /* arg hosted state */ \ 278da2e3ebdSchin unsigned char ignoresrc; /* arg ignore source state */ \ 279da2e3ebdSchin unsigned char initialized; /* arg initialized state */ \ 280da2e3ebdSchin unsigned char standalone; /* arg standalone state */ \ 281da2e3ebdSchin unsigned char spare_1; /* padding spare */ 282da2e3ebdSchin 283da2e3ebdSchin #define _PP_GLOBALS_PRIVATE_ /* ppglobals private additions */ \ 284da2e3ebdSchin char* checkpoint; /* checkpoint version */ \ 285da2e3ebdSchin int constack; /* pp.control size */ \ 286da2e3ebdSchin struct ppinstk* in; /* input stream stack pointer */ \ 287da2e3ebdSchin char* addp; /* addbuf pointer */ \ 288da2e3ebdSchin char* args; /* predicate args */ \ 289da2e3ebdSchin char* addbuf; /* ADD buffer */ \ 290da2e3ebdSchin char* catbuf; /* catenation buffer */ \ 291da2e3ebdSchin char* hdrbuf; /* HEADEREXPAND buffer */ \ 292da2e3ebdSchin char* hidebuf; /* pp:hide buffer */ \ 293da2e3ebdSchin char* path; /* full path of last #include */ \ 294da2e3ebdSchin char* tmpbuf; /* very temporary buffer */ \ 295da2e3ebdSchin char* valbuf; /* builtin macro value buffer */ \ 296da2e3ebdSchin char* optflags; /* OPT_* flags indexed by X_* */ \ 297da2e3ebdSchin int lastout; /* last output char */ \ 298da2e3ebdSchin /* the rest are implicitly initialized */ \ 299da2e3ebdSchin char* include; /* saved path of last #include */ \ 300da2e3ebdSchin char* prefix; /* current directory prefix */ \ 301da2e3ebdSchin struct ppmember* member; /* include archive member data */ \ 302da2e3ebdSchin int hidden; /* hidden newline count */ \ 303da2e3ebdSchin int hiding; /* number of symbols in hiding */ \ 304da2e3ebdSchin int level; /* pplex() recursion level */ \ 305da2e3ebdSchin struct \ 306da2e3ebdSchin { \ 307da2e3ebdSchin int input; /* pool input */ \ 308da2e3ebdSchin int output; /* pool output */ \ 309da2e3ebdSchin } pool; /* loop on input,output,error */ \ 310da2e3ebdSchin struct \ 311da2e3ebdSchin { \ 312da2e3ebdSchin long ro_state; /* original pp.ro_state */ \ 313da2e3ebdSchin long ro_mode; /* original pp.ro_mode */ \ 314da2e3ebdSchin long ro_option; /* original pp.ro_option */ \ 315da2e3ebdSchin int on; /* PP_RESET enabled */ \ 316da2e3ebdSchin Hash_table_t* symtab; /* original pp.symtab scope */ \ 317da2e3ebdSchin } reset; /* PP_RESET state */ \ 318da2e3ebdSchin int truncate; /* identifier truncation length */ \ 319da2e3ebdSchin struct ppmacstk* macp; /* top of macro actual stack */ \ 320da2e3ebdSchin char* maxmac; /* maximum size of macro stack */ \ 321da2e3ebdSchin char* mactop; /* top of current macro frame */ \ 322da2e3ebdSchin char* toknxt; /* '\0' of pp.token */ \ 323da2e3ebdSchin long* control; /* control block flags pointer */ \ 324da2e3ebdSchin long* maxcon; /* max control block frame */ \ 325da2e3ebdSchin struct oplist* chop; /* include prefix chop list */ \ 326da2e3ebdSchin struct ppfile* insert; /* inserted line sync file */ \ 327da2e3ebdSchin struct ppfile* original; /* original include name */ \ 328da2e3ebdSchin struct ppdirs* found; /* last successful ppsearch dir */ \ 329da2e3ebdSchin int vendor; /* vendor includes only */ \ 330da2e3ebdSchin Hash_table_t* dirtab; /* directive hash table */ \ 331da2e3ebdSchin Hash_table_t* strtab; /* string hash table */ \ 332da2e3ebdSchin PPBUILTIN builtin; /* builtin macro handler */ \ 333da2e3ebdSchin PPCOMMENT comment; /* pass along comments */ \ 334da2e3ebdSchin PPINCREF incref; /* include file push/return */ \ 335da2e3ebdSchin PPLINESYNC linesync; /* pass along line sync info */ \ 336da2e3ebdSchin PPLINESYNC olinesync; /* original linesync value */ \ 337da2e3ebdSchin PPMACREF macref; /* called on macro def/ref */ \ 338da2e3ebdSchin PPOPTARG optarg; /* unknown option arg handler */ \ 339da2e3ebdSchin PPPRAGMA pragma; /* pass along unknown pragmas */ \ 340da2e3ebdSchin struct counter counter; /* monitoring counters */ \ 341da2e3ebdSchin char funbuf[256]; /* last __FUNCTION__ */ 342da2e3ebdSchin 343da2e3ebdSchin #define _PP_SYMBOL_PRIVATE_ /* ppsymbol private additions */ \ 344da2e3ebdSchin struct pphide* hidden; /* hidden symbol info */ 345da2e3ebdSchin 346da2e3ebdSchin #if MACKEYARGS 347da2e3ebdSchin #define _PP_MACRO_PRIVATE_ /* ppmacro private additions */ \ 348da2e3ebdSchin struct pptuple* tuple; /* tuple macro */ \ 349da2e3ebdSchin union \ 350da2e3ebdSchin { \ 351da2e3ebdSchin char* formal; /* normal formals list */ \ 352da2e3ebdSchin struct ppkeyarg* key; /* keyword formals table */ \ 353da2e3ebdSchin } args; /* macro args info */ \ 354da2e3ebdSchin int size; /* body size */ 355da2e3ebdSchin #define formals args.formal /* formal argument list */ 356da2e3ebdSchin #define formkeys args.key /* formal keyword argument list */ 357da2e3ebdSchin #else 358da2e3ebdSchin #define _PP_MACRO_PRIVATE_ /* ppmacro private additions */ \ 359da2e3ebdSchin struct pptuple* tuple; /* tuple macro */ \ 360da2e3ebdSchin char* formals; /* formal argument list */ \ 361da2e3ebdSchin int size; /* body size */ 362da2e3ebdSchin #endif 363da2e3ebdSchin 364da2e3ebdSchin #define _PP_DIRS_PRIVATE_ /* ppdirs private additions */ \ 365da2e3ebdSchin unsigned char c; /* files here are C language */ \ 366da2e3ebdSchin unsigned char index; /* prefix,local,standard index */ \ 367da2e3ebdSchin unsigned char type; /* dir type */ \ 368da2e3ebdSchin union \ 369da2e3ebdSchin { \ 370da2e3ebdSchin char* buffer; /* TYPE_BUFFER buffer */ \ 371da2e3ebdSchin Sfio_t* sp; /* archive stream */ \ 372da2e3ebdSchin struct ppdirs* subdir; /* subdir list */ \ 373da2e3ebdSchin } info; /* type info */ \ 374da2e3ebdSchin struct ppfileid id; /* directory id */ \ 375da2e3ebdSchin 376da2e3ebdSchin #if !PROTOMAIN 377da2e3ebdSchin #include <ast.h> 378da2e3ebdSchin #include <error.h> 379da2e3ebdSchin #endif 380da2e3ebdSchin 381da2e3ebdSchin #undef newof 382da2e3ebdSchin #define newof(p,t,n,x) ((p)?(t*)realloc((char*)(p),sizeof(t)*(n)+(x)):(t*)calloc(1,sizeof(t)*(n)+(x))) 383da2e3ebdSchin 384da2e3ebdSchin #include "pp.h" 385da2e3ebdSchin #include "ppdef.h" 386da2e3ebdSchin #include "ppkey.h" 387da2e3ebdSchin 388da2e3ebdSchin #undef setstate /* random clash! */ 389da2e3ebdSchin 390da2e3ebdSchin /* 391da2e3ebdSchin * DEBUG is encoded with the following bits 392da2e3ebdSchin */ 393da2e3ebdSchin 394da2e3ebdSchin #define TRACE_message 01 395da2e3ebdSchin #define TRACE_count 02 396da2e3ebdSchin #define TRACE_debug 04 397da2e3ebdSchin 398da2e3ebdSchin #if DEBUG && !lint 399da2e3ebdSchin #define PANIC (ERROR_PANIC|ERROR_SOURCE|ERROR_SYSTEM),__FILE__,__LINE__ 400da2e3ebdSchin #else 401da2e3ebdSchin #define PANIC ERROR_PANIC 402da2e3ebdSchin #endif 403da2e3ebdSchin 404da2e3ebdSchin #if DEBUG & TRACE_count 405da2e3ebdSchin #define count(x) pp.counter.x++ 406da2e3ebdSchin #else 407da2e3ebdSchin #define count(x) 408da2e3ebdSchin #endif 409da2e3ebdSchin 410da2e3ebdSchin #if DEBUG & TRACE_message 411da2e3ebdSchin #define message(x) do { if (tracing) error x; } while (0) 412da2e3ebdSchin #else 413da2e3ebdSchin #define message(x) 414da2e3ebdSchin #endif 415da2e3ebdSchin 416da2e3ebdSchin #if DEBUG & TRACE_debug 417da2e3ebdSchin #define debug(x) do { if (tracing) error x; } while (0) 418da2e3ebdSchin #else 419da2e3ebdSchin #define debug(x) 420da2e3ebdSchin #endif 421da2e3ebdSchin 422da2e3ebdSchin /* 423da2e3ebdSchin * note that MEMCPY advances the associated pointers 424da2e3ebdSchin */ 425da2e3ebdSchin 426da2e3ebdSchin #define MEMCPY(to,fr,n) \ 427da2e3ebdSchin do switch(n) \ 428da2e3ebdSchin { default : memcpy(to,fr,n); to += n; fr += n; break; \ 429da2e3ebdSchin case 7 : *to++ = *fr++; \ 430da2e3ebdSchin case 6 : *to++ = *fr++; \ 431da2e3ebdSchin case 5 : *to++ = *fr++; \ 432da2e3ebdSchin case 4 : *to++ = *fr++; \ 433da2e3ebdSchin case 3 : *to++ = *fr++; \ 434da2e3ebdSchin case 2 : *to++ = *fr++; \ 435da2e3ebdSchin case 1 : *to++ = *fr++; \ 436da2e3ebdSchin case 0 : break; \ 437da2e3ebdSchin } while (0) 438da2e3ebdSchin 439da2e3ebdSchin #define NEWDIRECTIVE (-1) 440da2e3ebdSchin 441da2e3ebdSchin #undef dirname 442da2e3ebdSchin #undef error 443da2e3ebdSchin 444da2e3ebdSchin #define dirname(x) ppkeyname(x,1) 445da2e3ebdSchin #define error pperror 446da2e3ebdSchin #define keyname(x) ppkeyname(x,0) 447da2e3ebdSchin #define nextframe(m,p) (m->next=m+(p-(char*)m+sizeof(struct ppmacstk)-1)/sizeof(struct ppmacstk)+1) 448da2e3ebdSchin #define popframe(m) (m=m->prev) 449da2e3ebdSchin #define pptokchr(c) pptokstr(NiL,(c)) 450da2e3ebdSchin #define pushcontrol() do { if (pp.control++ >= pp.maxcon) ppnest(); } while (0) 451da2e3ebdSchin #define pushframe(m) (m->next->prev=m,m=m->next) 452da2e3ebdSchin #define setmode(m,v) ((v)?(pp.mode|=(m)):(pp.mode&=~(m))) 453da2e3ebdSchin #define setoption(m,v) ((v)?(pp.option|=(m)):(pp.option&=~(m))) 454da2e3ebdSchin #define setstate(s,v) ((v)?(pp.state|=(s)):(pp.state&=~(s))) 455da2e3ebdSchin #define tracing (error_info.trace<0) 456da2e3ebdSchin 457da2e3ebdSchin #define ppgetfile(x) ((struct ppfile*)hashlook(pp.filtab,x,HASH_LOOKUP,NiL)) 458da2e3ebdSchin #define ppsetfile(x) ((struct ppfile*)hashlook(pp.filtab,x,HASH_CREATE|HASH_SIZE(sizeof(struct ppfile)),NiL)) 459da2e3ebdSchin 460da2e3ebdSchin #define ppkeyget(t,n) (struct ppsymkey*)hashlook(t,n,HASH_LOOKUP,NiL) 461da2e3ebdSchin #define ppkeyref(t,n) (struct ppsymkey*)hashlook(t,n,HASH_LOOKUP|HASH_INTERNAL,NiL) 462da2e3ebdSchin #define ppkeyset(t,n) (struct ppsymkey*)hashlook(t,n,HASH_CREATE|HASH_SIZE(sizeof(struct ppsymkey)),NiL) 463da2e3ebdSchin 464da2e3ebdSchin #define MARK '@' /* internal mark */ 465da2e3ebdSchin #define ARGOFFSET '1' /* macro arg mark offset */ 466da2e3ebdSchin 467da2e3ebdSchin #define STRAPP(p,v,r) do{r=(v);while((*p++)=(*r++));}while(0) 468da2e3ebdSchin #define STRCOPY(p,v,r) do{r=(v);while((*p++)=(*r++));p--;}while(0) 469da2e3ebdSchin #define STRCOPY2(p,r) do{while((*p++)=(*r++));p--;}while(0) 470da2e3ebdSchin 471da2e3ebdSchin #define SETFILE(p,v) (p+=sfsprintf(p,16,"%c%c%lx%c",MARK,'F',(long)v,MARK)) 472da2e3ebdSchin #define SETLINE(p,v) (p+=sfsprintf(p,16,"%c%c%lx%c",MARK,'L',(long)v,MARK)) 473da2e3ebdSchin 474da2e3ebdSchin #define peekchr() (*pp.in->nextchr) 475da2e3ebdSchin #define ungetchr(c) (*--pp.in->nextchr=(c)) 476da2e3ebdSchin 477da2e3ebdSchin #define MAXID 255 /* maximum identifier size */ 478da2e3ebdSchin #define MAXTOKEN PPTOKSIZ /* maximum token size */ 479da2e3ebdSchin #define MAXFORMALS 64 /* maximum number macro formals */ 480da2e3ebdSchin #define MAXHIDDEN 8 /* ppline if hidden>=MAXHIDDEN */ 481da2e3ebdSchin #define DEFMACSTACK (MAXFORMALS*32*32)/* default macstack size */ 482da2e3ebdSchin 483da2e3ebdSchin #define FSM_COMPATIBILITY 1 /* compatibility mode */ 484da2e3ebdSchin #define FSM_IDADD 2 /* add to identifer set */ 485da2e3ebdSchin #define FSM_IDDEL 3 /* delete from identifer set */ 486da2e3ebdSchin #define FSM_INIT 4 /* initilize */ 487da2e3ebdSchin #define FSM_MACRO 5 /* add new macro */ 488da2e3ebdSchin #define FSM_OPSPACE 6 /* handle <binop><space>= */ 489da2e3ebdSchin #define FSM_PLUSPLUS 7 /* C++ lexical analysis */ 490da2e3ebdSchin #define FSM_QUOTADD 8 /* add to quote set */ 491da2e3ebdSchin #define FSM_QUOTDEL 9 /* delete from quote set */ 492da2e3ebdSchin 493da2e3ebdSchin #define IN_TOP 01 /* top level -- directives ok */ 494da2e3ebdSchin 495da2e3ebdSchin #define IN_BUFFER (2|IN_TOP) /* buffer of lines */ 496da2e3ebdSchin #define IN_COPY 2 /* macro arg (copied) */ 497da2e3ebdSchin #define IN_EXPAND 4 /* macro arg (expanded) */ 498da2e3ebdSchin #define IN_FILE (4|IN_TOP) /* file */ 499da2e3ebdSchin #define IN_INIT (6|IN_TOP) /* initialization IN_BUFFER */ 500da2e3ebdSchin #define IN_MACRO 8 /* macro text */ 501da2e3ebdSchin #define IN_MULTILINE (8|IN_TOP) /* multi-line macro text */ 502da2e3ebdSchin #define IN_QUOTE 10 /* "..." macro arg (copied) */ 503da2e3ebdSchin #define IN_RESCAN (10|IN_TOP) /* directive rescan buffer */ 504da2e3ebdSchin #define IN_SQUOTE 12 /* '...' macro arg (copied) */ 505da2e3ebdSchin #define IN_STRING 14 /* string */ 506da2e3ebdSchin 507da2e3ebdSchin #define INC_CLEAR ((struct ppsymbol*)0) 508da2e3ebdSchin #define INC_IGNORE ((struct ppsymbol*)pp.addbuf) 509da2e3ebdSchin #define INC_TEST ((struct ppsymbol*)pp.catbuf) 510da2e3ebdSchin 511da2e3ebdSchin #define INC_BOUND(n) (1<<(n)) 512da2e3ebdSchin #define INC_MEMBER(n) (1<<((n)+INC_MAX)) 513da2e3ebdSchin #define INC_PREFIX 0 514da2e3ebdSchin #define INC_LOCAL 1 515da2e3ebdSchin #define INC_STANDARD 2 516da2e3ebdSchin #define INC_VENDOR 3 517da2e3ebdSchin #define INC_MAX 4 518da2e3ebdSchin #define INC_SELF (1<<(2*INC_MAX+0)) 519da2e3ebdSchin #define INC_EXISTS (1<<(2*INC_MAX+1)) 520da2e3ebdSchin #define INC_LISTED (1<<(2*INC_MAX+2)) 521da2e3ebdSchin #define INC_MAPALL (1<<(2*INC_MAX+3)) 522da2e3ebdSchin #define INC_MAPHOSTED (1<<(2*INC_MAX+4)) 523da2e3ebdSchin #define INC_MAPNOHOSTED (1<<(2*INC_MAX+5)) 524da2e3ebdSchin #define INC_MAPNOLOCAL (1<<(2*INC_MAX+6)) 525da2e3ebdSchin #define INC_HOSTED (1<<(2*INC_MAX+7)) 526da2e3ebdSchin 527da2e3ebdSchin #define TYPE_ARCHIVE (1<<0) 528da2e3ebdSchin #define TYPE_BUFFER (1<<1) 529da2e3ebdSchin #define TYPE_CHECKPOINT (1<<2) 530da2e3ebdSchin #define TYPE_DIRECTORY (1<<3) 531da2e3ebdSchin #define TYPE_HOSTED (1<<4) 532da2e3ebdSchin #define TYPE_INCLUDE (1<<5) 533da2e3ebdSchin #define TYPE_VENDOR (1<<6) 534da2e3ebdSchin 535da2e3ebdSchin #define TOK_BUILTIN (1<<0) /* last token was #( */ 536da2e3ebdSchin #define TOK_FORMAL (1<<1) /* last token was arg formal id */ 537da2e3ebdSchin #define TOK_ID (1<<2) /* last token was identifier */ 538da2e3ebdSchin #define TOK_TOKCAT (1<<3) /* last token was ## */ 539da2e3ebdSchin 540da2e3ebdSchin #define HADELSE (1<<0) /* already had else part */ 541da2e3ebdSchin #define KEPT (1<<1) /* already kept part of block */ 542da2e3ebdSchin #define SKIP (1<<2) /* skip this block */ 543da2e3ebdSchin #define BLOCKBITS 3 /* block flag bits */ 544da2e3ebdSchin 545da2e3ebdSchin #define SETIFBLOCK(p) (*(p)=(*((p)-1)&SKIP)|((long)error_info.line<<BLOCKBITS)) 546da2e3ebdSchin #define GETIFLINE(p) ((*(p)>>BLOCKBITS)&((1L<<(sizeof(long)*CHAR_BIT-BLOCKBITS))-1)) 547da2e3ebdSchin 548da2e3ebdSchin #define PUSH(t,p) \ 549da2e3ebdSchin do \ 550da2e3ebdSchin { \ 551da2e3ebdSchin count(push); \ 552da2e3ebdSchin if (!pp.in->next) \ 553da2e3ebdSchin { \ 554da2e3ebdSchin pp.in->next = newof(0, struct ppinstk, 1, 0); \ 555da2e3ebdSchin pp.in->next->prev = pp.in; \ 556da2e3ebdSchin } \ 557da2e3ebdSchin p = pp.in = pp.in->next; \ 558da2e3ebdSchin p->type = t; \ 559da2e3ebdSchin p->flags = 0; \ 560da2e3ebdSchin } while (0) 561da2e3ebdSchin 562da2e3ebdSchin #define PUSH_BUFFER(f,p,n) \ 563da2e3ebdSchin pppush(IN_BUFFER,f,p,n) 564da2e3ebdSchin 565da2e3ebdSchin #define PUSH_COPY(p,n) \ 566da2e3ebdSchin do \ 567da2e3ebdSchin { \ 568da2e3ebdSchin register struct ppinstk* cur; \ 569da2e3ebdSchin PUSH(IN_COPY, cur); \ 570da2e3ebdSchin cur->line = error_info.line; \ 571da2e3ebdSchin error_info.line = n; \ 572da2e3ebdSchin cur->nextchr = p; \ 573da2e3ebdSchin cur->prev->symbol->flags &= ~SYM_DISABLED; \ 574da2e3ebdSchin debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ 575da2e3ebdSchin } while (0) 576da2e3ebdSchin 577da2e3ebdSchin #define PUSH_EXPAND(p,n) \ 578da2e3ebdSchin do \ 579da2e3ebdSchin { \ 580da2e3ebdSchin register struct ppinstk* cur; \ 581da2e3ebdSchin PUSH(IN_EXPAND, cur); \ 582da2e3ebdSchin cur->line = error_info.line; \ 583da2e3ebdSchin error_info.line = n; \ 584da2e3ebdSchin cur->prev->symbol->flags &= ~SYM_DISABLED; \ 585da2e3ebdSchin cur->buffer = cur->nextchr = ppexpand(p); \ 586da2e3ebdSchin if (!(cur->prev->symbol->flags & SYM_MULTILINE)) \ 587da2e3ebdSchin cur->prev->symbol->flags |= SYM_DISABLED; \ 588da2e3ebdSchin debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ 589da2e3ebdSchin } while (0) 590da2e3ebdSchin 591da2e3ebdSchin #define PUSH_FILE(f,d) \ 592da2e3ebdSchin pppush(IN_FILE,f,NiL,d) 593da2e3ebdSchin 594da2e3ebdSchin #define PUSH_INIT(f,p) \ 595da2e3ebdSchin pppush(IN_INIT,f,p,1) 596da2e3ebdSchin 597da2e3ebdSchin #define PUSH_MACRO(p) \ 598da2e3ebdSchin do \ 599da2e3ebdSchin { \ 600da2e3ebdSchin register struct ppinstk* cur; \ 601da2e3ebdSchin PUSH(IN_MACRO, cur); \ 602da2e3ebdSchin cur->symbol = p; \ 603da2e3ebdSchin cur->nextchr = p->macro->value; \ 604da2e3ebdSchin p->flags |= SYM_DISABLED; \ 605da2e3ebdSchin if (p->flags & SYM_FUNCTION) pushframe(pp.macp); \ 606da2e3ebdSchin pp.state &= ~NEWLINE; \ 607da2e3ebdSchin debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ 608da2e3ebdSchin } while (0) 609da2e3ebdSchin 610da2e3ebdSchin #define PUSH_TUPLE(p,v) \ 611da2e3ebdSchin do \ 612da2e3ebdSchin { \ 613da2e3ebdSchin register struct ppinstk* cur; \ 614da2e3ebdSchin PUSH(IN_MACRO, cur); \ 615da2e3ebdSchin cur->symbol = p; \ 616da2e3ebdSchin cur->nextchr = v; \ 617da2e3ebdSchin p->flags |= SYM_DISABLED; \ 618da2e3ebdSchin pp.state &= ~NEWLINE; \ 619da2e3ebdSchin debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ 620da2e3ebdSchin } while (0) 621da2e3ebdSchin 622da2e3ebdSchin #define PUSH_MULTILINE(p) \ 623da2e3ebdSchin do \ 624da2e3ebdSchin { \ 625da2e3ebdSchin register struct ppinstk* cur; \ 626da2e3ebdSchin register int n; \ 627da2e3ebdSchin PUSH(IN_MULTILINE, cur); \ 628da2e3ebdSchin cur->symbol = p; \ 629da2e3ebdSchin cur->flags |= IN_defguard|IN_endguard|IN_noguard; \ 630da2e3ebdSchin pushcontrol(); \ 631da2e3ebdSchin cur->control = pp.control; \ 632da2e3ebdSchin *pp.control = 0; \ 633da2e3ebdSchin cur->file = error_info.file; \ 634da2e3ebdSchin n = strlen(error_info.file) + strlen(((struct ppsymbol*)p)->name) + 24; \ 635da2e3ebdSchin error_info.file = cur->buffer = newof(0, char, n, 0); \ 636da2e3ebdSchin sfsprintf(error_info.file, n, "%s:%s,%d", cur->file, p->name, error_info.line); \ 637da2e3ebdSchin cur->line = error_info.line; \ 638da2e3ebdSchin error_info.line = 1; \ 639da2e3ebdSchin cur->nextchr = p->macro->value; \ 640da2e3ebdSchin if (p->flags & SYM_FUNCTION) pushframe(pp.macp); \ 641da2e3ebdSchin pp.state &= ~NEWLINE; \ 642da2e3ebdSchin debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ 643da2e3ebdSchin } while (0) 644da2e3ebdSchin 645da2e3ebdSchin #define PUSH_QUOTE(p,n) \ 646da2e3ebdSchin do \ 647da2e3ebdSchin { \ 648da2e3ebdSchin register struct ppinstk* cur; \ 649da2e3ebdSchin PUSH(IN_QUOTE, cur); \ 650da2e3ebdSchin cur->nextchr = p; \ 651da2e3ebdSchin pp.state |= QUOTE; \ 652da2e3ebdSchin cur->line = error_info.line; \ 653da2e3ebdSchin error_info.line = n; \ 654da2e3ebdSchin debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ 655da2e3ebdSchin } while (0) 656da2e3ebdSchin 657da2e3ebdSchin #define PUSH_RESCAN(p) \ 658da2e3ebdSchin pppush(IN_RESCAN,NiL,p,0) 659da2e3ebdSchin 660da2e3ebdSchin #define PUSH_SQUOTE(p,n) \ 661da2e3ebdSchin do \ 662da2e3ebdSchin { \ 663da2e3ebdSchin register struct ppinstk* cur; \ 664da2e3ebdSchin PUSH(IN_SQUOTE, cur); \ 665da2e3ebdSchin cur->nextchr = p; \ 666da2e3ebdSchin pp.state |= SQUOTE; \ 667da2e3ebdSchin cur->line = error_info.line; \ 668da2e3ebdSchin error_info.line = n; \ 669da2e3ebdSchin debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ 670da2e3ebdSchin } while (0) 671da2e3ebdSchin 672da2e3ebdSchin #define PUSH_STRING(p) \ 673da2e3ebdSchin do \ 674da2e3ebdSchin { \ 675da2e3ebdSchin register struct ppinstk* cur; \ 676da2e3ebdSchin PUSH(IN_STRING, cur); \ 677da2e3ebdSchin cur->nextchr = p; \ 678da2e3ebdSchin if (pp.state & DISABLE) cur->flags |= IN_disable; \ 679da2e3ebdSchin debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ 680da2e3ebdSchin } while (0) 681da2e3ebdSchin 682da2e3ebdSchin #define PUSH_LINE(p) \ 683da2e3ebdSchin do \ 684da2e3ebdSchin { \ 685da2e3ebdSchin register struct ppinstk* cur; \ 686da2e3ebdSchin PUSH(IN_STRING, cur); \ 687da2e3ebdSchin cur->nextchr = p; \ 688da2e3ebdSchin pp.state |= DISABLE|NOSPACE|PASSEOF|STRIP; \ 689da2e3ebdSchin debug((-7, "PUSH in=%s next=%s", ppinstr(pp.in), pptokchr(*pp.in->nextchr))); \ 690da2e3ebdSchin } while (0) 691da2e3ebdSchin 692da2e3ebdSchin #define POP_LINE() \ 693da2e3ebdSchin do \ 694da2e3ebdSchin { \ 695da2e3ebdSchin debug((-7, "POP in=%s", ppinstr(pp.in))); \ 696da2e3ebdSchin pp.in = pp.in->prev; \ 697da2e3ebdSchin pp.state &= ~(DISABLE|NOSPACE|PASSEOF|STRIP); \ 698da2e3ebdSchin } while (0) 699da2e3ebdSchin 700da2e3ebdSchin struct ppcontext /* pp context */ 701da2e3ebdSchin { 702da2e3ebdSchin _PP_CONTEXT_PUBLIC_ 703da2e3ebdSchin _PP_CONTEXT_PRIVATE_ 704da2e3ebdSchin }; 705da2e3ebdSchin 706da2e3ebdSchin struct ppfile /* include file info */ 707da2e3ebdSchin { 708da2e3ebdSchin HASH_HEADER; /* this is a hash bucket too */ 709da2e3ebdSchin struct ppsymbol* guard; /* guard symbol */ 710da2e3ebdSchin struct ppfile* bound[INC_MAX]; /* include bindings */ 711da2e3ebdSchin int flags; /* INC_* flags */ 712da2e3ebdSchin }; 713da2e3ebdSchin 714da2e3ebdSchin #if CHECKPOINT 715da2e3ebdSchin 716da2e3ebdSchin struct ppindex /* checkpoint include index */ 717da2e3ebdSchin { 718da2e3ebdSchin struct ppindex* next; /* next in list */ 719da2e3ebdSchin struct ppfile* file; /* include file */ 720da2e3ebdSchin unsigned long begin; /* beginning output offset */ 721da2e3ebdSchin unsigned long end; /* ending output offset */ 722da2e3ebdSchin }; 723da2e3ebdSchin 724da2e3ebdSchin #endif 725da2e3ebdSchin 726da2e3ebdSchin struct ppsymkey /* pun for SYM_KEYWORD lex val */ 727da2e3ebdSchin { 728da2e3ebdSchin struct ppsymbol sym; /* symbol as usual */ 729da2e3ebdSchin int lex; /* lex value for SYM_KEYWORD */ 730da2e3ebdSchin }; 731da2e3ebdSchin 732da2e3ebdSchin #if PROTOMAIN && PROTO_STANDALONE 733da2e3ebdSchin 734da2e3ebdSchin #if defined(__STDC__) || defined(__cplusplus) || defined(c_plusplus) 735da2e3ebdSchin #define NiL 0 736da2e3ebdSchin #define NoP(x) (&x,1) 737da2e3ebdSchin #else 738da2e3ebdSchin #define NiL ((char*)0) 739da2e3ebdSchin #define NoP(x) 740da2e3ebdSchin #endif 741da2e3ebdSchin 742da2e3ebdSchin #define newof(p,t,n,x) ((p)?(t*)realloc((char*)(p),sizeof(t)*(n)+(x)):(t*)calloc(1,sizeof(t)*(n)+(x))) 743da2e3ebdSchin 744da2e3ebdSchin #define _PP_DELAY_ # 745da2e3ebdSchin 746da2e3ebdSchin _PP_DELAY_ ifdef __STDC__ 747da2e3ebdSchin 748da2e3ebdSchin _PP_DELAY_ include <stdlib.h> 749da2e3ebdSchin _PP_DELAY_ include <unistd.h> 750da2e3ebdSchin _PP_DELAY_ include <time.h> 751da2e3ebdSchin _PP_DELAY_ include <string.h> 752da2e3ebdSchin 753da2e3ebdSchin _PP_DELAY_ else 754da2e3ebdSchin 755da2e3ebdSchin _PP_DELAY_ define size_t int 756da2e3ebdSchin 757da2e3ebdSchin extern void* realloc(void*, size_t); 758da2e3ebdSchin extern void* calloc(size_t, size_t); 759da2e3ebdSchin extern char* ctime(time_t*); 760da2e3ebdSchin extern void free(void*); 761da2e3ebdSchin 762da2e3ebdSchin _PP_DELAY_ ifndef O_RDONLY 763da2e3ebdSchin 764da2e3ebdSchin extern int access(const char*, int); 765da2e3ebdSchin extern int close(int); 766da2e3ebdSchin extern int creat(const char*, int); 767da2e3ebdSchin extern void exit(int); 768da2e3ebdSchin extern int link(const char*, const char*); 769da2e3ebdSchin extern int open(const char*, int, ...); 770da2e3ebdSchin extern int read(int, void*, int); 771da2e3ebdSchin extern time_t time(time_t*); 772da2e3ebdSchin extern int unlink(const char*); 773da2e3ebdSchin extern int write(int, const void*, int); 774da2e3ebdSchin 775da2e3ebdSchin _PP_DELAY_ endif 776da2e3ebdSchin 777da2e3ebdSchin _PP_DELAY_ endif 778da2e3ebdSchin 779da2e3ebdSchin #else 780da2e3ebdSchin 781da2e3ebdSchin /* 782da2e3ebdSchin * library implementation globals 783da2e3ebdSchin */ 784da2e3ebdSchin 785da2e3ebdSchin #define ppassert _pp_assert 786da2e3ebdSchin #define ppbuiltin _pp_builtin 787da2e3ebdSchin #define ppcall _pp_call 788da2e3ebdSchin #define ppcontrol _pp_control 789da2e3ebdSchin #define ppdump _pp_dump 790da2e3ebdSchin #define ppexpand _pp_expand 791da2e3ebdSchin #define ppexpr _pp_expr 792da2e3ebdSchin #define ppfsm _pp_fsm 793da2e3ebdSchin #define ppinmap _pp_inmap 794da2e3ebdSchin #define ppinstr _pp_instr 795da2e3ebdSchin #define ppkeyname _pp_keyname 796da2e3ebdSchin #define pplexmap _pp_lexmap 797da2e3ebdSchin #define pplexstr _pp_lexstr 798da2e3ebdSchin #define ppload _pp_load 799da2e3ebdSchin #define ppmodestr _pp_modestr 800da2e3ebdSchin #define ppmultiple _pp_multiple 801da2e3ebdSchin #define ppnest _pp_nest 802da2e3ebdSchin #define ppoption _pp_option 803da2e3ebdSchin #define ppoptionstr _pp_optionstr 804da2e3ebdSchin #define pppclose _pp_pclose 805da2e3ebdSchin #define pppdrop _pp_pdrop 806da2e3ebdSchin #define pppopen _pp_popen 807da2e3ebdSchin #define pppread _pp_pread 808da2e3ebdSchin #define pppredargs _pp_predargs 809da2e3ebdSchin #define pppush _pp_push 810da2e3ebdSchin #define pprefmac _pp_refmac 811da2e3ebdSchin #define ppsearch _pp_search 812da2e3ebdSchin #define ppstatestr _pp_statestr 813da2e3ebdSchin #define pptokstr _pp_tokstr 814da2e3ebdSchin #define pptrace _pp_trace 815da2e3ebdSchin 816da2e3ebdSchin #endif 817da2e3ebdSchin 818da2e3ebdSchin extern void ppassert(int, char*, char*); 819da2e3ebdSchin extern void ppbuiltin(void); 820da2e3ebdSchin extern int ppcall(struct ppsymbol*, int); 821da2e3ebdSchin extern int ppcontrol(void); 822da2e3ebdSchin extern void ppdump(void); 823da2e3ebdSchin extern char* ppexpand(char*); 824da2e3ebdSchin extern long ppexpr(int*); 825da2e3ebdSchin extern void ppfsm(int, char*); 826da2e3ebdSchin extern char* ppinstr(struct ppinstk*); 827da2e3ebdSchin extern char* ppkeyname(int, int); 828da2e3ebdSchin extern char* pplexstr(int); 829da2e3ebdSchin extern void ppload(char*); 830da2e3ebdSchin extern void ppmapinclude(char*, char*); 831da2e3ebdSchin extern char* ppmodestr(long); 832da2e3ebdSchin extern int ppmultiple(struct ppfile*, struct ppsymbol*); 833da2e3ebdSchin extern void ppnest(void); 834da2e3ebdSchin extern int ppoption(char*); 835da2e3ebdSchin extern char* ppoptionstr(long); 836da2e3ebdSchin extern void pppclose(char*); 837da2e3ebdSchin extern int pppdrop(char*); 838da2e3ebdSchin extern char* pppopen(char*, int, char*, char*, char*, char*, int); 839da2e3ebdSchin extern int pppread(char*); 840da2e3ebdSchin extern int pppredargs(void); 841da2e3ebdSchin extern void pppush(int, char*, char*, int); 842da2e3ebdSchin extern struct ppsymbol* pprefmac(char*, int); 843da2e3ebdSchin extern int ppsearch(char*, int, int); 844da2e3ebdSchin extern char* ppstatestr(long); 845da2e3ebdSchin extern char* pptokstr(char*, int); 846da2e3ebdSchin extern void pptrace(int); 847da2e3ebdSchin 848da2e3ebdSchin #if _std_malloc 849da2e3ebdSchin 850da2e3ebdSchin #include <vmalloc.h> 851da2e3ebdSchin 852da2e3ebdSchin #undef free 853da2e3ebdSchin #define free(p) vmfree(Vmregion,(void*)p) 854da2e3ebdSchin #undef newof 855da2e3ebdSchin #define newof(p,t,n,x) vmnewof(Vmregion,p,t,n,x) 856da2e3ebdSchin #undef oldof 857da2e3ebdSchin #define oldof(p,t,n,x) vmoldof(Vmregion,p,t,n,x) 858da2e3ebdSchin #undef strdup 859da2e3ebdSchin #define strdup(s) vmstrdup(Vmregion,s) 860da2e3ebdSchin 861da2e3ebdSchin #endif 862da2e3ebdSchin 863da2e3ebdSchin #endif 864