Return to cpplib.h CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/cpplib.h, revision 1.1

1.1     ! root        1: /* Definitions for CPP library.
        !             2:    Copyright (C) 1995 Free Software Foundation, Inc.
        !             3:    Written by Per Bothner, 1994-95.
        !             4: 
        !             5: This program is free software; you can redistribute it and/or modify it
        !             6: under the terms of the GNU General Public License as published by the
        !             7: Free Software Foundation; either version 2, or (at your option) any
        !             8: later version.
        !             9: 
        !            10: This program is distributed in the hope that it will be useful,
        !            11: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            13: GNU General Public License for more details.
        !            14: 
        !            15: You should have received a copy of the GNU General Public License
        !            16: along with this program; if not, write to the Free Software
        !            17: Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
        !            18: 
        !            19:  In other words, you are welcome to use, share and improve this program.
        !            20:  You are forbidden to forbid anyone else to use, share and improve
        !            21:  what you give them.   Help stamp out software-hoarding!  */
        !            22: 
        !            23: #include <sys/types.h>
        !            24: #include <sys/stat.h>
        !            25: 
        !            26: #ifdef __cplusplus
        !            27: extern "C" {
        !            28: #endif
        !            29: 
        !            30: #define STATIC_BUFFERS
        !            31: 
        !            32: typedef unsigned char U_CHAR;
        !            33: 
        !            34: struct parse_file;
        !            35: typedef struct cpp_reader cpp_reader;
        !            36: typedef struct cpp_buffer cpp_buffer;
        !            37: typedef struct cpp_options cpp_options;
        !            38: typedef struct hashnode cpp_hashnode;
        !            39: 
        !            40: enum cpp_token {
        !            41:   CPP_EOF = -1,
        !            42:   CPP_OTHER = 0,
        !            43:   CPP_COMMENT = 1,
        !            44:   CPP_HSPACE,
        !            45:   CPP_VSPACE, /* newlines and #line directives */
        !            46:   CPP_NAME,
        !            47:   CPP_NUMBER,
        !            48:   CPP_CHAR,
        !            49:   CPP_STRING,
        !            50:   CPP_DIRECTIVE,
        !            51:   CPP_LPAREN,   /* "(" */
        !            52:   CPP_RPAREN,   /* ")" */
        !            53:   CPP_LBRACE,   /* "{" */
        !            54:   CPP_RBRACE,   /* "}" */
        !            55:   CPP_COMMA,    /* "," */
        !            56:   CPP_SEMICOLON,/* ";" */
        !            57:   CPP_3DOTS,    /* "..." */
        !            58: #if 0
        !            59:   CPP_ANDAND, /* "&&" */
        !            60:   CPP_OROR,   /* "||" */
        !            61:   CPP_LSH,    /* "<<" */
        !            62:   CPP_RSH,    /* ">>" */
        !            63:   CPP_EQL,    /* "==" */
        !            64:   CPP_NEQ,    /* "!=" */
        !            65:   CPP_LEQ,    /* "<=" */
        !            66:   CPP_GEQ,    /* ">=" */
        !            67:   CPP_PLPL,   /* "++" */
        !            68:   CPP_MINMIN, /* "--" */
        !            69: #endif
        !            70:   /* POP_TOKEN is returned when we've popped a cpp_buffer. */
        !            71:   CPP_POP
        !            72: };
        !            73: 
        !            74: #ifndef PARAMS
        !            75: #ifdef __STDC
        !            76: #define PARAMS(P) P
        !            77: #else
        !            78: #define PARAMS(P) ()
        !            79: #endif
        !            80: #endif /* !PARAMS */
        !            81: 
        !            82: typedef enum cpp_token (*parse_underflow_t) PARAMS((cpp_reader*));
        !            83: typedef int (*parse_cleanup_t) PARAMS((cpp_buffer *, cpp_reader*));
        !            84: 
        !            85: /* A parse_marker indicates a previous position,
        !            86:    which we can backtrack to. */
        !            87: 
        !            88: struct parse_marker {
        !            89:   cpp_buffer *buf;
        !            90:   struct parse_marker *next;
        !            91:   int position;
        !            92: };
        !            93: 
        !            94: extern void parse_set_mark PARAMS ((struct parse_marker*, cpp_reader*));
        !            95: extern void parse_clear_mark PARAMS ((struct parse_marker*));
        !            96: extern void parse_goto_mark PARAMS((struct parse_marker*, cpp_reader*));
        !            97: extern void parse_move_mark PARAMS((struct parse_marker*, cpp_reader*));
        !            98: 
        !            99: extern int cpp_handle_options PARAMS ((cpp_reader*, int, char**));
        !           100: extern enum cpp_token cpp_get_token PARAMS ((struct parse_marker*));
        !           101: extern void cpp_skip_hspace PARAMS((cpp_reader*));
        !           102: extern enum cpp_token cpp_get_non_space_token PARAMS ((cpp_reader *));
        !           103: 
        !           104: 
        !           105: /* Maintain and search list of included files, for #import.  */
        !           106: 
        !           107: #define IMPORT_HASH_SIZE 31
        !           108: 
        !           109: struct import_file {
        !           110:   char *name;
        !           111:   ino_t inode;
        !           112:   dev_t dev;
        !           113:   struct import_file *next;
        !           114: };
        !           115: 
        !           116: /* If we have a huge buffer, may need to cache more recent counts */
        !           117: #define CPP_LINE_BASE(BUF) ((BUF)->buf + (BUF)->line_base)
        !           118: 
        !           119: struct cpp_buffer {
        !           120:   unsigned char *buf;
        !           121:   unsigned char *cur;
        !           122:   unsigned char *rlimit; /* end of valid data */
        !           123:   unsigned char *alimit; /* end of allocated buffer */
        !           124:   unsigned char *prev;  /* start of current token */
        !           125: 
        !           126:   char *fname;
        !           127:   /* Filename specified with #line command.  */
        !           128:   char *nominal_fname;
        !           129: 
        !           130:   /* Record where in the search path this file was found.
        !           131:      For #include_next.  */
        !           132:   struct file_name_list *dir;
        !           133: 
        !           134:   long line_base;
        !           135:   long lineno; /* Line number at CPP_LINE_BASE. */
        !           136:   long colno; /* Column number at CPP_LINE_BASE. */
        !           137: #ifndef STATIC_BUFFERS
        !           138:   cpp_buffer *chain;
        !           139: #endif
        !           140:   parse_underflow_t underflow;
        !           141:   parse_cleanup_t cleanup;
        !           142:   void *data;
        !           143:   struct parse_marker *marks;
        !           144:   /* Value of if_stack at start of this file.
        !           145:      Used to prohibit unmatched #endif (etc) in an include file.  */
        !           146:   struct if_stack *if_stack;
        !           147: 
        !           148:   /* True if this is a header file included using <FILENAME>.  */
        !           149:   char system_header_p;
        !           150:   char seen_eof;
        !           151: 
        !           152:   /* True if buffer contains escape sequences.
        !           153:      Currently there are are only two kind:
        !           154:      "@-" means following identifier should not be macro-expanded.
        !           155:      "@ " means a token-separator.  This turns into " " in final output
        !           156:           if not stringizing and needed to separate tokens; otherwise nothing.
        !           157:      "@@" means a normal '@'.
        !           158:      (An '@' inside a string stands for itself and is never an escape.) */
        !           159:   char has_escapes;
        !           160: };
        !           161: 
        !           162: struct cpp_pending;  /* Forward declaration - for C++. */
        !           163: struct file_name_map_list;
        !           164: 
        !           165: typedef struct assertion_hashnode ASSERTION_HASHNODE;
        !           166: #define ASSERTION_HASHSIZE 37
        !           167: 
        !           168: #ifdef STATIC_BUFFERS
        !           169: /* Maximum nesting of cpp_buffers.  We use a static limit, partly for
        !           170:    efficiency, and partly to limit runaway recursion.  */
        !           171: #define CPP_STACK_MAX 200
        !           172: #endif
        !           173: 
        !           174: struct cpp_reader {
        !           175:   unsigned char *limit;
        !           176:   parse_underflow_t get_token;
        !           177:   cpp_buffer *buffer;
        !           178: #ifdef STATIC_BUFFERS
        !           179:   cpp_buffer buffer_stack[CPP_STACK_MAX];
        !           180: #endif
        !           181: 
        !           182:   int errors;                  /* Error counter for exit code */
        !           183:   void *data;
        !           184: 
        !           185:   U_CHAR *token_buffer;
        !           186:   int token_buffer_size;
        !           187: 
        !           188:   /* Line where a newline was first seen in a string constant.  */
        !           189:   int multiline_string_line;
        !           190: 
        !           191:   /* Current depth in #include directives that use <...>.  */
        !           192:   int system_include_depth;
        !           193: 
        !           194:   /* List of included files that contained #pragma once.  */
        !           195:   struct file_name_list *dont_repeat_files;
        !           196: 
        !           197:   /* List of other included files.
        !           198:      If ->control_macro if nonzero, the file had a #ifndef
        !           199:      around the entire contents, and ->control_macro gives the macro name.  */
        !           200:   struct file_name_list *all_include_files;
        !           201: 
        !           202:   /* Current maximum length of directory names in the search path
        !           203:      for include files.  (Altered as we get more of them.)  */
        !           204:   int max_include_len;
        !           205: 
        !           206:   /* Hash table of files already included with #include or #import.  */
        !           207:   struct import_file *import_hash_table[IMPORT_HASH_SIZE];
        !           208: 
        !           209:   struct if_stack *if_stack;
        !           210: 
        !           211:   /* Nonzero means we are inside an IF during a -pcp run.  In this mode
        !           212:      macro expansion is done, and preconditions are output for all macro
        !           213:      uses requiring them. */
        !           214:   char pcp_inside_if;
        !           215: 
        !           216:   /* Nonzero means we have printed (while error reporting) a list of
        !           217:      containing files that matches the current status. */
        !           218:   char input_stack_listing_current;
        !           219: 
        !           220:   /* If non-zero, macros are not expanded. */
        !           221:   char no_macro_expand;
        !           222: 
        !           223:   /* Print column number in error messages. */
        !           224:   char show_column;
        !           225: 
        !           226:   /* We're printed a warning recommending against using #import. */
        !           227:   char import_warning;
        !           228: 
        !           229:   /* If true, character between '<' and '>' are a single (string) token. */
        !           230:   char parsing_include_directive;
        !           231: 
        !           232:   /* True if escape sequences (as described for has_escapes in
        !           233:      parse_buffer) should be emitted. */
        !           234:   char output_escapes;
        !           235: 
        !           236:   /* 0: Have seen non-white-space on this line.
        !           237:      1: Only seen white space so far on this line.
        !           238:      2: Only seen white space so far in this file. */
        !           239:    char only_seen_white;
        !           240: 
        !           241:   /* Nonzero means this file was included with a -imacros or -include
        !           242:      command line and should not be recorded as an include file.  */
        !           243: 
        !           244:   int no_record_file;
        !           245: 
        !           246:   long lineno;
        !           247: 
        !           248:   struct tm *timebuf;
        !           249: 
        !           250:   ASSERTION_HASHNODE *assertion_hashtab[ASSERTION_HASHSIZE];
        !           251: 
        !           252:   /* Buffer of -M output.  */
        !           253:   char *deps_buffer;
        !           254: 
        !           255:   /* Number of bytes allocated in above.  */
        !           256:   int deps_allocated_size;
        !           257: 
        !           258:   /* Number of bytes used.  */
        !           259:   int deps_size;
        !           260: 
        !           261:   /* Number of bytes since the last newline.  */
        !           262:   int deps_column;
        !           263: };
        !           264: 
        !           265: #define CPP_BUF_PEEK(BUFFER) \
        !           266:   ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur : EOF)
        !           267: #define CPP_BUF_GET(BUFFER) \
        !           268:   ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur++ : EOF)
        !           269: #define CPP_FORWARD(BUFFER, N) ((BUFFER)->cur += (N))
        !           270: 
        !           271: /* Number of characters currently in PFILE's output buffer. */
        !           272: #define CPP_WRITTEN(PFILE) ((PFILE)->limit - (PFILE)->token_buffer)
        !           273: #define CPP_PWRITTEN(PFILE) ((PFILE)->limit)
        !           274: 
        !           275: /* Make sure PFILE->token_buffer has space for at least N more characters. */
        !           276: #define CPP_RESERVE(PFILE, N) \
        !           277:   (CPP_WRITTEN (PFILE) + N > (PFILE)->token_buffer_size \
        !           278:    && (cpp_grow_buffer (PFILE, N), 0))
        !           279: 
        !           280: /* Append string STR (of length N) to PFILE's output buffer.
        !           281:    Assume there is enough space. */
        !           282: #define CPP_PUTS_Q(PFILE, STR, N) \
        !           283:   (bcopy (STR, (PFILE)->limit, (N)), (PFILE)->limit += (N))
        !           284: /* Append string STR (of length N) to PFILE's output buffer.  Make space. */
        !           285: #define CPP_PUTS(PFILE, STR, N) CPP_RESERVE(PFILE, N), CPP_PUTS_Q(PFILE, STR,N)
        !           286: /* Append character CH to PFILE's output buffer.  Assume sufficient space. */
        !           287: #define CPP_PUTC_Q(PFILE, CH) (*(PFILE)->limit++ = (CH))
        !           288: /* Append character CH to PFILE's output buffer.  Make space if need be. */
        !           289: #define CPP_PUTC(PFILE, CH) (CPP_RESERVE (PFILE, 1), CPP_PUTC_Q (PFILE, CH))
        !           290: /* Make sure PFILE->limit is followed by '\0'. */
        !           291: #define CPP_NUL_TERMINATE_Q(PFILE) (*(PFILE)->limit = 0)
        !           292: #define CPP_NUL_TERMINATE(PFILE) (CPP_RESERVE(PFILE, 1), *(PFILE)->limit = 0)
        !           293: #define CPP_ADJUST_WRITTEN(PFILE,DELTA) ((PFILE)->limit += (DELTA))
        !           294: #define CPP_SET_WRITTEN(PFILE,N) ((PFILE)->limit = (PFILE)->token_buffer + (N))
        !           295: 
        !           296: #define CPP_OPTIONS(PFILE) ((cpp_options*)(PFILE)->data)
        !           297: #define CPP_BUFFER(PFILE) ((PFILE)->buffer)
        !           298: #ifdef STATIC_BUFFERS
        !           299: #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)+1)
        !           300: #define CPP_NULL_BUFFER(PFILE) (&(PFILE)->buffer_stack[CPP_STACK_MAX])
        !           301: #else
        !           302: #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)->chain)
        !           303: #define CPP_NULL_BUFFER(PFILE) ((cpp_buffer*)0)
        !           304: #endif
        !           305: 
        !           306: /* Pointed to by parse_file::data. */
        !           307: struct cpp_options {
        !           308:   char *in_fname;
        !           309: 
        !           310:   /* Name of output file, for error messages.  */
        !           311:   char *out_fname;
        !           312: 
        !           313:   struct file_name_map_list *map_list;
        !           314: 
        !           315:   /* Non-0 means -v, so print the full set of include dirs.  */
        !           316:   char verbose;
        !           317: 
        !           318:   /* Nonzero means use extra default include directories for C++.  */
        !           319: 
        !           320:   char cplusplus;
        !           321: 
        !           322:   /* Nonzero means handle cplusplus style comments */
        !           323: 
        !           324:   char cplusplus_comments;
        !           325: 
        !           326:   /* Nonzero means handle #import, for objective C.  */
        !           327: 
        !           328:   char objc;
        !           329: 
        !           330:   /* Nonzero means this is an assembly file, and allow
        !           331:      unknown directives, which could be comments.  */
        !           332: 
        !           333:   int lang_asm;
        !           334: 
        !           335:   /* Nonzero means turn NOTREACHED into #pragma NOTREACHED etc */
        !           336: 
        !           337:   char for_lint;
        !           338: 
        !           339:   /* Nonzero means handle CHILL comment syntax
        !           340:      and output CHILL string delimiter for __DATE___ etc. */
        !           341: 
        !           342:   char chill;
        !           343: 
        !           344:   /* Nonzero means copy comments into the output file.  */
        !           345: 
        !           346:   char put_out_comments;
        !           347: 
        !           348:   /* Nonzero means don't process the ANSI trigraph sequences.  */
        !           349: 
        !           350:   char no_trigraphs;
        !           351: 
        !           352:   /* Nonzero means print the names of included files rather than
        !           353:      the preprocessed output.  1 means just the #include "...",
        !           354:      2 means #include <...> as well.  */
        !           355: 
        !           356:   char print_deps;
        !           357: 
        !           358:   /* Nonzero if missing .h files in -M output are assumed to be generated
        !           359:      files and not errors.  */
        !           360: 
        !           361:   char print_deps_missing_files;
        !           362: 
        !           363:   /* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */
        !           364:   char print_deps_append;
        !           365: 
        !           366:   /* Nonzero means print names of header files (-H).  */
        !           367: 
        !           368:   char print_include_names;
        !           369: 
        !           370:   /* Nonzero means try to make failure to fit ANSI C an error.  */
        !           371: 
        !           372:   char pedantic_errors;
        !           373: 
        !           374:   /* Nonzero means don't print warning messages.  -w.  */
        !           375: 
        !           376:   char inhibit_warnings;
        !           377: 
        !           378:   /* Nonzero means warn if slash-star appears in a comment.  */
        !           379: 
        !           380:   char warn_comments;
        !           381: 
        !           382:   /* Nonzero means warn if there are any trigraphs.  */
        !           383: 
        !           384:   char warn_trigraphs;
        !           385: 
        !           386:   /* Nonzero means warn if #import is used.  */
        !           387: 
        !           388:   char warn_import;
        !           389: 
        !           390:   /* Nonzero means warn if a macro argument is (or would be)
        !           391:      stringified with -traditional.  */
        !           392: 
        !           393:   char warn_stringify;
        !           394: 
        !           395:   /* Nonzero means turn warnings into errors.  */
        !           396: 
        !           397:   char warnings_are_errors;
        !           398: 
        !           399:   /* Nonzero causes output not to be done,
        !           400:      but directives such as #define that have side effects
        !           401:      are still obeyed.  */
        !           402: 
        !           403:   char no_output;
        !           404: 
        !           405:   /* Nonzero means don't output line number information.  */
        !           406: 
        !           407:   char no_line_commands;
        !           408: 
        !           409: /* Nonzero means output the text in failing conditionals,
        !           410:    inside #failed ... #endfailed.  */
        !           411: 
        !           412:   char output_conditionals;
        !           413: 
        !           414:   /* Nonzero means -I- has been seen,
        !           415:      so don't look for #include "foo" the source-file directory.  */
        !           416:   char ignore_srcdir;
        !           417: 
        !           418: /* Zero means dollar signs are punctuation.
        !           419:    -$ stores 0; -traditional may store 1.  Default is 1 for VMS, 0 otherwise.
        !           420:    This must be 0 for correct processing of this ANSI C program:
        !           421:        #define foo(a) #a
        !           422:        #define lose(b) foo (b)
        !           423:        #define test$
        !           424:        lose (test)     */
        !           425:   char dollars_in_ident;
        !           426: #ifndef DOLLARS_IN_IDENTIFIERS
        !           427: #define DOLLARS_IN_IDENTIFIERS 1
        !           428: #endif
        !           429: 
        !           430:   /* Nonzero means try to imitate old fashioned non-ANSI preprocessor.  */
        !           431:   char traditional;
        !           432: 
        !           433:   /* Nonzero means give all the error messages the ANSI standard requires.  */
        !           434:   char pedantic;
        !           435: 
        !           436:   char done_initializing;
        !           437: 
        !           438:   struct file_name_list *include;      /* First dir to search */
        !           439:   /* First dir to search for <file> */
        !           440:   /* This is the first element to use for #include <...>.
        !           441:      If it is 0, use the entire chain for such includes.  */
        !           442:   struct file_name_list *first_bracket_include;
        !           443:   /* This is the first element in the chain that corresponds to
        !           444:      a directory of system header files.  */
        !           445:   struct file_name_list *first_system_include;
        !           446:   struct file_name_list *last_include; /* Last in chain */
        !           447: 
        !           448:   /* Chain of include directories to put at the end of the other chain.  */
        !           449:   struct file_name_list *after_include;
        !           450:   struct file_name_list *last_after_include;   /* Last in chain */
        !           451: 
        !           452:   /* Chain to put at the start of the system include files.  */
        !           453:   struct file_name_list *before_system;
        !           454:   struct file_name_list *last_before_system;   /* Last in chain */
        !           455: 
        !           456:   /* Directory prefix that should replace `/usr' in the standard
        !           457:      include file directories.  */
        !           458:   char *include_prefix;
        !           459: 
        !           460:   char inhibit_predefs;
        !           461:   char no_standard_includes;
        !           462:   char no_standard_cplusplus_includes;
        !           463: 
        !           464: /* dump_only means inhibit output of the preprocessed text
        !           465:              and instead output the definitions of all user-defined
        !           466:              macros in a form suitable for use as input to cccp.
        !           467:    dump_names means pass #define and the macro name through to output.
        !           468:    dump_definitions means pass the whole definition (plus #define) through
        !           469: */
        !           470: 
        !           471:   enum {dump_none = 0, dump_only, dump_names, dump_definitions}
        !           472:      dump_macros;
        !           473: 
        !           474: /* Nonzero means pass all #define and #undef directives which we actually
        !           475:    process through to the output stream.  This feature is used primarily
        !           476:    to allow cc1 to record the #defines and #undefs for the sake of
        !           477:    debuggers which understand about preprocessor macros, but it may
        !           478:    also be useful with -E to figure out how symbols are defined, and
        !           479:    where they are defined.  */
        !           480:   int debug_output;
        !           481: 
        !           482:   /* Pending -D, -U and -A options, in reverse order. */
        !           483:   struct cpp_pending *pending;
        !           484: 
        !           485:   /* File name which deps are being written to.
        !           486:      This is 0 if deps are being written to stdout.  */
        !           487:   char *deps_file;
        !           488: 
        !           489:   /* Target-name to write with the dependency information.  */
        !           490:   char *deps_target;
        !           491: };
        !           492: 
        !           493: #define CPP_TRADITIONAL(PFILE) (CPP_OPTIONS(PFILE)-> traditional)
        !           494: #define CPP_PEDANTIC(PFILE) (CPP_OPTIONS (PFILE)->pedantic)
        !           495: #define CPP_PRINT_DEPS(PFILE) (CPP_OPTIONS (PFILE)->print_deps)
        !           496: 
        !           497: /* Name under which this program was invoked.  */
        !           498: 
        !           499: extern char *progname;
        !           500: 
        !           501: /* The structure of a node in the hash table.  The hash table
        !           502:    has entries for all tokens defined by #define commands (type T_MACRO),
        !           503:    plus some special tokens like __LINE__ (these each have their own
        !           504:    type, and the appropriate code is run when that type of node is seen.
        !           505:    It does not contain control words like "#define", which are recognized
        !           506:    by a separate piece of code. */
        !           507: 
        !           508: /* different flavors of hash nodes --- also used in keyword table */
        !           509: enum node_type {
        !           510:  T_DEFINE = 1, /* the `#define' keyword */
        !           511:  T_INCLUDE,    /* the `#include' keyword */
        !           512:  T_INCLUDE_NEXT, /* the `#include_next' keyword */
        !           513:  T_IMPORT,      /* the `#import' keyword */
        !           514:  T_IFDEF,      /* the `#ifdef' keyword */
        !           515:  T_IFNDEF,     /* the `#ifndef' keyword */
        !           516:  T_IF,         /* the `#if' keyword */
        !           517:  T_ELSE,       /* `#else' */
        !           518:  T_PRAGMA,     /* `#pragma' */
        !           519:  T_ELIF,       /* `#elif' */
        !           520:  T_UNDEF,      /* `#undef' */
        !           521:  T_LINE,       /* `#line' */
        !           522:  T_ERROR,      /* `#error' */
        !           523:  T_WARNING,    /* `#warning' */
        !           524:  T_ENDIF,      /* `#endif' */
        !           525:  T_SCCS,       /* `#sccs', used on system V.  */
        !           526:  T_IDENT,      /* `#ident', used on system V.  */
        !           527:  T_ASSERT,     /* `#assert', taken from system V.  */
        !           528:  T_UNASSERT,   /* `#unassert', taken from system V.  */
        !           529:  T_SPECLINE,   /* special symbol `__LINE__' */
        !           530:  T_DATE,       /* `__DATE__' */
        !           531:  T_FILE,       /* `__FILE__' */
        !           532:  T_BASE_FILE,  /* `__BASE_FILE__' */
        !           533:  T_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
        !           534:  T_VERSION,    /* `__VERSION__' */
        !           535:  T_SIZE_TYPE,   /* `__SIZE_TYPE__' */
        !           536:  T_PTRDIFF_TYPE,   /* `__PTRDIFF_TYPE__' */
        !           537:  T_WCHAR_TYPE,   /* `__WCHAR_TYPE__' */
        !           538:  T_USER_LABEL_PREFIX_TYPE, /* `__USER_LABEL_PREFIX__' */
        !           539:  T_REGISTER_PREFIX_TYPE,   /* `__REGISTER_PREFIX__' */
        !           540:  T_TIME,       /* `__TIME__' */
        !           541:  T_CONST,      /* Constant value, used by `__STDC__' */
        !           542:  T_MACRO,      /* macro defined by `#define' */
        !           543:  T_DISABLED,   /* macro temporarily turned off for rescan */
        !           544:  T_SPEC_DEFINED, /* special `defined' macro for use in #if statements */
        !           545:  T_PCSTRING,   /* precompiled string (hashval is KEYDEF *) */
        !           546:  T_UNUSED      /* Used for something not defined.  */
        !           547:  };
        !           548: 
        !           549: /* Structure returned by create_definition */
        !           550: typedef struct macrodef MACRODEF;
        !           551: struct macrodef
        !           552: {
        !           553:   struct definition *defn;
        !           554:   U_CHAR *symnam;
        !           555:   int symlen;
        !           556: };
        !           557: 
        !           558: /* Structure allocated for every #define.  For a simple replacement
        !           559:    such as
        !           560:        #define foo bar ,
        !           561:    nargs = -1, the `pattern' list is null, and the expansion is just
        !           562:    the replacement text.  Nargs = 0 means a functionlike macro with no args,
        !           563:    e.g.,
        !           564:        #define getchar() getc (stdin) .
        !           565:    When there are args, the expansion is the replacement text with the
        !           566:    args squashed out, and the reflist is a list describing how to
        !           567:    build the output from the input: e.g., "3 chars, then the 1st arg,
        !           568:    then 9 chars, then the 3rd arg, then 0 chars, then the 2nd arg".
        !           569:    The chars here come from the expansion.  Whatever is left of the
        !           570:    expansion after the last arg-occurrence is copied after that arg.
        !           571:    Note that the reflist can be arbitrarily long---
        !           572:    its length depends on the number of times the arguments appear in
        !           573:    the replacement text, not how many args there are.  Example:
        !           574:    #define f(x) x+x+x+x+x+x+x would have replacement text "++++++" and
        !           575:    pattern list
        !           576:      { (0, 1), (1, 1), (1, 1), ..., (1, 1), NULL }
        !           577:    where (x, y) means (nchars, argno). */
        !           578: 
        !           579: typedef struct definition DEFINITION;
        !           580: struct definition {
        !           581:   int nargs;
        !           582:   int length;                  /* length of expansion string */
        !           583:   int predefined;              /* True if the macro was builtin or */
        !           584:                                /* came from the command line */
        !           585:   U_CHAR *expansion;
        !           586:   int line;                    /* Line number of definition */
        !           587:   char *file;                  /* File of definition */
        !           588:   char rest_args;              /* Nonzero if last arg. absorbs the rest */
        !           589:   struct reflist {
        !           590:     struct reflist *next;
        !           591:     char stringify;            /* nonzero if this arg was preceded by a
        !           592:                                   # operator. */
        !           593:     char raw_before;           /* Nonzero if a ## operator before arg. */
        !           594:     char raw_after;            /* Nonzero if a ## operator after arg. */
        !           595:     char rest_args;            /* Nonzero if this arg. absorbs the rest */
        !           596:     int nchars;                        /* Number of literal chars to copy before
        !           597:                                   this arg occurrence.  */
        !           598:     int argno;                 /* Number of arg to substitute (origin-0) */
        !           599:   } *pattern;
        !           600:   union {
        !           601:     /* Names of macro args, concatenated in reverse order
        !           602:        with comma-space between them.
        !           603:        The only use of this is that we warn on redefinition
        !           604:        if this differs between the old and new definitions.  */
        !           605:     U_CHAR *argnames;
        !           606:   } args;
        !           607: };
        !           608: 
        !           609: extern U_CHAR is_idchar[256];
        !           610: 
        !           611: /* Stack of conditionals currently in progress
        !           612:    (including both successful and failing conditionals).  */
        !           613: 
        !           614: struct if_stack {
        !           615:   struct if_stack *next;       /* for chaining to the next stack frame */
        !           616:   char *fname;         /* copied from input when frame is made */
        !           617:   int lineno;                  /* similarly */
        !           618:   int if_succeeded;            /* true if a leg of this if-group
        !           619:                                    has been passed through rescan */
        !           620:   U_CHAR *control_macro;       /* For #ifndef at start of file,
        !           621:                                   this is the macro name tested.  */
        !           622:   enum node_type type;         /* type of last directive seen in this group */
        !           623: };
        !           624: typedef struct if_stack IF_STACK_FRAME;
        !           625: 
        !           626: extern void cpp_buf_line_and_col PARAMS((cpp_buffer*, long*, long*));
        !           627: extern cpp_buffer* cpp_file_buffer PARAMS((cpp_reader*));
        !           628: extern void cpp_define PARAMS ((cpp_reader*, U_CHAR*));
        !           629: 
        !           630: extern void cpp_error ();
        !           631: extern void cpp_warning ();
        !           632: extern void cpp_pedwarn ();
        !           633: extern void cpp_error_with_line ();
        !           634: extern void cpp_pedwarn_with_line ();
        !           635: extern void cpp_pedwarn_with_file_and_line ();
        !           636: extern void fatal ();
        !           637: extern void cpp_error_from_errno ();
        !           638: extern void cpp_perror_with_name ();
        !           639: extern void cpp_pfatal_with_name ();
        !           640: 
        !           641: extern void cpp_grow_buffer PARAMS ((cpp_reader*, long));
        !           642: extern int cpp_parse_escape PARAMS ((cpp_reader*, char**));
        !           643: extern cpp_buffer* cpp_push_buffer PARAMS ((cpp_reader *, U_CHAR*, long));
        !           644: extern cpp_buffer* cpp_pop_buffer PARAMS ((cpp_reader *));
        !           645: 
        !           646: extern cpp_hashnode* cpp_lookup PARAMS ((cpp_reader*, const U_CHAR*,
        !           647:                                         int, int));
        !           648: 
        !           649: #ifdef __cplusplus
        !           650: }
        !           651: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.