cppadd.h

/******************************************************************************
Copyright (c) 2023 - present AinsleySnow
Copyright (c) 1993 - 2011 Daniel Stenberg

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/

/**********************************************************************
 *
 * cppadd.h
 *
 * Prototypes and structures added by Daniel Stenberg.
 *
 *******/

#include <stdarg.h>
#include <stdbool.h>
#include <memory.h>

struct Global
{

    /*
     * Commonly used global variables:
     * line       is the current input line number.
     * wrongline  is set in many places when the actual output
     *            line is out of sync with the numbering, e.g,
     *            when expanding a macro with an embedded newline.
     *
     * tokenbuf   holds the last identifier scanned (which might
     *            be a candidate for macro expansion).
     * errors     is the running cpp error counter.
     * infile     is the head of a linked list of input files (extended by
     *            #include and macros being expanded).  infile always points
     *            to the current file/macro.  infile->parent to the includer,
     *            etc.  infile->fd is NULL if this input stream is a macro.
     */
    int line;           /* Current line number          */
    int wrongline;      /* Force #line to compiler      */
    char *tokenbuf;     /* Buffer for current input token */
    char *functionname; /* Buffer for current function */
    int funcline;       /* Line number of current function */
    int tokenbsize;     /* Allocated size of tokenbuf,  */
                        /* not counting zero at end.    */
    int errors;         /* cpp error counter            */
    FILEINFO *infile;   /* Current input file           */
#if DEBUG
    int debug; /* true if debugging now        */
#endif
    /*
     * This counter is incremented when a macro expansion is initiated.
     * If it exceeds a built-in value, the expansion stops -- this tests
     * for a runaway condition:
     *    #define X Y
     *    #define Y X
     *    X
     * This can be disabled by falsifying rec_recover.  (Nothing does this
     * currently: it is a hook for an eventual invocation flag.)
     */
    int recursion;   /* Infinite recursion counter   */
    int rec_recover; /* Unwind recursive macros      */

    /*
     * instring is set true when a string is scanned.  It modifies the
     * behavior of the "get next character" routine, causing all characters
     * to be passed to the caller (except <DEF_MAGIC>).  Note especially that
     * comments and \<newline> are not removed from the source.  (This
     * prevents cpp output lines from being arbitrarily long).
     *
     * inmacro is set by #define -- it absorbs comments and converts
     * form-feed and vertical-tab to space, but returns \<newline>
     * to the caller.  Strictly speaking, this is a bug as \<newline>
     * shouldn't delimit tokens, but we'll worry about that some other
     * time -- it is more important to prevent infinitly long output lines.
     *
     * instring and inmarcor are parameters to the get() routine which
     * were made global for speed.
     */
    bool instring; /* true if scanning string      */
    bool inmacro;  /* true if #defining a macro    */

    /*
     * work[] and workp are used to store one piece of text in a temporay
     * buffer.  To initialize storage, set workp = work.  To store one
     * character, call save(c);  (This will fatally exit if there isn't
     * room.)  To terminate the string, call save(EOS).  Note that
     * the work buffer is used by several subroutines -- be sure your
     * data won't be overwritten.  The extra byte in the allocation is
     * needed for string formal replacement.
     */
    char work[NWORK + 1]; /* Work buffer                  */
    char *workp;          /* Work buffer pointer          */

    /*
     * keepcomments is set true by the -C option.  If true, comments
     * are written directly to the output stream.  This is needed if
     * the output from cpp is to be passed to lint (which uses commands
     * embedded in comments).  cflag contains the permanent state of the
     * -C flag.  keepcomments is always falsified when processing #control
     * commands and when compilation is supressed by a false #if
     *
     * If eflag is set, CPP returns "success" even if non-fatal errors
     * were detected.
     *
     * If nflag is non-zero, no symbols are predefined except __LINE__.
     * __FILE__, and __DATE__.  If nflag > 1, absolutely no symbols
     * are predefined.
     */
    bool keepcomments; /* Write out comments flag      */
    bool cflag;        /* -C option (keep comments)    */
    bool eflag;        /* -E option (never fail)       */
    bool nflag;        /* -N option (no predefines)    */
    bool wflag;        /* -W option (write #defines)   */

    /*
     * ifstack[] holds information about nested #if's.  It is always
     * accessed via *ifptr.  The information is as follows:
     *    WAS_COMPILING   state of compiling flag at outer level.
     *    ELSE_SEEN       set true when #else seen to prevent 2nd #else.
     *    TRUE_SEEN       set true when #if or #elif succeeds
     * ifstack[0] holds the compiling flag.  It is true if compilation
     * is currently enabled.  Note that this must be initialized true.
     */
    char ifstack[BLK_NEST]; /* #if information      */
    char *ifptr;            /* -> current ifstack[] */

    /*
     * incdir[] stores the -i directories (and the system-specific
     * #include <...> directories.
     */
    char *incdir[NINCLUDE]; /* -i directories               */
    char **incend;          /* -> free space in incdir[]    */

    /*
     * include[] stores the -X and -x files.
     */
    char *include[NINCLUDE];
    char includeshow[NINCLUDE]; /* show it or not! */
    char included;

    /*
     * This is the table used to predefine target machine and operating
     * system designators.        It may need hacking for specific circumstances.
     * Note: it is not clear that this is part of the Ansi Standard.
     * The -B option supresses preset definitions.
     */
    char *preset[30];       /* names defined at cpp start   */
    char *presetval[30];  /* values correspond to the preset macros */

    /*
     * The value of these predefined symbols must be recomputed whenever
     * they are evaluated.        The order must not be changed.
     */
    char *magic[5]; /* Note: order is important     */

    /*
     * This is the variable saying if Cpp should remove C++ style comments from
     * the output. Default is... true, yes, pronto, do it!!!
     */

    char cplusplus;

    char *sharpfilename;

    /*
     * parm[], parmp, and parlist[] are used to store #define() argument
     * lists.  nargs contains the actual number of parameters stored.
     */
    char parm[NPARMWORK + 1]; /* define param work buffer     */
    char *parmp;              /* Free space in parm           */
    char *parlist[LASTPARM];  /* -> start of each parameter   */
    int nargs;                /* Parameters for this macro    */
    bool variadic;            /* whether the macro is variadic or not */    

    DEFBUF *macro; /* Catches start of infinite macro      */

    DEFBUF *symtab[SBSIZE]; /* Symbol table queue headers   */

    int evalue; /* Current value from evallex() */

    char *(*input)(char *, int, void *); /* Input function */

    char *first_file; /* Preprocessed file. */

    void *userdata; /* Data sent to input function */

    void (*output)(int, void *); /* output function */

    void (*error)(void *, char *, va_list); /* error function */

    char linelines;

    char warnillegalcpp; /* warn for illegal preprocessor instructions? */

    char outputLINE; /* output 'line' in #line instructions */

    char showversion; /* display version */

    char showincluded; /* display included files */

    char showbalance; /* display paren balance */

    char showspace; /* display all whitespaces as they are */

    char comment; /* true if a comment just has been written to output */

    char *spacebuf; /* Buffer to store whitespaces in if -H */

    long chpos; /* Number of whitespaces in buffer */

    char nestcomments; /* Allow nested comments */

    char warnnestcomments; /* Warn at nested comments */

    char warnnoinclude; /* Warn at missing include file */

    char outputfile; /* output the main file */

    char out; /* should we output anything now? */

    char rightconcat;  /* should the right part of a concatenation be avaluated
                          before the concat (true) or after (false) */
    char *initialfunc; /* file to include first in all functions */

    char *excludedinit[20]; /* functions (names) excluded from the initfunc */
    int excluded;

    char outputfunctions; /* output all discovered functions to stderr! */

    char webmode; /* WWW process mode */
};

typedef enum
{
    ERROR_STRING_MUST_BE_IF,
    ERROR_STRING_MAY_NOT_FOLLOW_ELSE,
    ERROR_ERROR,
    ERROR_PREPROC_FAILURE,
    ERROR_MISSING_ARGUMENT,
    ERROR_INCLUDE_SYNTAX,
    ERROR_DEFINE_SYNTAX,
    ERROR_REDEFINE,
    ERROR_ILLEGAL_UNDEF,
    ERROR_RECURSIVE_MACRO,
    ERROR_EOF_IN_ARGUMENT,
    ERROR_MISPLACED_CONSTANT,
    ERROR_IF_OVERFLOW,
    ERROR_ILLEGAL_IF_LINE,
    ERROR_OPERATOR,
    ERROR_EXPR_OVERFLOW,
    ERROR_UNBALANCED_PARENS,
    ERROR_MISPLACED,
    ERROR_STRING_IN_IF,
    ERROR_DEFINED_SYNTAX,
    ERROR_ILLEGAL_ASSIGN,
    ERROR_ILLEGAL_BACKSLASH,
    ERROR_SIZEOF_SYNTAX,
    ERROR_SIZEOF_UNKNOWN,
    ERROR_SIZEOF_ILLEGAL_TYPE,
    ERROR_SIZEOF_NO_TYPE,
    ERROR_UNTERMINATED_STRING,
    ERROR_EOF_IN_COMMENT,
    ERROR_IFDEF_DEPTH,
    ERROR_ILLEGAL_CHARACTER,
    ERROR_ILLEGAL_CHARACTER2,
    ERROR_SIZEOF_BUG,
    ERROR_IF_OPERAND,
    ERROR_STRANGE_CHARACTER,
    ERROR_VA_OPT_RIGHT_PAR,
    ERROR_VA_OPT_EARLY_EOS,
    ERROR_NOT_PARAMETER_NAME,
    ERROR_MIDLIST_ELLIPSIS,

    BORDER_ERROR_WARN, /* below this number: errors, above: warnings */

    WARN_CONTROL_LINE_IN_MACRO,
    WARN_ILLEGAL_COMMAND,
    WARN_UNEXPECTED_TEXT_IGNORED,
    WARN_TOO_FEW_VALUES_TO_SIZEOF,
    WARN_TOO_MANY_VALUES_TO_SIZEOF,
    WARN_NOT_DEFINED,
    WARN_INTERNAL_ERROR,
    WARN_MACRO_NEEDS_ARGUMENTS,
    WARN_WRONG_NUMBER_ARGUMENTS,
    WARN_DIVISION_BY_ZERO,
    WARN_ILLEGAL_OCTAL,
    WARN_MULTIBYTE_NOT_PORTABLE,
    WARN_CANNOT_OPEN_INCLUDE,
    WARN_BRACKET_DEPTH,
    WARN_PAREN_DEPTH,
    WARN_BRACE_DEPTH,
    WARN_NESTED_COMMENT,

    BORDER_WARN_FATAL, /* below this number: warnings, above: fatals */

    FATAL_TOO_MANY_NESTINGS,
    FATAL_FILENAME_BUFFER_OVERFLOW,
    FATAL_TOO_MANY_INCLUDE_DIRS,
    FATAL_TOO_MANY_INCLUDE_FILES,
    FATAL_TOO_MANY_ARGUMENTS_MACRO,
    FATAL_MACRO_AREA_OVERFLOW,
    FATAL_ILLEGAL_MACRO,
    FATAL_TOO_MANY_ARGUMENTS_EXPANSION,
    FATAL_OUT_OF_SPACE_IN_ARGUMENT,
    FATAL_WORK_AREA_OVERFLOW,
    FATAL_WORK_BUFFER_OVERFLOW,
    FATAL_OUT_OF_MEMORY,
    FATAL_TOO_MUCH_PUSHBACK

} ErrorCode;

/**********************************************************************
 * RETURN CODES:
 *********************************************************************/

typedef enum
{
    FPP_OK,
    FPP_OUT_OF_MEMORY,
    FPP_TOO_MANY_NESTED_STATEMENTS,
    FPP_FILENAME_BUFFER_OVERFLOW,
    FPP_NO_INCLUDE,
    FPP_OPEN_ERROR,
    FPP_TOO_MANY_ARGUMENTS,
    FPP_WORK_AREA_OVERFLOW,
    FPP_ILLEGAL_MACRO,
    FPP_EOF_IN_MACRO,
    FPP_OUT_OF_SPACE_IN_MACRO_EXPANSION,
    FPP_ILLEGAL_CHARACTER,
    FPP_CANT_USE_STRING_IN_IF,
    FPP_BAD_IF_DEFINED_SYNTAX,
    FPP_IF_ERROR,
    FPP_SIZEOF_ERROR,
    FPP_UNTERMINATED_STRING,
    FPP_TOO_MANY_INCLUDE_DIRS,
    FPP_TOO_MANY_INCLUDE_FILES,
    FPP_INTERNAL_ERROR,

    FPP_LAST_ERROR
} ReturnCode;

/* Nasty defines to make them appear as three different functions! */
#define cwarn cerror
#define cfatal cerror

/**********************************************************************
 * PROTOTYPES:
 *********************************************************************/
int fppPreProcess(struct fppTag *);
void Freemem(void *);
void Error(struct Global *, char *, ...);
void Putchar(struct Global *, int);
void Putstring(struct Global *, char *);
void Putint(struct Global *, int);
char *savestring(struct Global *, char *);
ReturnCode addfile(struct Global *, FILE *, char *);
int catenate(struct Global *, ReturnCode *);
void cerror(struct Global *, ErrorCode, ...);
ReturnCode control(struct Global *, int *);
ReturnCode dodefine(struct Global *);
int dooptions(struct Global *, struct fppTag *);
void doundef(struct Global *);
void dumpparm(char *);
ReturnCode expand(struct Global *, DEFBUF *);
int get(struct Global *);
ReturnCode initdefines(struct Global *);
void outdefines(struct Global *);
ReturnCode save(struct Global *, int);
void scanid(struct Global *, int);
ReturnCode scannumber(struct Global *, int, ReturnCode (*)(struct Global *, int));
ReturnCode scanstring(struct Global *, int, ReturnCode (*)(struct Global *, int));
void unget(struct Global *);
ReturnCode ungetstring(struct Global *, char *);
ReturnCode eval(struct Global *, int *);
#ifdef DEBUG_EVAL
void dumpstack(OPTAB[NEXP], register OPTAB *, int[NEXP], register int *);
#endif
void skipnl(struct Global *);
int skipws(struct Global *);
ReturnCode macroid(struct Global *, int *);
ReturnCode getfile(struct Global *, int, char *, FILEINFO **);
DEFBUF *lookid(struct Global *, int);
DEFBUF *defendel(struct Global *, char *, int);
#if DEBUG
void dumpdef(char *);
void dumpadef(char *, register DEFBUF *);
#endif
ReturnCode openfile(struct Global *, char *);
int cget(struct Global *);
void deldefines(struct Global *);
char *Getmem(struct Global *, int);
ReturnCode openinclude(struct Global *, char *, int);
ReturnCode expstuff(struct Global *, char *, char *, int, int);