/* longline.t:  source of long logical line.    */

typedef  unsigned int  size_t; \

typedef struct __sfpos { \

char _pos[8]; \

} fpos_t; \

struct __sbuf { \

unsigned char *_base; \

int _size; \

}; \

typedef struct __sFILE { \

unsigned char *_p; \

int _r; \

int _w; \

short _flags; \

short _file; \

struct __sbuf _bf; \

int _lbfsize; \

 \

 \

void *_cookie; \

int (*_close)  (void *) ; \

int (*_read)  (void *, char *, int) ; \

fpos_t (*_seek)  (void *, fpos_t, int) ; \

int (*_write)  (void *, const char *, int) ; \

 \

 \

struct __sbuf _ub; \

unsigned char *_up; \

int _ur; \

 \

 \

unsigned char _ubuf[3]; \

unsigned char _nbuf[1]; \

 \

 \

struct __sbuf _lb; \

 \

 \

int _blksize; \

fpos_t _offset; \

} FILE; \

 \

   \

extern FILE __sF[]; \

   \

   \

void clearerr  (FILE *) ; \

int fclose  (FILE *) ; \

int feof  (FILE *) ; \

int ferror  (FILE *) ; \

int fflush  (FILE *) ; \

int fgetc  (FILE *) ; \

int fgetpos  (FILE *, fpos_t *) ; \

char *fgets  (char *, size_t, FILE *) ; \

FILE *fopen  (const char *, const char *) ; \

int fprintf  (FILE *, const char *, ...) ; \

int fputc  (int, FILE *) ; \

int fputs  (const char *, FILE *) ; \

                                             \

#ifndef X03FF

size_t fread  (void *, size_t, size_t, FILE *) ; \

FILE *freopen  (const char *, const char *, FILE *) ; \

int fscanf  (FILE *, const char *, ...) ; \

int fseek  (FILE *, long, int) ; \

int fsetpos  (FILE *, const fpos_t *) ; \

long ftell  (const FILE *) ; \

size_t fwrite  (const void *, size_t, size_t, FILE *) ; \

int getc  (FILE *) ; \

int getchar  (void) ; \

char *gets  (char *) ; \

 \

extern int sys_nerr; \

extern  const  char * const  sys_errlist[]; \

 \

void perror  (const char *) ; \

int printf  (const char *, ...) ; \

int putc  (int, FILE *) ; \

int putchar  (int) ; \

int puts  (const char *) ; \

int remove  (const char *) ; \

int rename  (const char *, const char *) ; \

void rewind  (FILE *) ; \

int scanf  (const char *, ...) ; \

void setbuf  (FILE *, char *) ; \

int setvbuf  (FILE *, char *, int, size_t) ; \

int sprintf  (char *, const char *, ...) ; \

int sscanf  (const char *, const char *, ...) ; \

FILE *tmpfile  (void) ; \

char *tmpnam  (char *) ; \

int ungetc  (int, FILE *) ; \

int vfprintf  (FILE *, const char *,  char * ) ; \

int vprintf  (const char *,  char * ) ; \

int vsprintf  (char *, const char *,  char * ) ; \

   \

   \

char *ctermid  (char *) ; \

FILE *fdopen  (int, const char *) ; \

int fileno  (FILE *) ; \

   \

   \

char *fgetln  (FILE *, size_t *) ; \

int fpurge  (FILE *) ; \

int getw  (FILE *) ; \

int pclose  (FILE *) ; \

FILE *popen  (const char *, const char *) ; \

int putw  (int, FILE *) ; \

void setbuffer  (FILE *, char *, int) ; \

int setlinebuf  (FILE *) ; \

char *tempnam  (const char *, const char *) ; \

int snprintf  (char *, size_t, const char *, ...) ; \

int vsnprintf  (char *, size_t, const char *,  char * ) ; \

int vscanf  (const char *,  char * ) ; \

int vsscanf  (const char *, const char *,  char * ) ; \

FILE *zopen  (const char *, const char *, int) ; \

   \

   \

FILE *funopen  (const void *, int (*)(void *, char *, int), int (*)(void *, const char *, int), fpos_t (*)(void *, fpos_t, int), int (*)(void *)) ; \

   \

   \

int __srget  (FILE *) ; \

int __svfscanf  (FILE *, const char *,  char * ) ; \

int __swbuf  (int, FILE *) ; \

   \

typedef  int  rune_t; \

                               \

#ifndef X07FF

typedef  int  wchar_t; \

typedef struct { \

rune_t min; \

rune_t max; \

rune_t map; \

unsigned long *types; \

} _RuneEntry; \

 \

typedef struct { \

int nranges; \

_RuneEntry *ranges; \

} _RuneRange; \

 \

typedef struct { \

char magic[8]; \

char encoding[32]; \

 \

rune_t (*sgetrune) \

 (const char *, unsigned int, char const **) ; \

int (*sputrune) \

 (rune_t, char *, unsigned int, char **) ; \

rune_t invalid_rune; \

 \

unsigned long runetype[ (1 <<8 ) ]; \

rune_t maplower[ (1 <<8 ) ]; \

rune_t mapupper[ (1 <<8 ) ]; \

_RuneRange runetype_ext; \

_RuneRange maplower_ext; \

_RuneRange mapupper_ext; \

 \

void *variable; \

int variable_len; \

} _RuneLocale; \

 \

 \

 \

extern _RuneLocale _DefaultRuneLocale; \

extern _RuneLocale *_CurrentRuneLocale; \

   \

unsigned long ___runetype  ( int ) ; \

 int  ___tolower  ( int ) ; \

 int  ___toupper  ( int ) ; \

   \

   \

int __istype  ( int , unsigned long) ; \

int __isctype  ( int , unsigned long) ; \

 int  toupper  ( int ) ; \

 int  tolower  ( int ) ; \

   \

extern int errno; \

   \

void *memchr  (const void *, int, size_t) ; \

int memcmp  (const void *, const void *, size_t) ; \

void *memcpy  (void *, const void *, size_t) ; \

void *memmove  (void *, const void *, size_t) ; \

void *memset  (void *, int, size_t) ; \

char *strcat  (char *, const char *) ; \

char *strchr  (const char *, int) ; \

int strcmp  (const char *, const char *) ; \

int strcoll  (const char *, const char *) ; \

char *strcpy  (char *, const char *) ; \

size_t strcspn  (const char *, const char *) ; \

char *strerror  (int) ; \

size_t strlen  (const char *) ; \

char *strncat  (char *, const char *, size_t) ; \

int strncmp  (const char *, const char *, size_t) ; \

char *strncpy  (char *, const char *, size_t) ; \

char *strpbrk  (const char *, const char *) ; \

char *strrchr  (const char *, int) ; \

size_t strspn  (const char *, const char *) ; \

char *strstr  (const char *, const char *) ; \

char *strtok  (char *, const char *) ; \

size_t strxfrm  (char *, const char *, size_t) ; \

 \

 \

 \

int bcmp  (const void *, const void *, size_t) ; \

void bcopy  (const void *, void *, size_t) ; \

void bzero  (void *, size_t) ; \

int ffs  (int) ; \

char *index  (const char *, int) ; \

void *memccpy  (void *, const void *, int, size_t) ; \

char *rindex  (const char *, int) ; \

int strcasecmp  (const char *, const char *) ; \

char *strdup  (const char *) ; \

void strmode  (int, char *) ; \

int strncasecmp  (const char *, const char *, size_t) ; \

char *strsep  (char **, const char *) ; \

void swab  (const void *, void *, size_t) ; \

 \

   \

typedef struct { \

int quot; \

int rem; \

} div_t; \

 \

typedef struct { \

long quot; \

long rem; \

} ldiv_t; \

extern int __mb_cur_max; \

 \

   \

   void \

abort  (void)    ; \

   int \

abs  (int) ; \

int atexit  (void (*)(void)) ; \

double atof  (const char *) ; \

int atoi  (const char *) ; \

long atol  (const char *) ; \

void *bsearch  (const void *, const void *, size_t, size_t, int (*)(const void *, const void *)) ; \

void *calloc  (size_t, size_t) ; \

   div_t \

div  (int, int) ; \

   void \

exit  (int)    ; \

void free  (void *) ; \

char *getenv  (const char *) ; \

   long \

labs  (long) ; \

   ldiv_t \

ldiv  (long, long) ; \

void *malloc  (size_t) ; \

void qsort  (void *, size_t, size_t, int (*)(const void *, const void *)) ; \

int rand  (void) ; \

void *realloc  (void *, size_t) ; \

void srand  (unsigned) ; \

double strtod  (const char *, char **) ; \

long strtol  (const char *, char **, int) ; \

unsigned long \

strtoul  (const char *, char **, int) ; \

int system  (const char *) ; \

 \

 \

int mblen  (const char *, size_t) ; \

size_t mbstowcs  (wchar_t *, const char *, size_t) ; \

int wctomb  (char *, wchar_t) ; \

int mbtowc  (wchar_t *, const char *, size_t) ; \

size_t wcstombs  (char *, const wchar_t *, size_t) ; \

 \

 \

int putenv  (const char *) ; \

int setenv  (const char *, const char *, int) ; \

 \

 \

 \

double drand48  (void) ; \

double erand48  (unsigned short[3]) ; \

long lrand48  (void) ; \

long nrand48  (unsigned short[3]) ; \

long mrand48  (void) ; \

long jrand48  (unsigned short[3]) ; \

void srand48  (long) ; \

unsigned short *seed48  (unsigned short[3]) ; \

void lcong48  (unsigned short[7]) ; \

 \

void *alloca  (size_t) ; \

 \

char *getbsize  (int *, long *) ; \

char *cgetcap  (char *, char *, int) ; \

int cgetclose  (void) ; \

                                                     \

#ifndef X0FFF

int cgetent  (char **, char **, char *) ; \

int cgetfirst  (char **, char **) ; \

int cgetmatch  (char *, char *) ; \

int cgetnext  (char **, char **) ; \

int cgetnum  (char *, char *, long *) ; \

int cgetset  (char *) ; \

int cgetstr  (char *, char *, char **) ; \

int cgetustr  (char *, char *, char **) ; \

 \

int daemon  (int, int) ; \

char *devname  (int, int) ; \

int getloadavg  (double [], int) ; \

 \

extern char *optarg; \

extern int opterr, optind, optopt; \

int getopt  (int, char * const *, const char *) ; \

 \

extern char *suboptarg; \

int getsubopt  (char **, char * const *, char **) ; \

 \

char *group_from_gid  (unsigned long, int) ; \

int heapsort  (void *, size_t, size_t, int (*)(const void *, const void *)) ; \

char *initstate  (unsigned, char *, int) ; \

int mergesort  (void *, size_t, size_t, int (*)(const void *, const void *)) ; \

int radixsort  (const unsigned char **, int, const unsigned char *, unsigned) ; \

int sradixsort  (const unsigned char **, int, const unsigned char *, unsigned) ; \

long random  (void) ; \

char *realpath  (const char *, char resolved_path[]) ; \

char *setstate  (char *) ; \

void srandom  (unsigned) ; \

char *user_from_uid  (unsigned long, int) ; \

void unsetenv  (const char *) ; \

 \

   \

typedef  int  ptrdiff_t; \

typedef  unsigned long  clock_t; \

 \

 \

 \

 \

typedef  long  time_t; \

struct tm { \

int tm_sec; \

int tm_min; \

int tm_hour; \

int tm_mday; \

int tm_mon; \

int tm_year; \

int tm_wday; \

int tm_yday; \

int tm_isdst; \

long tm_gmtoff; \

char *tm_zone; \

}; \

   \

char *asctime  (const struct tm *) ; \

clock_t clock  (void) ; \

char *ctime  (const time_t *) ; \

double difftime  (time_t, time_t) ; \

struct tm *gmtime  (const time_t *) ; \

struct tm *localtime  (const time_t *) ; \

time_t mktime  (struct tm *) ; \

size_t strftime  (char *, size_t, const char *, const struct tm *) ; \

time_t time  (time_t *) ; \

 \

 \

void tzset  (void) ; \

 \

 \

 \

char *timezone  (int, int) ; \

void tzsetwall  (void) ; \

 \

   \

extern int getopt( int argc, char * const * argv, const char * opts); \

extern char * stpcpy( char * dest, const char * src); \

typedef struct defbuf { \

struct defbuf * link; \

short nargs; \

 \

char * parmnames; \

 \

char * repl; \

char name[1]; \

} DEFBUF; \

typedef struct fileinfo { \

char * bptr; \

unsigned line; \

FILE * fp; \

long pos; \

struct fileinfo * parent; \

struct ifinfo * initif; \

char * filename; \

char * buffer; \

} FILEINFO; \

typedef struct ifinfo { \

int stat; \

unsigned ifline; \

unsigned elseline; \

} IFINFO; \

typedef struct val_sign { \

long val; \

int sign; \

} VAL_SIGN; \

extern    int cflag; \

extern int eflag; \

extern    int iflag; \

extern    int lflag; \

extern    int pflag; \

extern int qflag; \

 \

extern    int tflag; \

 \

 \

 \

extern    int digraphs; \

 \

extern    int stdc_val; \

extern long cplus; \

extern int stdc2; \

extern    int has_pragma; \

 \

extern    int std_line_prefix; \

extern    int warn_level; \

extern int errors; \

extern    unsigned line; \

extern    int wrongline; \

extern    int keepcomments; \

extern    int no_output; \

extern    int in_directive; \

extern    int in_define; \

extern    unsigned macro_line; \

extern    int openum; \

extern    IFINFO * ifptr; \

extern    FILEINFO * infile; \

extern int mkdep; \

 \

extern    char * workp; \

extern    char * const work_end; \

extern    char identifier[  0xFF  + 1]; \

extern const char type[]; \

extern IFINFO ifstack[]; \

extern char work[]; \

extern    int debug; \

extern void curfile( void); \

extern int openfile( const char * filename, int local); \

extern void unpredefine( int clearall); \

 \

extern int control( int newlines); \

extern DEFBUF * lookid( const char * name); \

extern DEFBUF * install( const char * name, int nargs, const char * parmnames \

, const char * repl); \

extern int undefine( const char * name); \

extern void dumpadef( const char * why, const DEFBUF * dp, int newdef); \

extern void dumpdef( void); \

 \

extern long eval( void); \

extern VAL_SIGN * evalnum( const char * nump); \

 \

extern DEFBUF * is_macro( char ** cp); \

extern char * expand( DEFBUF * defp, char * out, char * out_end); \

 \

extern int get_unexpandable( int c, int diag); \

extern void skipnl( void); \

extern int skipws( void); \

extern int scantoken( int c, char ** out_pp, char * out_end); \

extern char * scanquote( int delim, char * out, char * out_end, int diag); \

extern int get( void); \

 \

extern int trigraph( char * in); \

extern void unget( void); \

extern FILEINFO * ungetstring( const char * text, const char * name); \

extern char * savestring( const char * text); \

extern FILEINFO * getfile( const char * name, size_t bufsize); \

extern char * (xmalloc)( size_t size); \

extern char * (xrealloc)( char * ptr, size_t size); \

extern void cfatal( const char * format, const char * arg1, int arg2 \

, const char * arg3); \

extern void cerror( const char * format, const char * arg1, int arg2 \

, const char * arg3); \

extern void cwarn( const char * format, const char * arg1, int arg2 \

, const char * arg3); \

 \

extern void dooptions( int argc, char ** argv, char ** in_pp \

, char ** out_pp); \

extern int reopen_stdout( const char * filename); \

extern void setstdin( char * cp); \

extern void put_start_file( char * filename); \

extern void sharp( void); \

extern void putfname( char * filename); \

extern int getredirection( int argc, char ** argv); \

 \

extern void put_depend( const char * filename); \

 \

extern int doinclude( void); \

 \

extern void dopragma( void); \

extern void put_source( const char * src); \

extern void alloc_mem( void); \

 \

 \

 \

extern void dumpstring( const char * why, const char * text); \

extern void dumpunget( const char * why); \

 \

extern void print_heap( void); \

static void scanid( int c); \

static char * scannumber( int c, char * out, char * out_end); \

static char * scanop( int c, char * out); \

static char * parse_line( void); \

static char * read_a_comment( char * sp); \

static char * getline( int in_comment); \

static void at_eof( int in_comment); \

void dumptoken( int token_type, const char * cp); \

int \

 \

get_unexpandable( int c, int diag) \

{ \

DEFBUF * defp; \

FILEINFO * file; \

FILE * fp =  0 ; \

int token_type =  0 ; \

 \

while (c !=  '\0'  && c != '\n' \

&& (fp = infile->fp, \

(token_type = scantoken( c, (workp = work, &workp), work_end)) ==  65 ) \

&& fp !=  0  \

&& (defp = is_macro( (char **) 0 )) !=  0 ) { \

expand( defp, work, work_end); \

file = ungetstring( work, defp->name); \

c = skipws(); \

if (file != infile && macro_line !=  65535U  && (warn_level & 1)) \

cwarn( "Macro \"%s\" is expanded to 0 token" \

, defp->name, 0,  ((char *)  0 ) ); \

} \

 \

if (c == '\n' || c ==  '\0' ) { \

unget(); \

return  0 ; \

} \

 \

if (diag && fp ==  0  && token_type ==  65 ) { \

 \

if ( (strcmp(identifier, "defined") == 0)  && (warn_level & 1)) \

cwarn( "Macro \"%s\" is expanded to \"defined\"" \

, defp->name, 0,  ((char *)  0 ) ); \

} \

return token_type; \

} \

 \

void \

 \

skipnl( void) \

{ \

while (infile && infile->fp ==  0 ) { \

infile->bptr += strlen( infile->bptr); \

get(); \

} \

if (infile) \

infile->bptr += strlen( infile->bptr); \

} \

 \

int \

 \

skipws( void) \

{ \

   int c; \

 \

do { \

c = get(); \

} \

 \

while (c == ' ' || c ==  0x1F ); \

return c; \

} \

int \

 \

scantoken( int c, char ** out_pp, char * out_end) \

{ \

   char * out = *out_pp; \

int ch_type; \

int token_type = 0; \

int ch; \

 \

 \

ch_type = type[ c] & (~ ((char)128)  &  255 ); \

switch (ch_type) { \

case  1 : \

switch (c) { \

 \

case 'L': \

ch =  (*infile->bptr++ &  255 ) ; \

if (type[ ch] &  16 ) { \

if (ch == '"') \

token_type =  68 ; \

else \

token_type =  70 ; \

c = ch; \

*out++ = 'L'; \

break; \

} else { \

 (infile->bptr--) ; \

} \

 \

default: \

scanid( c); \

out = stpcpy( out, identifier); \

token_type =  65 ; \

break; \

} \

if (token_type ==  65 ) \

break; \

 \

case  16 : \

out = scanquote( c, out, out_end,  0 ); \

if (token_type == 0) { \

if (c == '"') \

token_type =  67 ; \

else \

token_type =  69 ; \

} \

break; \

case  4 : \

ch =  (*infile->bptr++ &  255 ) ; \

 (infile->bptr--) ; \

if (type[ ch] !=  2 ) \

goto operat; \

 \

case  2 : \

out = scannumber( c, out, out_end); \

token_type =  66 ; \

break; \

case  8 : \

operat: out = scanop( c, out); \

token_type =  71 ; \

break; \

default: \

if \

 \

 \

 \

((type[ c] &  32 ) || c ==  0x1E  || c ==  0x1D ) \

 \

token_type =  73 ; \

else \

token_type =  72 ; \

*out++ = c; \

*out =  '\0' ; \

break; \

} \

 \

if (out_end < out) \

cfatal( "Buffer overflow scanning token \"%s\"" \

, *out_pp, 0,  ((char *)  0 ) ); \

 \

if (debug &  2 ) \

dumptoken( token_type, *out_pp); \

*out_pp = out; \

 \

return token_type; \

} \

 \

static void \

 \

scanid( int c) \

{ \

static    char * const limit = &identifier[  0xFF ]; \

int long_ident =  0 ; \

   char * bp; \

 \

bp = identifier; \

 \

do { \

*bp++ = c; \

                                                            \

#ifndef X1FFF

c =  (*infile->bptr++ &  255 ) ; \

} while ((type[ c] & ( 1  |  2 )) && bp < limit); \

if (type[ c] & ( 1  |  2 )) { \

long_ident =  1 ; \

do { \

c =  (*infile->bptr++ &  255 ) ; \

} while (type[ c] & ( 1  |  2 )); \

} \

 (infile->bptr--) ; \

*bp =  '\0' ; \

 \

if (long_ident && (warn_level & 1)) \

cwarn( "Too long identifier truncated to \"%s\"" \

, identifier, 0,  ((char *)  0 ) ); \

 \

if (infile->fp && bp - identifier >  0x1F  && (warn_level & 2)) \

cwarn( "Identifier longer than %.0s%d bytes \"%s\"" \

,  ((char *)  0 ) ,  0x1F , identifier); \

} \

 \

char * \

 \

scanquote( int delim, char * out, char * out_end, int diag) \

{ \

const char * const skip_line = ", skipped the line"; \

const char * skip; \

   int c; \

int c1; \

char * out_p = out; \

 \

*out_p++ = delim; \

 \

if (delim == '<') \

delim = '>'; \

 \

 \

while ((c =  (*infile->bptr++ &  255 ) ) !=  '\0' ) { \

 \

 \

if (type[ c] &  64 ) { \

c1 =  (*infile->bptr++ &  255 ) ; \

if (type[ c1] &  ((char)128) ) { \

*out_p++ = c; \

*out_p++ = c1; \

goto chk_limit; \

} else { \

 (infile->bptr--) ; \

*out_p++ = c; \

if (infile->fp !=  0  &&  ifstack[0].stat  && diag) { \

*out_p = c1; \

*(out_p + 1) =  '\0' ; \

if (warn_level & 1) \

cwarn( \

"Illegal multi-byte character sequence \"%s\" in quotation", \

out_p - 1, 0,  ((char *)  0 ) ); \

} \

continue; \

} \

} \

 \

if (c == delim) { \

break; \

} else if (c == '\\' \

 \

&& delim != '>' \

 \

) { \

*out_p++ = c; \

c =  (*infile->bptr++ &  255 ) ; \

 \

if (type[ c] &  64 ) { \

 (infile->bptr--) ; \

continue; \

} \

} else if (c == ' ' && delim == '>' && infile->fp ==  0 ) { \

continue; \

 \

} else if (c == '\n') { \

break; \

} \

if (diag &&  __istype((c),  0x00000200L )  && ((type[ c] &  32 ) == 0) && (warn_level & 1)) \

cwarn( \

"Illegal control character %.0s0x%02x in quotation" \

,  ((char *)  0 ) , c,  ((char *)  0 ) ); \

*out_p++ = c; \

chk_limit: \

if (out_end < out_p) { \

*out_end =  '\0' ; \

cfatal( "Too long quotation %s", out, 0,  ((char *)  0 ) ); \

} \

} \

 \

if (c == '\n' || c ==  '\0' ) \

 (infile->bptr--) ; \

if (c == delim) \

*out_p++ = delim; \

*out_p =  '\0' ; \

if (diag) { \

skip = (infile->fp ==  0 ) ?  ((char *)  0 )  : skip_line; \

if (c != delim) { \

if (delim == '"') \

cerror( "Unterminated string literal %s%.0d%s" \

, out, 0, skip); \

else if (delim == '\'') \

cerror( "Unterminated character constant %s%.0d%s" \

, out, 0, skip); \

 \

else \

cerror( "Unterminated header name %s%.0d%s" \

, out, 0, skip); \

 \

out_p =  0 ; \

} else if (delim == '\'' && out_p - out <= 2) { \

cerror( "Empty character constant %s%.0d%s" \

, out, 0, skip); \

out_p =  0 ; \

} \

if (out_p - out >  0x1FD  && (warn_level & 2)) \

cwarn( "Quotation longer than %.0s%d bytes %s" \

,  ((char *)  0 ) ,  0x1FD , out); \

 \

} \

 \

return out_p; \

} \

static char * \

 \

scannumber( int c, char * out, char * out_end) \

{ \

char * out_p = out; \

 \

do { \

*out_p++ = c; \

if (c == 'E' || c == 'e') { \

c =  (*infile->bptr++ &  255 ) ; \

if (c == '+' || c == '-') { \

*out_p++ = c; \

c =  (*infile->bptr++ &  255 ) ; \

} \

} else { \

c =  (*infile->bptr++ &  255 ) ; \

} \

} while (type[ c] & ( 2  |  4  |  1 )); \

 \

*out_p =  '\0' ; \

if (out_end < out_p) \

cfatal( "Too long pp-number token \"%s\"" \

, out, 0,  ((char *)  0 ) ); \

 (infile->bptr--) ; \

return out_p; \

} \

static char * \

 \

scanop( int c, char * out) \

{ \

int c2, c3; \

 \

int c4; \

 \

 \

*out++ = c; \

 \

switch (c) { \

case '~': openum =  5 ; break; \

case '(': openum =  2 ; break; \

case ')': openum =  27 ; break; \

case '?': openum =  25 ; break; \

case ';': case '[': case ']': case '{': \

case '}': case ',': \

openum =  32 ; \

break; \

default: \

openum =  33 ; \

} \

 \

if (openum !=  33 ) { \

*out =  '\0' ; \

return out; \

} \

 \

c2 =  (*infile->bptr++ &  255 ) ; \

*out++ = c2; \

 \

switch (c) { \

case '=': \

openum = ((c2 == '=') ?  18  :  32 ); \

break; \

case '!': \

openum = ((c2 == '=') ?  19  :  6 ); \

break; \

case '&': \

switch (c2) { \

case '&': openum =  23 ; break; \

case '=': break; \

default : openum =  20 ; break; \

} \

break; \

case '|': \

switch (c2) { \

case '|': openum =  24 ; break; \

case '=': break; \

default : openum =  22 ; break; \

} \

break; \

case '<': \