6437624 RFE: Add ksh93 (as /usr/bin/ksh93) and libshell.so to OS/Net

6505835 AST tools and library (libpp) required for creating l10n messages for ksh93
PSARC/2006/550 Korn Shell 93 Integration
PSARC/2006/587 /etc/ksh.kshrc for ksh93
PSARC/2007/035 ksh93 Amendments
Contributed by Roland Mainz <roland.mainz@nrubsig.org>

--HG--
rename : usr/src/lib/libcmd/common/mapfile-vers => deleted_files/usr/src/lib/libcmd/common/mapfile-vers
rename : usr/src/lib/libcmd/common/placeholder.c => deleted_files/usr/src/lib/libcmd/common/placeholder.c

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