ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng)/ProfitPress-MegaCDROM2.B6I/PROG/MISC/JRCPP.ZIP/DIAGNOST.DOC

Text File | 1990-03-27 | 138.5 KB | 2,657 lines

    JRCPP DIAGNOSTIC MESSAGE REFERENCE MANUAL (3/23/90)



    Copyright (C) 1990 James Roskind, All rights reserved. Permission
    is  granted  to copy and distribute this file as part any machine
    readable archive containing the entire, unmodified, JRCPP  PUBLIC
    DISTRIBUTION PACKAGE (henceforth call the "Package").  The set of
    files that form the Package are described in the README file that
    is  a  part  of the Package.  Permission is granted to individual
    users of the Package to copy individual portions of  the  Package
    (i.e.,  component  files) in any form (e.g.: printed, electronic,
    electro-optical, etc.) desired  for  the  purpose  of  supporting
    users   of  the  Package  (i.e.,  providing  online,  or  onshelf
    documentation access; executing the  binary  JRCPP  code,  etc.).
    Permission  is  not  granted  to  distribute copies of individual
    portions of the Package, unless a machine readable version of the
    complete  Package  is also made available with such distribution.
    Abstracting with credit is permitted.   There  is  no  charge  or
    royalty  fee  required  for  copies  made in compliance with this
    notice.  To otherwise copy  elements  of  this  package  requires
    prior permission in writing from James Roskind.

    James Roskind
    516 Latania Palm Drive
    Indialantic FL 32903

    End of copyright notice


What  the  above  copyright  means  is  that  you are free to use and
distribute (or even sell) the entire set of files  in  this  Package,
but  you  can't split them up, and distribute them as separate files.
The notice also says that you  cannot  modify  the  copies  that  you
distribute, and this ESPECIALLY includes NOT REMOVING the any part of
the copyright notice in any file.  JRCPP  currently  implements  a  C
Preprocessor,  but  the  users  of  this Package do NOT surrender any
right of ownership or copyright to any source text that is  processed
by JRCPP, either before or after processing.  Similarly, there are no
royalty or fee requirements for using the post-preprocessed output of
JRCPP.

This  Package is expected to be distributed by shareware and freeware
channels (including BBS sites), but the fees paid for  "distribution"
costs  are  strictly  exchanged  between  the  distributor,  and  the
recipient, and James Roskind makes no express or  implied  warranties
about  the  quality  or integrity of such indirectly acquired copies.
Distributors  and  users  may  obtain   the   Package   (the   Public
distribution form) directly from the author by following the ordering
procedures in the REGISTRATION file.


DISCLAIMER:

JAMES ROSKIND PROVIDES THIS FILE "AS  IS"  WITHOUT  WARRANTY  OF  ANY
KIND,  EITHER  EXPRESS  OR IMPLIED, INCLUDING BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY OR  FITNESS  FOR  A  PARTICULAR
PURPOSE.   THE  ENTIRE  RISK AS TO THE QUALITY AND PERFORMANCE OF THE
PROGRAM AND DOCUMENTATION IS WITH YOU.   Some  states  do  not  allow
disclaimer  of express or implied warranties in certain transactions,
therefore, this statement may not apply to you.


UNIX is a registered trademark of AT&T Bell Laboratories.
____________________________________________________________________



    JRCPP DIAGNOSTIC MESSAGE REFERENCE MANUAL (3/23/90)


INTRODUCTION

The term "diagnostic messages" is meant to be a generalization of the
concept  of  "error  messages".  Diagnostic  messages are any sort of
message that is communicated from the C  Preprocessor  to  the  user.
The  most  common  cause  of  a diagnostic message is an error in the
source code.  Other messages carry information ranging from stylistic
commentary   (e.g.:   "found   '/*'  with  comment"),  or  procedural
commentary (e.g.: "header file  was  found  in  ...  directory"),  to
catastrophic operating systems problems (e.g.: "out of memory").

This  section  begins  with  a  description of the diagnostic message
system, and the meaning of the various diagnostic levels.   A  second
section  provides  a  complete  list  of  the  170+  actual  messages
currently supported, sorted by diagnostic  number.  A  third  section
provides  a  listing of the messages sorted by diagnostic level.  The
last  section  offers  a  detailed  explanation  for  each  supported
messages.


DIAGNOSTIC MESSAGES- OVERVIEW


JRCPP  has  a  fixed list of diagnostic messages, each of which has a
corresponding number.  To  be  complete,  diagnostics  consist  of  a
default  severity  level, an error number, and a textual message. The
possible severity levels include F (fatal), E (error), W (warning), H
(hint),  and  S  (silent).  Error messages numbers range from 1001 to
9999.   Text  of  the  messages  is  typically  less  than  about  60
characters.   When  a  message  is  actually submitted to the user, a
source line number, file name, and relevant text is typically  added,
which brings the entire message line to typically over 80 characters.
The format of the diagnostics is  modeled  after  common  C  compiler
error messaging systems, and standard tools should be able to process
the diagnostics.

One concept that is novel to this JRCPP is  the  distinction  between
the  "default  severity  level"  associated  with  a message, and its
"actual severity level", which is computed  when  the  diagnostic  is
generated.   This  fundamental separation permits users to change the
"actual severity level" of  any  diagnostic  message.  With  no  user
intervention,  the  "actual  severity level" is the "default severity
level", and the user can rely on  the  "factory  settings"  for  each
message.   In  many  other  compilers a user is permitted to change a
threshold or "warning level" in the compiler, in order to change  the
response   to  the  fixed  set  of  diagnostics.   In  contrast,  the
thresholds for response to diagnostics are fixed in  JRCPP,  but  the
user  is  permitted  to  changed  the  severity  level  of any of the
diagnostics.   The  ability  to  change  the  level  associated  with
individual  messages allows the user to customize the compiler to the
individual needs of a project,  and  even  to  specific  sections  of
source code.

In  order  to  support a mechanism that is similar to the traditional
"warning level" setting in other compilers, the  severity  levels  of
whole  groups  of diagnostics with similar severities can be adjusted
at once.  In addition, since the levels can be adjusted in the source
code (via #pragma diagnostic_adjust ...) it is possible to vary these
levels at distinct points in the program (for example:  reducing  the
diagnostic  scrutiny  ONLY during the inclusion of a header file that
is know to be "non-standard" in style and  content).  Adjustment  can
range from preventing a bothersome message from appearing at all, all
the way to the other extreme of forcing the preprocessor to  stop  as
soon as a certain diagnostic is generated.


The   "#pragma  adjust_diagnostic  ..."  directive  can  be  used  to
customize  the  run  time  diagnostic  levels  associated  with  each
message.   It  can  either  change  the  diagnostic levels of all the
diagnostics that share a common level  (e.g.:  change  all  "warning"
diagnostics  to  "error"  diagnostics), or it can specifically change
the diagnostic level of a specific message.  See  the  discussion  of
this under PRAGMA DIRECTIVES, for details of its use.


DIAGNOSTIC MESSAGES- SEVERITY LEVELS

As mentioned earlier, the possible severity levels include F (fatal),
E (error), W (warning), H (hint), and S  (silent).   This  subsection
discusses  the  meaning of each level, along with the philosophy used
to establish default severity levels.

"Fatal" level messages can be expected to terminate the preprocessing
operation immediately.  Moreover, there is generally no facility (via
pragmas) to diminish the diagnostic level of a  message  that  has  a
"fatal"  default severity. Messages are only given a default level of
fatal if: 1) there appears to be no reasonably way  to  recover  from
the  condition;  or  2)  recovery  from the error could inadvertently
damage extraneous files.  Examples of  unrecoverable  errors  include
"out  of  memory",  and  "cannot  open source file".  An example of a
fatal error based upon the second principle is  "unexpected  argument
on  command  line".   If there is an extra argument, then it is quite
possible that the proposed output file is  **NOT**  the  output  file
that  the  user  desired, but is instead an input file!!  Rather than
risking damage to a user's file, a fatal diagnostic is provided,  and
preprocessing ceases.

"Error"  level  messages  indicate  that a significant error has been
detected, but recovery seems possible, and reasonable.   Due  to  the
severity  of  the error, no preprocessed output will be produced, but
preprocessing  will  continue  and  additional  diagnostics  may   be
generated.   Default  settings  of  diagnostics  to "Error" generally
indicate a violation of the ANSI C standard,  and  hence  a  lack  of
"consistent"  portability (i.e.: this is a good chance that some ANSI
C compiler will be totally unable to process the source  file).   The
error recovery that is provided by JRCPP is targeted at compatibility
with prior art that a "Classic C"  preprocessor  might  provide,  and
failing  that, at almost any reasonable error recovery.  For example,
if a totally unrecognized directive is encountered, it was "probably"
a  misspelling  of  a  well  defined  directive.  The  simplest error
recovery strategy is to "ignore" it completely (this also gives  some
sense  of  compatibility  with  future language definitions, or other
"nonstandard" preprocessors). If the user is  satisfied  enough  with
the  recovery, then "#pragma diagnostic ..." directive may be used to
downgrade the level (to a warning or silent) in order to  obtain  the
preprocessed  output.   It  should be clearly understood however that
the source code  that  triggers  diagnostic  with  default  level  of
"error",  might  not  be  preprocessed  identically  by  other ANSI C
preprocessors.

"Warning" level messages indicate that a possibility exists that  the
user  has  made  an error in the source code.  Generally only totally
legal constructs are given a default level of warning.  For  example,
since  comments  do not nest, the presence of a "/*" within a comment
is  syntactically  of  no  consequence.   Based  on  popular   coding
experience,  the  presence  of  a "/*" within a comment is usually an
indication that a prior comment was accidentally not closed (and that
source  code  between  the  two comments is being lost).  It is quite
common for extremely cautious users to upgrade  all  "warning"  level
messages to "error" level in order to guarantee the cleanest of code.

"Silent"  level messages should not be confused with such concepts as
"ignore".  Message are only given a default level of "silent"  if  it
is  believed  that the diagnostic will have almost no practical value
to code diagnosis, and hence  it  should  be  suppressed.   Moreover,
there  is  generally  no  error  recovery needed for default "silent"
level messages.  The most common use of the "silent" level  is  by  a
user,  as  it provides a category to place a "warning" that occurs so
often in the diagnostic listing that it clutters the listing.

The only default "silent" diagnostics are messages that are generally
of no significance to the user.  However, in some debugging scenarios
it is often desirable for a user to be made aware of actions taken by
the  preprocessor,  that  should in general, be ignored. Such actions
are given a default level of "silent", and a user may choose to raise
these  levels  in order to make the activities visible. An example of
this class of message  is  notification  of  where  the  preprocessor
looked to find an include file.  Typically, the preprocessor looks in
several places before finding a file, and the user may  wish  to  see
the exact list of directories searched.

The  existence  of  a  "silent"  level  allows  a user to downgrade a
diagnostic that would otherwise distract code development.  When  the
preprocessor generates a diagnostic, it must generally establish some
meaning for the questionable code, and support its error recovery  by
whatever  actions  are  deemed  appropriate.   This error recovery is
performed independent of the diagnostic level that is  reassigned  to
the  message  by  the  user.   Most simply put, changing a message to
"silent" level only prevents the user from seeing the message, and it
does not change the activities of the preprocessor.

"Hint" level messages indicate a severity somewhere between "warning"
and "silent".  A diagnostic with level "hint" will appear  the  first
time  the  problem  is  encountered,  but will then change its actual
severity level to "silent", and hence never appear again.  This class
of diagnostics are very useful when it is significant to the user (at
least as significant as a warning) that something has been noted, but
it can be expected that TOO MANY other occurrences of this triggering
construct will be diagnosed, and the  diagnostic  file  would  become
cluttered.   If this category were not present, the user would either
be forced to endure endless counts  of  notification  of  a  specific
diagnostic,  or  else  never  receive  notification of a problem.  An
example of the use of default level  "hint"  is  the  presence  of  a
backslash  in  an include file name.  If the user is using this (ANSI
undefined, but JRCPP accepted) construct, then it is likely that  the
user  will  repeat this construct in each #include statement.  With a
default level of hint, this construct will only be diagnosed once.

A user may chose to change the severity level of some diagnostics  to
a  hint  level to remove their dominance from the diagnostic listing,
without accepting them as commonplace  and  silencing  them  totally.
For example, if a user has source code that makes use of $ characters
in identifier names, then it is typically sufficient to  be  notified
the  first  time  this occurs that the construct is in use, but it is
desirable  that  no  further  notification  be  given  (i.e.:   avoid
notification   at  each  occurrence  of  the  offending  identifier).
Similarly, if it is desirable to reduce the number of  warning  level
diagnostics produced by JRCPP, all the default level "warning" can be
changed to "hint", and then each message will occurs at most once  in
the diagnostic listing.


In summary: Fatal  ==> stop immediately
        Error  ==> stop after complete error check of source
        Warning==> continue, but notify user
            Hint   ==> continue, but notify the user the first time only
        Silent ==> continue, and don't notify user


DIAGNOSTIC MESSAGES- CONCISE LIST, SORTED BY DIAGNOSTIC NUMBER


W, 1001, "preserve comment option not supported"
E, 1002, "complex macro predefinition not supported"
E, 1003, "cannot predefine non-identifier"
E, 1004, "unable to predefine macro"
W, 1005, "dependency collection option not yet supported"
E, 1006, "command line option 'p' not supported"
E, 1008, "unrecognized command line option; use -U to undefine macros"
E, 1009, "attempt to undef non-identifier"
W, 1011, "option to restrict names to 8 characters is not supported"
E, 1012, "directory name required"
E, 1013, "unrecognized option"
F, 1014, "unable to open source file"
F, 1015, "output file cannot be the same as input file"
F, 1016, "output file cannot have '.c' postfix"
F, 1017, "unexpected argument on command line"
E, 1018, "identifiers must begin with a letter or '_'"
E, 1018, "identifiers must begin with a letter or '_'"
E, 1019, "valid identifier must contain only alphanumeric or '_'"
E, 1020, "file name in environment variable is too large"
W, 1021, "support for non-ANSI // comments provided"
W, 1022, "__STDC__ definition has been removed"
W, 1023, "ANSI standard macros have been undefined"


E, 2001, "final new line in file is hidden by backslash"
E, 2002, "new line inserted at end of file"
E, 2003, "missing comment terminator '*/' at end of file"


W, 3001, "found "/*" within standard comment"
E, 3002, "illegal vertical whitespace translated to spaces"
E, 3003, "identifier includes '$' character"
W, 3004, "multicharacter character constants not supported"
E, 3005, "character constant missing close quote (')"
E, 3006, "string literal contains invalid escape sequence(s)"
E, 3007, "string literal missing close quote (")"
W, 3008, "illegal character in source stream"
E, 3009, "identifier includes '$' character"
E, 3010, "multicharacter character constants not supported"
E, 3011, "unable to form single token out of character(s)"
E, 3012, "Wide string literal cannot be used as file name"
W, 3013, "escape sequences other than `\\' are not honored in #line directives"
E, 3014, "no text present in file name"
E, 3015, "loss of precision during conversion"
E, 3016, "loss of precision during conversion"
E, 3017, "unable to open preprocessed output file"
E, 3018, "missing terminator on file name"
E, 3019, "file name terminator is not at right end of token"
H, 3020, "#include file name contains "/*" sequence"
H, 3021, "#include file name contains '\' character"
H, 3022, "#include file name contains "'" character"
E, 3023, "invalid file name token in #include directive"
H, 3024, "#include <...> file name contains `"' character"
E, 3025, "cannot open include file"
E, 3026, "existing macro definition being overwritten"
S, 3027, "trying to open include file in ancestor's directory"
S, 3028, "include file found using ancestral path"
S, 3029, "trying to open include file independent of ancestors"
S, 3030, "include file found without ancestral dependence"
F, 3031, "OS reports two input files cannot be opened"
H, 3032, "file temporarily closed"
F, 3033, "unable to temporarily close file"
F, 3034, "OS failure in ftell prevented extension of #include nesting"
F, 3035, "unable to reopen file"
F, 3036, "unable to reposition in file after reopening"
E, 3037, "Unsupported wide character constant translation ignored"
E, 3038, "nil character constant evaluated as single quote  '\'' "
E, 3039, "invalid character constant evaluated in if/elif directive"
E, 3040, "multicharacter character constant truncated during evaluation"
S, 3041, "application include file opened"
S, 3042, "system include file opened"
W, 3043, "found "*/" in "//" style comment"
W, 3044, "found "/*" within standard comment in inactive code"
W, 3045, "found "/*" within "//" style comment"
W, 3046, "found "/*" within "//" style comment in inactive code"
S, 3047, ""//*" may be misunderstood under C++"
W, 3048, ""//*" would be misparsed without "//" style comments"
W, 3049, "illegal vertical whitespace ignored in inactive code"
S, 3050, "identifier includes '$' character in inactive code"
W, 3051, "multicharacter character constant encountered in inactive code"
W, 3052, "character constant missing close quote in inactive code (')"
W, 3053, "string literal in inactive code is missing close quote (")"
W, 3054, "illegal character in inactive code in source stream"
W, 3055, "string literal in inactive code contains invalid escape sequence(s)"
E, 3056, "character constant has no characters"
W, 3057, "character constant in inactive code has no characters"



E, 4001, "unrecognized or unmatched preprocessor directive"
E, 4002, "missing #endif for #if group"
E, 4003, "missing expression for #if directive, FALSE assumed"
E, 4004, "missing identifier name in #ifdef directive, FALSE assumed"
E, 4005, "missing identifier name in #ifndef directive, TRUE assumed"
E, 4006, "syntax error in #if directive, FALSE assumed"
E, 4007, "syntax error in #ifdef directive, FALSE assumed"
E, 4008, "syntax error in #ifndef directive, TRUE assumed"
E, 4009, "missing expression for #elif directive, FALSE assumed"
E, 4010, "syntax error in #elif directive, FALSE assumed"
E, 4011, "unexpected token(s) on line after #else"
W, 4012, "unexpected token(s) on line after #endif"
E, 4013, "missing file name in #include directive"
E, 4016, "unexpected token(s) following file name in #include directive"
E, 4017, "missing line number and file in #line directive"
E, 4018, "first token in #line directive is not a line number"
E, 4019, "second token in #line directive is not a string literal (file name)"
E, 4020, "unexpected 3rd token in #line directive"
E, 4021, "#error encountered; no message provided"
W, 4022, "#pragma missing specification tokens"
E, 4023, "parameter list in macro definition not complete"
E, 4024, "missing identifier name in #define"
E, 4025, "invalid #define directive"
E, 4026, "unexpected token(s) following identifier in #undef"
E, 4027, "non-identifier in #undef directive"
E, 4028, "missing identifier name in #undef"
E, 4029, "syntax error in preprocessor scan"
E, 4030, "syntax error in expanded #if/#elif expression, FALSE assumed"
E, 4031, "syntax error at end of expanded #if/#elif expression, FALSE assumed"
E, 4032, "cannot #define keyword 'defined'"
E, 4033, "cannot #define internal macro name"
E, 4034, "non-benign macro redefinition ignored"
E, 4035, "cannot #define keyword 'defined'"
E, 4036, "cannot #define internal macro name"
E, 4037, "non-benign macro redefinition ignored"
E, 4038, "cannot #undef keyword 'defined'"
E, 4039, "attempted #undef of internal macro ignored"
E, 4040, "function like macro missing ')' after arguments"
E, 4041, "macro has whitespace argument"
E, 4042, "extra arguments to macro ignored"
E, 4043, "macro has solo whitespace argument"
E, 4044, "not enough arguments for macro, whitespace arguments supplied"
E, 4045, "operator '##' ignored at start of replacement list"
E, 4046, "operator '##' ignored at end of replacement list"
E, 4047, "'##' operator followed by '##' operator in macro replacement list"
E, 4048, "'#' operator applied to whitespace"
E, 4049, "operator '##' illegal at start of replacement list"
E, 4050, "operator '#' illegal at end of replacement list"
E, 4051, "operator '#' not followed by a macro parameter"
E, 4052, "operator '##' illegal at end of replacement list"
E, 4053, "line number in #line directive must be between 1 and 32767"
W, 4054, "expected integer or diagnostic level"
W, 4055, "expected 'silent', 'hint', 'warning', or 'error'"
W, 4056, "diagnostic numbers are between 1001 and 9999"
W, 4057, "expected diagnostic number, or severity level"
W, 4058, "expected 'fatal', 'error', 'warning' 'hint' or 'silent'"
W, 4059, "expected ancestral selection and/or 'current_directory'"
E, 4060, "unrecognized pragma undefine_macros selector"
W, 4061, "expected expected 'ANSI', 'platform', 'command_line', or 'user'"
E, 4062, "unrecognized pragma after_output_dump selector"
W, 4063, "expected 'profile' or 'macros'"
W, 4064, "expected 'off', or 'on' (the default is 'on')"
W, 4065, "expected 'off', or 'on' (the default is 'on')"
W, 4066, "expected 'off', or 'on' (the default is 'on')"
W, 4067, "expected 'off', or 'on' (the default is 'on')"
W, 4068, "expected 'off', or 'on' (the default is 'on')"
W, 4069, "unexpected token(s) at end of pragma line ignored"
S, 4070, "benign redefinition of manifest macro ignored"
S, 4071, "benign redefinition of function-like macro ignored"
S, 4072, "macro #undef action undertaken"
W, 4073, "consecutive paste operators in macro definition"
E, 4074, "line number must be a digit sequences only"
W, 4075, "keyword 'defined' evaluated as 0 in if/elif directive"
E, 4076, "scanner limitation: too many characters in pasted string"
S, 4077, "macro #undef requested for undefined identifier"
H, 4078, "use of bulk undefine may limit portability"
H, 4079, "use of bulk undefine may limit portability"
H, 4080, "use of bulk undefine may limit portability"


E, 5001, "#error encountered"
W, 5002, "unrecognized #pragma"
E, 5003, "unexpected token(s) on #ifdef line ignored"
E, 5004, "unexpected token(s) on #ifndef line ignored"
E, 5005, "neither <...> nor "..." style include found"
W, 5006, "cannot change 'fatal' default diagnostic level"
H, 5007, "diagnostic display may be diminished"
E, 5008, "only one ancestral path selection is allowed"
H, 5009, "non-ANSI C behavior requested"
H, 5010, "non-ANSI C behavior requested"
H, 5011, "non-ANSI C behavior requested"
H, 5012, "non-ANSI C behavior requested"
H, 5013, "non-ANSI C behavior requested"


F, 6001, "lexical scanner reading source: ...message..."
F, 6002, "lexical scanner reading pasted text: ...message..."
F, 6003, "preprocessing token parser error"
E, 6004, "#if/elif evaluated false due to: yacc stack overflow"
F, 6005, "out of memory. Object requested was "
F, 6006, "out of memory during character pool reallocation"
F, 6007, "out of memory during concatenation operation"
F, 6008, "out of memory during stringize operation"
F, 6009, "out of memory while unquoting file name"
F, 6010, "out of memory while extracting name in include directive"
F, 6011, "out of memory while extracting directory prefix"
E, 6012, "#if/elif evaluated false due to division by zero"
E, 6013, "#if/elif evaluated false due to modulus of zero"


DIAGNOSTIC MESSAGES GROUPED BY DEFAULT SEVERITY

DIAGNOSTICS WITH DEFAULT SEVERITY OF FATAL ERROR
F, 1014, "unable to open source file"
F, 1015, "output file cannot be the same as input file"
F, 1016, "output file cannot have '.c' postfix"
F, 1017, "unexpected argument on command line"
F, 3031, "OS reports two input files cannot be opened"
F, 3033, "unable to temporarily close file"
F, 3034, "OS failure in ftell prevented extension of #include nesting"
F, 3035, "unable to reopen file"
F, 3036, "unable to reposition in file after reopening"
F, 6001, "lexical scanner reading source: ...message..."
F, 6002, "lexical scanner reading pasted text: ... message..."
F, 6003, "preprocessing token parser error"
F, 6005, "out of memory. Object requested was "
F, 6006, "out of memory during character pool reallocation"
F, 6007, "out of memory during concatenation operation"
F, 6008, "out of memory during stringize operation"
F, 6009, "out of memory while unquoting file name"
F, 6010, "out of memory while extracting name in include directive"
F, 6011, "out of memory while extracting directory prefix"

DIAGNOSTICS WITH DEFAULT SEVERITY OF ERROR
E, 1002, "complex macro predefinition not supported"
E, 1003, "cannot predefine non-identifier"
E, 1004, "unable to predefine macro"
E, 1006, "command line option 'p' not supported"
E, 1008, "unrecognized command line option; use -U to undefine macros"
E, 1009, "attempt to undef non-identifier"
E, 1012, "directory name required"
E, 1013, "unrecognized option"
E, 1018, "identifiers must begin with a letter or '_'"
E, 1018, "identifiers must begin with a letter or '_'"
E, 1019, "valid identifier must contain only alphanumeric or '_'"
E, 1020, "file name in environment variable is too large"
E, 2001, "final new line in file is hidden by backslash"
E, 2002, "new line inserted at end of file"
E, 2003, "missing comment terminator '*/' at end of file"
E, 3002, "illegal vertical whitespace translated to spaces"
E, 3003, "identifier includes '$' character"
E, 3005, "character constant missing close quote (')"
E, 3006, "string literal contains invalid escape sequence(s)"
E, 3007, "string literal missing close quote (")"
E, 3009, "identifier includes '$' character"
E, 3010, "multicharacter character constants not supported"
E, 3011, "unable to form single token out of character(s)"
E, 3012, "Wide string literal cannot be used as file name"
E, 3014, "no text present in file name"
E, 3015, "loss of precision during conversion"
E, 3016, "loss of precision during conversion"
E, 3017, "unable to open preprocessed output file"
E, 3018, "missing terminator on file name"
E, 3019, "file name terminator is not at right end of token"
E, 3023, "invalid file name token in #include directive"
E, 3025, "cannot open include file"
E, 3026, "existing macro definition being overwritten"
E, 3037, "Unsupported wide character constant translation ignored"
E, 3038, "nil character constant evaluated as single quote  '\'' "
E, 3039, "invalid character constant evaluated in if/elif directive"
E, 3040, "multicharacter character constant truncated during evaluation"
E, 3056, "character constant has no characters"
E, 4001, "unrecognized or unmatched preprocessor directive"
E, 4002, "missing #endif for #if group"
E, 4003, "missing expression for #if directive, FALSE assumed"
E, 4004, "missing identifier name in #ifdef directive, FALSE assumed"
E, 4005, "missing identifier name in #ifndef directive, TRUE assumed"
E, 4006, "syntax error in #if directive, FALSE assumed"
E, 4007, "syntax error in #ifdef directive, FALSE assumed"
E, 4008, "syntax error in #ifndef directive, TRUE assumed"
E, 4009, "missing expression for #elif directive, FALSE assumed"
E, 4010, "syntax error in #elif directive, FALSE assumed"
E, 4011, "unexpected token(s) on line after #else"
E, 4013, "missing file name in #include directive"
E, 4016, "unexpected token(s) following file name in #include directive"
E, 4017, "missing line number and file in #line directive"
E, 4018, "first token in #line directive is not a line number"
E, 4019, "second token in #line directive is not a string literal (file name)"
E, 4020, "unexpected 3rd token in #line directive"
E, 4021, "#error encountered; no message provided"
E, 4023, "parameter list in macro definition not complete"
E, 4024, "missing identifier name in #define"
E, 4025, "invalid #define directive"
E, 4026, "unexpected token(s) following identifier in #undef"
E, 4027, "non-identifier in #undef directive"
E, 4028, "missing identifier name in #undef"
E, 4029, "syntax error in preprocessor scan"
E, 4030, "syntax error in expanded #if/#elif expression, FALSE assumed"
E, 4031, "syntax error at end of expanded #if/#elif expression, FALSE assumed"
E, 4032, "cannot #define keyword 'defined'"
E, 4033, "cannot #define internal macro name"
E, 4034, "non-benign macro redefinition ignored"
E, 4035, "cannot #define keyword 'defined'"
E, 4036, "cannot #define internal macro name"
E, 4037, "non-benign macro redefinition ignored"
E, 4038, "cannot #undef keyword 'defined'"
E, 4039, "attempted #undef of internal macro ignored"
E, 4040, "function like macro missing ')' after arguments"
E, 4041, "macro has whitespace argument"
E, 4042, "extra arguments to macro ignored"
E, 4043, "macro has solo whitespace argument"
E, 4044, "not enough arguments for macro, whitespace arguments supplied"
E, 4045, "operator '##' ignored at start of replacement list"
E, 4046, "operator '##' ignored at end of replacement list"
E, 4047, "'##' operator followed by '##' operator in macro replacement list"
E, 4048, "'#' operator applied to whitespace"
E, 4049, "operator '##' illegal at start of replacement list"
E, 4050, "operator '#' illegal at end of replacement list"
E, 4051, "operator '#' not followed by a macro parameter"
E, 4052, "operator '##' illegal at end of replacement list"
E, 4053, "line number in #line directive must be between 1 and 32767"
E, 4060, "unrecognized pragma undefine_macros selector"
E, 4062, "unrecognized pragma after_output_dump selector"
E, 4074, "line number must be a digit sequences only"
E, 4076, "scanner limitation: too many characters in pasted string"
E, 5001, "#error encountered"
E, 5003, "unexpected token(s) on #ifdef line ignored"
E, 5004, "unexpected token(s) on #ifndef line ignored"
E, 5005, "neither <...> nor "..." style include found"
E, 5008, "only one ancestral path selection is allowed"
E, 6004, "#if/elif evaluated false due to: yacc stack overflow"
E, 6012, "#if/elif evaluated false due to division by zero"
E, 6013, "#if/elif evaluated false due to modulus of zero"

DIAGNOSTICS WITH DEFAULT SEVERITY OF WARNING
W, 1001, "preserve comment option not supported"
W, 1005, "dependency collection option not yet supported"
W, 1011, "option to restrict names to 8 characters is not supported"
W, 1021, "support for non-ANSI // comments provided"
W, 1022, "__STDC__ definition has been removed"
W, 1023, "ANSI standard macros have been undefined"
W, 3001, "found "/*" within standard comment"
W, 3004, "multicharacter character constants not supported"
W, 3008, "illegal character in source stream"
W, 3013, "escape sequences other than `\\' are not honored in #line directives"
W, 3043, "found "*/" in "//" style comment"
W, 3044, "found "/*" within standard comment in inactive code"
W, 3045, "found "/*" within "//" style comment"
W, 3046, "found "/*" within "//" style comment in inactive code"
W, 3048, ""//*" would be misparsed without "//" style comments"
W, 3049, "illegal vertical whitespace ignored in inactive code"
W, 3051, "multicharacter character constant encountered in inactive code"
W, 3052, "character constant missing close quote in inactive code (')"
W, 3053, "string literal in inactive code is missing close quote (")"
W, 3054, "illegal character in inactive code in source stream"
W, 3055, "string literal in inactive code contains invalid escape sequence(s)"
W, 3057, "character constant in inactive code has no characters"
W, 4012, "unexpected token(s) on line after #endif"
W, 4022, "#pragma missing specification tokens"
W, 4054, "expected integer or diagnostic level"
W, 4055, "expected 'silent', 'hint', 'warning', or 'error'"
W, 4056, "diagnostic numbers are between 1001 and 9999"
W, 4057, "expected diagnostic number, or severity level"
W, 4058, "expected 'fatal', 'error', 'warning' 'hint' or 'silent'"
W, 4059, "expected ancestral selection and/or 'current_directory'"
W, 4061, "expected expected 'ANSI', 'platform', 'command_line', or 'user'"
W, 4063, "expected 'profile' or 'macros'"
W, 4064, "expected 'off', or 'on' (the default is 'on')"
W, 4065, "expected 'off', or 'on' (the default is 'on')"
W, 4066, "expected 'off', or 'on' (the default is 'on')"
W, 4067, "expected 'off', or 'on' (the default is 'on')"
W, 4068, "expected 'off', or 'on' (the default is 'on')"
W, 4069, "unexpected token(s) at end of pragma line ignored"
W, 4073, "consecutive paste operators in macro definition"
W, 4075, "keyword 'defined' evaluated as 0 in if/elif directive"
W, 5002, "unrecognized #pragma"
W, 5006, "cannot change 'fatal' default diagnostic level"

DIAGNOSTICS WITH DEFAULT SEVERITY OF HINT
H, 3020, "#include file name contains "/*" sequence"
H, 3021, "#include file name contains '\' character"
H, 3022, "#include file name contains "'" character"
H, 3024, "#include <...> file name contains `"' character"
H, 3032, "file temporarily closed"
H, 4078, "use of bulk undefine may limit portability"
H, 4079, "use of bulk undefine may limit portability"
H, 4080, "use of bulk undefine may limit portability"
H, 5007, "diagnostic display may be diminished"
H, 5009, "non-ANSI C behavior requested"
H, 5010, "non-ANSI C behavior requested"
H, 5011, "non-ANSI C behavior requested"
H, 5012, "non-ANSI C behavior requested"
H, 5013, "non-ANSI C behavior requested"

DIAGNOSTICS WITH DEFAULT SEVERITY OF SILENT
S, 3027, "trying to open include file in ancestor's directory"
S, 3028, "include file found using ancestral path"
S, 3029, "trying to open include file independent of ancestors"
S, 3030, "include file found without ancestral dependence"
S, 3041, "application include file opened"
S, 3042, "system include file opened"
S, 3047, ""//*" may be misunderstood under C++"
S, 3050, "identifier includes '$' character in inactive code"
S, 4070, "benign redefinition of manifest macro ignored"
S, 4071, "benign redefinition of function-like macro ignored"
S, 4072, "macro #undef action undertaken"
S, 4077, "macro #undef requested for undefined identifier"



DIAGNOSTIC MESSAGES- EXPLANATIONS AND USER RESPONSES

W, 1001, "preserve comment option not supported"

    The   command   line   option   "-C"  is  understood  by  some  C
    preprocessors  as  a  request   to   preserve   comments   during
    preprocessing.   This  option  is not supported by this facility.
    See "BUGS/FEATURES" for more details.

E, 1002, "complex macro predefinition not supported"

    The command line option "-Didentifier=token"  was  supplied,  but
    the "token" is not a "simple single token".  The "token" supplied
    was either a nil string ("-Didentifier="), or it was  an  invalid
    preprocessing  token,  or  it consisted of multiple tokens (e.g.:
    "-Didentifier=a+b").  The command  line  can  only  be  used  for
    defining  a  token  to be "1" by default (e.g.: "-Didentifier" is
    equivalent to "-Didentifier=1"), or to define  a  manifest  macro
    with a replacement list that consists of a single token.

E, 1003, "cannot predefine non-identifier"

    The  command  line  option "-Didentifier" or "-Didentifier=token"
    was supplied, but "identifier" is not a  valid  identifier  name.
    Valid  names  begin  with  a letter (a-z or A-Z) or an underscore
    ("_"), and continue with a sequence of letters, underscores,  and
    digits  (1-9).  An additional error message (1018 or 1019) should
    provide further description of the nature of the problem.

E, 1004, "unable to predefine macro"

    The command line option  "-Didentifier"  or  "-Didentifier=token"
    was   supplied,   but   the   predefinition  was  NOT  performed.
    Additional  error  messages  should  provide  details   of   what
    prevented the definition.

W, 1005, "dependency collection option not yet supported"

    The  command line option "-M" is understood by some preprocessors
    to mean that a list of dependent files (e.g.: header  files  that
    were  included)  should  be  listed.   This  option  is  used  to
    automatically create dependency  files  for  facilities  such  as
    "make".     This   option   will   be   supported   "soon",   see
    "BUGS/FEATURES" for details.

E, 1006, "command line option 'p' not supported"

    The command line option "-p" is taken by  some  preprocessors  to
    limit  examination  of  identifier  names to 8 characters, and to
    flag extraneous tokens on "#else", and "#endif" lines as  errors.
    The  above  errors  are  always  detected, but this option is not
    supported.

?, 1007, ""

    There is no error 1007.

E, 1008, "unrecognized command line option; use -U to undefine macros"

    A command line option  (a  string  beginning  with  a  "-u")  was
    supplied,  but the characters that followed did not correspond to
    any known options.  Use the "-help" option to get a valid list of
    available options.  Also note that the "-U" option can be used to
    undefine specific macro identifiers.

E, 1009, "attempt to undef non-identifier"

    The  command  line  option  "-Uidentifier"  was   supplied,   but
    "identifier"  is  not a valid identifier name.  Valid names begin
    with a letter (a-z or A-Z) or an underscore ("_"),  and  continue
    with  a  sequence  of  letters, underscores, and digits (1-9). An
    additional error message (1018 or 1019)  should  provide  further
    description of the nature of the problem.

?, 1010, ""

    There is no error 1010.

W, 1011, "option to restrict names to 8 characters is not supported"

    The  command line option "-T" is understood by some preprocessors
    to restrict the significance of identifiers names to 8 characters
    (other   characters  would  be  ignored).   This  option  is  not
    supported.


E, 1012, "directory name required"

    When supplied, this directory name will be appended to the end of
    the   list  of  directory  names  that  were  acquired  from  the
    environment  variable  "INCLUDE".  Unlike  the  traditional   cpp
    counterpart,  the "-Y" option to JRCPP requires a directory name,
    and does not "replace" the existing search list.  This  augmented
    list  of  directories  extends  the  search  path for <...> style
    (a.k.a. system) include directives, as  well  as  "...."  (a.k.a.
    standard)  include  directives.  See also the command line option
    "-I", and the discussion  of  the  #include  directive,  and  the
    searching algorithm used.

E, 1013, "unrecognized option"

    A  command  line  option  (a  string  beginning  with  a "-") was
    supplied, but the characters that followed did not correspond  to
    any known options.  Use the "-help" option to get a valid list of
    available options.

F, 1014, "unable to open source file"

    The first argument on the command line that does not begin with a
    "-"  is  assumed to be the source text file. The preprocessor was
    unable to open the file specified.   Note  that  if  no  file  is
    specified, then standard input is used to obtain the source text.

F, 1015, "output file cannot be the same as input file"

    The  first  two command line arguments that do not begin with "-"
    are assumed to be the source (input) file  and  the  preprocessed
    (output)  file.   The  two  names  supplied are the same, and the
    result would have been that the source file would be destroyed by
    the  preprocessing  execution.   Generally, this is a user error,
    and in order to prevent loss of data,  such  overwriting  is  not
    permitted.

F, 1016, "output file cannot have '.c' postfix"

    The  second command line argument that does not begin with "-" is
    assumed to be the file to which preprocessed data is written.  To
    prevent  a  user from (incorrectly) assuming that several C files
    can be preprocessed at the same time, with the **BAD** result  of
    overwriting  the user's own source file, an output file name with
    the common source postfix ".c" is NOT permitted.  If such a  name
    is  desired,  the  user should either write to an alternate name,
    and then rename the resulting file, or should use redirection  of
    standard  output  (the  default output destination) to create the
    file.

F, 1017, "unexpected argument on command line"

    The presence of a command line argument that does not begin  with
    a  "-" marks the end of the list of options, and the beginning of
    the list of file names (source input, followed optionally  by  an
    output  file  name).  No other arguments should be present on the
    command line beyond this point, but  the  indicated  (extraneous)
    argument was found.

E, 1018, "identifiers must begin with a letter or '_'"

    A command line option provided an "identifier", that did not meet
    the requirements of an  ANSI  C  identifier.   Specifically,  the
    first character was neither a letter nor an underscore ("_").

E, 1019, "valid identifier must contain only alphanumeric or '_'"

    A command line option provided an "identifier", that did not meet
    the requirements of an ANSI  C  identifier.   Specifically,  some
    character  was  neither  a  letter nor an underscore ("_"), nor a
    digit.

E, 1020, "file name in environment variable is too large"

    The environment variable "INCLUDE" is supposed to contain  a  ";"
    delimited  list  of directories to search for include files.  One
    of those directory names exceeded the  static  (sorry,  for  this
    limit,  but  I  doubt  that  it  will bother anyone) limit on the
    length of a directory provided  via  this  environment  variable.
    The  limit  is  currently  511 characters (four times the longest
    legal line length under MSDOS!?!).  Usually this error is  caused
    by  the  presence of a long environment variable called "INCLUDE"
    that  is  actually  **NOT**  a  list  of  directory  names.   See
    "BUGS/FEATURES".


W, 1021, "support for non-ANSI // comments provided"

    The "-B" option was supplied on the command line, and as a result
    the C++ style comments beginning with  "//"  will  be  supported.
    Note  that  this  acceptance is not generally compatible with the
    ANSI C standard. This diagnostic is present in  order  to  comply
    with  the  ANSI  C  Standard that all errors produce at least one
    diagnostic message (and since "//" style comments **MIGHT**  hide
    some code, this message is always provided).

W, 1022, "__STDC__ definition has been removed"

    The  command  line  option "-undef" was supplied, and as a result
    all platform specific macros as well as __STDC__ have  had  their
    definition  removed.   Note  that  the  internal macros __LINE__,
    __FILE__, __DATE__, and __TIME__ are not effected by this option.
    Finer  granularity  of removal of these internally defined macros
    by the "#pragma undefine_macros ...".  This diagnostic is present
    in  order  to  comply  with  the  ANSI C Standard that all errors
    produce at least one diagnostic message (and  since  this  option
    allows  the identifier __STDC__ to be used in a define directive,
    ANSI C violations **MIGHT** be missed later).

W, 1023, "ANSI standard macros have been undefined"

    The command line option  "-undefANSI"  was  provided,  and  as  a
    result  the  internal  macros  __LINE__,  __FILE__, __DATE__, and
    __TIME__ have had their definitions removed. This  diagnostic  is
    present  in  order  to  comply  with the ANSI C Standard that all
    errors produce at least one diagnostic  message  (and  since  the
    macro names that are removed by this mechanism can now become the
    legal subject of #define  and  #undef  directives,  such  ANSI  C
    violations **MIGHT** be missed later).



E, 2001, "final new line in file is hidden by backslash"

    Source  files  must  either be empty, or end in a carriage return
    that is **NOT** logically removed by a preceding backslash.   The
    indicated  file ends with a new line, but the preceding character
    was a backslash. The backslash should be removed.

E, 2002, "new line inserted at end of file"

    All source files must either be empty, or end  in  either  a  new
    line.  The indicated file has a final character that is not a new
    line.  An empty new line should be added to the end of the file.

E, 2003, "missing comment terminator '*/' at end of file"

    The end of file was reached, but a comment was started ("/*") and
    has  not  yet  ended.   Since  all comments are translated into a
    single white space, this error may lead to fairly bizarre errors.
    For  example, if the unterminated comment was initiated on a line
    with a directive, then tokens following the eventual  termination
    of  the  comment  will  appear  logically  on  the  line with the
    directive!?!? To rectify this error, close the comment.  Although
    the  implementation  is CAPABLE OF closing this comment when this
    error occurs, it  was  decided  that  a  **BIZARRE**  user  might
    actually  relish  this performance, and so the comment is **NOT**
    automatically closed.

W, 3001, "found "/*" within standard comment"

    Since standard "/*" based comments do not nest, a "/*"  within  a
    comment  has  no  major significance.  The most common reason for
    this diagnostic is that the user forgot to close a prior comment,
    and  a "/*" indicating the start of a new comment has been found!
    IF this was the reason for the error, then  it  is  quite  likely
    that  some  code  has  also  inadvertently  been  commented  out.
    Without this diagnostic such simple user errors in C are **VERY**
    difficult  to  locate.   As  is suggested by the presence of this
    diagnostic, users should typically not  have  "/*"  within  their
    comments, and this diagnostic can then prove most valuable.  If a
    user wishes temporarily remove  a  block  of  code,  rather  than
    enclosing it in a "/*" based comment, the preprocessor directives
    "#if 0" and "#endif" are suggested  to  enclose  the  block  (and
    these constructs **DO** nest).

E, 3002, "illegal vertical whitespace translated to spaces"

    After  a "#" near the start of a line (preceded only by arbitrary
    whitespace),  the  preprocessor   scans   for   a   preprocessing
    directive.  This  directive  is  terminated  by a newline, and is
    permitted   to   contain   arbitrary   amounts   of   "horizontal
    whitespace".   "Horizontal  whitespace"  includes horizontal tabs
    and spaces (and equivalently  comments).  In  contrast,  vertical
    whitespace,    such    as    a    page-feed,   vertical-tab,   or
    carriage-return, is **NOT** permitted AFTER THE #.  Note that  it
    is  very  difficult to read a listing that has a page feed in the
    middle of a preprocessing directive!  This error  indicates  that
    vertical  whitespace  has  be  detected, and it has been replaced
    with spaces.

E, 3003, "identifier includes '$' character"

    The  ANSI  C  standard  clearly  defines  what   constitutes   an
    identifier  as an alphabetic or underscore character, followed by
    a  sequence  of  alphanumeric  or  underscore  characters.   Some
    machine language implementations make extensive use of the "$" as
    part  of  external   identifiers.    As   a   consequence,   this
    preprocessor  flags  such  a  character in the source stream, but
    scans it in as a complete identifier name. Notice that outside of
    single  and  double  quotes,  the  source  character  "$"  is not
    permitted to be a part of any  standard  token,  and  hence  this
    (clearly  noted)  extension  does not interfere with any standard
    ANSI C constructs.

    For the language lawyers, it should be noted that a $ is actually
    a  valid  preprocessing  token  in  its  own  right.   Hence  the
    "perfect" ANSI C preprocessor would not consider it to be part of
    the  adjacent  identifier(s).   Note  that this exposed character
    does not form a valid token (for parsing), and hence it  must  be
    destroyed or formed into a part of a valid token somewhere during
    preprocessing  activities  (e.g.:  destroyed  because  it  is  an
    argument  to a macro that is not used; made part of a valid token
    by being stringized as part of a macro  expansion).  The  current
    version  of  JRCPP supports the interpretation that a $ character
    defaults to be part of an  identifier,  but  future  versions  of
    JRCPP may require an explicit option to support this feature.


W, 3004, "multicharacter character constants not supported"

    A  character  constant is a single quote, followed by a non-empty
    list of escape sequences  or  characters,  and  terminated  by  a
    single  quote  (example:  '\n').  Although the standard specifies
    what the interpretation of character constants containing exactly
    one  escape  sequence  or  character,  the  ANSI  C  standard  is
    specifically vague in its description of the meaning of  multiple
    characters  (Intel and Motorola architectures generally differ in
    their interpretation of such constants!).  As a result,  portable
    code  SHOULD  NOT make use of character constants containing more
    than one escape sequence or character in a single constant  (this
    has to do, in most cases, with either interpreting such constants
    as "'ab'" as being the same  as  either  "(256*'a'+'b')",  OR  as
    being  the  same  as "(256*'b'+'a')"). Although this preprocessor
    will  process  (as  part  of  source  text)  multiple   character
    constants   as   would   be  expected,  the  interpretation  when
    evaluating "#if" and  "#elif"  directives  does  ***NOT***  honor
    characters  after the first.  Hence for example, "'AB'" is valued
    identically  "'A'"  or  "'Aanything'"  during  preprocessor   #if
    evaluation.   It  is  suggested  that you avoid such not portable
    constructs, and beware of  odd  performance  in  the  context  of
    preprocessor if directives.

E, 3005, "character constant missing close quote (')"

    Character   constants   are   delimited  by  single  quote  ("'")
    characters, and must lie entirely on a single  line.  The  source
    text contains a single quote character which marks the start of a
    character constant, but there is no corresponding close quote  on
    the  same  line.   This  is  typically  a  typo,  but can also be
    instigated by such text as "'\'".  If the user wanted a backslash
    character,  then the source text should have contained "'\\'", to
    provide the single character.  In  contrast,  the  text  "'\'..."
    provides  a  starting  "'",  followed by the ***ESCAPED*** single
    quote character "\'", followed by all the remainder  of  text  on
    that  line.  To correct this error either add the forgotten close
    quote, or properly "escape out" the backslash that  precedes  the
    desired close quote.

E, 3006, "string literal contains invalid escape sequence(s)"

    String  literals  are delimited by double quotes ("), and contain
    source  characters  and  escape  sequences.   The  valid   escape
    sequences  include  "simple escape" sequences such as '\a', '\b',
    '\f', '\n', '\r', '\t', '\v', '\'', '\"', '\?', and '\\', as well
    as   octal   and  hexadecimal  escape  sequences.   Octal  escape
    sequences are of the form '\d', or \'dd', or '\ddd', where 'd' is
    an  octal  digit  between  0 and 7 inclusive.  Hexadecimal escape
    sequences begin with the sequence '\x', and consist of 1 or  more
    additional  alphanumeric  characters.   The presence of any other
    backslash combinations is considered an error,  even  though  the
    sequence is passed correctly through the preprocessor.

E, 3007, "string literal missing close quote (")"

    String  literals are delimited by double quotes ("), and must lie
    entirely on a single line.  This diagnostic  indicates  that  the
    end of the line was reached and the close quote was not provided.
    Note that the escape sequence '\"' can be used to  represent  the
    quote character in an escape sequence, and prevent interpretation
    of the final quote  as  a  delimiter.   For  example,  '"slash=/,
    backslash=\"'  does  not  have  a terminating quote.  The correct
    form of the  above  example  is  '"slash=/,  backslash=\\"'.   To
    correct  this problem, either add the missing quote, or un-escape
    the terminating quote.

W, 3008, "illegal character in source stream"

    A character was found in a source file that cannot be part of any
    preprocessing  token,  in  the  context  of  its occurrence.  For
    example, the backslash character "\" is not part of  any  lexical
    token  when  it  is  outside  of  a  string  literal or character
    constant.  If this lone character is not discarded (such  as  via
    #if  exclusion)  or manipulated into an actual token (such as via
    the stringize operator #), then  this  character  will  cause  an
    error during the phases of compilation FOLLOWING preprocessing.

E, 3009, "identifier includes '$' character"

    This  error  message  is  produced  after  a  macro expansion has
    required pasting of two tokens (re: the  ##  operator),  and  the
    resulting  character  sequence is a non-standard identifier.  See
    diagnostic 3003 for more details.

E, 3010, "multicharacter character constants not supported"

    This diagnostic message is produced after a macro  expansion  has
    required  pasting  of  two  tokens (re: the ## operator), and the
    resulting character sequence is a multicharacter  constant.   See
    diagnostic 3004 for more details.

E, 3011, "unable to form token out of character(s)"

    This  diagnostic  message is produced after a macro expansion has
    required pasting of two tokens (re: the  ##  operator),  and  the
    resulting  character sequence does not form a single preprocessor
    token.  The character sequence will be passed forward  correctly,
    but  these results are not guaranteed to be supported on all ANSI
    C conforming preprocessors.


E, 3012, "Wide string literal cannot be used as file name"

    An attempt was made to use a wide string literal as the name of a
    source file (e.g.: `#line 8 L"name" ').  Since the interpretation
    of wide string literals is implementation  dependent,  and  JRCPP
    does  not  provide  an interpretation for them, this construct is
    poorly defined within JRCPP.  JRCPP will attempt to interpret the
    string  literal  as though it were not a wide string literal, but
    proper interpretation  cannot  be  guaranteed.   The  only  major
    significance  of  this confusion is that the #line directives (if
    any) that are  inserted  in  the  post-preprocessed  output  will
    **NOT**  have notations to indicate that a wide string literal us
    being used.

W, 3013, "escape sequences other than `\\' are not honored  in  #line
directives"

    An escape sequence other than "\\" was found within a  file  name
    specified  in  a  #line directive.  The name provided in a user's
    #line directive is potentially used to form a  name  in  a  #line
    directive  provided  in  the the output (post-preprocessed) file,
    and is also used to identify the location of  a  construct  in  a
    diagnostic  message. Since such sequences as "\n", if interpreted
    as escape sequences, would corrupt the output #line directives as
    well  as  the  format  of  diagnostic  messages.  JRCPP skips the
    backslash that initiates the escape sequence as the file name  is
    scanned.  Note that the "\\" sequence is the only escape sequence
    honored in a file name string supplied in a #line directive.

E, 3014, "no text present in file name"

    A #include directive provided  a  file  name  that  had  no  text
    between the delimiters (e.g.: `#include "" ', or `#include <> ').
    A file name is required in a #include directive.

E, 3015, "loss of precision during conversion"

    The translation  of  the  digit  sequence  provided  in  a  #line
    directive  caused  an  overflow.   This  number  supplied is well
    beyond the range guaranteed by the ANSI C standard (a maximum  of
    32767),  and  moreover,  beyond  the  supported  range  of  JRCPP
    (typically a "signed long" on most architectures).

E, 3016, "loss of precision during conversion"

    The translation  of  the  digit  sequence  provided  in  a  #line
    directive  caused  an  overflow.   This  number  supplied is well
    beyond the range guaranteed by the ANSI C standard (a maximum  of
    32767),  and  moreover,  beyond  the  supported  range  of  JRCPP
    (typically a "signed long" on most architectures).

E, 3017, "unable to open preprocessed output file"

    An attempt was made to open the  output  file  specified  in  the
    command  line, but the operating system call failed.  Check to be
    sure that the file name is valid for your operating system,  that
    access  permission  is  provided  to the specified directory, and
    that access is permitted to the specific file name (i.e.: that  a
    file  by  the  same  name  is  not  already  in  place  AND write
    protected).  Additionally,  there  may  be  restrictions  on  the
    number of open files permitted from the current session, and this
    limit should (when all else fails) be consulted.

E, 3018, "missing terminator on file name"

    An attempt was  made  to  combine  the  tokens  provided  on  the
    #include  line  to form a valid include file name (e.g.: <...> or
    "...").  None of the tokens contained the necessary terminator (>
    or "). The #include directive has been ignored.

E, 3019, "file name terminator is not at right end of token"

    Although  the  left  most  section  of  the  text  of the include
    directive contains a standard file  name  form  (e.g.:  <...>  or
    "..."),  there is some additional text beyond the end of the file
    name sequence.  This text has been ignored.

H, 3020, "#include file name contains "/*" sequence"

    A #include directive contains a file name that has  the  sequence
    `/*'  embedded  within  it.  Such characters cause implementation
    defined behavior.  JRCPP simply accepts such  sequences  as  they
    are  supplied.  Since  this  sequence  is VERY rarely a part of a
    valid file  name,  the  user  is  advised  to  verify  that  such
    placement was intentional.

H, 3021, "#include file name contains '\' character"

    A  #include directive contains a file name that has the character
    `\' within it.   Such  characters  cause  implementation  defined
    behavior.  JRCPP accepts such backslashes, but does **NOT** treat
    them as the start of escape sequences.  For DOS/OS2 applications,
    it is suggested that the equivalent (and generally more portable)
    character `/` be used where a backslash is required as part of  a
    path name.

H, 3022, "#include file name contains "'" character"

    A  #include directive contains a file name that has the character
    "'" within it.   Such  characters  cause  implementation  defined
    behavior.  JRCPP  accepts  such  characters  as  entered (i.e.: a
    single quote).

E, 3023, "invalid file name token in #include directive"

    The "#include" directive expects that the tokens that  follow  it
    are  (or  will  macro  expand  to)  one  of  the file name forms:
    <file_name>, or "file_name".  This error indicates that the  form
    was  not  correct, as should be apparent in the sample text given
    with this  diagnostic.  Note  that  if  the  quoted  form  (i.e.:
    "file_name")  is  used,  then the characters **in** the file name
    cannot be quote characters. Similarly, if the angle bracket  form
    (i.e.:  <file_name>)  is used, the characters in file_name cannot
    include the closing angle bracket ">". This error is  NOT  caused
    by a badly formed file name, or a file that cannot be found.

H, 3024, "#include <...> file name contains `"' character"

    A #include directive of the form <file_name> contains a file name
    that has the double quote character `"' within it.  The  presence
    of  this character causes implementation defined behavior.  JRCPP
    accepts this character as part of the file name.

E, 3025, "cannot open include file"

    This message  indicates  that  the  file  name  selected  in  the
    "#include"  directive either cannot be found, or cannot be opened
    for reading (perhaps due to access restrictions). This error  may
    be  caused by restrictions on the number of open files allowed by
    the specific operating system, either in total, or on a  specific
    (network) device.

E, 3026, "existing macro definition being overwritten"

    The  user  has  elected  to  substitute  the  internal macro name
    __cplusplus for the ANSI C standard macro __STDC__ via (probably)
    the    #pragma    cplusplus_mode   directive.    The   identifier
    "__cplusplus"  was  already  defined  when  this  directive   was
    provided,  and the old definition has been overwritten.  Note the
    the identifier __cplusplus has also  attained  "special  internal
    status", and can no longer be used in as the subject of a #define
    or #undef directives.

S, 3027, "trying to open include file in ancestor's directory"

    A #include directive was specified, and a path prefix  was  taken
    from  one  of the ancestral source files (e.g.: one of the source
    files in the chain of #includes that led to this #include).   The
    diagnostic  shows  the entire path and file name that was used in
    the attempt to open the file.  This  directive  was  provided  to
    allow  users  to  more clearly see the areas searched in order to
    find an included file.   See  the  "#pragma  include_search  ..."
    directive for details on how to control the search algorithm.

S, 3028, "include file found using ancestral path"

    A  file  specified  in  a  #include  directive was located in the
    directory indicated.  Note that the path prefix for this filename
    was  taken  from  one of the ancestral source files (e.g.: one of
    the source files in the chain  of  #includes  that  led  to  this
    #include).   Note  that this message is not produced if the basis
    of the search was the "current directory", or  when  an  absolute
    path  was provided. This directive was provided to allow users to
    more clearly see the areas searched in order to find an  included
    file.  See the "#pragma include_search ..." directive for details
    on how to control the search algorithm.

S, 3029, "trying to open include file independent of ancestors"

    A #include directive was specified, and either an  absolute  path
    was  created,  or  else  the  current  director  was used for the
    search.  Note that  the  location  of  the  file  containing  the
    #include  directive  (as  well  as  the inclusion ancestors) were
    **NOT** involved in creating the path prefix for  this  attempted
    opening  of  the file. This directive was provided to allow users
    to more clearly see the  areas  searched  in  order  to  find  an
    included  file.   See  the "#pragma include_search ..." directive
    for details on how to control the search algorithm.

S, 3030, "include file found without ancestral dependence"

    A file specified in a  #include  directive  was  located  in  the
    directory  indicated.   The  filename used was either an absolute
    path/filename, or else the current directory was used. Note  that
    the  path  prefix for this filename was not derived from the file
    containing the  #include  directive  (or  any  of  the  ancestral
    inclusion  source  files)  This  directive  was provided to allow
    users to more clearly see the areas searched in order to find  an
    included  file.   See  the "#pragma include_search ..." directive
    for details on how to control the search algorithm.

F, 3031, "OS reports two input files cannot be opened"

    An attempt to open a  #include  file  has  been  refused  by  the
    operating  system  with  an  explanation that "too many files are
    open", despite the fact that ONLY one other source  (input)  file
    is  currently  open.  JRCPP temporarily closes source files so as
    not to be constrained by operating restrictions on the number  of
    open  files.  JRCPP's requirements for open files are only stdin,
    stdout, stderr, and at  most  two  source  input  files  (or  one
    post-preprocessing  output file).  This error indicates that such
    resources are not available to  JRCPP,  and  execution  has  been
    terminated.   Check  to be sure that the configuration parameters
    provided are not accidentally set at this incredibly  low  value.
    There  may  also be restrictions due to the use of a network, and
    the number of files that may be open across  the  network  (again
    check  the configuration parameters).  In any case, the resources
    should be made available to JRCPP, and the  preprocessing  should
    be retried.

H, 3032, "file temporarily closed"

    The  level  of  nested #include files has grown large enough that
    the operating system has declared that "too many files are open".
    JRCPP   has   temporarily  closed  a  source  file  in  order  to
    accommodate the operating system, but will reopen the  file  when
    the  contents  must be scanned.  Since there are no static limits
    on the depth of nested includes, this message may be a sign of an
    "infinite  loop"  via  #include  directives.  Alternatively, this
    message may just be a sign that the #include  nesting  is  large,
    and  the  operating  system does not allow many files open at the
    same time. If there is suspicion that the user may  have  induced
    an  "infinite include loop", then the severity of this diagnostic
    should be changed to "Warning", and the activities  can  be  more
    clearly monitored.

F, 3033, "unable to temporarily close file"

    The operating system has refused to allow JRCPP to close a source
    file.   The  indicated  source  file  needed  to  be  closed   to
    accommodate  a restriction by the operating system that "too many
    files were open", which became a problem when the level of nested
    #include  directives  grew too large.  Since the operating system
    refused to allow the  closing  of  the  file,  JRCPP  is  clearly
    confused   about  what  is  going  on  in  the  environment,  and
    preprocessing stops.  This should generally only be caused by  an
    operating system error beyond the control of JRCPP.

F, 3034, "OS failure in ftell prevented extension of #include nesting"

    The operating system restriction of the number of nested #include
    files has caused  JRCPP  to  consider  temporarily  closing  some
    source  file.   Unfortunately,  the  operating  system  call that
    reveals the current location in the source file has failed  (this
    can  occur when the command line has specified that the source be
    taken from standard input, rather than an actual file).

F, 3035, "unable to reopen file"

    The operating system restrictions on the number of files that may
    be  open  at  one time has caused JRCPP to temporarily close some
    source file.  When it was necessary to continue reading from that
    source  file,  an attempt was made to reopen the source file, but
    the operating system request failed.  This rather  unusual  error
    should  only occur if the environment changed (e.g.: the file was
    deleted  or  made  inaccessible)  while  the  source   file   was
    temporarily  closed.   Retry  the preprocessing action, but avoid
    changing the source files WHILE the preprocessor is scanning them.

F, 3036, "unable to reposition in file after reopening"

    The operating system restrictions on the number of files that may
    be  open  at  one time has caused JRCPP to temporarily close some
    source file.  When it was necessary to continue reading from that
    source  file,  the  file  was  reopened, but the operating system
    request to reposition the scan of the file where processing  left
    off,  has failed.  This rather unusual error should only occur if
    the environment changed (e.g.: the file was modified)  while  the
    source  file  was  temporarily  closed.   Retry the preprocessing
    action,  but  avoid  changing  the   source   files   WHILE   the
    preprocessor is scanning them.

E, 3037, "Unsupported wide character constant translation ignored"

    A  #if  or  #elif  directive  required  the  evaluation of a wide
    character  constant.   Since  the  meaning  of   wide   character
    constants  (e.g.: L'...' ) is implementation dependent, and JRCPP
    has no  definition  for  the  interpretation  of  wide  character
    constants,  the  value  is  very likely to be other than what was
    desired by the user.  The character constant will be evaluated as
    though  it were an ordinary character constant (i.e.: the initial
    "L" is ignored).

E, 3038, "nil character constant evaluated as single quote '\'' "

    A #if or #elif directive required the evaluation of  a  character
    constant  that  consisted  of only two consecutive single quotes.
    The value of the constant is taken to be that of a single  quote,
    which is equivalent to: '\''

E, 3039, "invalid character constant evaluated in if/elif directive"

    A  #if  or #elif directive required the evaluation of a character
    constant that was ill formed (it  did  not  include  the  closing
    quote).    The   constant   has  been  interpreted  as  though  a
    terminating quote was supplied.

E,  3040,  "multicharacter character constant truncated during evaluation"

    A #if or #elif directive required the evaluation of  a  character
    constant  that  contained  more  than  a single character.  JRCPP
    interprets  such  constants  as  having  a  value  equal  to  the
    character  constant consisting of only the left most character in
    the constant.  The behavior in this area is not  defined  by  the
    ANSI  C  standard, and the results are notably non-portable.  See
    diagnostic 3004 for more details.

S, 3041, "application include file opened"

    A #include directive of the  form  "file_name"  has  located  the
    requested source file in the directory indicated.  Note that even
    if the search algorithm required the use of the  "system  include
    path",   any   file  requested  via  this  format  provides  this
    diagnostic.  Note also that this diagnostic is silent by default,
    an  will  not  appear  in  diagnostic  listings  unless a #pragma
    diagnostic_adjust directive is used.

S, 3042, "system include file opened"

    A #include directive of the  form  <file_name>  has  located  the
    requested source file in the directory indicated.  Note that this
    diagnostic is silent by default, an will not appear in diagnostic
    listings unless a #pragma diagnostic_adjust directive is used.

W, 3043, "found "*/" in "//" style comment"

    The  character  sequence  */  appears  within  a // style comment
    (i.e.: a comment that begins with //, and continues to the end of
    the  line). Since comments do not nest, the */ has no significant
    whatever. However, an attempt to comment out a  series  of  lines
    using  a /*...*/ style comment would be prematurely terminated by
    this sequence.  This message is only a stylistic warning.

W, 3044, "found "/*" within standard comment in inactive code"

    Inactive  code  is  a  section  of  source  text  that   is   not
    preprocessed   because   of   enclosing   conditional   inclusion
    directives (such as #if ).  A /* was found while passing  over  a
    comment  in  an  inactive  section  of code.  Note that this is a
    common error in active code, as a failure to  close  one  comment
    causes all source code up until the end of the next comment to be
    discarded.  In an inactive code segment, this  stylistic  warning
    might  is  still significant, as a comment can contain what would
    otherwise be considered a preprocessing directive! Hence a #endif
    might  be  accidentally  contained in an erroneously unterminated
    comment.

W, 3045, "found "/*" within "//" style comment"

    The character sequences /* was found within a // style comment. A
    //  style comment begins with //, and continues to the end of the
    current line.  Since comments do not nest in  any  way,  this  /*
    sequence (which would ordinarily indicate the start of a comment)
    is ignored.  If the user has accidentally commented out (via  //)
    the  start  of  a  /*...*/ style comment, then tokens on the next
    line will be exposed (incorrectly) to preprocessing  scan.   This
    warning is only a stylistic warning.

W, 3046, "found "/*" within "//" style comment in inactive code"

    Inactive   code   is  a  section  of  source  text  that  is  not
    preprocessed   because   of   enclosing   conditional   inclusion
    directives  (such as #if ).  The character sequences /* was found
    within a // style comment within a section of inactive  code.   A
    //  style comment begins with //, and continues to the end of the
    current line.  Since comments do not nest in  any  way,  this  /*
    sequence (which would ordinarily indicate the start of a comment)
    is ignored.  If the user has accidentally commented out (via  //)
    the  start  of  a  /*...*/ style comment, then tokens on the next
    line will be exposed (incorrectly) to preprocessing scan, and can
    confuse  the count of #if nesting if they happened to form a #if,
    #else, ... etc. directive.  This  warning  is  only  a  stylistic
    warning.

S, 3047, ""//*" may be misunderstood under C++"

    Although  //  style  comments  are  not  supported,  it may prove
    desirable to support such in future ports of the user's code.   A
    //  style  comment  begins with a //, and continues to the end of
    the current line.  The user has accidentally provided one of  the
    few  character  sequences  that make the use of // style comments
    more difficult.  Specifically, the user has initiated  a  /*...*/
    style  comment  IMMEDIATELY after a divide operator ('/').  If //
    style comments were supported,  this  tokens  sequence  would  be
    misunderstood.   It is suggested that the user place at least one
    blank character after the divide operator. This warning is only a
    stylistic warning.

W, 3048, ""//*" would be misparsed without "//" style comments"

    In  the  indicated  section  of code, // style comments are being
    supported. A // style comment begins with a //, and continues  to
    the  end  of  the  line.  There  is  a chance that the code being
    scanned has an example of the divide operator ('/')  followed  by
    the  start  of  a /*...*/ style comment. This construct, although
    EXTREMELY rare, can be found in ANSI  C  compliant  source  text.
    Since  this  is  an  area  of  ambiguity between the new style //
    comments, and  the  old  style  /*...*/  based  comments,  it  is
    suggested   that   this   text   be   written  less  ambiguously.
    Specifically, it is suggested that a space be placed after the //
    start  of  comment,  and  before  the  *.   This  warning is on a
    stylistic warning.

W, 3049, "illegal vertical whitespace ignored in inactive code"

    Vertical whitespace (such a vertical tab or  page  feed)  in  not
    permitted  (according  to  the ANSI C Standard) to the right of a
    `#' on a line that is interpreted as a  preprocessing  directive.
    Inactive  code  is  a section of text that is not being processed
    because of conditional inclusion directives (such  as  #if).   If
    this  code  were  active,  this  whitespace  character would have
    induced  an  error.   Note  that  vertical  whitespace   may   be
    misconstrued  by  some  preprocessors as the end of the line, and
    allow the characters that  follow  to  be  examined  as  possible
    directive lines.  The user should replace such illegal whitespace
    with horizontal whitespace such as "spaces", or "tabs".

S, 3050, "identifier includes '$' character in inactive code"

    Inactive  code  is  a  section  of  source  text  that   is   not
    preprocessed   because   of   enclosing   conditional   inclusion
    directives (such as #if ).  The `$' character has been  noted  as
    part  of  an  identifier  in  a  section  of  inactive code.  See
    diagnostic 3003 for more details.

W, 3051, "multicharacter character constant encountered in inactive code"

    Inactive   code   is  a  section  of  source  text  that  is  not
    preprocessed   because   of   enclosing   conditional   inclusion
    directives  (such  as  #if ).  Multicharacter character constants
    contain more than one character or escape sequences within a pair
    of  single quotes.  Such constructs are notable non portable, and
    generally  avoided.   Occasionally  an   unterminated   character
    constant is misconstrued for a multicharacter character constant.
    See diagnostic 3004 for more details.


W, 3052, "character constant missing close quote in inactive code (')"

    Inactive  code  is  a  section  of  source  text  that   is   not
    preprocessed   because   of   enclosing   conditional   inclusion
    directives (such as #if ). An incomplete character  constant  was
    identified   within   inactive  code.   Note  that  this  may  be
    indicative of damage to a source file, although it may simply  be
    so conditionally excluded code fragments.

W, 3053, "string literal in inactive code is missing close quote (")"

    Inactive   code   is  a  section  of  source  text  that  is  not
    preprocessed   because   of   enclosing   conditional   inclusion
    directives  (such  as  #if  ).  An  incomplete string literal was
    identified  within  inactive  code.   Note  that  this   may   be
    indicative  of damage to a source file, although it may simply be
    so conditionally excluded code fragments.

W, 3054, "illegal character in inactive code in source stream"

    Inactive  code  is  a  section  of  source  text  that   is   not
    preprocessed   because   of   enclosing   conditional   inclusion
    directives (such as #if ).  Although the fact that  an  arbitrary
    character forms a preprocessing token, and the fact that areas of
    inactive code do not have to form valid tokens of any sort,  this
    error  can  commonly  be  indicative  of  a corrupted source file
    (although it may simply represent the present of  code  fragments
    that were conditionally excluded).

W, 3055, "string literal in inactive code contains invalid escape sequence(s)"

    Inactive   code   is  a  section  of  source  text  that  is  not
    preprocessed   because   of   enclosing   conditional   inclusion
    directives  (such as #if ).  A cursory scan of the text within an
    inactive code sequence revealed that a string  literal  contained
    an  invalid  escape  sequence.   An escape sequence begins with a
    backslash character, and has one of several specific forms.   See
    diagnostic 3006 for more details.

E, 3056, "character constant has no characters"

    A  character  constant  is  either  badly  formed,  or  it has no
    characters. If the user wants to create a constant with  a  value
    equal  to  a single quote, then the correct syntax is '\''.  Note
    that '' actually  has  no  meaning,  and  might  even  have  been
    interpreted  as two consecutive tokens, each of which is a single
    quote.

W, 3057, "character constant in inactive code has no characters"

    Inactive  code  is  a  section  of  source  text  that   is   not
    preprocessed   because   of   enclosing   conditional   inclusion
    directives (such as #if ). A character constant is  either  badly
    formed,  or  it  has no characters. If the user wants to create a
    constant with a value equal to a single quote, then  the  correct
    syntax  is '\''.  Note that '' actually has no meaning, and might
    even have been interpreted as two  consecutive  tokens,  each  of
    which is a single quote.


E, 4001, "unrecognized or unmatched preprocessor directive"

    All  preprocessor  directive  begin  with  a  "#"  as  the  first
    non-white character on the line.  If  the  non-white  token  that
    follows this "#" is not any of the known preprocessing directives
    (e.g.: if, ifdef,  ifndef,  elif,  else,  endif,  pragma,  error,
    define,  undef,  include)  then  the directive is "unrecognized".
    Note that this is significant even within section  of  code  that
    are  "ifdef-ed  out",  in  that  the  preprocessor  is  trying to
    maintain a proper nesting count for if directives. If a  bounding
    preprocessor  directive  (e.g.: elif, else, endif) is encountered
    but it is not syntactically possible to associate it with a prior
    if,   the   the  directive  is  "unmatched".   For  example,  the
    appearance of "#endif" without a prior "#if..."  directive  would
    be an unmatched directive error.

E, 4002, "missing #endif for #if group"

    For   each   preprocessing   if   directive,   there  must  be  a
    corresponding "#endif" directive to terminate the group of  lines
    controlled  by  the  if/ifdef/ifndef.   The  end of file has been
    reached, but the terminating endif has not been found.  Note that
    it is not currently considered worthy of a diagnostic to identify
    when an include file has ended without  terminating  an  if-group
    that  was  begun within that file.  Most of the time, when a user
    erroneously fails to terminate an if directive at any point,  the
    directive  will go unterminated until the complete end of source,
    at which point it will be identified by this diagnostic.

E, 4003, "missing expression for #if directive, FALSE assumed"

    A preprocessing "if" directive is supposed to consist  of  "#if",
    followed by an expression (which must be first macro expanded and
    then evaluated).  This error is produced if EITHER  there  wasn't
    anything  (other than white space after the "if", or if the macro
    expansion of the tokens following the "if" provided no tokens  to
    evaluate.   For  example,  "#define  a" followed by "#if a" would
    result in this error, as the macro "a"  expands  to  nothingness.
    As  a  form  of  error  recovery, the preprocessor acts as if the
    expression evaluated to false (i.e.: 0).

E, 4004, "missing identifier name in #ifdef directive, FALSE assumed"

    The syntax of the #ifdef" directive requires that  an  identifier
    name follow the "ifdef" token.  This error is generated when only
    whitespace follows the "ifdef" directive.  As  a  form  of  error
    recovery, the preprocessor acts as if an identifier was presented
    that was not defined, and hence the directive evaluates to FALSE.

E, 4005, "missing identifier name in #ifndef directive, TRUE assumed"

    The syntax of the #ifndef" directive requires that an  identifier
    name  follow  the  "ifndef"  token.  This error is generated when
    only whitespace follows the "ifndef" directive.   As  a  form  of
    error  recovery,  the  preprocessor  acts as if an identifier was
    presented that was not defined, and hence the directive evaluates
    to TRUE.

E, 4006, "syntax error in #if directive, FALSE assumed"

    A  syntax  error  occurred  while parsing the latter section of a
    "#if" directive.  Since the expression could not  be  read  as  a
    whole,  simplistic error recovery has assumed that the expression
    would have been false (e.g.: 0) anyway.  Note that a common cause
    for  this  problem is the incorrect use of the "defined" operator
    within a "#if" directive.  The only two syntactically valid forms
    are  "defined identifier", and "defined ( identifier )", although
    these forms may be used repeatedly alongside other expressions to
    construct  the complete expression.  Also notice that this syntax
    must be abided by prior to macro expansion, as the  scanning  for
    and  evaluation  of  the  "defined" operator is done **PRIOR** to
    macro evaluation.

E, 4007, "syntax error in #ifdef directive, FALSE assumed"

    A syntax error occurred while parsing the  latter  section  of  a
    "#ifdef"   directive.    The   only   non-white   token  that  is
    syntactically valid after the "ifdef" directive is an identifier.
    If  a  non-identifier is placed at that point then a syntax error
    is produced.  Error  recovery  in  this  case  asserts  that  was
    provided  was not defined (it wasn't even an identifier), and the
    directive evaluates to false.

E, 4008, "syntax error in #ifndef directive, TRUE assumed"

    A syntax error occurred while parsing the  latter  section  of  a
    "#ifndef"   directive.    The   only   non-white  token  that  is
    syntactically  valid  after  the   "ifndef"   directive   is   an
    identifier.   If  a non-identifier is placed at that point then a
    syntax error is produced.  Error recovery in  this  case  asserts
    that was provided was not defined (it wasn't even an identifier),
    and the directive evaluates to true.


E, 4009, "missing expression for #elif directive, FALSE assumed"

    A preprocessing  "elif"  directive  is  supposed  to  consist  of
    "#elif",  followed  by  an  expression (which must be first macro
    expanded and then evaluated).  This error is produced  if  EITHER
    there  wasn't  anything (other than white space after the "elif",
    or the  macro  expansion  of  the  tokens  following  the  "elif"
    provided  no  tokens  to  evaluate.   For example, "#define a" in
    active code, followed much later by "#elif a",  would  result  in
    this  error,  as the macro "a" expands to nothingness.  As a form
    of error recovery, the preprocessor acts  as  if  the  expression
    evaluated to false (i.e.: 0).

E, 4010, "syntax error in #elif directive, FALSE assumed"

    A  syntax  error  occurred  while parsing the latter section of a
    "#elif" directive.  Since the expression could not be read  as  a
    whole,  simplistic error recovery has assumed that the expression
    would have been false (e.g.: 0) anyway.  Note that a common cause
    for  this  problem is the incorrect use of the "defined" operator
    within a "#elif" directive.  The  only  two  syntactically  valid
    forms  are  "defined  identifier",  and "defined ( identifier )",
    although these forms  may  be  used  repeatedly  alongside  other
    expressions  to  construct  the complete expression.  Also notice
    that this syntax must be abided by prior to macro  expansion,  as
    the scanning for and evaluation of the "defined" operator is done
    **PRIOR** to macro evaluation.


E, 4011, "unexpected token(s) on line after #else"

    The "#else" directive is syntactically expected to be alone on  a
    line  (not  counting  whitespace).   This error is generated when
    tokens are found later on  the  line.   Note  that  there  is  no
    significance to these tokens, as they are not processed or passed
    along in any way.

W, 4012, "unexpected token(s) on line after #endif"

    The "#else" directive is syntactically expected to be alone on  a
    line  (not  counting  whitespace).   This error is generated when
    tokens are found later on  the  line.   Note  that  there  is  no
    significance to these tokens, as they are not processed or passed
    along in any way.

E, 4013, "missing file name in #include directive"

    The  preprocessing  "#include"  directive  expects  a  file  name
    (either  enclosed  in quotes, or in angle brackets <...>.  Either
    there is nothing after the  "include"  directive,  or  the  macro
    expansion  of  the  tokens  that  followed  "include" expanded to
    nothingness.  If tokens (other than whitespace)  are  present  on
    the  line  after  "include", check to see that the desired tokens
    and macro definitions are in place.

?, 4014, ""

    There is no diagnostic 4014.

?, 4015, ""

    There is no diagnostic 4015.


E, 4016, "unexpected token(s) following file name in #include directive"

    After macro expanding the token sequence that follows  "#include"
    in  an  "include" directive, the syntax requires that ONLY a file
    name be present.  This error indicates that additional tokens are
    present  on  the  line after the file name, and the error message
    should show the text of the first such token.

E, 4017, "missing line number and file in #line directive"

    This  error  message  is  produced  when  nothing   (other   than
    whitespace)  appears  after  "line"  in a "#line" directive.  The
    syntax requires that the first token be an integer between 1  and
    32767, and that an option second argument specify a file name.

E, 4018, "first token in #line directive is not a line number"

    A  preprocessor  "#line" directive was encountered, but the first
    argument supplied was not  an  integer  constant  (note:  decimal
    points and sign are NOT allowed in an integer constant).

E, 4019, "second token in #line directive is not a string literal (file name)"

    The  second  argument  to  a  "#line"  directive must be a string
    literal (delimited by double quotes `"').  This  error  indicates
    that the second argument is not of the form "file_name".

E, 4020, "unexpected 3rd token in #line directive"

    The  "#line" directive expects no more than 2 arguments, the line
    number to associate with the next line, and the file  name.  This
    error  indicates  that at least one (useless) additional token is
    present after the required arguments.

E, 4021, "#error encountered; no message provided"

    The source text included a "#error" directive.  The line did  not
    have  any addition text to present.  Note that a comment is white
    space,  and  hence  cannot  appear  in  an  "#error"  diagnostic.
    Arbitrary  text  may  be  placed  on  the  line with the "#error"
    directive, and it will have no impact on  the  source  code,  but
    will display with this diagnostic.

W, 4022, "#pragma missing specification tokens"

    The  "#pragma"  directive  is  supposed to include some text with
    implementation defined meaning.   This  error  indicates  that  a
    pragma  was  encountered,  but  there  were no tokens (other than
    whitespace, or equivalently comments) on the  latter  section  of
    the line.

E, 4023, "parameter list in macro definition not complete"

    An  attempt  was  (apparently)  made  to define a "function like"
    macro, but the parameter list was never completed.   A  "function
    like"  macro  is  defined using a "#define" directive, and by not
    leaving a space between the macro name, and  a  parenthesis  that
    follows  it.  This  error  either  indicates  that  the  list  of
    parameters for the macro was never terminated by a ")", or that a
    syntax  error  in  the  parameter  list  stopped the scan for the
    closing parenthesis.  Check to be sure that there  is  a  closing
    ')',  and  that  all  the  parameters are identifiers (you cannot
    leave any out), and that the parameters (if more  than  one)  are
    separated  by  commas.   Typically a syntax error diagnostic will
    accompany this message and reveal where the scan was terminated.

E, 4024, "missing identifier name in #define"

    A "#define"  directive  was  encountered  that  had  nothing  but
    whitespace  after  the "define" keyword.  The "#define" directive
    requires, at a minimum, the name of an identifier to be defined.

E, 4025, "invalid #define directive"

    A  syntax  error  was  encountered  while  scanning  a  "#define"
    directive,  and  hence this directive will be ignored.  The first
    argument to a "#define" directive must be an identifier.  Failure
    to  provide  an  identifier, and to instead provide another token
    (such as a number or an arithmetic operator) is the  most  common
    cause of this diagnostic.

E, 4026, "unexpected token(s) following identifier in #undef"

    Exactly  on  argument  is expected for a "#undef" directive.  The
    argument must be the name of the macro  being  removed  from  the
    macro  database.  This error indicates that some non-white tokens
    (identified in an  associated  syntax  diagnostic)  were  present
    after the identifier name.  Note that these tokens were ignored.

E, 4027, "non-identifier in #undef directive"

    The  token  that  follows  "#undef" in such a directive must be a
    valid identifier name.  This message (and  an  associated  syntax
    diagnostic) indicates that a non-identifier (such as a number, or
    arithmetic operator) was  found  when  the  identifier  name  was
    expected.

E, 4028, "missing identifier name in #undef"

    This  diagnostic  indicates that the "#undef" directive was found
    alone on a line.  The "#undef" directive requires  one  argument,
    specifying  an  identifier,  that is to be removed from the macro
    database.

E, 4029, "syntax error in preprocessor scan"

    The indicated token "confused" the parser, as  the  token  cannot
    reasonably occur where it was found.  An additional error message
    should accompany this message and indicate the context  in  which
    the preprocessor was confused (surprised).

E,  4030,  "syntax  error  in  expanded  #if/#elif  expression, FALSE
assumed"

    This  diagnostic indicates that a sequence of tokens was gathered
    for a "#if"  or  "#elif",  but  after  these  tokens  were  macro
    expanded,  the  resulting  sequence  was  not  a  valid  constant
    expression.  Note that the exact procedure is to: 1)  gather  the
    tokens; 2) replace the "defined" operator with the results of its
    test (0L or 1L); 3) macro expand the  resulting  token  sequence;
    and  4) attempt to evaluate the resulting tokens as having formed
    a constant expression.   This  message  indicates  an  error  was
    encountered in step 4 of this operation.

E, 4031, "syntax error at end of expanded #if/#elif expression, FALSE
assumed"

    This  diagnostic indicates that a sequence of tokens was gathered
    for a "#if"  or  "#elif",  but  after  these  tokens  were  macro
    expanded,  the  resulting  sequence  was  not  a  valid  constant
    expression.  Specifically, there were insufficiently many  tokens
    (e.g.:  there is a missing ')'; or the last token on the line was
    a binary operator, and there is a missing right  operand).   Note
    that  the exact procedure is to: 1) gather the tokens; 2) replace
    the "defined" operator with the results of its test (0L  or  1L);
    3)  macro  expand the resulting token sequence; and 4) attempt to
    evaluate  the  resulting  tokens  as  having  formed  a  constant
    expression.   This  message indicates an error was encountered in
    step 4 of this operation.

E, 4032, "cannot #define keyword 'defined'"

    The preprocessing keyword "defined" has special  significance  in
    the  evaluation  of  "#if"  and "#elif" directives.  As a result,
    ANSI C precludes macro defining this identifier.   This  specific
    diagnostic occurred during an attempt to define "defined" to be a
    manifest macro.

E, 4033, "cannot #define internal macro name"

    There are several internally defined macros that ANSI C precludes
    from  redefinition.  These names are "__STDC__" (or "__cplusplus"
    when  in  c++  mode;  see  sections  on   #pragma),   "__FILE__",
    "__LINE__", "__DATE__", "__TIME__".  This specific diagnostic was
    generated when an attempt was  made  to  redefine  one  of  these
    macros to be an ordinary manifest macro.

E, 4034, "non-benign macro redefinition ignored"

    Once  a  macro  has  been  defined  via a "#define" directive, it
    cannot (without  being  "#undef"-ed  again)  be  the  subject  of
    another  macro  definition,  unless the "redefinition" is "almost
    identical" to the original definition.  The "almost" reflects the
    fact   that  the  nature  of  the  whitespace  contained  in  the
    definition may be altered slightly, but the nonwhite tokens,  and
    the  presence  of separating whitespace, must be unchanged.  This
    ANSI C specification appears to be targeted at allowing  multiple
    header  files, with effectively the same macro definitions, to be
    included without conflicts. Note that it is  NOT  permissible  to
    define  a  macro  to  be  both  a  manifest macro (doesn't have a
    parenthesized list of parameters) AND a function  like  macro  at
    the  same  time.   This specific diagnostic was generated when an
    attempt was made  to  redefine  a  macro  as  a  manifest  macro,
    independent   of   its   former  definition  (which  was  notably
    different).

E, 4035, "cannot #define keyword 'defined'"

    The preprocessing keyword "defined" has special  significance  in
    the  evaluation  of  "#if"  and "#elif" directives.  As a result,
    ANSI C precludes macro defining this identifier.   This  specific
    diagnostic occurred during an attempt to define "defined" to be a
    function like or parameterized macro.

E, 4036, "cannot #define internal macro name"

    There are several internally defined macros that ANSI C precludes
    from  redefinition.  These names are "__STDC__" (or "__cplusplus"
    when  in  c++  mode;  see  sections  on  #pragma)  ,  "__FILE__",
    "__LINE__", "__DATE__", "__TIME__".  This specific diagnostic was
    generated when an attempt was  made  to  redefine  one  of  these
    macros to be a function like, or parameterized macro.

E, 4037, "non-benign macro redefinition ignored"

    Once  a  macro  has  been  defined  via a "#define" directive, it
    cannot (without  being  "#undef"-ed  again)  be  the  subject  of
    another  macro  definition,  unless the "redefinition" is "almost
    identical" to the original definition.  The "almost" reflects the
    fact   that  the  nature  of  the  whitespace  contained  in  the
    definition may be altered slightly, but the nonwhite tokens,  and
    the  presence  of separating whitespace, must be unchanged.  This
    ANSI C specification appears to be targeted at allowing  multiple
    header  files, with effectively the same macro definitions, to be
    included without conflicts. Note that it is  NOT  permissible  to
    define  a  macro  to  be  both  a  manifest macro (doesn't have a
    parenthesized list of parameters) AND a function  like  macro  at
    the  same  time.   This specific diagnostic was generated when an
    attempt was  made  to  redefine  a  macro  function  like  macro,
    independent   of   its   former  definition  (which  was  notably
    different).

E, 4038, "cannot #undef keyword 'defined'"

    The preprocessing keyword "defined" has special  significance  in
    the  evaluation  of  "#if"  and "#elif" directives.  As a result,
    ANSI C precludes macro defining this identifier,  also  precludes
    providing "defined" as the subject of a "#undef" directive (which
    caused this diagnostic).

E, 4039, "attempted #undef of internal macro ignored"

    There are several internally defined macros that ANSI C precludes
    from  redefinition  and  "undefining". These names are "__STDC__"
    (or "__cplusplus" when in c++ mode;  see  sections  on  #pragma),
    "__FILE__",  "__LINE__",  "__DATE__",  "__TIME__".  This specific
    diagnostic was generated when an attempt was made to undefine one
    of these macros.

E, 4040, "function like macro missing ')' after arguments"

    Some  source  text  (or  expanded  source  text)  that  was being
    expanded included an identifier that was defined  as  a  function
    like macro, which had the potential to be expanded.  In addition,
    this identifier was followed by a '(',  which  confirmed  that  a
    expansion    of   the   function   like   macro   was   required.
    Unfortunately, the ')' that marks the end of  the  argument  list
    was not provide (note that parenthesis nest as the search for the
    closing parenthesis is made).  Note that the search for a closing
    ')'  will  NOT  proceed  beyond the next preprocessing directive.
    Hence this diagnostic may be caused by a directive in the  middle
    of   an   argument   list.   See  #pragma  delayed_expansion,  or
    BUGS/FEATURES for details of this scanning limitation.

E, 4041, "macro has whitespace argument"

    One of the arguments to a function like macro invocation (i.e.: a
    point  at  which macro expansion is called for) is missing, or at
    most  there  is  white  space.   For  example:  after  the  macro
    definition  "#define  f(a,b,c)",  the presence of "f(, /*comments
    are  whitespace*/,  )",  would  cause  3   renditions   of   this
    diagnostic.   Note  that  in  the  example  the first argument is
    missing, the second is formed by multiple  whitespaces,  and  the
    third  is formed by a space.  It should also be realized that the
    arguments are identified  BEFORE  they  are  macro  expanded  (if
    needed).   Hence  the  fact  that an argument, AFTER isolation as
    such, expands to nothingness is not generally a  source  of  this
    diagnostic.

E, 4042, "extra arguments to macro ignored"

    A  macro  invocation  of a function like macro has more arguments
    than are prescribed by  its  macro  definition.   The  additional
    arguments are ignored.

E, 4043, "macro has solo whitespace argument"

    The  indicated function like macro was defined to accept a single
    argument, but the invocation of that macro had only whitespace as
    an  argument.   Since arguments are defined by ANSI C to be other
    than whitespace, this is  unacceptable.   As  an  error  recovery
    mechanism,  a  whitespace sequence has been provided as though it
    were the argument.

E,  4044,  "not  enough  arguments  for  macro,  whitespace arguments
supplied"

    The indicated function like macro  was  defined  to  accept  more
    arguments  than  were provided in the indicated invocation.  As a
    form of error recovery, whitespace has been provided  (as  though
    it  were  a  valid  argument)  for  all the undefined (rightmost)
    parameters.

E, 4045, "operator '##' ignored at start of replacement list"

    A macro  definition  had  only  parameters  to  the  left  of  an
    indicated  paste  ("##") operator.  When the macro invocation was
    requested, some additional error recovery caused whitespace to be
    provided  as  arguments  (see  accompanying  diagnostics).   As a
    result of this situation, there was nothing to paste to the  left
    of  the trailing tokens.  The error recovery in this situation is
    too ignore the paste operator.  For example: "#define F(a)  a  ##
    hello",  followed  by  "F()" will produce this diagnostic.  Since
    the arguments that are being placed adjacent to a paste  operator
    are  NOT  expanded prior to placement, the associated diagnostic,
    involving the use of  white  space  as  an  argument,  is  always
    present  when  this  diagnostic  is produced.  Note that not only
    does the  "##"  operator  not  have  any  function,  it  is  also
    prevented  from  activating  paste functionality as it is used is
    the original context (perhaps as an argument).

E, 4046, "operator '##' ignored at end of replacement list"

    A macro definition  had  only  parameters  to  the  right  of  an
    indicated  paste  ("##") operator.  When the macro invocation was
    requested, some additional error recovery caused whitespace to be
    provided  as  arguments  (see  accompanying  diagnostics).   As a
    result of this situation, there was nothing to paste to the right
    of  the  leading tokens.  The error recovery in this situation is
    too ignore the paste operator. For example: "#define  F(a)  hello
    ## a", followed by "F()" will produce this diagnostic.  Since the
    arguments that are being placed adjacent to a paste operator  are
    NOT  expanded  prior  to  placement,  the  associated diagnostic,
    involving the use of  white  space  as  an  argument,  is  always
    present  when  this  diagnostic  is produced.  Note that not only
    does the  "##"  operator  not  have  any  function,  it  is  also
    prevented  from  activating  paste functionality as it is used is
    the original context (perhaps as an argument).

E, 4047, "'##' operator followed by '##' operator in macro replacement list"

    This diagnostic is generated only if the macro is  expanded.   It
    may  be  generated  because  the  a  definition  placed two paste
    operators ("##") consecutively (such as "#define m  hello  ##  ##
    there"),  or as a consequence of a "missing argument" diagnostic.
    An example of the latter case is  "define  F(a)  hello  ##  a  ##
    there",  followed  by "F()".  This diagnostic should be corrected
    by  either  adjusting  the  erroneous  macro  definition   (first
    example),  or  by preventing the associated "whitespace argument"
    error from inducing this problem.  The error recovery  result  of
    this construct is that the token to the left of the first "##" is
    pasted onto the "##" to the right.   This  will  typically  cause
    additional  errors  as the resulting token is scanned (and cannot
    be classified).

E, 4048, "'#' operator applied to whitespace"

    At macro definition time, it was verified that  the  argument  of
    the  stringize  operator  ("#")  was a parameter.  Unfortunately,
    this diagnostic indicates  that  at  macro  invocation  time  the
    corresponding parameter was missing, and whitespace (as indicated
    by accompanying diagnostics) was provided as  an  argument.   The
    error recovery in this situation provided for the construction of
    the string literal with no contents  at  all  (i.e.:  "").   This
    result  is  generally not well defined, as the ANSI C description
    calls for the removal of  all  leading  and  trailing  whitespace
    before  creating  the string, while at the same time it indicates
    that internal whitespace should be reduced to a single space.

E, 4049, "operator '##' illegal at start of replacement list"

    This diagnostic indicates that a macro  definition  has  a  paste
    operator  ("##")  at the start of the replacement list. Since the
    paste operator requires a  left  operand  (and  pasting  is  done
    BEFORE plugging the complete macro expansion into its surrounding
    context), the paste operator is guaranteed to  not  have  a  left
    argument,  and  hence  will  not  perform  any action.  The error
    recovery in this context is to simply leave the paste operator at
    the  start  of  the replacement list.  Note that it is internally
    prevented from inducing a paste operation in other contexts (such
    as when provided as an argument to another macro).

E, 4050, "operator '#' illegal at end of replacement list"

    The  replacement  list  for  a macro ends in a stringize operator
    ("#"). Since the operator requires a right operand, there  is  no
    possibility  that  a  macro  invocation  would provide such.  The
    error recovery in this situation  involves  effectively  deleting
    the trailing "#" from the macro definition.

E, 4051, "operator '#' not followed by a macro parameter"

    The  right  operand  of  the  stringize operator ("#") in a macro
    definition is not a parameter.  The meaningless "#" is discarded.
    Normally the token just to the right of "#" in a replacement list
    is a parameter  for  the  macro,  and  the  intent  is  that  the
    corresponding  argument  be  stringized  (enclosed  gracefully in
    quotes) at macro invocation time.

E, 4052, "operator '##' illegal at end of replacement list"

    This diagnostic indicates that a macro  definition  has  a  paste
    operator  ("##")  at  the  end of the replacement list. Since the
    paste operator requires a right  operand  (and  pasting  is  done
    BEFORE plugging the complete macro expansion into its surrounding
    context), the paste operator is guaranteed to not  have  a  right
    argument,  and  hence  will  not  perform  any action.  The error
    recovery in this context is to simply leave the paste operator at
    the  end  of  the  replacement  list.  Note that it is internally
    prevented from inducing a paste operation in other contexts (such
    as when provided as an argument to another macro).

E, 4053, "line number in #line directive must be between 1 and 32767"

    For  compatibility  with  a  variety  of  implementations, ANSI C
    requires that the first argument (the line number) in  a  "#line"
    directive  be  in  the  range  of  1-32767.   This implementation
    actually supports any line numbers less than 2<<31 (2 to the 31st
    power).  Note  that  negative  line numbers cannot be entered, as
    they are actually evaluated as an expression, including a leading
    unary  minus  operator,  and hence would cause syntax errors in a
    "#line" directive.


W, 4054, "expected integer or diagnostic level"

    The #pragma diagnostic_adjust  was  selected,  but  the  required
    arguments  were  not  supplied.   JRCPP assumes that the macro is
    only accidentally named identically to JRCPP's pragma, and so the
    pragma is passed unchanged to the post-preprocessed output file.

W, 4055, "expected 'silent', 'hint', 'warning', or 'error'"

    A #pragma diagnostic_adjust directive was provided, but the first
    argument was an identifier other than the a valid severity level.
    The two arguments to diagnostic_adjust are a severity level (or a
    specific  diagnostic  number),  followed  by  a  users  specified
    severity   level.    This  pragma  is  processed  as  though  the
    similarity to a valid JRCPP  pragma  was  coincidental,  and  the
    directive  is  passed  unchanged to the post-preprocessing output
    file.

W, 4056, "diagnostic numbers are between 1001 and 9999"

    A #pragma diagnostic_adjust directive was provided, but the first
    argument  was  an  integer outside the valid range for diagnostic
    numbers.  The two arguments to diagnostic_adjust are  a  severity
    level  (or  a  specific  diagnostic  number), followed by a users
    specified severity level.  This pragma is processed as though the
    similarity  to  a  valid  JRCPP  pragma was coincidental, and the
    directive is passed unchanged to  the  post-preprocessing  output
    file.

W, 4057, "expected diagnostic number, or severity level"

    A #pragma diagnostic_adjust directive was provided, but the first
    argument was neither an  integer  nor  and  identifier.  The  two
    arguments  to  diagnostic_adjust  are  a  severity  level  (or  a
    specific  diagnostic  number),  followed  by  a  users  specified
    severity   level.    This  pragma  is  processed  as  though  the
    similarity to a valid JRCPP  pragma  was  coincidental,  and  the
    directive  is  passed  unchanged to the post-preprocessing output
    file.


W, 4058, "expected 'fatal', 'error', 'warning' 'hint' or 'silent'"

    A #pragma  diagnostic_adjust  directive  was  provided,  but  the
    second  argument  was  not  a  valid  severity  level.   The  two
    arguments  to  diagnostic_adjust  are  a  severity  level  (or  a
    specific  diagnostic  number),  followed  by  a  users  specified
    severity level. This pragma is processed as though the similarity
    to  a  valid  JRCPP pragma was coincidental, and the directive is
    passed unchanged to the post-preprocessing output file.

W, 4059, "expected ancestral selection and/or 'current_directory'"

    A  #pragma  include_search  directive  was  provided,   but   the
    arguments  were  not  valid  for this pragma.  There should be at
    most two arguments, one of which specifies the extent (if any) of
    the    use   of   ancestral   files   and   their   path   prefix
    (only_eldest_ancestor,     OR      only_youngest_ancestor      OR
    all_ancestors),  and one argument that specifies the use (if any)
    of the current directory as a  path  prefix  (current_directory).
    This  pragma  is  processed  as  though the similarity to a valid
    JRCPP pragma  was  coincidental,  and  the  directive  is  passed
    unchanged to the post-preprocessing output file.

E, 4060, "unrecognized pragma undefine_macros selector"

    The  "#pragma undefine_macros ..." directive was encountered, but
    one of the arguments was not a valid macro group selector.  Since
    a  prior  selector was valid, the scan of this directive will NOT
    be  abandoned.  The  valid   groups   include   "ANSI",   "STDC",
    "platform",  "command_line",  and "user".  Note that the "#pragma
    after_output_dump macros" can be use to  obtain  a  list  of  the
    contents of each of these macro groups. This specific argument is
    being ignored, and the scan of  the  otherwise  valid  pragma  is
    continuing.  Note that this error simply marks the exclusion of a
    single argument, and if later arguments are  present  and  valid,
    then they will be accepted and processed.

W, 4061, "expected expected 'ANSI',  'platform',  'command_line',  or
'user'"

    The  "#pragma undefine_macros ..." directive was encountered, but
    none of the arguments was not a valid macro group selector.   The
    valid  groups include "ANSI", "STDC", "platform", "command_line",
    and "user". Note  that  the  "#pragma  after_output_dump  macros"
    lists  the  contents  of  each  of  these  macro groups. Since no
    meaning could be ascribed to this #pragma,  the  pragma  will  be
    passed unchanged to the output file.

E, 4062, "unrecognized pragma after_output_dump selector"

    A  "#pragma after_output_dump ..." directive was encountered, but
    the indicated argument was neither 'profile' nor  'macros'.  This
    specific   argument  is  being  ignored,  and  the  scan  of  the
    potentially valid pragma is  continuing.  Note  that  this  error
    simply  marks  the  exclusion  of a single argument, and if other
    arguments are present and correct, then they will be acted upon.

W, 4063, "expected 'profile' or 'macros'"

    A #"pragma after_output_dump" directive was encountered, but none
    of  the  arguments  were valid selectors ('profile' or 'macros').
    Since no meaning could be ascribed to this  #pragma,  the  pragma
    will be passed unchanged to the output file.

W, 4064, "expected 'off', or 'on' (the default is 'on')"

    A  "#pragma delayed_expansion" directive was encountered, but the
    argument was other than 'on', 'off',  or  nothing.  Setting  this
    option  to 'on' allows directives that cannot change the state of
    the macro database to occur during an argument list for  a  macro
    invocation.  Since  no meaning could be ascribed to this #pragma,
    the pragma will be passed unchanged to the output file.

W, 4065, "expected 'off', or 'on' (the default is 'on')"

    A "#pragma cplusplus_comment" directive was encountered, but  the
    argument  was  other  than  'on', 'off', or nothing. Setting this
    option to 'on' causes the lexical scan of source text to  support
    the  //  style  comments.   Since no meaning could be ascribed to
    this #pragma, the pragma will be passed unchanged to  the  output
    file.

W, 4066, "expected 'off', or 'on' (the default is 'on')"

    A  "#pragma describe_macro_expansions" directive was encountered,
    but the argument was other than 'on', 'off', or nothing.  Setting
    this  option  to  'on' directs JRCPP to provide an explanation of
    the macro expansion process as  the  next  group  of  tokens  are
    expanded.  Note  that groups of tokens that are expanded together
    are typically bounded by  directives.   Hence  a  pair  of  these
    pragmas  can be used to turn this option on for only a few lines,
    and then turn it back off.  Since no meaning could be ascribed to
    this  #pragma,  the pragma will be passed unchanged to the output
    file.

W, 4067, "expected 'off', or 'on' (the default is 'on')"

    A "#pragma space_between_tokens" directive was  encountered,  but
    the argument was other than 'on', 'off', or nothing. Setting this
    option to 'off'  directs  JRCPP  to  avoid  adding  extra  spaces
    between  consecutive tokens as the output file is generated. Note
    that the actual output file is generated after the entire  source
    text  has  been preprocessed, and hence it is generally of little
    value to alternately turn this feature off and then on. Since  no
    meaning  could  be  ascribed  to this #pragma, the pragma will be
    passed unchanged to the output file.

W, 4068, "expected 'off', or 'on' (the default is 'on')"

    A "#pragma display_progress" directive was encountered,  but  the
    argument  was  other  than  'on', 'off', or nothing. Setting this
    option to 'on' causes a series of status messages  to  appear  on
    stderr,  so  that  progress  of  JRCPP can be monitored. Since no
    meaning could be ascribed to this #pragma,  the  pragma  will  be
    passed unchanged to the output file.

W, 4069, "unexpected token(s) at end of pragma line ignored"

    JRCPP  was  able  to  interpret  and act based upon the indicated
    pragma. However, there were additional tokens on the end  of  the
    line that are being ignored.

S, 4070, "benign redefinition of manifest macro ignored"

    A define directive redefined an existing manifest macro.  The new
    definition is similar enough to the previous definition that  the
    action  is  considered  benign  (i.e., has no impact).  Note that
    this diagnostic is silent, but users may chose to raise its level
    in order to quickly identify header files that are being included
    repeatedly (and wastefully providing the same macro definitions).
    Although  the  redefinition  is  benign, it may also be a symptom
    that several distinct files have the same definitions (which  may
    identify a problem before it becomes significant).

S, 4071, "benign redefinition of function-like macro ignored"

    A  define  directive  redefined  an existing function like macro.
    The new definition is similar enough to the  previous  definition
    that the action is considered benign (i.e., has no impact).  Note
    that this diagnostic is silent, but users may chose to raise  its
    level  in  order  to quickly identify header files that are being
    included repeatedly (and  wastefully  providing  the  same  macro
    definitions).   Although  the redefinition is benign, it may also
    be  a  symptom  that  several  distinct  files  have   the   same
    definitions  (which  may  identify  a  problem  before it becomes
    significant).

S, 4072, "macro #undef action undertaken"

    A #undef directive was encountered, and the indicated  macro  was
    defined.   The  macro  is  now  being  undefined.  Note that this
    diagnostic is silent, but may prove useful if there is a question
    of where a given macro was undefined.

W, 4073, "consecutive paste operators in macro definition"

    A  macro  definition  was provided that had two consecutive paste
    operators  ("##").   If  this  macro  is  ever  expanded   (i.e.,
    invoked), then a more severe diagnostic will be produced.

E, 4074, "line number must be a digit sequences only"

    A #line directive was encountered, but the line number was not of
    the expected  format.   Specifically,  an  integer  constant  was
    provided  with  a suffix of either 'u', 'l', 'U', or 'L', or some
    combination (as is valid for an integer constant).   The  postfix
    is ignored.

W, 4075, "keyword 'defined' evaluated as 0 in if/elif directive"

    Macro expansion of the token sequence in a #if or #elif directive
    created the identifier 'defined'.  Since  the  keyword  'defined'
    only  has  special meaning before the macro expansion process, it
    is treated like any other  identifier,  and  replaced  with  '0'.
    Since  this  is  an  area  were  the  results  are implementation
    defined, this construct might not be portable.  It  is  suggested
    that  you  avoid  the use of the identifier 'defined' in a #if or
    #elif directive, and use ONLY the  operator  'defined'  prior  to
    macro expansion.

E, 4076, "scanner limitation: too many characters in pasted string"

    The result of a paste operator ("##") in a macro replacement list
    has created a token with a long spelling.  This token is so large
    that  it  exceeds  the  buffer  size of the lexical analyser that
    "reclassifies"  such  tokens.    This   reclassification   should
    actually  have  no significance unless the token is used in a #if
    or #elif directive.  Fundamentally this diagnostic indicates that
    a static limit in JRCPP has been exceeded.

S, 4077, "macro #undef requested for undefined identifier"

    A  #undef directive was encountered, but the named identifier was
    not currently defined.  Hence this directive had no effect.  Note
    that   this  diagnostic  is  silent,  but  may  prove  useful  in
    diagnosing  incorrectly  typed  identifier  names  in  an   undef
    directive.

H, 4078, "use of bulk undefine may limit portability"

    The  directive  "#pragma  undefine_macros platform" has requested
    that several macros be undefined (specifically,  all  the  macros
    that  are  provided  by  JRCPP  as  platform  specific, including
    _JRCPP). Since this pragma is not a an ANSI standard feature, the
    underlying  source  file  may  not be fully portable (i.e., other
    implementation would still have the  macro  definitions  intact).
    Since this directive is commonly used in conjunction with JRCPP's
    capability  of  precalculating  a  combined  header  file,  which
    requires  JRCPP  functionality,  this  diagnostic  is often quite
    acceptable.

H, 4079, "use of bulk undefine may limit portability"

    The  directive   "#pragma   undefine_macros   command_line"   has
    requested that several macros be undefined (specifically, all the
    macros that were defined on the command line).  Since this pragma
    is not a an ANSI standard feature, the underlying source file may
    not be fully portable (i.e.,  other  implementation  would  still
    have the macro definitions, if any, intact). Since this directive
    is commonly  used  in  conjunction  with  JRCPP's  capability  of
    precalculating  a  combined  header  file,  which  requires JRCPP
    functionality, this diagnostic is often quite acceptable.

H, 4080, "use of bulk undefine may limit portability"

    The directive "#pragma undefine_macros user" has  requested  that
    several  macros  be  undefined (specifically, all the macros that
    have been defined from within  any  source  files).   Since  this
    pragma  is  not a an ANSI standard feature, the underlying source
    file may not be fully portable (i.e., other implementation  would
    still  have  the  macro  definitions, if any, intact). Since this
    directive is commonly used in conjunction with JRCPP's capability
    of  precalculating  a  combined header file, which requires JRCPP
    functionality, this diagnostic is often quite acceptable.

E, 5001, "#error encountered"

    A "#error" directive was found in active code (i.e.: it  was  not
    ifdef-ed  out).   The text following the directive is supplied as
    part of the diagnostic.

W, 5002, "unrecognized #pragma"

    A "#pragma" directive was encountered, but the text that followed
    was meaningless to this preprocessor.  The pragma will be present
    in the preprocessed output, but whitespace within the pragma will
    not be preserved.

E, 5003, "unexpected token(s) on #ifdef line ignored"

    A  "#ifdef  identifier" directive was encountered, but there were
    additional tokens on the  line  to  the  right  of  "identifier".
    These extraneous tokens have been ignored.

E, 5004, "unexpected token(s) on #ifndef line ignored"

    A  "#ifndef identifier" directive was encountered, but there were
    additional tokens on the  line  to  the  right  of  "identifier".
    These extraneous tokens have been ignored.

E, 5005, "neither <...> nor "..." style include found"

    A "#include ...." directive was encountered.  Unfortunately, even
    after macro expanding the token list (if any)  that  was  on  the
    line, the token sequence did not combine to form any known format
    for an include file name.  The directive has been ignored.

W, 5006, "cannot change 'fatal' default diagnostic level"

    The "#pragma diagnostic_adjust ..." pragma was supplied,  but  an
    attempt  was  made  to  change  all  diagnostics  with  a default
    severity level of Fatal  to  something  else.   Diagnostics  with
    default  severity  of  fatal  cannot  be adjusted, and hence this
    pragma is not valid as far as  JRCPP  is  concerned,  and  it  is
    passed unchanged to the preprocessed output file.

H, 5007, "diagnostic display may be diminished"

    The  user  has  elected  to adjust some diagnostic level in a way
    that may reduce the amount  of  diagnostic  information  that  is
    produced.  The  user should be wary that errors may be identified
    but not revealed, or severe errors may be downgraded to warnings,
    and an output file may still be produced.

E, 5008, "only one ancestral path selection is allowed"

    The directive "#pragma include_search ..." was provided, but more
    than    one    of    the    3    mutually    exclusive    options
    "only_eldest_ancestor",       "only_youngest_ancestor",       and
    "all_ancestors" was specified.  The later option was ignored, and
    the  first  ancestral option will be acted on (assuming there are
    no other syntax errors).

H, 5009, "non-ANSI C behavior requested"

    The #pragma  undefine_macros  has  requested  that  the  internal
    definitions  of  __FILE__,  __LINE__,  __DATE__,  and __TIME__ be
    removed from the the database.  This leaves open the  option  for
    notably  non-ANSI  behavior,  as any and all of these identifiers
    may now be redefined. Although this option  is  in  violation  of
    ANSI,  utilizing  it  provides  an  easy method of falsifying the
    value of __DATE__ and __TIME__ in order to  produce  a  mis-dated
    compilation.

H, 5010, "non-ANSI C behavior requested"

    The  #pragma  undefine_macros  has  requested  that  the internal
    definitions of __STDC__ be removed from the the  database.   This
    leaves  open  the  option  for notably non-ANSI behavior, as this
    identifier may now be  redefined.  Although  this  option  is  in
    violation  of  ANSI,  it  provides  a simple method of creating a
    preprocessor that can be used with  a  non-ANSI  compiler.   This
    simulation  often  assists  in  porting  code  that  has built in
    dependency on the value of __STDC__ in hopes of easing a port.

H, 5011, "non-ANSI C behavior requested"

    The directive "#pragma cplusplus_mode" was encountered.   One  of
    the  results  of  this  pragma is that __STDC__ is undefined, and
    made available for redefinition (note that __cplusplus takes  its
    place).   Since this option removes an "unremovable" aspect of an
    ANSI C preprocessor, the performance is clearly  non-ANSI.   Also
    note  that  //  style  comments  are  being  supported, which may
    further violate ANSI C behavior.

H, 5012, "non-ANSI C behavior requested"

    The directive "#pragma cplusplus_comment  ..."  was  encountered.
    The  //  style  comments  are being supported as a consequence of
    this pragma, and hence ANSI C compatibility cannot be guaranteed.

H, 5013, "non-ANSI C behavior requested"

    The  directive  "#pragma  space_between_tokens  ..."   has   been
    observed,   and   as   a   result,  additional  spaces  will  not
    automatically be added to the output file.   The  consequence  of
    this  omission  is  that  certain token pairs may, if they do not
    already have  white  space  separation,  "flow  together".   This
    result  is  occasionally  desirable  when  attempting to simulate
    certain aspects of a classical C preprocessor (re:  the  Reismann
    model).   This  flowing  together  of  tokens may cause effective
    pasting of consecutive tokens, and  a  net  effect  of  providing
    non-ANSI C compliant preprocessing.




F, 6001, "lexical scanner reading source: ...message..."

    This  diagnostic  is  always  produced in conjunction with a more
    detailed error 'message'.  This 'message' is usually "flex  input
    buffer  overflowed".   If  any  other  'message' is produced as a
    refinement  of  this  diagnostic,  it  should  be  considered  an
    internal compiler error, and the software manufacturer or support
    agency should be consulted.   The  typical  message  "flex  input
    buffer  overflowed"  indicates that an attempt was made to form a
    token that was larger than a hard wired static buffer (currently,
    511  characters).   Although  this  message  can  be generated by
    providing a single token (such as an  identifier  name)  that  is
    longer  than  511  characters,  there  is  a  more  likely  cause
    involving comments.   Comments  are  broken  into  "pieces"  that
    correspond   to   "logical   lines".    A  logical  line  is  the
    concatenation of a  series  of  physical  lines  accomplished  by
    placing  backslash  ("\")  characters  at the end of lines.  This
    practice of concatenating lines is most common  when  defining  a
    long  and complex macro. If, for example, such a macro definition
    exceeded 511 characters, AND an attempt was made to  comment  out
    the  macro  by  enclosing it in comment delimiters "/*" and "*/",
    then this message would be produced.  The  work  around  in  this
    "most common" of these "extremely rare" cases is to use enclosing
    "#if 0" and "#endif"  to  remove  the  code  from  consideration,
    rather  than  using  comment delimiters.  Note that this is NOT a
    problem that occurs when comments are simply long,  as  they  are
    then  considered  to  be  a series of "comment segments", each of
    which corresponds to a physical line,  which  is  generally  much
    less than 512 characters in length.  Note also that with features
    provided in ANSI C involving the placement of consecutive  string
    literals,  and  the  interpretation  of such sequences, it is not
    necessary to have string literals that are over 511 characters in
    length  (including the delimiting quotes).  See BUGS/FEATURES for
    additional comments.

F, 6002, "lexical scanner reading pasted text: ...message..."

    This diagnostic is always produced in  conjunction  with  a  more
    detailed   'message'   (depending   on  the  problem).   If  this
    diagnostic is  produced  it  should  be  considered  an  internal
    compiler  error,  and the software manufacturer or support agency
    should be consulted.

F, 6003, "preprocessing token parser error: yacc stack overflow"

    This message indicates that the level of nesting of  preprocessor
    if  directives  is too large for the current parser.  The current
    limit is at least 50 levels of if directives deep, and this limit
    is  only  significant  if  all the nested if statements have both
    "#elif" and "#else" sections, AND the nesting is through the else
    clauses.   As  a  practical  matter,  this  limit should be of no
    importance to a user.  See BUGS/FEATURES for more details.

E, 6004, "#if/elif evaluated false due to: yacc stack overflow"

    This message indicates that the level of  nesting  complexity  of
    the  expression  provided in a "#if" or "#elif" directive exceeds
    about 75 levels of parenthesis, or  about  30  levels  of  nested
    conditional   expressions  (re:  the  ternary  operator  sequence
    "a?b:c").  This should be of little consequence to  a  user,  but
    see BUGS/FEATURES for more details.


F, 6005, "out of memory. Object requested was ..."

    The  preprocessor  was  unable  to  allocate  any more memory for
    preprocessing.  This error is most  common  under  MSDOS.   While
    running  in MSDOS, be sure that you are not running in a "command
    shell" underneath a program that is using up a  lot  of  physical
    memory   (some   "make"   utilities  demonstrate  this  "hoggish"
    feature).  Also under MSDOS, if you have  not  already  done  so,
    purchasing  and  installing  additional  memory,  up  to the full
    640KByte limit, can often prevent this diagnostic.  This  problem
    can  be  reduced  (and often removed) under MSDOS by reducing the
    number of TSR (Terminate and Stay Resident)  programs  that  have
    been  installed.   On  virtual  memory  systems, such as OS/2 and
    UNIX, this error should only occur if  virtual  memory  has  been
    exhausted  by filling all available swap space available on disk.
    Solutions to this problem in  a  virtual  memory  system  include
    purchasing additional physical memory (i.e., RAM), and purchasing
    or enlarging the available swap space (i.e., get a  bigger  disk,
    and/or  set  up  the swap area on a partition with more available
    space).


F, 6006, "out of memory during character pool reallocation"

    JRCPP exhausted available memory.  This problem occurred  when  a
    new  heap  (character  pool) was being created to hold additional
    strings of text (generally, the spellings of tokens).

F, 6007, "out of memory during concatenation operation"

    JRCPP exhausted available memory.  This problem occurred when two
    tokens strings were being concatenated, and a working area needed
    to be allocated.

F, 6008, "out of memory during stringize operation"

    JRCPP exhausted available memory.  This problem occurred  when  a
    token's  spelling  was  being "stringized" (enclosed in quotes as
    requested by the # operator), and a working  area  needed  to  be
    allocated.

F, 6009, "out of memory while unquoting file name"

    JRCPP  exhausted  available memory.  This problem occurred when a
    file name provided in an #line directive had to be extracted, and
    a working area needed to be allocated.

F, 6010, "out of memory while extracting name in include directive"

    JRCPP  exhausted  available memory.  This problem occurred when a
    file name provided in an #include directive had to  be  extracted
    from the surrounding quotes or angle brackets, and a working area
    needed to be allocated.

F, 6011, "out of memory while extracting directory prefix"

    JRCPP exhausted available memory.  This  problem  occurred  while
    processing  a  #include  directive.   The  path  prefix was being
    extracted from some ancestral include file, and  a  working  area
    needed to be allocated.

E, 6012, "#if/elif evaluated false due to division by zero"

    The  evaluation  of  the  token  sequence  on a #if or #elif line
    required a division by an expression that evaluated to zero.  The
    evaluator  has  abandoned  examination of the expression, and has
    supplied a default (error recovery) evaluation of FALSE.


E, 6013, "#if/elif evaluated false due to modulus of zero"

    The evaluation of the token sequence  on  a  #if  or  #elif  line
    required  taking  the  modulus by an expression that evaluated to
    zero (example: 4 % 0). The evaluator has abandoned examination of
    the  expression,  and  has  supplied  a  default (error recovery)
    evaluation of FALSE.