root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/libraries/mcpp/test-l/longline.c
Alessandro Bonazzi e075990ed3 Patch level : 12.0 no-patch 
Files correlati     :
Commento            :

Aggiunto il preprocessore c++ mcpp per sostituire il compilatore nella compilazione delle maschere.
2020-11-28 16:24:08 +01:00

1538 lines
34 KiB
C
Raw Blame History

/* longline.c: 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 '<': \
switch (c2) { \
case '<': c3 = (*infile->bptr++ & 255 ) ; \
if (c3 == '=') { \
openum = 34 ; \
*out++ = c3; \
} else { \
openum = 12 ; \
(infile->bptr--) ; \
} \
break; \
case '=': openum = 15 ; break; \
\
case ':': \
if (digraphs) \
openum = 0x42 ; \
else \
openum = 14 ; \
break; \
case '%': \
if (digraphs) \
openum = 0x40 ; \
else \
openum = 14 ; \
break; \
\
default : openum = 14 ; break; \
} \
break; \
case '>': \
switch (c2) { \
case '>': c3 = (*infile->bptr++ & 255 ) ; \
if (c3 == '=') { \
openum = 34 ; \
*out++ = c3; \
} else { \
openum = 13 ; \
(infile->bptr--) ; \
} \
break; \
case '=': openum = 17 ; break; \
default : openum = 16 ; break; \
} \
break; \
case '#': \
\
if (in_define) \
openum = ((c2 == '#') ? 31 : 30 ); \
else \
\
openum = 32 ; \
break; \
case '+': \
switch (c2) { \
case '+': \
case '=': break; \
default : openum = 10 ; break; \
} \
break; \
case '-': \
switch (c2) { \
case '-': \
case '=': \
\
break; \
case '>': \
\
if (cplus) { \
if ((c3 = (*infile->bptr++ & 255 ) ) == '*') { \
openum = 34 ; \
*out++ = c3; \
} else { \
\
(infile->bptr--) ; \
} \
} \
break; \
default : openum = 11 ; break; \
} \
break; \
case '%': \
switch (c2) { \
case '=': break; \
\
case '>': \
if (digraphs) \
openum = 0x41 ; \
else \
openum = 9 ; \
break; \
case ':': \
if (! digraphs || ! in_define) { \
openum = 9 ; \
} else if ((c3 = (*infile->bptr++ & 255 ) ) == '%') { \
if ((c4 = (*infile->bptr++ & 255 ) ) == ':') { \
openum = 31 ; \
*out++ = c3; \
*out++ = c4; \
} else { \
(infile->bptr--) ; \
(infile->bptr--) ; \
openum = 30 ; \
} \
} else { \
(infile->bptr--) ; \
openum = 30 ; \
} \
break; \
\
default : openum = 9 ; break; \
} \
break; \
case '*': \
if (c2 != '=') \
openum = 7 ; \
\
break; \
case '/': \
if (c2 != '=') \
openum = 8 ; \
\
break; \
case '^': \
if (c2 != '=') \
openum = 21 ; \
\
break; \
case '.': \
\
if (c2 == '.') { \
c3 = (*infile->bptr++ & 255 ) ; \
if (c3 == '.') { \
openum = 34 ; \
*out++ = c3; \
break; \
} else { \
(infile->bptr--) ; \
openum = 32 ; \
} \
} \
\
else if (cplus && c2 == '*') \
; \
\
else \
openum = 32 ; \
break; \
case ':': \
\
if (stdc2 && c2 == ':') \
; \
\
else if (c2 == '>' && digraphs) \
openum = 0x43 ; \
\
else \
openum = 26 ; \
break; \
default: \
\
cfatal( "Bug: Punctuator is mis-implemented %.0s0x%x" \
, ((char *) 0 ) , c, ((char *) 0 ) ); \
\
openum = 32 ; \
break; \
} \
\
switch (openum) { \
\
case 30 : \
\
if (c == '%') break; \
\
\
case 32 : \
case 6 : case 20 : case 22 : case 14 : \
case 16 : case 10 : case 11 : case 9 : \
case 7 : case 8 : case 21 : case 5 : \
case 26 : \
\
(infile->bptr--) ; \
out--; \
break; \
default: \
break; \
} \
\
*out = '\0' ; \
return out; \
} \
int \
\
get( void) \
{ \
int len; \
int c; \
FILEINFO * file; \
\
if ((file = infile) == 0 ) \
return 0 ; \
if (debug & 32 ) { \
printf( "get(%s), line %u, bptr = %d, buffer" \
, file->filename ? file->filename : "NULL" \
, line, (int) (file->bptr - file->buffer)); \
dumpstring( ((char *) 0 ) , file->buffer); \
dumpunget( "get entrance"); \
} \
if ((c = (*file->bptr++ & 255 )) != '\0' ) { \
\
return c; \
} \
if (file->fp && \
parse_line() != 0 ) \
return get(); \
infile = file->parent; \
if (infile == 0 ) \
return 0 ; \
free(( char *)file->buffer); \
if (file->filename) \
free( file->filename); \
if (file->fp) { \
fclose( file->fp); \
if (! (strcmp("stdin", infile->filename) == 0) ) { \
infile->fp = fopen( infile->filename, "r"); \
fseek( infile->fp, infile->pos, 0 ); \
} \
len = (int) (infile->bptr - infile->buffer); \
infile->buffer = xrealloc( infile->buffer, 0x4000 ); \
\
infile->bptr = infile->buffer + len; \
line = infile->line; \
wrongline = 1 ; \
} \
free(( char *)file); \
return get(); \
} \
\
static char * \
\
parse_line( void) \
{ \
char * temp; \
char * limit; \
char * tp; \
char * sp; \
int c; \
\
if ((sp = getline( 0 )) == 0 ) \
return 0 ; \
tp = temp = xmalloc( (size_t) 0x4000 ); \
limit = temp + 0x4000 - 2; \
\
while ((c = *sp++ & 255 ) != '\n') { \
\
switch (c) { \
case '/': \
switch (*sp++) { \
case '*': \
if ((sp = read_a_comment( sp)) == 0 ) { \
free( temp); \
return 0 ; \
} \
\
\
\
\
\
if (temp < tp && *(tp - 1) != ' ') \
*tp++ = ' '; \
break; \
\
case '/': \
if (stdc2) { \
\
if (keepcomments) { \
(--((&__sF[1]))->_w < 0 ? ((&__sF[1]))->_w >= ((&__sF[1]))->_lbfsize ? (*((&__sF[1]))->_p = ('/')), *((&__sF[1]))->_p != '\n' ? (int)*((&__sF[1]))->_p++ : __swbuf('\n', (&__sF[1])) : __swbuf((int)('/'), (&__sF[1])) : (*((&__sF[1]))->_p = ('/'), (int)*((&__sF[1]))->_p++)) ; \
(--((&__sF[1]))->_w < 0 ? ((&__sF[1]))->_w >= ((&__sF[1]))->_lbfsize ? (*((&__sF[1]))->_p = ('*')), *((&__sF[1]))->_p != '\n' ? (int)*((&__sF[1]))->_p++ : __swbuf('\n', (&__sF[1])) : __swbuf((int)('*'), (&__sF[1])) : (*((&__sF[1]))->_p = ('*'), (int)*((&__sF[1]))->_p++)) ; \
while ((c = *sp++) != '\n') \
(--((&__sF[1]))->_w < 0 ? ((&__sF[1]))->_w >= ((&__sF[1]))->_lbfsize ? (*((&__sF[1]))->_p = (c)), *((&__sF[1]))->_p != '\n' ? (int)*((&__sF[1]))->_p++ : __swbuf('\n', (&__sF[1])) : __swbuf((int)(c), (&__sF[1])) : (*((&__sF[1]))->_p = (c), (int)*((&__sF[1]))->_p++)) ; \
(--((&__sF[1]))->_w < 0 ? ((&__sF[1]))->_w >= ((&__sF[1]))->_lbfsize ? (*((&__sF[1]))->_p = ('*')), *((&__sF[1]))->_p != '\n' ? (int)*((&__sF[1]))->_p++ : __swbuf('\n', (&__sF[1])) : __swbuf((int)('*'), (&__sF[1])) : (*((&__sF[1]))->_p = ('*'), (int)*((&__sF[1]))->_p++)) ; \
(--((&__sF[1]))->_w < 0 ? ((&__sF[1]))->_w >= ((&__sF[1]))->_lbfsize ? (*((&__sF[1]))->_p = ('/')), *((&__sF[1]))->_p != '\n' ? (int)*((&__sF[1]))->_p++ : __swbuf('\n', (&__sF[1])) : __swbuf((int)('/'), (&__sF[1])) : (*((&__sF[1]))->_p = ('/'), (int)*((&__sF[1]))->_p++)) ; \
} \
goto end_line; \
} \
\
default: \
*tp++ = '/'; \
sp--; \
break; \
} \
break; \
case '\r': \
case '\f': \
\
\
\
case '\v': \
\
if (warn_level & 1) \
cwarn( "Converted %.0s0x%02x to a space" \
, ((char *) 0 ) , c, ((char *) 0 ) ); \
case '\t': \
case ' ': \
\
if (temp < tp && *(tp - 1) != ' ') \
*tp++ = ' '; \
break; \
case '"': \
case '\'': \
infile->bptr = sp; \
\
tp = scanquote( c, tp, limit, 1 ); \
if (tp == 0 ) { \
free( temp); \
return parse_line(); \
} \
sp = infile->bptr; \
break; \
default: \
if ( __istype((c), 0x00000200L ) ) { \
cerror( \
"Illegal control character %.0s0x%x, skipped the character" \
, ((char *) 0 ) , c, ((char *) 0 ) ); \
} else { \
*tp++ = c; \
} \
break; \
} \
\
if (limit < tp) { \
*tp = '\0' ; \
cfatal( "Too long line spliced by comments :%s" \
, temp, 0, ((char *) 0 ) ); \
} \
} \
\
\
end_line: \
\
if (temp < tp && *(tp - 1) == ' ') \
tp--; \
*tp++ = '\n'; \
*tp = '\0' ; \
infile->bptr = strcpy( infile->buffer, temp); \
free( temp); \
if (macro_line != 0 && macro_line != 65535U ) { \
\
\
\
\
\
\
\
\
\
\
if (*(infile->buffer) == '#' \
\
|| (*(infile->buffer) == '%' && *(infile->buffer + 1) == ':') \
\
) \
\
if (warn_level & 1) \
cwarn( \
"Macro started at line %.0s%u swallowed directive-like line" \
, ((char *) 0 ) , macro_line, ((char *) 0 ) ); \
} \
return infile->buffer; \
} \
\
static char * \
\
read_a_comment( char * sp) \
{ \
int c; \
\
if (keepcomments) { \
(--((&__sF[1]))->_w < 0 ? ((&__sF[1]))->_w >= ((&__sF[1]))->_lbfsize ? (*((&__sF[1]))->_p = ('/')), *((&__sF[1]))->_p != '\n' ? (int)*((&__sF[1]))->_p++ : __swbuf('\n', (&__sF[1])) : __swbuf((int)('/'), (&__sF[1])) : (*((&__sF[1]))->_p = ('/'), (int)*((&__sF[1]))->_p++)) ; \
(--((&__sF[1]))->_w < 0 ? ((&__sF[1]))->_w >= ((&__sF[1]))->_lbfsize ? (*((&__sF[1]))->_p = ('*')), *((&__sF[1]))->_p != '\n' ? (int)*((&__sF[1]))->_p++ : __swbuf('\n', (&__sF[1])) : __swbuf((int)('*'), (&__sF[1])) : (*((&__sF[1]))->_p = ('*'), (int)*((&__sF[1]))->_p++)) ; \
} \
c = *sp++; \
\
while (1) { \
if (keepcomments) \
(--((&__sF[1]))->_w < 0 ? ((&__sF[1]))->_w >= ((&__sF[1]))->_lbfsize ? (*((&__sF[1]))->_p = (c)), *((&__sF[1]))->_p != '\n' ? (int)*((&__sF[1]))->_p++ : __swbuf('\n', (&__sF[1])) : __swbuf((int)(c), (&__sF[1])) : (*((&__sF[1]))->_p = (c), (int)*((&__sF[1]))->_p++)) ; \
\
switch (c) { \
case '/': \
if ((c = *sp++) != '*') \
continue; \
if (warn_level & 1) \
cwarn( "\"/*\" in comment", ((char *) 0 ) , 0, ((char *) 0 ) ); \
if (keepcomments) \
(--((&__sF[1]))->_w < 0 ? ((&__sF[1]))->_w >= ((&__sF[1]))->_lbfsize ? (*((&__sF[1]))->_p = (c)), *((&__sF[1]))->_p != '\n' ? (int)*((&__sF[1]))->_p++ : __swbuf('\n', (&__sF[1])) : __swbuf((int)(c), (&__sF[1])) : (*((&__sF[1]))->_p = (c), (int)*((&__sF[1]))->_p++)) ; \
\
case '*': \
if ((c = *sp++) != '/') \
continue; \
if (keepcomments) \
(--((&__sF[1]))->_w < 0 ? ((&__sF[1]))->_w >= ((&__sF[1]))->_lbfsize ? (*((&__sF[1]))->_p = (c)), *((&__sF[1]))->_p != '\n' ? (int)*((&__sF[1]))->_p++ : __swbuf('\n', (&__sF[1])) : __swbuf((int)(c), (&__sF[1])) : (*((&__sF[1]))->_p = (c), (int)*((&__sF[1]))->_p++)) ; \
return sp; \
case '\n': \
if (! keepcomments) \
wrongline = 1 ; \
if ((sp = getline( 1 )) == 0 ) \
return 0 ; \
break; \
default: \
break; \
} \
\
c = *sp++; \
} \
\
return sp; \
} \
\
static char * \
\
getline( int in_comment) \
{ \
\
int converted = 0 ; \
\
\
int esc; \
\
int len; \
char * ptr; \
\
if (infile == 0 ) \
return 0 ; \
ptr = infile->bptr = infile->buffer; \
\
while (fgets( ptr, (int) (infile->buffer + 0x4000 - ptr), infile->fp) \
!= 0 ) { \
\
line++; \
if (line == 32768U && (warn_level & 1)) \
cwarn( "Line number %.0s\"%u\" got beyond range" \
, ((char *) 0 ) , line, ((char *) 0 ) ); \
\
if (debug & ( 2 | 32 )) { \
printf( "\n#line %u (%s)", line \
, infile->filename ? infile->filename : "NULL"); \
dumpstring( ((char *) 0 ) , ptr); \
} \
\
len = strlen( ptr); \
if ( 0x4000 - 1 <= ptr - infile->buffer + len \
&& *(ptr + len - 1) != '\n') { \
if ( 0x4000 - 1 <= len) \
cfatal( "Too long source line" \
, ((char *) 0 ) , 0, ((char *) 0 ) ); \
else \
cfatal( "Too long logical line" \
, ((char *) 0 ) , 0, ((char *) 0 ) ); \
} \
if (*(ptr + len - 1) != '\n') \
break; \
if (lflag) \
put_source( ptr); \
\
if (tflag) \
converted = trigraph( ptr); \
if (converted) \
len = strlen( ptr); \
\
\
\
len -= 2; \
if (len >= 0) { \
esc = (*(ptr + len) == '\\'); \
if (esc) { \
ptr = infile->bptr += len; \
wrongline = 1 ; \
continue; \
} \
} \
\
\
if (ptr - infile->buffer + len + 2 > 0x1FD + 1 && (warn_level & 2)) \
\
cwarn( "Logical source line longer than %.0s%d bytes" \
, ((char *) 0 ) , 0x1FD , ((char *) 0 ) ); \
\
return infile->bptr = infile->buffer; \
} \
\
\
if ( (((infile->fp)->_flags & 0x0040 ) != 0) ) \
cfatal( "File read error", ((char *) 0 ) , 0, ((char *) 0 ) ); \
at_eof( in_comment); \
if (iflag) { \
no_output--; \
keepcomments = cflag && ifstack[0].stat && !no_output; \
} \
return 0 ; \
} \
\
\
\
\
\
int \
\
trigraph( char * in) \
{ \
const char * const tritext = "=(/)'<!>-\0#[\\]^{|}~"; \
int count = 0; \
const char * tp; \
\
while ((in = strchr( in, '?')) != 0 ) { \
if (*++in != '?') \
continue; \
while (*++in == '?') \
; \
if ((tp = strchr( tritext, *in)) == 0 ) \
continue; \
in[ -2] = tp[ 10 ]; \
in--; \
memmove( in, in + 2, strlen( in + 1)); \
count++; \
} \
\
if (count && (warn_level & 8)) \
cwarn( "%.0s%d trigraph(s) converted" \
, ((char *) 0 ) , count, ((char *) 0 ) ); \
return count; \
} \
static void \
\
at_eof( int in_comment) \
{ \
const char * const format \
= "End of %s with %.0d%s"; \
const char * const unterm_if_format \
= "End of %s within #if (#ifdef) section started at line %u"; \
const char * const unterm_macro_format \
= "End of %s within macro call started at line %u"; \
const char * const input \
= infile->parent ? "file" : "input"; \
const char * const no_newline \
= "no newline, skipped the line"; \
const char * const unterm_com \
= "unterminated comment, skipped the line"; \
\
const char * const backsl = "\\, skipped the line"; \
int len; \
char * cp = infile->buffer; \
IFINFO * ifp; \
\
len = strlen( cp); \
if (len && *(cp += (len - 1)) != '\n') { \
line++; \
*++cp = '\n'; \
*++cp = '\0' ; \
cerror( format, input, 0, no_newline); \
} \
\
\
if (infile->buffer < infile->bptr) \
cerror( format, input, 0, backsl); \
\
\
if (in_comment) \
cerror( format, input, 0, unterm_com); \
\
if (infile->initif < ifptr) { \
ifp = infile->initif + 1; \
\
cerror( unterm_if_format, input, ifp->ifline, ((char *) 0 ) ); \
ifptr = infile->initif; \
ifstack[0].stat = ifptr->stat; \
} \
\
if (macro_line != 0 && macro_line != 65535U ) { \
\
cerror( unterm_macro_format, input, macro_line, ((char *) 0 ) ); \
macro_line = 65535U ; \
} \
} \
\
void \
\
unget( void) \
{ \
if (infile != 0 ) { \
--infile->bptr; \
\
if (infile->bptr < infile->buffer) \
cfatal( "Bug: Too much pushback", ((char *) 0 ) , 0, ((char *) 0 ) ); \
\
} \
\
\
if (debug & 32 ) \
dumpunget( "after unget"); \
\
} \
\
FILEINFO * \
\
ungetstring( const char * text, const char * name) \
{ \
FILEINFO * file; \
size_t size; \
\
if (text) \
size = strlen( text) + 1; \
else \
size = 1; \
file = getfile( name, size); \
if (text) \
memcpy( file->buffer, text, size); \
else \
*file->buffer = '\0' ; \
return file; \
} \
\
char * \
\
savestring( const char * text) \
{ \
char * result; \
size_t size; \
\
size = strlen( text) + 1; \
result = xmalloc( size); \
memcpy( result, text, size); \
return result; \
} \
\
FILEINFO * \
\
getfile( const char * name, size_t bufsize) \
{ \
FILEINFO * file; \
size_t s_name; \
\
file = (FILEINFO *) xmalloc( sizeof (FILEINFO)); \
file->buffer = xmalloc( bufsize); \
if (name) { \
s_name = strlen( name) + 1; \
file->filename = (char *) xmalloc( s_name); \
memcpy( file->filename, name, s_name); \
} else { \
file->filename = 0 ; \
} \
\
file->bptr = file->buffer; \
return file; } \
#endif
#endif
#endif
#endif
Reference in New Issue View Git Blame Copy Permalink