OpenSolaris_b135/lib/libpp/common/ppproto.c
/***********************************************************************
* *
* This software is part of the ast package *
* Copyright (c) 1986-2009 AT&T Intellectual Property *
* and is licensed under the *
* Common Public License, Version 1.0 *
* by AT&T Intellectual Property *
* *
* 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
*
* convert C prototypes to ANSI, K&R and C++ styles or K&R to ANSI
* slips into the pp block read
*
* define PROTOMAIN for standalone proto
* PROTOMAIN is coded for minimal library support
*/
static const char id[] = "\n@(#)$Id: proto (AT&T Research) 2008-05-11 $\0\n";
#if PROTOMAIN
#include "ppfsm.c"
#include <hashkey.h>
#if PROTO_STANDALONE
#undef O_RDONLY
#endif
#else
#include "pplib.h"
#include "ppfsm.h"
#endif
#define MAGICGEN "/* : : generated by proto : : */\n"
#define MAGICDIR "pragma" /* proto magic directive */
#define MAGICARG "prototyped" /* proto magic directive arg */
#define MAGICOFF "noticed" /* no notice if found in pragma */
#define MAGICTOP 64 /* must be in these top lines */
#define NOTICED "Copyright" /* no notice if found in magic */
#define PUBLICDOMAIN "Public Domain" /* no notice if found in magic */
struct proto /* proto buffer state */
{
int brace; /* {..} level */
int call; /* call level */
int fd; /* input file descriptor */
char* file; /* input file name */
long flags; /* coupled flags */
long options; /* uncoupled flags */
char* package; /* header package */
int line; /* input line count */
int test; /* testing */
char* tp; /* input token base */
int iz; /* input buffer size */
char* ib; /* input buffer base */
char* ip; /* input buffer pointer */
int oz; /* output buffer size */
char* ob; /* output buffer base */
char* op; /* output buffer pointer */
char* ox; /* output buffer externalize */
char cc[3]; /* beg mid end comment char */
char pushback[4]; /* pushback area for caller */
char variadic[256]; /* variadic args buffer */
/* output buffer */
/* slide buffer */
/* input buffer */
};
/*
* proto is separate from pp so these undef's are ok
*/
#undef CLASSIC
#define CLASSIC (1L<<0)
#undef DECLARE
#define DECLARE (1L<<1)
#undef DEFINE
#define DEFINE (1L<<2)
#undef DIRECTIVE
#define DIRECTIVE (1L<<3)
#undef ERROR
#define ERROR (1L<<4)
#undef EXTERN
#define EXTERN (1L<<5)
#undef EXTERNALIZE
#define EXTERNALIZE (1L<<6)
#undef IDID
#define IDID (1L<<7)
#undef INDIRECT
#define INDIRECT (1L<<8)
#undef INIT
#define INIT (1L<<9)
#undef INIT_DEFINE
#define INIT_DEFINE (1L<<10)
#undef INIT_INCLUDE
#define INIT_INCLUDE (1L<<11)
#undef JUNK
#define JUNK (1L<<12)
#undef LINESYNC
#define LINESYNC (1L<<13)
#undef MANGLE
#define MANGLE (1L<<14)
#undef MATCH
#define MATCH (1L<<15)
#undef MORE
#define MORE (1L<<16)
#undef OTHER
#define OTHER (1L<<17)
#undef PASS
#define PASS (1L<<18)
#undef PLUSONLY
#define PLUSONLY (1L<<19)
#undef PLUSPLUS
#define PLUSPLUS (1L<<20)
#undef RECURSIVE
#define RECURSIVE (1L<<21)
#undef SHARP
#define SHARP (1L<<22)
#undef SKIP
#define SKIP (1L<<23)
#undef SLIDE
#define SLIDE (1L<<24)
#undef TOKENS
#define TOKENS (1L<<25)
#undef TYPEDEF
#define TYPEDEF (1L<<26)
#undef VARIADIC
#define VARIADIC (1L<<27)
#undef VARIADIC2
#define VARIADIC2 (1L<<28)
#undef YACC
#define YACC (1L<<29)
#undef YACCSPLIT
#define YACCSPLIT (1L<<30)
#undef YACC2
#define YACC2 (1L<<31)
#undef GLOBAL
#define GLOBAL (MORE)
#undef REGULAR
#define REGULAR (1L<<0)
#ifndef CHUNK
#define CHUNK 1024
#endif
#define BLOCK (8*CHUNK)
#define T_VA_START (N_TOKEN+1)
#define RESERVED(b,e,n) ((((long)(b))<<16)|(((long)(e))<<8)|((long)(n)))
/*
* generate integer
* pointer to end returned
*/
static char*
number(register char* p, register long n)
{
register long d;
for (d = 1000000; d > 1; d /= 10)
if (n >= d) *p++ = '0' + (n / d) % 10;
*p++ = '0' + n % 10;
return p;
}
#if PROTOMAIN
static int errors;
#if PROTO_STANDALONE
/*
* namespace pollution forces us to claim parts of libc
*/
#undef memcpy
#define memcpy(t,f,n) memcopy(t,f,n)
#undef strcpy
#define strcpy(t,f) strcopy(t,f)
#undef strlen
#define strlen(s) sstrlen(s)
#undef strncmp
#define strncmp(s,t,n) sstrncmp(s,t,n)
/*
* environmentally safe strlen()
*/
static int
sstrlen(register const char* s)
{
register const char* b;
for (b = s; *s; s++);
return s - b;
}
/*
* environmentally safe strncmp()
*/
static int
sstrncmp(register const char* s, register char* t, register int n)
{
register const char* e = s + n;
while (s < e)
{
if (*s != *t || !*s)
return *s - *t;
s++;
t++;
}
return 0;
}
/*
* strcpy() except pointer to end returned
*/
static char*
strcopy(register char* s, register const char* t)
{
while (*s++ = *t++);
return s - 1;
}
#endif
static void
proto_error(char* iob, int level, char* msg, char* arg)
{
register char* p;
char buf[1024];
p = strcopy(buf, "proto: ");
if (iob)
{
register struct proto* proto = (struct proto*)(iob - sizeof(struct proto));
if (proto->line)
{
if (proto->file)
{
*p++ = '"';
p = strcopy(p, proto->file);
*p++ = '"';
*p++ = ',';
*p++ = ' ';
}
p = strcopy(p, "line ");
p = number(p, proto->line);
}
else if (proto->file)
p = strcopy(p, proto->file);
}
else
{
p = strcopy(p, msg);
msg = arg;
arg = 0;
}
if (*(p - 1) != ' ')
{
*p++ = ':';
*p++ = ' ';
}
if (level == 1)
p = strcopy(p, "warning: ");
p = strcopy(p, msg);
if (arg)
{
*p++ = ' ';
p = strcopy(p, arg);
}
*p++ = '\n';
write(2, buf, p - buf);
if (level >= 3)
exit(level - 2);
if (level >= 2)
errors++;
}
/*
* memcpy() but pointer to end returned
*/
static char*
memcopy(register char* s, register char* t, int n)
{
register char* e = t + n;
while (t < e) *s++ = *t++;
return s;
}
#include "../libast/port/astlicense.c"
#else
#define memcopy(s,t,n) (((char*)memcpy(s,t,n))+(n))
#endif
/*
* generate line sync
* pointer to end returned
*/
static char*
linesync(register struct proto* proto, register char* p, register long n)
{
#if PROTOMAIN
if (proto->flags & LINESYNC)
#endif
{
#if PROTOMAIN
p = strcopy(p, "\n#line ");
#else
p = strcopy(p, "\n# ");
#endif
p = number(p, n);
*p++ = '\n';
}
return p;
}
/*
* output init header
* pointer to end returned
*/
static char*
init(struct proto* proto, char* op, int flags)
{
register char* s;
if (flags & INIT_DEFINE)
{
op = strcopy(op, "\
\n\
#if !defined(__PROTO__)\n\
# if defined(__STDC__) || defined(__cplusplus) || defined(_proto) || defined(c_plusplus)\n\
# if defined(__cplusplus)\n\
# define __LINKAGE__ \"C\"\n\
# else\n\
# define __LINKAGE__\n\
# endif\n\
# define __STDARG__\n\
# define __PROTO__(x) x\n\
# define __OTORP__(x)\n\
# define __PARAM__(n,o) n\n\
# if !defined(__STDC__) && !defined(__cplusplus)\n\
# if !defined(c_plusplus)\n\
# define const\n\
# endif\n\
# define signed\n\
# define void int\n\
# define volatile\n\
# define __V_ char\n\
# else\n\
# define __V_ void\n\
# endif\n\
# else\n\
# define __PROTO__(x) ()\n\
# define __OTORP__(x) x\n\
# define __PARAM__(n,o) o\n\
# define __LINKAGE__\n\
# define __V_ char\n\
# define const\n\
# define signed\n\
# define void int\n\
# define volatile\n\
# endif\n\
# define __MANGLE__ __LINKAGE__\n\
# if defined(__cplusplus) || defined(c_plusplus)\n\
# define __VARARG__ ...\n\
# else\n\
# define __VARARG__\n\
# endif\n\
# if defined(__STDARG__)\n\
# define __VA_START__(p,a) va_start(p,a)\n\
# else\n\
# define __VA_START__(p,a) va_start(p)\n\
# endif\n\
# if !defined(__INLINE__)\n\
# if defined(__cplusplus)\n\
# define __INLINE__ extern __MANGLE__ inline\n\
# else\n\
# if defined(_WIN32) && !defined(__GNUC__)\n\
# define __INLINE__ __inline\n\
# endif\n\
# endif\n\
# endif\n\
#endif\n\
#if !defined(__LINKAGE__)\n\
#define __LINKAGE__ /* 2004-08-11 transition */\n\
#endif\n\
");
}
else
op = strcopy(op, "\
\n\
#if !defined(__PROTO__)\n\
#include <prototyped.h>\n\
#endif\n\
#if !defined(__LINKAGE__)\n\
#define __LINKAGE__ /* 2004-08-11 transition */\n\
#endif\n\
");
if (proto->package)
{
s = "\
#ifndef __MANGLE_%_DATA__\n\
# ifdef _BLD_%\n\
# ifdef __EXPORT__\n\
# define __MANGLE_%_DATA__ __MANGLE__ __EXPORT__\n\
# else\n\
# define __MANGLE_%_DATA__ __MANGLE__\n\
# endif\n\
# define __MANGLE_%_FUNC__ __MANGLE__\n\
# else\n\
# ifdef __IMPORT__\n\
# define __MANGLE_%_DATA__ __MANGLE__ __IMPORT__\n\
# else\n\
# define __MANGLE_%_DATA__ __MANGLE__\n\
# endif\n\
# define __MANGLE_%_FUNC__ __MANGLE__\n\
# endif\n\
#endif\n\
";
for (;;)
{
switch (*op++ = *s++)
{
case 0:
op--;
break;
case '%':
op = strcopy(op - 1, proto->package);
continue;
default:
continue;
}
break;
}
}
return op;
}
#define BACKOUT() (op=ko)
#define CACHE() do{CACHEIN();CACHEOUT();call=proto->call;}while(0)
#define CACHEIN() (ip=proto->ip)
#define CACHEOUT() (op=proto->op)
#define GETCHR() (*(unsigned char*)ip++)
#define KEEPOUT() (ko=op)
#define LASTOUT() (*(op-1))
#define PUTCHR(c) (*op++=(c))
#define SYNC() do{SYNCIN();SYNCOUT();proto->flags&=~(EXTERN|INIT|OTHER|VARIADIC|VARIADIC2);proto->flags|=flags&(EXTERN|INIT|OTHER|VARIADIC|VARIADIC2);proto->call=call;}while(0)
#define SYNCIN() (proto->ip=ip)
#define SYNCOUT() (proto->op=op)
#define UNGETCHR() (ip--)
#define UNPUTCHR() (op--)
/*
* advance to the next non-space character
*/
static char*
nns(register char* s)
{
while (*s == ' ' || *s == '\t' || *s == '\n')
s++;
return s;
}
#define DIR_if 01
#define DIR_el 02
#define DIR_en 03
#define DIR 03
/*
* update directive mask
*/
static int
directive(register char* s, int dir)
{
switch (*(s = nns(s)))
{
case 'e':
case 'i':
dir <<= 2;
switch (*++s)
{
case 'f':
dir |= DIR_if;
break;
case 'l':
dir |= DIR_el;
break;
case 'n':
dir |= DIR_en;
break;
}
break;
}
return dir;
}
/*
* the tokenizer
* top level calls loop until EOB
* recursive calls just return the next token
*/
static int
lex(register struct proto* proto, register long flags)
{
register char* ip;
register char* op;
register int c;
register int state;
register short* rp;
char* m;
char* e;
char* t;
char* bp;
char* v;
char* im;
char* ko;
char* aom;
int n;
int line;
int quot;
int brack;
int sub;
int x;
int vc;
char* ie = 0;
char* om = 0;
char* aim = 0;
char* aie = 0;
char* func = 0;
int call = 0;
int dir = 0;
int group = 0;
int last = 0;
int paren = 0;
#if PROTOMAIN
char* qe = 0;
int qn = 0;
int args = 0;
#endif
CACHE();
#if PROTOMAIN
if (flags & EXTERN) KEEPOUT();
#endif
fsm_start:
proto->tp = ip;
state = PROTO;
bp = ip;
do
{
rp = fsm[state];
fsm_get:
while (!(state = rp[c = GETCHR()]));
fsm_next:
;
} while (state > 0);
if ((n = ip - bp - 1) > 0)
{
ip = bp;
MEMCPY(op, ip, n);
ip++;
}
state = ~state;
fsm_terminal:
switch (TERM(state))
{
case S_CHR:
if (op > proto->ob && *(op - 1) == '=' && (op == proto->ob + 1 || *(op - 2) != '=')) switch (c)
{
case '+':
case '-':
case '*':
case '&':
PUTCHR(' ');
break;
}
PUTCHR(c);
break;
case S_CHRB:
UNGETCHR();
c = LASTOUT();
break;
case S_COMMENT:
switch (c)
{
case '\n':
if (INCOMMENTXX(rp)) goto fsm_newline;
PUTCHR(c);
proto->line++;
rp = fsm[COM2];
break;
case '/':
#if PROTOMAIN
if ((flags & (EXTERN|MATCH)) == EXTERN) BACKOUT();
else
#endif
PUTCHR(c);
if (INCOMMENTXX(rp))
{
rp = fsm[COM5];
break;
}
goto fsm_start;
case EOF:
break;
default:
#if PROTOMAIN
if ((flags & (EXTERN|MATCH)) == EXTERN) BACKOUT();
else
#endif
PUTCHR(c);
rp = fsm[INCOMMENTXX(rp) ? COM5 : COM3];
break;
}
bp = ip;
goto fsm_get;
case S_EOB:
if (c)
{
if (state = fsm[TERMINAL][INDEX(rp)+1])
goto fsm_terminal;
SYNC();
return 0;
}
UNGETCHR();
fsm_eob:
if ((flags & (DECLARE|GLOBAL|RECURSIVE)) == GLOBAL && (proto->flags & MORE))
{
#if PROTOMAIN
if (!(flags & EXTERN)) /* XXX */
#endif
flags |= SLIDE;
c = ip - proto->ib;
if (!(flags & MATCH))
im = proto->tp;
if (ip > proto->ib)
{
n = ip - im;
if (ip - n < proto->ib)
proto->flags |= ERROR;
memcopy(proto->ib - n, ip - n, n);
ip = proto->ib;
}
proto->tp -= c;
if (flags & MATCH)
{
im -= c;
ie -= c;
}
if (aim)
aim -= c;
if (aie)
aie -= c;
if ((n = read(proto->fd, ip, proto->iz)) > 0)
{
if ((proto->options & REGULAR) && n < proto->iz)
{
proto->flags &= ~MORE;
close(proto->fd);
}
*(ip + n) = 0;
if (state & SPLICE)
goto fsm_splice;
bp = ip;
goto fsm_get;
}
*ip = 0;
proto->flags &= ~MORE;
close(proto->fd);
}
if (state & SPLICE)
goto fsm_splice;
/* NOTE: RECURSIVE lex() should really SLIDE too */
if (!(flags & RECURSIVE) && (state = rp[c = EOF]))
{
bp = ip;
goto fsm_next;
}
SYNC();
return 0;
case S_LITBEG:
quot = c;
#if PROTOMAIN
if (c == '"' && qe)
{
for (n = 0, t = qe + 1; t < op && (*t == ' ' || *t == '\t' || *t == '\n' && ++n || *t >= 'A' && *t <= 'Z' || *t == '_'); t++);
if (t == op)
{
op = qe;
qe = 0;
qn = n;
}
else PUTCHR(c);
}
else
#endif
PUTCHR(c);
rp = fsm[LIT1];
bp = ip;
goto fsm_get;
case S_LITEND:
if (c == quot)
{
#if PROTOMAIN
if (!(flags & DIRECTIVE))
qe = (c == '"') ? op : (char*)0;
#endif
PUTCHR(c);
#if PROTOMAIN
while (qn > 0)
{
qn--;
PUTCHR('\n');
}
#endif
}
else if (c != '\n' && c != EOF)
{
PUTCHR(c);
bp = ip;
goto fsm_get;
}
else
{
#if PROTOMAIN
while (qn > 0)
{
qn--;
PUTCHR('\n');
}
#endif
UNGETCHR();
}
c = T_INVALID;
break;
case S_LITESC:
#if PROTOMAIN
if (flags & CLASSIC) PUTCHR(c);
else
#endif
switch (c)
{
case 'a':
n = CC_bel;
goto fsm_oct;
case 'E':
n = CC_esc;
goto fsm_oct;
case 'v':
n = CC_vt;
goto fsm_oct;
case 'x':
SYNC();
lex(proto, (flags & GLOBAL) | RECURSIVE);
for (n = x = 0; (c = GETCHR()), x < 3; x++) switch (c)
{
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
case '8': case '9':
n = (n << 4) + c - '0';
break;
case 'a': case 'b': case 'c': case 'd':
case 'e': case 'f':
n = (n << 4) + c - 'a' + 10;
break;
case 'A': case 'B': case 'C': case 'D':
case 'E': case 'F':
n = (n << 4) + c - 'A' + 10;
break;
default:
goto fsm_hex;
}
fsm_hex:
UNGETCHR();
fsm_oct:
PUTCHR(((n >> 6) & 07) + '0');
PUTCHR(((n >> 3) & 07) + '0');
PUTCHR((n & 07) + '0');
break;
default:
PUTCHR(c);
break;
}
rp = fsm[LIT1];
bp = ip;
goto fsm_get;
case S_MACRO:
UNGETCHR();
#if PROTOMAIN
if ((flags & EXTERN) && *proto->tp == 's' && !strncmp(proto->tp, "static", 6))
{
c = T_EXTERN;
break;
}
#endif
if (*proto->tp == '_' && !strncmp(proto->tp, "__STDPP__directive", 6)) c = '#';
else c = T_ID;
break;
case S_NL:
fsm_newline:
proto->line++;
#if PROTOMAIN
if (flags & EXTERN)
{
if (op != proto->ob && LASTOUT() != ' ' && LASTOUT() != '\n')
PUTCHR(' ');
}
else
#endif
PUTCHR(c);
if (flags & DIRECTIVE)
{
#if PROTOMAIN
if (flags & CLASSIC)
{
if (flags & EXTERN) BACKOUT();
if (flags & JUNK)
{
*(ip - 1) = 0;
op = strcopy(om, "/* ");
op = strcopy(op, im);
op = strcopy(op, " */\n");
}
flags &= ~(DEFINE|DIRECTIVE|IDID|INDIRECT|JUNK|MATCH|SHARP|TYPEDEF);
}
else
#endif
{
if ((flags & (DEFINE|SHARP)) == (DEFINE|SHARP))
{
*(ip - 1) = 0;
op = strcopy(om, "#if defined(__STDC__) || defined(__STDPP__)\n");
op = strcopy(op, im);
op = strcopy(op, "\n#else\n");
bp = ip;
ip = im;
*op++ = *ip++;
while (*op = *ip++)
if (*op++ == '#' && *ip != '(')
{
op--;
while (*--op == ' ' || *op == '\t');
if (*ip == '#')
{
op = strcopy(op + 1, "/**/");
while (*++ip == ' ' || *ip == '\t');
}
else
{
if (*op != '"') *++op = '"';
op++;
while (*ip == ' ' || *ip == '\t') ip++;
while ((c = *ip) >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z' || c >= '0' && c <= '9' || c == '_') *op++ = *ip++;
while (*ip == ' ' || *ip == '\t') ip++;
if (*ip == '"') ip++;
else *op++ = '"';
}
}
ip = bp;
op = strcopy(op, "\n#endif\n");
op = linesync(proto, op, proto->line);
}
flags &= ~(DEFINE|DIRECTIVE|IDID|INDIRECT|MATCH|OTHER|SHARP|SKIP|TOKENS|TYPEDEF);
}
call = 0;
group = 0;
paren = 0;
last = '\n';
}
if (paren == 0 && (flags & (MATCH|RECURSIVE|SKIP|SLIDE)) == SLIDE)
{
#if PROTOMAIN
if (flags & EXTERN) BACKOUT();
#endif
SYNC();
return 0;
}
goto fsm_start;
case S_QUAL:
PUTCHR(c);
rp = fsm[NEXT(state)];
bp = ip;
goto fsm_get;
case S_TOK:
PUTCHR(c);
c = TYPE(state);
break;
case S_TOKB:
UNGETCHR();
c = TYPE(state);
break;
case S_RESERVED:
UNGETCHR();
c = T_ID;
if (!(flags & DECLARE)) switch (RESERVED(*proto->tp, *(ip - 1), ip - proto->tp))
{
case RESERVED('N', 'N', 3):
if (proto->tp[1] == 'o')
c = T_DO;
break;
case RESERVED('d', 'o', 2):
c = T_DO;
break;
case RESERVED('e', 'e', 4):
if (!(flags & RECURSIVE) && (flags & (DIRECTIVE|TOKENS)) != DIRECTIVE && !strncmp(proto->tp, "else", 4))
{
c = T_ELSE;
goto fsm_id;
}
break;
case RESERVED('e', 'n', 6):
if (!strncmp(proto->tp, "extern", 6))
c = T_EXTERN;
break;
case RESERVED('f', 'r', 3):
if (!(flags & RECURSIVE) && !strncmp(proto->tp, "for", 3))
{
c = T_FOR;
goto fsm_id;
}
break;
case RESERVED('i', 'f', 2):
c = T_IF;
break;
case RESERVED('i', 'e', 6):
if (!strncmp(proto->tp, "inline", 6) && !(flags & (MATCH|SKIP|TOKENS|TYPEDEF)) && proto->brace == 0 && paren == 0 && group == 0 && (last == ';' || last == '}' || last == '\n' || last == 0))
{
flags |= SKIP;
SYNC();
line = proto->line;
op = strcopy(op - 6, "__INLINE__");
SYNC();
}
break;
case RESERVED('r', 'n', 6):
if (!(flags & RECURSIVE) && !strncmp(proto->tp, "return", 6))
{
c = T_RETURN;
goto fsm_id;
}
break;
case RESERVED('s', 'c', 6):
if ((proto->options & EXTERNALIZE) && !strncmp(proto->tp, "static", 6))
{
proto->ox = op - 6;
flags |= EXTERNALIZE;
}
break;
case RESERVED('t', 'f', 7):
if (!(flags & RECURSIVE) && !strncmp(proto->tp, "typedef", 7))
{
flags |= TYPEDEF;
c = T_EXTERN;
}
break;
case RESERVED('v', 't', 8):
if (*ip == '(' && !strncmp(proto->tp, "va_start", 8)) c = T_VA_START;
break;
case RESERVED('v', 'd', 4):
if (!strncmp(proto->tp, "void", 4))
{
if (flags & (CLASSIC|PLUSONLY|INIT_DEFINE|INIT_INCLUDE)) c = T_VOID;
else
{
SYNC();
line = proto->line;
if (lex(proto, (flags & GLOBAL) | RECURSIVE) == '*')
{
memcopy(op - 4, "__V_", 4);
memcopy(ip - 4, "__V_", 4);
}
else c = T_VOID;
proto->line = line;
SYNC();
bp = ip;
}
}
break;
case RESERVED('w', 'e', 5):
if (!(flags & RECURSIVE) && !strncmp(proto->tp, "while", 5))
{
c = T_WHILE;
goto fsm_id;
}
break;
}
#if PROTOMAIN
if ((flags & CLASSIC) && c != T_EXTERN)
c = T_ID;
#endif
break;
case S_VS:
goto fsm_start;
case S_WS:
UNGETCHR();
#if PROTOMAIN
if ((flags & (EXTERN|MATCH)) == EXTERN)
{
while (op > proto->ob && (*(op - 1) == ' ' || *(op - 1) == '\t'))
op--;
if (op > proto->ob && *(op - 1) != '\n') *op++ = ' ';
}
#endif
goto fsm_start;
default:
if (state & SPLICE)
{
if (c == '\\')
{
if (!(n = GETCHR()))
{
goto fsm_eob;
fsm_splice:
c = '\\';
n = GETCHR();
}
if (n == '\n')
{
proto->line++;
PUTCHR('\\');
PUTCHR('\n');
bp = ip;
goto fsm_get;
}
UNGETCHR();
}
state &= ~SPLICE;
if (state >= TERMINAL)
goto fsm_terminal;
rp = fsm[state];
}
PUTCHR(c);
bp = ip;
goto fsm_get;
}
if (!(flags & (INIT_DEFINE|INIT_INCLUDE|RECURSIVE)))
{
if (!(flags & DIRECTIVE)) switch (c)
{
case '(':
#if PROTOMAIN
if (!(flags & CLASSIC) || proto->brace == 0)
#endif
{
if (paren++ == 0)
{
#if PROTOMAIN
if (!(flags & CLASSIC) || group <= 1)
#endif
{
#if PROTOMAIN
args = 0;
#endif
if (group++ == 0) group++;
else if (flags & INDIRECT) call++;
flags |= MATCH;
im = ip - 1;
om = op - 1;
}
sub = 0;
}
else if (paren == 2 && !aim)
{
sub++;
if (last == '(')
{
flags &= ~MATCH;
om = 0;
}
else if (flags & INDIRECT)
{
aim = ip - 1;
aom = op - 1;
}
else if ((flags & (MATCH|TOKENS)) == MATCH)
{
for (m = ip - 2; m > im && (*m == ' ' || *m == '\t'); m--);
if (m != im && sub == 1)
{
m = im + (*nns(ip) == '*');
}
if (m == im)
{
flags &= ~MATCH;
om = 0;
}
}
else if ((flags & MATCH) && sub == 1 && *nns(ip) != '*')
{
flags &= ~MATCH;
om = 0;
}
}
flags &= ~TOKENS;
}
break;
case ')':
#if PROTOMAIN
if (!(flags & CLASSIC) || proto->brace == 0)
#endif
if (--paren == 0)
{
#if PROTOMAIN
if (flags & CLASSIC)
{
if (group != 2)
{
c = T_ID;
break;
}
group++;
}
#endif
ie = ip;
}
else if (paren == 1 && (flags & INDIRECT) && !aie)
aie = ip;
break;
case '*':
if (last == '(' && group == 2)
{
group--;
if (paren == 1)
{
flags |= INDIRECT;
aim = aie = 0;
}
}
break;
case '#':
dir = directive(ip, dir);
if (proto->brace == 0 && paren == 0 && last != '=' && (flags & (CLASSIC|DECLARE|DIRECTIVE|MATCH|PLUSONLY|SKIP|TOKENS)) == (MATCH|TOKENS) && ((dir & DIR) != DIR_en || ((dir>>2) & DIR) != DIR_if))
flags |= DIRECTIVE;
else if (!(flags & (DECLARE|DIRECTIVE)))
{
flags |= DIRECTIVE;
if (!(flags & PLUSONLY))
{
bp = ip;
while (*ip == ' ' || *ip == '\t') ip++;
if (*ip == 'l' && *++ip == 'i' && *++ip == 'n' && *++ip == 'e')
{
if (*++ip == ' ' || *ip == '\t')
{
proto->line = 0;
while (*++ip >= '0' && *ip <= '9')
proto->line = proto->line * 10 + *ip - '0';
proto->line--;
}
}
#if PROTOMAIN
else if ((flags & (CLASSIC|EXTERN)) == CLASSIC)
{
n = 0;
t = ip + 6;
while (ip < t && *ip >= 'a' && *ip <= 'z')
n = HASHKEYPART(n, *ip++);
switch (n)
{
case HASHKEY4('e','l','s','e'):
case HASHKEY5('e','n','d','i','f'):
while (*ip == ' ' || *ip == '\t') ip++;
if (*ip != '\n' && *ip != '/' && *(ip + 1) != '*')
{
flags |= JUNK|MATCH;
im = ip;
om = op + (ip - bp);
}
break;
case HASHKEY4('e','l','i','f'):
case HASHKEY5('e','r','r','o','r'):
case HASHKEY2('i','f'):
case HASHKEY5('i','f','d','e','f'):
case HASHKEY6('i','f','n','d','e','f'):
case HASHKEY5('u','n','d','e','f'):
break;
case HASHKEY6('i','n','c','l','u','d'):
if (*ip == 'e') ip++;
/*FALLTHROUGH*/
case HASHKEY6('d','e','f','i','n','e'):
case HASHKEY6('p','r','a','g','m','a'):
if (*ip < 'a' || *ip > 'z') break;
/*FALLTHROUGH*/
default:
flags |= JUNK|MATCH;
im = bp - 1;
om = op - 1;
break;
}
}
else
#endif
{
if (*ip == 'i' && *++ip == 'n' && *++ip == 'c' && *++ip == 'l' && *++ip == 'u' && *++ip == 'd' && *++ip == 'e')
{
while (*++ip == ' ' || *ip == '\t');
if (*ip++ == '<' && *ip++ == 's' && *ip++ == 't' && *ip++ == 'd' && *ip++ == 'a' && *ip++ == 'r' && *ip++ == 'g' && *ip++ == '.' && *ip++ == 'h' && *ip++ == '>')
{
op = strcopy(op, "\
if !defined(va_start)\n\
#if defined(__STDARG__)\n\
#include <stdarg.h>\n\
#else\n\
#include <varargs.h>\n\
#endif\n\
#endif\n\
");
op = linesync(proto, op, proto->line);
break;
}
}
else if (*ip == 'd' && *++ip == 'e' && *++ ip == 'f' && *++ip == 'i' && *++ip == 'n' && *++ip == 'e' && (*++ip == ' ' || *ip == '\t'))
{
while (*++ip == ' ' || *ip == '\t');
if (*ip == 'e' && *++ip == 'x' && *++ ip == 't' && *++ip == 'e' && *++ip == 'r' && *++ip == 'n' && (*++ip == ' ' || *ip == '\t'))
{
t = ip;
while (*++t == ' ' || *t == '\t');
if (*t == 'e' && *++t == 'x' && *++ t == 't' && *++t == 'e' && *++t == 'r' && *++t == 'n' && (*++t == ' ' || *t == '\t' || *t == '\n' || *t == '\r'))
ip = t;
t = ip;
while (*++t == ' ' || *t == '\t');
if (*t == '_' && *(t + 1) == '_')
{
op = strcopy(op, "undef __MANGLE__\n");
op = linesync(proto, op, proto->line);
op = strcopy(op, "#define __MANGLE__ __LINKAGE__");
break;
}
}
flags |= DEFINE|MATCH;
im = bp - 1;
om = op - 1;
}
else if (*ip == 'u' && *++ip == 'n' && *++ ip == 'd' && *++ip == 'e' && *++ip == 'f' && (*++ip == ' ' || *ip == '\t'))
{
while (*++ip == ' ' || *ip == '\t');
if (*ip == 'e' && *++ip == 'x' && *++ ip == 't' && *++ip == 'e' && *++ip == 'r' && *++ip == 'n' && (*++ip == ' ' || *ip == '\t' || *ip == '\n' || *ip == '\r'))
{
op = strcopy(op, "undef __MANGLE__\n");
op = linesync(proto, op, proto->line);
op = strcopy(op, "#define __MANGLE__ __LINKAGE__");
break;
}
flags |= DEFINE|MATCH;
im = bp - 1;
om = op - 1;
}
}
ip = bp;
}
break;
}
else
break;
/*FALLTHROUGH*/
case '{':
if (proto->brace++ == 0 && paren == 0)
{
if (last == '=') flags |= INIT;
#if PROTOMAIN
else if (flags & CLASSIC)
{
if ((flags & (MATCH|OTHER|SKIP)) == MATCH)
{
if (args)
{
v = number(op, args < 0 ? -args : args);
v = strcopy(v, " argument actual/formal mismatch");
*v++ = ' ';
v = memcopy(v, im, ie - im);
*v = 0;
proto_error((char*)proto + sizeof(struct proto), 2, op, NiL);
}
ip--;
/*UNDENT...*/
v = ie;
while (ie < ip)
if (*ie++ == '/' && *ie == '*')
{
e = ie - 1;
while (++ie < ip)
{
if (*ie == '*')
{
while (ie < ip && *ie == '*') ie++;
if (ie < ip && *ie == '/')
{
while (++ie < ip && (*ie == ' ' || *ie == '\t'));
while (e > v && (*(e - 1) == ' ' || *(e - 1) == '\t')) e--;
if (e > v && *e != '\n') *e++ = ' ';
t = ie;
while (--e >= v)
*--t = *e;
v = t;
break;
}
}
}
}
ie = v;
/*...INDENT*/
op = om++;
if (flags & EXTERN)
{
v = op;
while (v > ko && *--v != ' ');
if (*v != ' ')
{
om = (v = (op += 4)) + 1;
while (v >= ko + 4)
{
*v = *(v - 4);
v--;
}
memcopy(ko, "int ", 4);
}
if (*v == ' ')
{
while (*(v + 1) == '*')
*v++ = '*';
*v = '\t';
if ((v - ko) <= 8)
{
om = (e = ++op) + 1;
while (e > v)
{
*e = *(e - 1);
e--;
}
}
}
om = (v = (op += 7)) + 1;
while (v >= ko + 7)
{
*v = *(v - 7);
v--;
}
memcopy(ko, "extern ", 7);
}
PUTCHR('(');
t = op;
e = 0;
/*UNDENT...*/
while (ie < ip)
{
if ((c = *ie) == ' ' || c == '\t' || c == '\n')
{
while ((c = *++ie) == ' ' || c == '\t' || c == '\n');
if (ie >= ip) break;
if (c != '*' && op > om) PUTCHR(' ');
}
if ((n = ((c = *ie) == ',')) || c == ';')
{
if (flags & EXTERN)
{
m = op;
while (op > om && ((c = *(op - 1)) == '(' || c == ')' || c == '[' || c == ']'))
op--;
v = op;
while (op > om && (c = *(op - 1)) != ' ' && c != '*')
op--;
while (*(op - 1) == ' ')
op--;
if (!e)
{
e = op;
while (e > om && *(e - 1) == '*')
e--;
}
#if _s5r4_386_compiler_bug_fixed_
if (op <= om || *(op - 1) == ',' && (*op++ = ' '))
op = strcopy(op, "int");
#else
if (op <= om)
op = strcopy(op, "int");
else if (*(op - 1) == ',')
op = strcopy(op, " int");
#endif
while (v < m)
PUTCHR(*v++);
}
PUTCHR(',');
if (n)
{
if (x = !e) e = op - 1;
PUTCHR(' ');
m = t;
while (m < e)
PUTCHR(*m++);
if (x)
{
m = e;
while (*--e != ' ');
while (*(e - 1) == '*') e--;
op -= m - e;
}
}
while ((c = *++ie) == ' ' || c == '\t' || c == '\n');
if (ie >= ip) UNPUTCHR();
else PUTCHR(' ');
if (!n)
{
t = op;
e = 0;
}
}
else if (*ie == '*')
{
if (op > om && (c = *(op - 1)) == ' ') op--;
while (*ie == '*') PUTCHR(*ie++);
while (*ie == ' ' || *ie == '\t' || *ie == '\n') ie++;
if (c != '(') PUTCHR(' ');
}
else if (*ie == '(')
{
if (op > om && *(op - 1) == ' ') op--;
PUTCHR(*ie++);
while (*ie == ' ' || *ie == '\t' || *ie == '\n') ie++;
}
else if (*ie == ')')
{
if (op > om && *(op - 1) == '(')
proto_error((char*)proto + sizeof(struct proto), 1, "function pointer argument prototype omitted", NiL);
PUTCHR(*ie++);
while (*ie == ' ' || *ie == '\t' || *ie == '\n') ie++;
}
else if ((flags & EXTERN) && (op == om || *(op - 1) == ' ') && *ie == 'r' && !strncmp(ie, "register", 8) && (*(ie + 8) == ' ' || *(ie + 8) == '\t' || *(ie + 8) == '\n'))
{
ie += 8;
if (op > om) UNPUTCHR();
}
else PUTCHR(*ie++);
}
/*...INDENT*/
if (op <= om) op = strcopy(op, "void");
PUTCHR(')');
if (flags & EXTERN)
{
PUTCHR(';');
PUTCHR('\n');
SYNCOUT();
KEEPOUT();
}
else
{
PUTCHR('\n');
PUTCHR(*ip);
}
ip++;
flags &= ~(MATCH|SKIP);
}
}
#endif
else if ((flags & (MATCH|PLUSONLY|SKIP|TOKENS)) == (MATCH|TOKENS))
{
line = proto->line;
op = strcopy(om, " __PARAM__(");
op = memcopy(op, im, ie - im);
PUTCHR(',');
PUTCHR(' ');
PUTCHR('(');
flags &= ~(MATCH|SKIP);
if (flags & VARIADIC)
{
if ((vc = ie - im + 1) > sizeof(proto->variadic)) vc = sizeof(proto->variadic);
memcopy(proto->variadic, im, vc);
op = strcopy(op, "va_alist)) __OTORP__(va_dcl)\n{");
}
else
{
flags |= SKIP;
proto->ip = im;
proto->op = op;
group = 0;
brack = 0;
for (;;)
{
switch (lex(proto, (flags & GLOBAL) | RECURSIVE))
{
case '[':
brack++;
continue;
case ']':
brack--;
continue;
case '(':
if (paren++) group++;
continue;
case ')':
if (--paren == 0)
{
group = 0;
if (flags & MATCH)
{
flags &= ~(MATCH|SKIP);
op = memcopy(op, m, e - m);
}
break;
}
continue;
case ',':
if (paren == 1)
{
group = 0;
if (flags & MATCH)
{
flags &= ~(MATCH|SKIP);
op = memcopy(op, m, e - m);
}
PUTCHR(',');
PUTCHR(' ');
proto->op = op;
}
continue;
case T_ID:
if (group <= 1 && !brack)
{
flags |= MATCH;
m = proto->tp;
e = proto->ip;
}
continue;
default:
continue;
}
break;
}
PUTCHR(')');
PUTCHR(')');
}
if (!(flags & SKIP))
{
flags |= SKIP;
proto->op = strcopy(op, " __OTORP__(");
proto->ip = im + 1;
n = *(ie - 1);
*(ie - 1) = ';';
c = *ie;
*ie = 0;
lex(proto, (flags & GLOBAL) | DECLARE);
*(ie - 1) = n;
*ie = c;
proto->ip = ie;
op = proto->op;
PUTCHR(')');
}
if (flags & EXTERNALIZE) memcpy(proto->ox, "extern", 6);
op = linesync(proto, op, proto->line = line);
if (flags & DIRECTIVE)
{
proto->brace = 0;
PUTCHR('\n');
PUTCHR('#');
}
else if (!(flags & VARIADIC)) PUTCHR('{');
}
}
flags &= ~(IDID|INDIRECT|MATCH|OTHER|SKIP);
call = 0;
group = 0;
break;
case '}':
flags &= ~(IDID|INDIRECT|MATCH|OTHER|SKIP|TOKENS);
if (--proto->brace == 0)
{
flags &= ~(INIT|VARIADIC|VARIADIC2);
#if PROTOMAIN
if (flags & EXTERN) BACKOUT();
#endif
}
call = 0;
group = 0;
paren = 0;
break;
case '=':
if (last == '?') flags |= DIRECTIVE;
else if (paren == 0 && (flags & (INIT|MATCH|SKIP)) == MATCH)
{
if (last == ')' && proto->brace && (group != 2 || call != 2)) flags |= SKIP;
else goto fsm_statement;
}
goto fsm_other;
case ',':
#if PROTOMAIN
if (flags & CLASSIC)
{
if (paren == 1) args++;
else
{
args--;
flags &= ~MATCH;
}
break;
}
#endif
if (paren == 0 && (flags & DECLARE)) *(op - 1) = c = ';';
/*FALLTHROUGH*/
case ';':
fsm_statement:
if (flags & INIT) /* ignore */;
#if PROTOMAIN
else if (flags & CLASSIC)
{
if (paren == 0)
{
if ((flags & MATCH) && last == ')')
flags &= ~MATCH;
if (!(flags & MATCH))
{
call = 0;
group = 0;
flags &= ~SKIP;
if (flags & EXTERN) BACKOUT();
if (flags & SLIDE)
{
SYNC();
return 0;
}
}
else
{
args--;
if ((flags & (EXTERN|SKIP)) == (EXTERN|SKIP))
BACKOUT();
}
}
}
#endif
else if (paren == 0)
{
if ((flags & (MATCH|OTHER|SKIP)) == MATCH && call > 1)
{
if ((flags & MANGLE) && func)
{
func[0] = 'F';
func[1] = 'U';
func[2] = 'N';
func[3] = 'C';
func = 0;
}
if ((flags & (DECLARE|INDIRECT)) == INDIRECT && aim && aie < im)
{
while (aie < ip && (*aie == ' ' || *aie == '\t' || *aie == '\n')) aie++;
v = aim;
while (v < aie)
if (*v++ == ')') break;
while (v < aie && (*v == ' ' || *v == '\t' || *v == '\n')) v++;
if (v == aie || !(flags & PLUSPLUS))
{
if (flags & PLUSPLUS) n = 3;
else if (v == aie && *v == '(') n = 10;
else n = 11;
ko = op;
om += n;
v = op += n;
while (v >= ko + n)
{
*v = *(v - n);
v--;
}
if (flags & PLUSPLUS) memcopy(aom, "(...))", 6);
else if (n == 10) memcopy(aom, "(__VARARG__))", 13);
else
{
ko = strcopy(aom, " __PROTO__(");
ko = memcopy(ko, aim, aie - aim);
*ko = ')';
if (++ko >= om)
{
*ko++ = ')';
om = ko;
}
}
}
}
else if (flags & TYPEDEF)
{
op = om;
while (*--op == ' ' || *op == '\t' || *op == '\n');
if (*op != ')')
{
op = om += 14;
*--op = ')';
while ((x = *(op - 14)) >= 'A' && x <= 'Z' || x >= 'a' && x <= 'z' || x >= '0' && x <= '9' || x == '_')
*--op = x;
memcopy(op - 13, "(__OTORP__(*)", 13);
}
}
if (flags & OTHER)
;
else if (flags & PLUSPLUS)
{
op = om;
if (!(flags & TOKENS)) op = strcopy(op, "(...)");
else op = memcopy(op, im, ie - im);
PUTCHR(c);
}
else
{
if (flags & DECLARE) op = strcopy(om, "()");
else if (!(flags & TOKENS)) op = strcopy(om, "(__VARARG__)");
else
{
op = strcopy(om, " __PROTO__(");
op = memcopy(op, im, ie - im);
PUTCHR(')');
}
if (flags & EXTERNALIZE) memcpy(proto->ox, "extern", 6);
PUTCHR(c);
}
flags &= ~(MATCH|VARIADIC|VARIADIC2);
if (c == ',' && !(flags & INDIRECT))
{
call = 1;
group = 0;
break;
}
}
else if (flags & (OTHER|SKIP)) call = 0;
if (c == ';')
{
flags &= ~(EXTERNALIZE|MANGLE|TOKENS|TYPEDEF);
call = 0;
if (flags & SLIDE)
{
SYNC();
return 0;
}
}
else call = call > 1 && c == ',';
group = 0;
flags &= ~(IDID|INDIRECT|MATCH|OTHER|SKIP);
}
else if (paren == 1 && group == 1 && !(flags & (IDID|MANGLE))) flags |= TOKENS|OTHER;
break;
case T_DO:
case T_IF:
flags |= TOKENS|SKIP;
break;
case T_EXTERN:
#if PROTOMAIN
if (flags & CLASSIC)
{
if (proto->brace == 0)
flags |= SKIP;
}
else
#endif
if (paren == 0 && !(flags & TYPEDEF))
{
flags |= MANGLE;
if (!(flags & PLUSONLY) || proto->package)
{
op = strcopy(op, " __MANGLE__");
if (proto->package)
{
op = strcopy(op - 1, proto->package);
func = op + 1;
op = strcopy(op, "_DATA__");
}
}
else
func = 0;
}
break;
case T_VARIADIC:
if (paren == 0 && (flags & (DECLARE|VARIADIC)) == DECLARE)
{
op -= 3;
SYNC();
return c;
}
if (paren == 1 && !(flags & SKIP))
flags |= VARIADIC;
flags |= TOKENS;
break;
case T_VOID:
goto fsm_id;
case T_VA_START:
if ((flags & (PLUSONLY|VARIADIC)) == VARIADIC)
{
flags &= ~MATCH;
line = proto->line;
op = strcopy(op - 8, "__VA_START__");
SYNC();
for (;;)
{
switch (lex(proto, (flags & GLOBAL) | RECURSIVE))
{
case 0:
case ';':
break;
case T_ID:
if (!(flags & MATCH))
{
flags |= MATCH;
m = proto->tp;
e = proto->ip;
}
continue;
default:
continue;
}
break;
}
CACHE();
if (flags & MATCH)
{
v = m;
n = e - m;
}
else
{
v = "ap";
n = 2;
}
op = strcopy(op, " __OTORP__(");
proto->ip = proto->variadic;
proto->op = op;
flags &= ~MATCH;
group = 0;
bp = proto->ip + 1;
if (*bp == 'r' && !strncmp(bp, "register", 8) && (*(bp + 8) == ' ' || *(bp + 8) == '\t')) bp += 9;
for (;;)
{
switch (lex(proto, (flags & GLOBAL) | RECURSIVE))
{
case '(':
if (paren++) group++;
continue;
case ')':
if (--paren == 0)
{
if (flags & MATCH)
{
flags &= ~MATCH;
if (!(flags & VARIADIC2))
{
op = memcopy(op, m, e - m);
op = strcopy(op, " = ");
}
op = strcopy(op, "va_arg(");
op = memcopy(op, v, n);
PUTCHR(',');
PUTCHR(' ');
if (m > bp) op = memcopy(op, bp, m - bp);
else op = strcopy(op, "int ");
if (group > 1) op = strcopy(op, ")()");
else op = memcopy(op, e, proto->ip - e - 1);
PUTCHR(')');
PUTCHR(';');
}
group = 0;
break;
}
continue;
case ',':
if (paren == 1)
{
if (flags & MATCH)
{
flags &= ~MATCH;
if (!(flags & VARIADIC2))
{
op = memcopy(op, m, e - m);
op = strcopy(op, " = ");
}
op = strcopy(op, "va_arg(");
op = memcopy(op, v, n);
PUTCHR(',');
PUTCHR(' ');
if (m > bp) op = memcopy(op, bp, m - bp);
else op = strcopy(op, "int ");
if (group > 1) op = strcopy(op, ")()");
else op = memcopy(op, e, proto->ip - e - 1);
PUTCHR(')');
PUTCHR(';');
bp = proto->ip + 1;
if (*bp == 'r' && !strncmp(bp, "register", 8) && (*(bp + 8) == ' ' || *(bp + 8) == '\t')) bp += 9;
}
group = 0;
proto->op = op;
}
continue;
case T_ID:
if (group <= 1)
{
flags |= MATCH;
m = proto->tp;
e = proto->ip;
}
continue;
default:
continue;
}
break;
}
op = strcopy(op, ")");
flags |= VARIADIC2;
proto->line = line;
call = 0;
break;
}
/*FALLTHROUGH*/
case T_ID:
fsm_id:
#if PROTOMAIN
if (flags & CLASSIC)
{
if (!args && paren == 1) args++;
break;
}
#endif
if (paren == 0)
{
if (last == ')')
{
if (proto->brace == 0 && !(flags & DECLARE)) flags |= SKIP;
call = !call;
}
else if ((flags & SKIP) || c == T_ID || c == T_VOID) call++;
else flags |= SKIP;
if (last == T_ID) flags |= IDID;
}
c = T_ID;
flags |= TOKENS;
break;
case T_INVALID:
if (*proto->tp >= '0' && *proto->tp <= '9')
{
n = 0;
for (;; op--)
{
switch (*(op - 1))
{
case 'f':
case 'F':
t = op;
while ((c = *--t) >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z');
if (*t == '.')
op--;
n = 0;
break;
case 'l':
case 'L':
if (!(n & 01))
{
n |= 01;
t = op;
while ((c = *--t) >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z');
if (*t == '.')
{
n = 0;
op--;
break;
}
}
continue;
case 'u':
case 'U':
n |= 02;
continue;
}
break;
}
if (n & 01)
*op++ = 'L';
if (n & 02)
{
m = op;
t = op = m + 10;
while ((c = *--m) >= '0' && c <= '9' || c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z')
*--t = c;
c = *t;
strcopy(m + 1, "(unsigned)");
*t = c;
break;
}
}
goto fsm_other;
#if PROTOMAIN
case '[':
if ((flags & CLASSIC) && paren == 0 && group <= 2) flags |= SKIP;
/*FALLTHROUGH*/
#endif
default:
fsm_other:
#if PROTOMAIN
if (flags & CLASSIC) break;
#endif
flags |= TOKENS;
if (paren == 0) flags |= OTHER;
break;
}
else if (c == '#' && *ip != '(') flags |= SHARP;
last = c;
#if PROTOMAIN
if ((flags & (EXTERN|MATCH)) == (EXTERN|MATCH) && ((flags & (DIRECTIVE|SKIP)) || proto->brace || c != '(' && c != ')' && c != '*' && c != T_ID))
CACHEOUT();
else
#endif
SYNCOUT();
goto fsm_start;
}
else if (flags & (INIT_DEFINE|INIT_INCLUDE))
{
#if PROTOMAIN
if ((flags & YACC) && c == '%' && *ip == '{') t = 0;
else
#endif
{
if (c == '#') for (t = ip; *t == ' ' || *t == '\t'; t++);
else t = "";
if (*t++ == 'i' && *t++ == 'f' && *t++ == 'n' && *t++ == 'd' && *t++ == 'e' && *t++ == 'f')
{
#if !PROTOMAIN
while (*t == ' ' || *t == '\t') t++;
if (*t != '_')
#endif
t = 0;
}
}
if (t)
{
ip = bp;
op = proto->op;
}
else while (*ip != '\n') *op++ = *ip++;
op = init(proto, op, flags);
op = linesync(proto, op, proto->line);
flags &= ~(INIT_DEFINE|INIT_INCLUDE);
proto->flags &= ~(INIT_DEFINE|INIT_INCLUDE);
goto fsm_start;
}
SYNC();
return c;
}
/*
* close a proto buffer stream
*/
void
pppclose(char* iob)
{
register struct proto* proto = (struct proto*)(iob - sizeof(struct proto));
if (proto->flags & MORE) close(proto->fd);
free((char*)proto); /* some ANSI cc's botch the free() prototype */
}
/*
* open a new proto buffer stream
* read buffer pointer returned
* 0 returned on error or if no magic
*
* file !=0 file path to open, otherwise use fd
* fd open file fd if file==0
* notice !=0 copyright notice info commented at the top
* options !=0 additional notice name=value pairs, space or ; separated
* package !=0 generate header for this package
*/
char*
pppopen(char* file, int fd, char* notice, char* options, char* package, char* comment, int flags)
{
register struct proto* proto;
register char* iob;
register long n;
register char* s;
int pragma;
char* b;
#if PROTOMAIN
int comlen;
char com[80];
#endif
int m = 0;
static int retain;
/*
* initialize proto
*/
#if PROTOMAIN
if (flags & PROTO_CLASSIC) flags &= ~PROTO_INCLUDE;
#endif
if (flags & PROTO_RETAIN) flags &= ~retain;
else retain &= PROTO_INITIALIZED;
if (file && (fd = open(file, O_RDONLY)) < 0) return 0;
#if !PROTOMAIN
if ((n = lseek(fd, 0L, 2)) > 0)
{
if (lseek(fd, 0L, 0)) return 0;
if (n < CHUNK) n = CHUNK;
else if (n > 2 * BLOCK) n = 0;
m = 1;
}
if (n > 0)
{
/*
* file read in one chunk
*/
if (!(proto = newof(0, struct proto, 1, 4 * n + 2)))
return 0;
proto->iz = n;
proto->oz = 3 * n;
n = 0;
}
else
#endif
{
/*
* file read in BLOCK chunks
*/
n = BLOCK;
if (!(proto = newof(0, struct proto, 1, 5 * n + 2)))
return 0;
proto->iz = n;
proto->oz = 3 * n;
proto->flags |= MORE;
}
proto->fd = fd;
proto->package = package;
iob = (char*)proto + sizeof(struct proto);
proto->op = proto->ob = iob;
proto->ip = proto->ib = iob + proto->oz + n;
if (m) proto->options |= REGULAR;
if (!comment)
comment = "/*";
if (!(proto->cc[0] = comment[0]))
notice = options = 0;
else if (comment[1])
{
proto->cc[1] = comment[1];
proto->cc[2] = comment[2] ? comment[2] : comment[0];
}
else
proto->cc[1] = proto->cc[2] = comment[0];
/*
* read the first chunk
*/
n = read(fd, proto->ip, proto->iz);
if (!(proto->flags & MORE))
close(fd);
if (n < 0)
{
pppclose(iob);
return 0;
}
*(proto->ip + n) = 0;
/*
* check for proto pragma in first block of lines
* pragma blanked out if found
*
* -1 no pragma
* 0 #pragma noprototyped
* 1 #pragma prototyped
*
* NOTE: matches may occur inside comments and quotes
*/
#if PROTOMAIN
if (!notice && !options || (comlen = astlicense(com, sizeof(com), NiL, "type=check", proto->cc[0], proto->cc[1], proto->cc[2])) <= 0)
*com = 0;
#endif
pragma = -1;
s = proto->ip;
m = MAGICTOP;
while (m-- > 0 && *s)
{
while (*s == ' ' || *s == '\t') s++;
if (*s == '#')
{
b = s++;
while (*s == ' ' || *s == '\t') s++;
if (!strncmp(s, MAGICDIR, sizeof(MAGICDIR) - 1) && (*(s += sizeof(MAGICDIR) - 1) == ' ' || *s == '\t'))
{
while (*s == ' ' || *s == '\t') s++;
if (*s == 'n' && *(s + 1) == 'o')
{
s += 2;
pragma = -2;
}
if (!strncmp(s, MAGICARG, sizeof(MAGICARG) - 1) && (*(s += sizeof(MAGICARG) - 1) == ' ' || *s == '\t' || *s == '\n' || *s == '\r'))
while (*s)
{
if ((*(s - 1) == ' ' || *(s - 1) == '\t') && *s == *MAGICOFF && !strncmp(s, MAGICOFF, sizeof(MAGICOFF) - 1))
notice = options = 0;
if (*s++ == '\n')
{
pragma += 2;
#if PROTOMAIN
if (!(flags & PROTO_DISABLE) || (flags & PROTO_NOPRAGMA))
#endif
for (s--; b < s; *b++ = ' ');
goto magic;
}
}
pragma = -1;
}
}
else if (*s == '/' && !strncmp(s, MAGICGEN, sizeof(MAGICGEN) - 1))
{
pragma = 0;
break;
}
#if PROTOMAIN
else if (*s == '%' && *(s + 1) == '{')
proto->flags |= YACC;
if (notice || options)
{
if (*s == *com && !strncmp(s, com, comlen))
notice = options = 0;
else
while (*s)
{
if (*s == *NOTICED && !strncmp(s, NOTICED, sizeof(NOTICED) - 1))
{
s += sizeof(NOTICED) - 1;
while (*s == ' ' || *s == '\t')
s++;
if (*s == '(' && (*(s + 1) == 'c' || *(s + 1) == 'C') && *(s + 2) == ')' || *s >= '0' && *s <= '9' && *(s + 1) >= '0' && *(s + 1) <= '9')
{
notice = options = 0;
break;
}
}
if (*s == *PUBLICDOMAIN && !strncmp(s, PUBLICDOMAIN, sizeof(PUBLICDOMAIN) - 1))
{
notice = options = 0;
break;
}
else if (*s++ == '\n')
{
s--;
break;
}
}
}
#endif
while (*s && *s++ != '\n');
}
magic:
if (flags & PROTO_PLUSPLUS) proto->flags |= PLUSPLUS;
if (flags & PROTO_TEST) proto->test = 1;
if (flags & PROTO_EXTERNALIZE) proto->options |= EXTERNALIZE;
#if PROTOMAIN
if (flags & PROTO_CLASSIC) pragma = -pragma;
if (flags & PROTO_DISABLE) pragma = 0;
if (flags & PROTO_LINESYNC) proto->flags |= LINESYNC;
if (!(proto->flags & YACC) && file && (m = strlen(file)) > 2 && file[--m] == 'y' && file[--m] == '.')
proto->flags |= YACC;
#endif
if (pragma <= 0)
{
if (flags & PROTO_PLUSPLUS)
{
flags &= ~(PROTO_HEADER|PROTO_INCLUDE);
proto->flags |= PLUSONLY;
}
else if (!(flags & (PROTO_FORCE|PROTO_PASS)))
{
pppclose(iob);
return 0;
}
else if ((flags & (PROTO_FORCE|PROTO_PASS)) == PROTO_PASS || !pragma)
{
proto->flags |= PASS;
if (proto->flags & MORE)
proto->oz += proto->iz;
proto->iz = n;
if (notice || options)
{
if (proto->cc[0] == '#' && proto->ip[0] == '#' && proto->ip[1] == '!')
{
s = proto->ip;
while (*s && *s++ != '\n');
m = s - proto->ip;
proto->op = memcopy(proto->op, proto->ip, m);
proto->ip = s;
proto->iz = n -= m;
}
#if PROTOMAIN
if (proto->cc[0])
{
if ((comlen = astlicense(proto->op, proto->oz, notice, options, proto->cc[0], proto->cc[1], proto->cc[2])) < 0)
proto_error((char*)proto + sizeof(struct proto), 1, proto->op, NiL);
else
proto->op += comlen;
}
if (!(flags & PROTO_CLASSIC) && !(proto->flags & YACC))
#endif
proto->op = linesync(proto, proto->op, 1);
proto->iz += proto->op - proto->ob;
}
memcopy(proto->op, proto->ip, n);
return iob;
}
}
#if PROTOMAIN
if (!(retain & PROTO_INITIALIZED))
{
retain |= PROTO_INITIALIZED;
ppfsm(FSM_INIT, NiL);
}
#endif
proto->line = 1;
#if CHUNK >= 512
if (notice || options || (flags & (PROTO_HEADER|PROTO_INCLUDE)))
{
#if PROTOMAIN
if (notice || options)
{
if ((comlen = astlicense(proto->op, proto->oz, notice, options, proto->cc[0], proto->cc[1], proto->cc[2])) < 0)
proto_error((char*)proto + sizeof(struct proto), 1, proto->op, NiL);
else
proto->op += comlen;
}
#endif
if (flags & PROTO_INCLUDE)
{
proto->flags |= INIT_INCLUDE;
if (flags & PROTO_RETAIN)
retain |= PROTO_INCLUDE;
}
else if (flags & PROTO_HEADER)
{
if (flags & PROTO_RETAIN) retain |= PROTO_HEADER;
#if PROTOMAIN
if (flags & PROTO_CLASSIC)
{
*proto->op++ = '#';
proto->op = strcopy(proto->op, MAGICDIR);
*proto->op++ = ' ';
proto->op = strcopy(proto->op, MAGICARG);
*proto->op++ = '\n';
}
else
#endif
proto->flags |= INIT_DEFINE;
}
#if PROTOMAIN
if (!(flags & PROTO_CLASSIC))
{
if (proto->flags & YACC)
{
proto->op = strcopy(proto->op, "\n%{\n" + !notice);
proto->op = strcopy(proto->op, MAGICGEN);
proto->op = strcopy(proto->op, "%}\n");
}
else
{
if (n || notice || options)
*proto->op++ = '\n';
proto->op = strcopy(proto->op, MAGICGEN);
if (n)
proto->op = linesync(proto, proto->op, proto->line);
else if (proto->flags & (INIT_DEFINE|INIT_INCLUDE))
proto->op = init(proto, proto->op, proto->flags);
}
}
#endif
}
#endif
#if PROTOMAIN
proto->file = file;
if (flags & PROTO_CLASSIC)
{
proto->flags |= CLASSIC;
if (!(flags & PROTO_HEADER)) proto->flags |= EXTERN;
}
#endif
return iob;
}
/*
* read next proto'd chunk into iob
* the chunk is 0 terminated and its size is returned
*/
int
pppread(char* iob)
{
register struct proto* proto = (struct proto*)(iob - sizeof(struct proto));
register int n;
if (proto->flags & PASS)
{
if (proto->iz)
{
n = proto->iz;
proto->iz = 0;
}
else if (!(proto->flags & MORE)) n = 0;
else if ((n = read(proto->fd, proto->ob, proto->oz)) <= 0 || (proto->options & REGULAR) && n < proto->oz)
{
proto->flags &= ~MORE;
close(proto->fd);
}
}
else
{
if (proto->op == proto->ob)
{
if (proto->flags & ERROR) return -1;
#if PROTOMAIN
if (proto->flags & YACC)
{
register char* ip = proto->ip;
register char* op = proto->ob;
register char* ep = proto->ob + proto->oz - 2;
if (!*ip)
{
ip = proto->ip = proto->ib;
if (!(proto->flags & MORE)) n = 0;
else if ((n = read(proto->fd, ip, proto->iz)) <= 0 || (proto->options & REGULAR) && n < proto->iz)
{
if (n < 0) n = 0;
proto->flags &= ~MORE;
close(proto->fd);
}
ip[n] = 0;
}
if (proto->flags & YACCSPLIT)
{
proto->flags &= ~YACCSPLIT;
if (*ip == '%')
{
*op++ = *ip++;
if (proto->flags & YACC2) proto->flags &= ~YACC;
else proto->flags |= YACC2;
}
}
if (proto->flags & YACC)
while (op < ep && (n = *op++ = *ip))
{
ip++;
if (n == '%')
{
if (*ip == '%' && (ip == proto->ip + 1 || *(ip - 2) == '\n'))
{
*op++ = *ip++;
if (proto->flags & YACC2) proto->flags &= ~YACC;
else proto->flags |= YACC2;
break;
}
if (!*ip)
{
*op++ = '%';
proto->flags |= YACCSPLIT;
break;
}
}
else if (n == '\n') proto->line++;
}
proto->op = memcopy(proto->ob, proto->ip, ip - proto->ip);
proto->ip = ip;
}
else
#endif
lex(proto, proto->flags);
if ((proto->flags & (ERROR|MORE)) == ERROR)
proto->op = strcopy(proto->op, "/* NOTE: some constructs may not have been converted */\n");
}
n = proto->op - proto->ob;
proto->op = proto->ob;
}
return n;
}
#if !PROTOMAIN
/*
* drop control of iob after first pppread()
* return value is input fd
* if fd<0 then all data in iob
*/
int
pppdrop(char* iob)
{
register struct proto* proto = (struct proto*)(iob - sizeof(struct proto));
if (proto->flags & MORE)
{
proto->flags &= ~MORE;
return proto->fd;
}
return -1;
}
#endif