# MCPP-MANUAL

## == How to Use MCPP ==

#### for V.2.7.2 (2008/11)
Kiyoshi Matsui (kmatsui@t3.rim.or.jp)

## Contents

1. Overview
  1.1. High Portability
  1.2. Standard C Mode with Highest Conformance and Other Modes
  1.3. Notations in this Manual
2. Invocation Options and Environment Settings
  2.1. Two Kinds of Build and Five Behavioral Modes
  2.2. How to Specify Invocation Options
  2.3. Common Options
  2.4. Options by mcpp Behavioral Modes
  2.5. Common Options Except for Some Compiler Systems
  2.6. Options by Compiler System
  2.7. Environment Variables
  2.8. Multi-Byte Character Encodings
  2.9. How to Use mcpp in One-Pass Compilers
  2.10. How to Use mcpp in IDE
    2.10.1. How to Make mcpp available in Visual C++ IDE
    2.10.2. How to Make mcpp available in Mac OS X / Xcode.app
3. Enhancement and Compatibility
  3.1. #pragma MCPP put_defines, #pragma MCPP preprocess and others
    3.1.1. Pre-preprocessing of Header File
  3.2. #pragma once
    3.2.1. Tool to Write #pragma once to Header Files
  3.3. #pragma MCPP warning, #include_next, #warning
  3.4. #pragma MCPP push_macro, #pragma __setlocale and others
  3.5. #pragma MCPP debug, #pragma MCPP end_debug, #debug, #end_debug
    3.5.1. #pragma MCPP debug path, #debug path
    3.5.2. #pragma MCPP debug token, #debug token
    3.5.3. #pragma MCPP debug expand, #debug expand
    3.5.4. #pragma MCPP debug if, #debug if
    3.5.5. #pragma MCPP debug expression, #debug expression
    3.5.6. #pragma MCPP debug getc, #debug getc
    3.5.7. #pragma MCPP debug memory, #debug memory
    3.5.8. #pragma MCPP debug macro_call
  3.6. #assert, #asm, #endasm
  3.7. New C99 Features (_Pragma() operator, Variadic Macro and others)
  3.8. Particular specifications for certain compiler system
    3.8.1. Variadic macro of GCC and Visual C
    3.8.2. Handling of 'defined' by GCC
    3.8.3. Asm Statement in Borland C and Other Special Syntaxes
    3.8.4. #import and Others
  3.9. Problems of GCC and Compatibility with GCC
    3.9.1. Preprocessing FreeBSD 2/Kernel Sources
    3.9.2. Preprocessing FreeBSD 2/Libc
    3.9.3. Problems Concerning GCC 2/cpp
    3.9.4. Preprocessing Linux/glibc 2.1
    3.9.5. To Use mcpp with GCC 2
      3.9.5.1. To Sort mcpp's Warnings
    3.9.6. Preprocessing GCC 3.2 Source
    3.9.7. To Use mcpp with GCC 3 or 4
    3.9.8. Preprocessing Linux/glibc 2.4
    3.9.9. The Problems of Linux / stddef.h, limits.h and #include_next
    3.9.10. Problems of Mac OS X / Apple-GCC and its System Headers
    3.9.11. Preprocessing firefox 3.0b3pre
  3.10. Visual C++ System Header Problems
    3.10.1. Comment Generating Macro?
    3.10.2. '$' in Identifiers
4. Implementation-defined Behaviors
  4.1. Status Value on Exit
  4.2. Include Directory Search Path
  4.3. How to Construct Header Name
  4.4. Evaluation of #if Expression
  4.5. Character Constant Evaluation in #if Expression
  4.6. #if sizeof (type)
  4.7. How to Handle White-Space Sequence
  4.8. Default Specifications for mcpp Executables
5. Diagnostic Messages
  5.1. Diagnostic Messages Format
  5.2. Translation Limits
  5.3. Fatal Errors
    5.3.1. mcpp's Own Bugs
    5.3.2. Physical Errors
    5.3.3. Translation Limits and Internal Buffer Errors
    5.3.4. #pragma MCPP preprocessed Related Errors
  5.4. Errors
    5.4.1. Character and Token Related Errors
    5.4.2. Unterminated Source File Related Errors
    5.4.3. Ill-Balanced Preprocessing Group Related Errors
    5.4.4. Simple Syntax Errors on Directive Lines
    5.4.5. Syntax Errors in #if Expressions
    5.4.6. #if Expression Evaluation Errors
    5.4.7. #define Related Errors
    5.4.8. #undef Related Errors
    5.4.9. Macro Expansion Errors
    5.4.10. #error and #assert
    5.4.11. Failure of #include
    5.4.12. Other Errors
  5.5. Warnings (Class 1)
    5.5.1. Character, Token and Comment Related Warnings
    5.5.2. Unterminated Source File Related Warnings
    5.5.3. Directive Line Related Warnings
    5.5.4. #if Expression Related Warnings
    5.5.5. Macro Expansion Related Warnings
    5.5.6. Line Number Related Warnings
    5.5.7. #pragma MCPP warning, #warning
  5.6. Warnings (Class 2)
  5.7. Warnings (Class 4)
  5.8. Warnings (Class 8)
  5.9. Warnings (Class 16)
  5.10. Diagnostic Messages Index
6. Reporting on Bugs and Others

# 1. Overview

mcpp is a C preprocessor developed by kmatsui (Kiyoshi Matsui) based on DECUS cpp written by Martin Minow, and then rewritten entirely. mcpp means Matsui cpp. This software is supplied as source codes, and to use mcpp in any compiler systems, a small amount of modifications to adapt to the compiler system are required before it can be compiled into an executable. *1

This document describes the specification for mcpp executables that has been already ported to certain compiler systems. For those who want to know more about mcpp or want to port it to other compiler systems, refer to mcpp source and its document mcpp-porting.html.

All these sources and related documents are provided as an open-source-software.

Before going into detail, some of the mcpp features are introduced here.

Note:

*1 mcpp V.2.6.3 onward provides some binary packages too, at the following site.

> http://mcpp.sourceforge.net/

## 1.1. High portability

mcpp is a portable preprocessor, supporting various operating systems, including Linux, FreeBSD and Windows. Its source has a wide portability, and can be compiled by any compilers which support Standard C or C++ (ANSI/ISO C or C++). The library functions used are only the classic ones.

To port mcpp to each compiler system, in many cases, one only needs to change some macro definitions in the header files and simply compile it. In the worst case, adding several dozen of lines into a source file would be enough.

To process multi-byte characters (Kanji), it supports Japanese EUC-JP, shift-JIS and ISO2022-JP, Chinese GB-2312, Taiwanese Big-5 and Korean KSC-5601 (KSX 1001), as well as UTF-8. For shift-JIS, ISO2022-JP or Big-5, mcpp can complement the compiler-proper if it does not recognize them.

## 1.2. Standard C mode with highest conformance and other modes

mcpp has various behavioral modes. Other than Standard-conforming mode, there are K&R 1st mode, "Reiser" cpp mode and what I call post-Standard mode. mcpp has also an execution option for C++ preprocessor.

Different from many existing preprocessors, Standard mode of mcpp has the highest conformance to Standards: all of C90, C99 and C++98. It has been developed aiming to become the reference model of the Standard C preprocessor. Those versions of the Standard can be specified by an execution option. *1

In addition, it provides several useful enhancements: '#pragma MCPP debug', which traces the process of macro expansion or #if expression evaluation, and the header file "pre-preprocessing" facility.

mcpp also provides several useful execution options, such as warning level or include directory specification options.

Even if there are any mistakes in the source, mcpp deals suitably with accurate plain diagnostic messages without running out of control or displaying misguiding error messages. It also displays warnings for portability problems. The detailed documents are also attached.

In spite of its high quality, mcpp's code size and memory usage is relatively small.

A disadvantage of mcpp, if any, is slower processing speed. It takes two or three times time of GCC 3.*, 4.* / cc1, but seeing that its processing speed is almost the same as that of Borland C 5.5/cpp32 and that it runs a little bit faster when the header file pre-preprocessing facility is used, it cannot be described as particularly slow. mcpp puts an emphasis on standard conformance, source portability and operability in a small memory space, making this level of processing speed inevitable.

Validation Suite for Standard C Preprocessing, which is used to test the extent to which a preprocessor conforms to Standard C, its documentation cpp-test.html, which contains results of applying Validation Suite to various preprocessors, are also released with mcpp. When looking through this file, you will notice that so-called Standard-conforming preprocessors have so many conformance-related problems.

During the course of developing mcpp V.2.3, it was selected as one of the "Exploratory Software Projects for 2002" by Information-technology Promotion Agency (IPA), Japan, along with its Validation Suite. From July 2002 to February 2003, the project, financed by IPA, proceeded under advice of Yutaka Niibe project manager. I asked "HighWell, Inc." Limited Company, Tokyo, for translation of all the documents. For technical details, I revised and corrected the translated documents.

mcpp was continuously adopted to one of the "Exploratory Software Projects" in 2003 by Hiroshi Ichiji project manager. The update of mcpp proceeded into the next version, V.2.4. *2

After the project, I am still going on updating mcpp and Validation Suite.

Note:

*1 ISO/IEC 9899:1990 (JIS X 3010-1993) had been used as C Standard, but in 1999, ISO/IEC 9899:1999 was adopted as a new Standard. This document calls the former C90 and latter C99. The former is generally called ANSI C or C89 because it migrated from ANSI X3.159-1989. ISO/IEC 9899:1990 + Amendment 1995 is sometimes called C95. C++ Standards are ISO/IEC 14882:1998 and its corrigendum version ISO/IEC 14882:2003. This document calls both of them C++98.

*2 The outline of the "Exploratory Software Project" can be seen at the following site (Japanese only).

> http://www.ipa.go.jp/jinzai/esp/

mcpp from V.2.3 through V.2.5 had been located at:

> http://www.m17n.org/mcpp/

In April 2006, mcpp project moved to:

> http://mcpp.sourceforge.net/

The old version of mcpp, cpp V.2.2 and Validation Suite V.1.2 are located in the following Vector's web site. They are in the directory called dos/prog/c, but they are not for MS-DOS exclusively. Sources are for UNIX, WIN32, MS-DOS. The documents are Japanese only.

> http://www.vector.co.jp/soft/dos/prog/se081188.html
> http://www.vector.co.jp/soft/dos/prog/se081189.html
> http://www.vector.co.jp/soft/dos/prog/se081186.html

The text files in these archive files available at Vector use [CR]+[LF] as a <newline> and encode Kanji in shift-JIS for DOS/Windows. On the other hand, those from V.2.3 through V.2.5 available at SourceForge use [LF] as a <newline> and encode Kanji in EUC-JP for UNIX. From V.2.6 on two types of archive, .tar.gz file with [LF]/EUC-JP and .zip file with [CR]+[LF]/shift-JIS, are provided.

## 1.3. Notations in this Manual

Though this manual was text-file in the older versions, it has changed to html-file at V.2.6.2.
This manual uses the following typographical conventions:

- `source:`
  `Navy` colored constant-width font is used for code snippets and command line inputs.
- `__STDC__:`
  `Maroon` colored constant-width font is used for Standard predefined macros or any other macros found in some codes.
- STD:
  Italic font is used for the macros defined in mcpp source file named system.H. This manual uses these names to denote various mcpp settings. Note that these macros are only used in compilation of mcpp, and that the mcpp executable does not have such macros.

# 2. Invocation Options and Environment Settings

## 2.1. Two Kinds of Build and Five Behavioral Modes

There are two types of build (or compiling configuration) for mcpp executable. *1, *2

1. Compiler-independent-build: the preprocessor which behaves on its own not depending on compiler system. The invocation options of compiler-independent-build are the same across the compilers with which mcpp is compiled. Although it can preprocess source files, it cannot behave as an integrated part of a compiler system.
2. Compiler-specific-build: the preprocessor to replace the resident preprocessor of certain compiler system, if possible. Each compiler-specific-build has some different specifications for compatibility with the compiler system. It has the options common with the compiler-independent-build, except a few options different from the commons to avoid conflict with the compiler system.

Each mcpp executable has following 5 behavioral modes regardless of the building types.

1. STD: Standards (C90, C99, C++98) conforming mode. This is the default.
2. COMPAT: A variation of STD mode, which expands recursive macro more than the Standards' specification.
3. POSTSTD: Special "post-Standard" mode created by the author, based on the Standards and simplified removing all the Standards irregular specifications.
4. KR: K&R 1st specification mode.
5. OLDPREP: "Reiser" model cpp mode (old-preprocessor mode).

The mode of mcpp is specified by the run-time options as follows:

- `-@std`
  The STD mode (default).
- `-@compat`
  The COMPAT mode.
- `-@poststd, -@post`
  The POSTSTD mode.
- `-@kr`
  The KR mode.
- `-@oldprep, -@old`
  The OLDPREP mode.

In this document, I group OLDPREP and KR into pre-Standard modes, and group STD, COMPAT and POSTSTD into Standard modes. Since COMPAT mode is almost the same with STD mode, STD includes COMPAT unless otherwise mentioned. *3

There are differences in the macro expansion methods between Standard and pre-Standard modes. Roughly speaking, this difference is the difference between C90 and pre-C90. The biggest difference is the expansion of the function-like macros (macros with arguments). For the arguments with macros, while in Standard mode, mcpp substitutes the parameter within the replacement list of the original macro after completely expanding the arguments, in pre-Standard, mcpp substitutes the parameter without expanding, then expands the argument at rescan time.

Also, in Standard mode, a macro is not expanded recursively in principle, even if the macro definition is recursive directly or indirectly. If there is a recursive macro definition in pre-Standard mode, it causes infinite recursion and becomes an error at expansion time.

Handling of \ at line end is also different by mode. In Standard mode, after processing the trigraph, the sequence of <backslash><newline> gets deleted before tokenization, but in pre-Standard mode, these only get deleted when they are within the string literals or in a #define line.

There is a subtle difference in tokenization (token parsing, decomposition to tokens). In Standard mode, it tokenizes on "token based processing" principle. To put it concretely, in Standard mode, spaces will be inserted surrounding the expanded macro to prevent the unexpected merging with its adjacent tokens. In pre-Standard mode, traditional, convenient and tacit tokenization and the macro expansion methods of "character based text replacement" are left a trace. About these, please see cpp-test.html#2.

In Standard mode, it handles the numeric token, called preprocessing number, according to the Standard specification. In pre-Standard, the numeric tokens are the same as integer constant tokens or floating point tokens. The suffix 'U', 'u', 'LL' and 'll' of the integer constant and the suffixes 'F', 'f', 'L' and 'l' of floating point are not recognized as a part of the tokens in pre-Standard.

The string literals and character constants of wide characters are recognized as single tokens only in Standard mode.

Digraph, #error, #pragma, and _Pragma() operator are available only in Standard mode. Also, -S <n> option (strict-ansi specs) and -+ option (the one run as C++ preprocessor) are used only in Standard mode. Pre-defined macros `__STDC__`, `__STDC_VERSION__` are defined in Standard mode, and they don't get defined in pre-Standard.

#if defined, #elif cannot be used in pre-Standard mode. Macros cannot be used within argument of #include or #line in pre-Standard. Predefined macros, `__FILE__`, `__LINE__`, `__DATE__`, `__TIME__` are not defined at pre-Standard.

On the other hand, #assert, #asm (#endasm), #put_defines and #debug are available in pre-Standard mode only.

#if expression is evaluated in long / unsigned long or long long / unsigned long long at Standard mode, and in (signed) long only at pre-Standard. sizeof (type) in #if expression can be used only in pre-Standard.

Trigraphs and UCN (universal character name) are available only in STD mode.

The output of diagnostic messages is also slightly different between the modes. Please see chapter 5 for details.

Any other items, which do not have any distinct rules between K&R 1st and the Standards, follow the C90 rules in pre-Standard mode.

The difference of OLDPREP mode from KR mode and the difference of POSTSTD and COMPAT modes from STD mode are as follows:

- OLDPREP
  1. Convert comment to 0 space instead of 1 space. Usually this conversion is done in the output at the end. In macro definition, however, the conversion is done immediately after the definition.
  2. When there are string literals or character constants in the replacement list of the macro definition, and if any of the parameter names match to any part of these, that part will be substituted with the argument corresponding to the parameter when calling the macro. That is to say, when the content of the string literal or character constant is searched as token sequence, stripping the enclosing quotes, if a parameter name is found, that will be substituted.
  3. You can write anything you like in the lines of #else, #endif. (One usually writes MACRO of corresponding #if MACRO or #ifdef MACRO.)
  4. It stops "unterminated string literal" and "unterminated character constant" errors. If there is no closure of the literal " or ', it assumes the close at line end.
  5. It treats '# 123' line as '#line 123'.
- COMPAT
  Expand recursive macro more than the Standard's specification. On expanding recursive macro, set the range of non-re-replacing of the same name narrower than the Standard.
  Refer to cpp-test.html#3.4.26 about the specifications of recursive macro expansion. See test-t/recurs.t for a sample of recursive macro. *4
- POSTSTD
  This mode differs from STD mode in the following points:
  1. Does not recognize trigraphs. Digraphs are converted at translation phase 1, that is, the beginning of preprocessing. Does not deal with digraph as a token.
  2. Simplified tokenization according to complete token-base rule. When there is no white space, as a token separator between preprocessing tokens in the source code, insert a space automatically. (However, this does not get inserted between macro name and the following "(" within macro definition). Therefore, even for stringizing by # operator, it gets stringized after a space is inserted between all the preprocessing tokens. Also, at the re-definition of macros, it does not matter whether there is a token separator or not.
  3. At the re-definition of function-like macros, the difference of the parameter name is not relevant.
  4. Character constants cannot be used in #if expressions (it will cause an error).
  5. It removed irregular "function-unlike" rules for function-like macro expansion. Hence, rescanning only targets to the replacement list of the macro, and not the sequence after that.
  6. Normally, the header name with the format of #include <stdio.h> is accepted, but it gets a warning. (by class 2 warning option.) If the header name with the format of <stdio.h> is used in a macro, it can get an error at a particular instance. It recommends to use the format of #include "stdio.h".
  7. The rule, a space is required between macro name and replacement list in macro definition, is added in C99, but this rule is not complied with. (A space is inserted automatically at tokenization.)
  8. UCN (universal-character-name) is not recognized. Multi-byte characters in identifier are not recognized.
  9. In C++, eleven identifier-like operators are not dealt as operators.

Moreover, there is a mode called lang-asm. That is a mode to process anomalous sources which are assembler sources and nevertheless have comments, directives and macros of C embedded. While POST_STD cannot become this mode, STD, KR and OLD get to this mode when specified by an option. See 2.5 for its specifications.

For the above reasons, there are some different specifications in mcpp executables. So, please read this manual carefully. This chapter describes first the common options, next the behavioral-mode-dependent options, then the the options common to most compiler systems, finally the compiler-dependent options for each compiler-specific-build.

Note:

*1 There is another one named subroutine-build which is called as a subroutine from some other main program. The behavioral specification of subroutine-build is, however, the same with either of compiler-specific-build or compiler-independent-build according to its compile time setting. Hence, this manual does not mention subroutine-build particularly. As for subroutine-build, refer to mcpp-porting.html#3.12.

*2 The binary packages provided at the SourceForge site are of compiler-independent-builds.

*3 mcpp had two separate executables for Standard mode and pre-Standard mode; they were integrated into one at V.2.6.

*4 This option is for compatibility with GCC, Visual C++ and other major implementations. 'compat' means "compatible mode".

## 2.2. How to Specify Invocation Options

The <arg> and [arg] shown below indicate required and optional arguments respectively. Note that the <, >, [, or ] character itself must not be entered.

mcpp invocation takes a form of:

    mcpp [-<opts> [-<opts>]] [in_file] [out_file] [-<opts> [-<opts>]]

Note that you have to replace the above "mcpp" with other name, depending on how mcpp is installed.

When out_file (an output path) is omitted, stdout is used unless the -o option is specified. When in_file (an input path) is omitted, stdin is used. A diagnostic message is output to stderr unless the -Q option is specified.

If any of these files cannot be opened, preprocessing is terminated, issuing an error message.

For an option with argument, white-space characters may or may not be inserted between the option character and an argument. In other words, both of "-I<arg>" and "-I <arg>" are acceptable. For options without argument, both of "-Qi" and "-Q -i" are valid.

For an option with an argument, missing a required argument causes an error except for the -M option,

If -D, -U, -I, or -W option is specified multiple times, each of them is valid. For -S, -V, or -+ option, only the first one is valid. For -2, or -3 option, its specification switches each time an option is specified. For other options, the last one is valid.

The option letters are case sensitive.

The switch character is '-', not '/', even under Windows.

When invalid options are specified, a usage statement is displayed. To check valid options, enter a command, such as "mcpp -?". In addition to the usage message, there are several error messages, but they are self-explanatory. I will omit their explanations.

## 2.3. Common Options

This section covers common options across mcpp modes or compiler systems.

- `-C`
  Output also comments in source code. This option is useful for debugging. Note that a comment is moved ahead of a logical source line when output. This is because a comment is processed before macro expansion or directive processing, and a comment may appear during a macro invocation.
- `-D <macro>[=[<value>]]`
- `-D <macro(a,b)>[=[<value>]]`
  Define a macro named "macro". This option can be used to change the definitions of predefined macros other than `__STDC__`, `__STDC_VERSION__`, `__FILE__`, `__LINE__`, `__DATE__`, `__TIME__` and `__cplusplus`. (`__STDC_HOSTED__`, C99's predefined macro, is exceptionally redefined by this option, because some compiler systems, like GCC V.3, use the -D option to define `__STDC_HOSTED__`.) To specify a value, use "=<value>". If "=<value>" is omitted, 1 is assumed. (Note that in bcc32, the macro is defined as zero-token by default.) Do not enter white-space characters immediately before "=". If a white-space character is entered immediately after "=", the macro is defined as zero token.
  A macro with arguments can be defined by this option.
  This option can be specified repeatedly.
- `-e <encoding>`
  Change a multi-byte character encoding to <encoding>. For <encoding>, refer to 2.8.
- `-I <directory>`
  Specify the first directory in the include directory search path order with <directory>. For a search path, refer to 4.2. If a directory name contains spaces, it has to be enclosed with " and ".
- `-I 1, -I 2, -I 3`
  Specify a directory from which mcpp begins searching when it encounters a #include "header" directive (i.e. not <header> format). -I1, -I2 and -I3 indicate the current directory, the source file (i.e. includer) directory, and the both respectively. For details, see 4.2.
- `-j`
  On outputting a diagnostic message, mcpp displays only one line of diagnostic without additional information, such as source lines. (By default, one line of diagnostic message is followed by a source code line having a problem. If the source code line in question is found in a #included file, all the #including file names and including line numbers are also displayed in sequence. For a diagnostic on macro, mcpp displays also its definition information).
  When Validation Suite is used in the GCC testsuite, this option has to be specified to output a diagnostic message in the same format as GCC.

The -M* options are to output source file dependency lines for makefile. When there are several source files and the -M* option is specified for each of these source files to process and merge the outputs into a file, dependency description lines are aligned. These options are similar to those of GCC, but there are several differences. *1

- `-M`
  Output lines that describe dependency among source files. The output destination is the file specified in a command line, or stdout if omitted. If a dependency description is too long to fit in a line, it is folded over the next lines. The preprocessing result is not output.
- `-MM`
  Almost the same with -M, except that the following header files are not output.
  1. Files specified in the format of #include <stdio.h>.
  2. Files specified using an absolute path name, such as #include "/usr/include/stdio.h".
  3. Files specified in the format of #include "stdio.h" that are found not in the current or source directory, depending on compiler systems or the -I <n> option, but in system include directories, including those specified with the -I <directory> option or with environment variables.
  But, GCC-specific-build differs from this, it output the header files excluding only system headers, as GCC does.
- `-MD [FILE]`
  Almost the same with -M, except that the preprocessing result is output to the specified file on a command line or stdout. If FILE is specified, mcpp outputs dependency description lines to that file. Otherwise, they are output to a file having the same base filename with the source file and the suffix of ".d" instead of ".c".
- `-MMD [FILE]`
  Almost the same with -MD, except that, like -MM, the files that are regarded as system header are not output. An output file mcpp outputs dependency description lines to is same as -MD [FILE].
- `-MF FILE`
  The dependency lines are output to FILE. -MF FILE takes precedence over -MD FILE or -MMD FILE.
- `-MP`
  "Phony targets" are also output. Each included file can be written as a phony target without a dependency as follows:

      test.o: test.c test.h
      test.h:

- `-MT TARGET`
  The target name is specified as TARGET not foo.o. -MT '$(objpfx)foo.o' outputs the following line.

      $(objpfx)foo.o: foo.c

- `-MQ TARGET`
  Same as -MT, except that a string that has a special meaning to 'make' is 'quoted' as follows:

      $$(objpfx)foo.o: foo.c

- `-N`
  Disable all the predefined macros, including those that begin with "_", except for the ones required by Standards and `__MCPP`. The Standard predefined macros include `__FILE__, __LINE__, __DATE__, __TIME__, __STDC__, __STDC_VERSION__`, as well as `__STDC_HOSTED__` for C99 and `__cplusplus` for C++. If you want to disable `__MCPP`, use the -U option.
- `-o <file>`
  Output the preprocessed source to the file. If this option is omitted, the second file argument is regarded as an output path, so this option is not necessary, however, some compiler drivers use this option.
- `-P`
  Do not output line number information for the compiler-proper. This option is specified when you want to use mcpp for purpose other than C preprocessing.
- `-Q`
  Output diagnostic messages to the "mcpp.err" file in the current directory. As these messages are appended to this file, it may become bigger. Delete it from time to time.
- `-U <macro>`
  Undefine predefined macro named "macro". This option cannot undefine `__FILE__, __LINE__, __DATE__, __TIME__, __STDC__, __STDC_VERSION__` (and `__STDC_HOSTED__` for C99), as well as `__cplusplus` invoked with -+ options.
- `-v`
  Output the mcpp version and a search order of include directories to stderr.
  However, when -K option, explained at 2.4, is specified or #pragma MCPP macro_call directive, explained at 3.5.8, is specified, this option changes its meaning.
- `-W <level>`
  Specify a warning level with <level>. <level> should be 0 or "OR" of any one or more values of 1, 2, 4, 8 and 16. 1, 2, 4, 8 or 16 indicates a warning class. For example, if -W 5 is specified, warnings of classes 1 and 4 are output. If 0 is specified, no warnings are output. If this option is specified several times, all the specified values are "ORed" together. For example, -W 1 -W 2 -W 4 is equivalent to -W 7. Instead of -W 7 you can also write as -W "1|2|4". (Enclose with " and " so as | is not interpreted as a pipe.) If this option is omitted, -W 1 is assumed. For warning messages, refer from 5.5 through 5.9.
- `-z`
  The preprocessing results of the #included files are not output, but macros are defined. The #include lines themselves are output instead, though #include lines in an included file is not output. This option is used in debug of preprocessing.

Note:

*1 mcpp differs from GCC in that:

1. mcpp does not provide the -MG option because its option specification is too complicated. (Therefore, I will omit its explanation.) The -M option can substitute for the -MG option because when include files cannot be found using the -M option, mcpp fails but outputs dependency description lines.
2. mcpp, other than GCC-specific-build, excludes a wider range of header files when using the -MM and -MMD options.

## 2.4. Options by mcpp Behavioral Modes

mcpp has several behavioral modes. For their specifications refer to sec 2.1.

This manual shows a list of various mcpp behaviors by mode, which may not be readable. Please be patient. In this manual, all the uppercased names that do not begin with "__" and displayed in italics, such as DIGRAPHS_INIT, TRUE, FALSE, etc, are macros defined in system.H. These macros are only used for compiling mcpp itself and a mcpp executable generated does not predefine these macros. You must understand this point clearly.

The following options are available in Standard mode:

- `-+`
  Behave as C++ preprocessor. mcpp predefines the `__cplusplus` macro (its value is defined in system.H and defaults to 1), interprets the text from // to the end of a logical line as a comment and recognizes `"::", ".*", "->*"` as a single token. It evaluates "true" and "false" tokens in a #if expression to 1 and 0, respectively. If `__STDC__` and `__STDC_VERSION__` are defined, they are undefined. (For GCC-specific-mcpp, `__STDC__` is not undefined for compatibility with GCC.) The predefined macros that do not begin with "_" are also undefined. However, extended characters are not converted to UCN. *1, *2
- `-2`
  Reverse initial settings for the digraphs processing. With DIGRAPHS_INIT == FALSE, mcpp recognizes digraphs. Otherwise, it doesn't.
- `-h <n>`
  Define the value of `__STDC_HOSTED__` macro with <n>.
- `-S <n>`
  Change the value of `__STDC__` to <n> in C. In C++, this option is ignored. The range of <n> has to be 0-9. With <n> set to 1 or higher, the predefined macros that do not begin with "_", such as `unix`, `linux`, are disabled. S indicates `__STDC__`. If this option is omitted, `__STDC__` is set to a default value (i.e. 1).
  For a GCC-specific-build, -pedantic, -pedantic-errors, or -lang-c89 is equivalent to -S1, so the next -S is ignored. This option does not disable the non-conforming predefined macros such as `unix, linux, i386` for compatibility with GCC. These macros are disabled only by -ansi or -std=iso* options.
- `-V <value>`
  Change the values of the predefined macros `__STDC_VERSION__` for C and `__cplusplus` for C++ to <value>. <value> is of a long type. (In C95, C99, and C++ Standard, this value is set to 199409L, 199901L and 199711L, respectively.) With `__STDC__` set to 0, `__STDC_VERSION__` is always set to 0L, overriding the -V option.
  If this option is omitted for C, `__STDC_VERSION__` is set to the value of STDC_VERSION in system.H. (For GCC V.2.7 - V.2.9, 199409L. For others, 0L.) If specifying -V199901L results in `__STDC_VERSION__` >= 199901L, mcpp conforms to the following C99 specifications (See 3.7.):
  1. Treats the text from // to the end of a line as a comment. *3
  2. Allows the sequence of p+, P+, p-, and P-, as well as e+, E+, e-, and E-, in the preprocessing-number. This is to represent a bit pattern of a floating-point number in Hex, like 0x1.FFFFFEp+128.
  3. Enables the _Pragma operator (A _Pragma( "foo bar") has the same effect as specifying a #pragma foo bar.)
  4. mcpp compiled with the EXPAND_PRAGMA macro set to TRUE will macro-expand an argument on a #pragma line that does not begin with STDC or MCPP. (By default, EXPAND_PRAGMA is set to FALSE in other than Visual C-specific-build and Borland C-specific-build, so macro expansion does not occur.)
  5. Allows an escape sequence of Universal-Character-Name (UCN) in identifiers, character constants, string literals and pp-numbers. (This is only enabled in STD mode.)
  Note that although C99 provides for variable argument macros, mcpp allows them in the C90 and C++ modes. *4
  In C++ also, when specifying -V199901L results in `__cplusplus` >= 199901L, mcpp will enter the C99 compatibility mode, providing the above 2-4 enhancements. (1 is enabled unconditionally and 5 is almost the same.) These are mcpp's own enhancements that do not conform to the C++ Standard.
  The -D option cannot be used with `__STDC__`, `__STDC_VERSION__`, and `__cplusplus`. This is to distinguish system-defined macros from user-defined ones.

The following option is available for STD mode:

- `-3`
  Reverse initial settings for the trigraphs processing. With TRIGRAPHS_INIT == FALSE, mcpp recognizes trigraphs. Otherwise, it does not.
- `-K`
  Enable macro notification mode which embeds macro notifications into comments. This mode is designed to allow reconstruction of the original source position from the preprocessed output. The primary purpose of the macro notification mode is to allow C/C++ refactoring tools to refactor source code without having to implement a special-purpose C preprocessor. This mode is also handy for debugging macro expansions. The goal for macro expansion mode is to annotate every macro expansion, while still allowing the code to be compiled. *5
  This mode is also enabled by the following pragma:

      #pragma MCPP debug macro_call

  The -K option has almost the same effect with this pragma at top of an input file except predefined macros are notified only by this option. About the specs of macro notification, see 3.5.8. #pragma MCPP debug macro_call.
  This option implies -k option. The -v option changes its meaning in this mode, and outputs more verbose notations. On the other hand, -a (-x assembler-with-cpp) or -C options automatically disable -K option. *6
- `-k`
  Keep horizontal white spaces ('\t' and space characters) without squeezing them into one space. Comment is converted to spaces of the same length. This option is to keep column position of source file in preprocessed output except within macro expansion. (Column position of macros are known by -K option.) *7

Note:

*1 C++'s `__STDC__` is not desirable and causes many problems. GCC document says that `__STDC__` needs to be predefined in C++ because many header files expect `__STDC__` to be defined. The header files should be blamed for this. For common parts among C90, C99 and C++, "`#if __STDC__ || __cplusplus`" should be used.

*2 Different from C99, the C++ Standard makes much of UCN. So did C 1997/11 draft. Half-hearted implementation is not permitted. However, implementing Unicode in earnest is too much burden for preprocessor.

*3 In C90 mcpp treats // as a comment but issues a warning.

*4 This is for compatibility with GCC.

*5 If you install GCC-specific-mcpp, cc1 (cc1plus) is set to be handed from mcpp preprocessed file with -fpreprocessed option. Though this option means that the input is already preprocessed, cc1 still processes comment. Therefore, you can safely pass output of -K to cc1 with -fpreprocessed. Furthermore, if you add -save-temps option to gcc (g++) command, preprocessed output is left as *.i (*.ii) file, and you can read it by some refactoring tool.

*6 Comment insertion by -K option causes column shifts in sources, and this makes *.S file of GCC, which is not C/C++ source and compiled with -x assembler-with-cpp option, unable to be assembled. Also comments kept by -C option are sometimes confusing with that inserted by -K option. Therefore these options cannot be used at the same time.

*7 This option fails to keep column position on some particularly complex cases. When line splicing by a <backslash><newline> and line splicing by a line-crossing comment are intermingled on one output line, or a comment crosses over 256 lines, column position will be lost. Note that each '\v' and '\f' is converted to a space with or without this option.

## 2.5. Common Options Except for Some Compiler Systems

The following 2 options can be used on UNIX-like systems, for either of compiler-independent-build and GCC-specific-build. On GCC-specific-build, however, these will get an error if the GCC does not support them.

- `-m32`
  Predefine macros for 32bit mode. If the CPU is `x86_64` or `ppc64`, predefined macros for 64bit mode are used by default. With this option, however, those for `i386` or `ppc` respectively are used.
- `-m64`
  Predefine macros for 64bit mode. If the CPU is `i386` or `ppc`, predefined macros for 32bit mode are used by default. With this option, however, those for `x86_64` or `ppc64` respectively are used.

Since GCC has so many options that GCC-specific-build of mcpp has some different options from the other builds in order to avoid conflicts with GCC. Note that the options in compiler-independent-build are all the same even if compiled by GCC. The options common to the builds other than GCC-specific are as follows.

- `-a`
  Accept the following notations used in some assembler sources without causing an error.

  1.     #APP

     If the token that follows the line top # does not agree with any of C directives as above, mcpp outputs this line as it is without causing an error.

  2.     # + any comment.

     If the token that follows the line top # is not even an identifier nor pp-number, mcpp discards the line with a warning, without causing an error.

  3.     "A very very
         long long
         string literal"

     The above old-fashioned string literals are concatenated into "`A very very\nlong long\nstring literal`".

  4. Even if token concatenation using a ## operator generates an invalid pp-token, it is not regarded as error.
  5. mcpp does not insert spaces around a macro expansion result, and does not regard an unintended token merging of the macro expansion result with its adjacent token as an error.

  These sometimes happen to GNU source code, however, this option for GCC is -x assembler-with-cpp or -lang-asm.
  This option cannot be used in POSTSTD mode.
  This manual calls this mode lang-asm mode.
  This mode is recommended when you use mcpp as a macro processor for some text other than C/C++, for example, as a cpp called from xrdb.

- `-I-`
  Cancel default include directories and enable only ones specified with an environment variable and the -I option. Instead of -I-, GCC-specific-build uses -nostdinc. In GCC, the -I- option provides quite different functionality. See 2.6.

## 2.6. Options by Compiler System

To use mcpp replacing the compiler system's resident preprocessor, install it in the directory where the resident preprocessor is located under an appropriate name. Before copying mcpp, be sure to change the name of resident preprocessor so that it may not be overwritten.

For settings on Linux, FreeBSD, or CygWIN see 3.9.5. For settings in GCC 3.*, 4.*, see also 3.9.7, and 3.9.7.1. For MinGW, see 3.9.7.1.

Possibly the compiler driver cannot pass some options to mcpp in a normal manner. However, GCC provides the -Wp almighty option to allow you to pass any options to the preprocessor. For example, if you specify as follows:

    gcc -Wp,-W31,-Q23

The -W31 and -Q23 options are passed to preprocessor. The options you want to pass to preprocessor have to be specified following -Wp with each option delimited by ", ". *1, *2

For other compiler systems, if their compiler driver source is available, it is recommended that this type of an almighty option should be added to the source. If you modify the compiler driver source code in the way that, for example, when -P<opt> is specified, only -<opt> is passed to preprocessor, it would be very convenient because any options can be passed.

An alternative way to use all the options of mcpp is to write a makefile in which first preprocess with mcpp, then compile the output file of mcpp as a source file. For this method, refer to sections 2.9 and 2.10.

The following options are available for some compiler-specific-builds. The compiler-independent-build has not these options, of course.

The following options are available for the LCC-Win32-specific-build.

- `-g <n>`
  Define the `__LCCDEBUGLEVEL` macro as <n>.
- `-O`
  Defines the `__LCCOPTIMLEVEL` macro as 1.

The following options are available for the Visual C-specific-build.

- `-arch:SSE, -arch:SSE2`
  Define the macro `_M_IX86_FP` as 1, 2 respectively.
- `-Fl <file>`
  Same as -include <file> for GCC.
- `-G<n>`
  If <n> is one of 3, 4, 5, 6, B, define the macro `_M_IX86` as 300, 400, 500, 600, 600, respectively.
- `-GR`
  Define the macro `_CPPRTTI` to 1.
- `-GX`
  Define the macro `_CPPUNWIND` to 1.
- `-GZ`
  Define the macro `__MSVC_RUNTIME_CHECKS` to 1.
- `-J`
  Define the macro `_CHAR_UNSIGNED` to 1.
- `-RTC*`
  If -RTC1, -RTCc, -RTCs, -RTCu and such option is specified, define the macro `__MSVC_RUNTIME_CHECKS` to 1.
- `-Tc, -TC`
  Specify that the source is written in C. The result is same with or without this option.
- `-Tp, -TP`
  Same as -+.
- `-u`
  Same as -N.
- `-Wall`
  Same as -W17 (-W1 -W16).
- `-WL`
  Same as -j.
- `-w`
  Same as -W0.
- `-X`
  Same as -I-.
- `-Za`
  Undefine the macro `_MSC_EXTENSIONS` and prohibit '$' in identifiers.
- `-Zc:wchar_t`
  Define the macros `_NATIVE_WCHAR_T_DEFINED` and `_WCHAR_T_DEFINED` to 1.
- `-Zl`
  Define the macro `_VC_NODEFAULTLIB` to 1.

mcpp on Mac OS X accepts the following option, on both of GCC-specific-build and compiler-independent-build.

- `-F <framework>`
  Put the <framework> directory to top of the framework directories to search. The standard framework directories are /System/Library/Frameworks and /Library/Frameworks by default.

mcpp on Mac OS X accepts the following option on GCC-specific-build.

- `-arch <arch>`
  Change the target architecture of machine as <arch> from the default one. This causes changes of some predefined macros. <arch> should be i386 or x86_64 on the preprocessor for x86, ppc or ppc64 on the one for ppc. (You can specify any of these 4 for `gcc` command. `gcc` command invokes the preprocessor for x86 on '`-arch i386`' or '`-arch x86_64`' options, and the one for ppc on '`-arch ppc`' or '`-arch ppc64`' options.)

The following options (until at the end of this 2.6 section) are available for the GCC-specific-build. Note that since `__STDC__` is set to 1 for GCC, the result is same with or without the -S1 option.

The followings are available across the modes.

- `-$`
  Same as -fno-dollars-in-identifiers.
- `-b`
  Output line number information just like C sources.
  The format used to pass the line number information from a preprocessor to compiler-proper is usually as follows:

      #line 123 "filename"

  Most compiler systems can use this C source format, but some systems cannot. The default specification of mcpp is such that, in compiler-specific-build for the compiler systems that cannot use the C source format, mcpp outputs the line number information in a format that the compiler-proper can accept it.
  However, with this option specified, even in compiler-specific-build for the compiler systems that do not accept the C source format outputs the line number information in that format. This option is used with '#pragma MCPP preprocess' to pre-preprocess header files.
- `-dD, -dM`
  Output valid macro definitions in the form of #define lines at the end of preprocessing.
  With the -dD option specified, the preprocessing result is output too. Predefined macros are not output.
  With the -dM option specified, the preprocessing result is not output, and predefined macros are output except the Standard predefined ones. *3, *4
- `-fexceptions`
  Define the macro `__EXCEPTIONS` to 1.
  `-fno-exceptions` does not define this macro.
- `-finput-charset=<encoding>`
  Same as -e <encoding>. Note that GCC convert the <encoding> to UTF-8 by this option, whereas mcpp does not convert any encoding.
- `-fno-dollars-in-identifiers`
  Prohibit '$' in identifiers. (Allow it by default.)
- `-fPIC, -fpic, -fPIE, -fpie`
  Any of these options defines both of the macro `__PIC__, __pic__` to 1.
- `-fstack-protector`
  Define the macro `__SSP__` to 1.
- `-fstack-protector-all`
  Define the macro `__SSP_ALL__` to 2.
- `-fworking-directory`
  Emit a special line as the second line of preprocessor's output to convey the current working directory.
- `-I-`
  Switch the specification of the -I <directory> before and after this option; directories specified with the -I options before -I- are used to search for header files only in the form of #include "header.h"; the directories specified with -I after -I-, if any, are used to search for all #include directives. In addition, during the former search, includer's directories are not used.
- `-include <file>`
  include the <file> before processing the main source file. This is equivalent to writing #include <file> at the beginning of the main source file.
- `-iquote <dir>`
  Add <dir> to the include path for #include "header.h" form.
- `-isysroot=<dir>, -isysroot <dir>, --sysroot=<dir>, --sysroot <dir>`
  Use <dir> as the logical root directory for system headers, that is, prefix <dir> to the path-list of system header directory. For example, if the default include directory is /usr/include and <dir> is /Developer/SDKs/MacOSX10.4u.sdk, then alter the include directory to /Developer/SDKs/MacOSX10.4u.sdk/usr/include.
- `-isystem <dir>`
  Add <dir> to the include path immediately before system-specific directories and immediately after site-specific directories.
- `-lang-c, -x c`
  Perform C preprocessing. The same as not specifying this option at all.
- `-mmmx`
  Predefine a macro `__MMX__` to 1.
  `-mno-mmx` undefines `__MMX__`.
- `-nostdinc`
  Same as -I- for other compiler systems.
- `-undef`
  Same as -N.
- `-O?`
  If ? is a non-0 digit, define a macro `__OPTIMIZE__` to 1.
- `-Wcomment, -Wcomments`
  Same as -W1. The result is same with or without this option.
- `-Wtrigraphs`
  Same as -W16.
- `-Wall`
  Same as -W17. (With -Wall, mcpp does not issue class 2 and 4 warnings because these warnings are issued frequently and annoying for Linux or some other system's standard header files. Class 8 warnings are generally surplus and bothering, but are helpful to confirm portability and etc. To use this option, be sure to specify gcc -Wp,-W31.)
- `-w`
  Same as -W0.

The following options are available for Standard mode.

- `-ansi`
  Define macro `__STRICT_ANSI__` as 1. Disable non-conforming predefined macros such as `linux, i386`.
  Do not remove comma preceding absent variable argument of GCC-spec variadic. *5
- `-digraphs`
  Recognize digraphs. Digraphs specification is also reversed by -2.
- `-lang-c89, -std=gnu89`
  Same as -S1. Not only C90 but also C95 specifications are used. The result is same with or without this option.
- `-std=c89, -std=c90`
  Almost same as -S1, except these imply -ansi.
- `-lang-c99, -lang-c9x, -std=gnu99, -std=gnu9x`
  Same as -V199901L.
- `-std=c99, -std=c9x`
  Same as -V199901L and also imply -ansi.
- `-lang-c++, -x c++`
  Perform C++ preprocessing. Same as -+.
- `-std=c++98`
  Same as -+ and also implies -ansi.
- `-pedantic, -pedantic-errors`
  Same as -W7 (i.e. -W1 -W2 -W4).
- `-std=iso<n>:<ym>`
  Specify a version of C Standard. To specify C, <n> is 9899 and C++, 14882. If <n> is 9899, <ym> is any of 1990, 199409, 1999 and 199901. If <n> is 14882, <ym> is 199711. If you enter other value than these in <ym>, `__STDC_VERSION__` or `__cplusplus` is set to that value. In this case, <ym> must be specified in six digits, like 200503.
  These options imply -ansi. On the other hand, -std=gnu* do not imply -ansi, also -pedantic does not imply -ansi.

For STD mode, following options are available. (These cannot be used in POSTSTD mode.)

- `-lang-asm, -x assembler-with-cpp`
  Same as -a for other compiler systems. Specify lang-asm mode. In GCC-specific-build, a macro `__ASSEMBLER__` is defined to 1, and '$' in identifiers are prohibited. When the main source file is named *.S, lang-asm mode is implicitly specified without this option.
- `-trigraphs`
  Recognize trigraphs. Trigraphs specification is also reversed by -3.

The following option is available for pre-Standard mode of GCC-specific-build.

- `-traditional, -traditional-cpp`
  Same as -@old.

The next option is available on CygWIN GCC-specific-build.

- `-mno-cygwin`
  Alter the include directory from /usr/include to /usr/include/mingw, and alter the predefined macros from the ones for cygwin1.dll to the ones for msvcrt.dll.

mcpp neither makes the following options an error nor does anything about them. (It sometime issues a warning.)

- `-A <predicate(answer)>`
  mcpp ignores this option. In GCC, this option is equivalent to writing #assert <predicate (answer)> in the source code. Standard C, does not permit extension directives other than #pragma. Fortunately, so far, gcc, by default, passes an equivalent macro with the -D option, so there are no actual problems unless a source program uses #assert, which is a rare case.
- `-g <n>`
- `-idirafter <dir>`
- `-iprefix <dir>, -iwithprefix <dir>, -iwithprefixbefore <dir>`
- `-noprecomp`
- `-remap`

In GCC V.3.3 or later, preprocessor has been absorbed into compiler, and independent preprocessor does not exist. Moreover, gcc often passes to preprocessor the options not for preprocessor, even if it is invoked with -no-integrated-cpp option. GCC-specific-build of mcpp for V.3.3 or later ignores the following options, if it cannot recognize them, as that kind of false options.

- `-c`
- `-E`
- `-f*`
- `-m*`
- `-quiet`
- `-W*`

Note:

*1 -Wa and -Wl are almighty options for assembler and linker, respectively. The documentation on UNIX/System V/cc describes these options. Probably, GCC provides the -W<x> option for compatibility.

*2 In GCC V.3, cpp was absorbed into cc1 (cc1plus). Therefore, the options specified with -Wp are normally passed to cc1 (cc1plus). To have cpp (cpp0), not ccl, preprocess, the -no-integrated-cpp option must be specified on gcc invocation.

*3 GCC V.3.3 or later predefines several dozen of macros. -dD option does not regard these macros as predefined and output them.

*4 The output of -dM option is similar to that of '#pragma MCPP put_defines' ('#put_defines') with the following differences:

1. 'put_defines' outputs also Standard predefined macros as comments.
2. 'put_defines' outputs also the file name and the line number of the macro definition as a comment, arranging to readable format. On the other hand, -d* options output in the same simple format with GCC, because some makefiles expect that format.

*5 Refer 3.9.6.3.

## 2.7. Environment Variables

In compiler-independent-build of mcpp, the include directories are not set up other than /usr/include and /usr/local/include in UNIX systems. Other directories, if required, must be specified using environment variables or runtime options. The environment variable in compiler-independent-build is INCLUDE for C and CPLUS_INCLUDE for C++. Searching the file starts from the includer's source directory by default. (refer to 4.2 for the search rule.) Besides, in Linux there is a confusion of include directories, hence special setup is necessary to cope with this problem. Refer to 3.9.9 for the problem.

For the default include directories on GCC-specific-build, refer to noconfig/*.dif files, and for search rule and environment variable name, refer to 4.2.

For the environment variable LC_ALL, LC_CTYPE, LANG, refer to 2.8.

## 2.8. Multi-Byte Character Encodings

mcpp can process various multi-byte character encodings as follows.

> EUC-JP | Japanese extended UNIX code (UJIS)
> shift-JIS | Japanese MS-Kanji
> GB-2312 | EUC-like Chinese encoding (Simplified Chinese)
> Big-Five | Taiwanese encoding (Traditional Chinese)
> KSC-5601 | EUC-like Korean encoding (KSX 1001)
> ISO-2022-JP1 | International standard Japanese
> UTF-8 | A kind of Unicode encoding

The encoding used during execution can be specified as follows (Priority is given in this order):

1. The encoding specified in '#pragma __setlocale( "<encoding>")' in source code. (For Visual C-specific-build, '#pragma setlocale( "<encoding>")'.) This directive allows you to specify several encodings in one source file.
2. The encoding specified with -e <encoding> or -finput-charset=<encoding> as run-time option.
3. The encoding specified with the LC_ALL, LC_CTYPE and LANG environment variables. Priority is given in this order.
4. The default encoding specified when mcpp is compiled.

How to specify a <encoding> is basically same across #pragma __setlocale, -e option, and the environment variables; in the table below, the encoding on the left-side hand is specified by the <encoding> on right-hand side; <encoding> is not case sensitive; '-' and '_' are ignored. Moreover, if it has '.', the character sequence to the '.' is ignored. Therefore, EUC_JP, EUC-JP, EUCJP, euc-jp, eucjp and ja_JP.eucJP are regarded as same. '*' represents any character sequence of zero or more bytes. (iso8859-1, iso8859-2 are equivalent to iso8859*.).

> EUC-JP | eucjp, euc, ujis
> shift-JIS | sjis, shiftjis, mskanji
> GB-2312 | gb2312, cngb, euccn
> BIG-FIVE | bigfive, big5, cnbig5, euctw
> KSC-5601 | ksc5601, ksx1001, wansung, euckr
> IS0-2022-JP1 | iso2022jp, iso2022jp1, jis
> UTF-8 | utf8, utf
> Not specified | c, en*, latin*, iso8859*

If any of the following encodings is specified, mcpp is no longer able to recognize multi-byte characters: C, en* (english), latin* and iso8859*. When a non-ASCII ISO-8859 Latin-<n> single-byte character set is used, one of these encodings must be specified. When an empty name is used (#pragma __setlocale( "")), the encoding is restored to the default.

Only in the Visual C-specific-build, the following encoding name can be specified with '#pragma setlocale'. This is for compatibility with Visual C++. It is recommended you should use these names because the Visual C++ compiler cannot recognize encoding names other than these. ('-' can be omitted for mcpp, but not for the Visual C++ compiler-proper.)

> shift-JIS | japanese, jpn
> GB-2312 | chinese-simplified, chs
> BIG-FIVE | chinese-traditional, cht
> KSC-5601 | korean, kor
> Not specified | C, english

In Visual C++, the default multi-byte character encoding varies, depending on what language the language parameter and "Region and Language Option" of Windows are set to. However, the #pragma setlocale specification takes precedence over these Windows's settings.

GCC sometimes fails to handle shift-JIS, ISO2022JP and BIG-FIVE encodings, which contain the byte of 0x5c value. So, GCC-specific-build of mcpp complements it. *1

Note

*1 If the --enable-c-mbchar option is specified to configure GCC itself, that GCC recognizes an encoding specified by an environmental variable LANG set to one of C-EUCJP, C-SJIS or C-JIS, gcc's info says. This way of configuring seems to be available from 1998 onward, but it has been seldom used, and its implementation does not work. Although GCC-specific-build of mcpp had supported these environmental variables, such as LANG=C-SJIS, it removed that feature since V.2.7.
Also GCC info says that, besides LANG, environmental variables LC_ALL and LC_CTYPE can be used to specify an encoding. However, the difference between using LC_ALL or LC_CTYPE or not lies only in their diagnostic messages, in actual.

## 2.9. How to Use mcpp in One-Pass Compilers

Compilers whose preprocessor is integrated into themselves are called one-pass compilers. These includes Visual C, Borland C, and LCC-Win32. Such compilers are becoming more popular because they can achieve a little higher processing speed. However, the time for preprocessing becomes shorter due to better hardware performance. In the first place, there is much point for preprocessing to be a common phase, mostly independent of run-time environment and compiler systems. It is not desirable that one-pass compilers become more popular. There will be more compiler-system-specific specifications.

Anyhow, it is impossible to replace the preprocessor of a one-pass compiler with mcpp. To use mcpp, a source program is preprocessed with mcpp and then the output is passed to a one-pass compiler. As you see, preprocessing takes place twice. It is useless but inevitable. Using of mcpp still has merits of source checking and can avail functions not available in resident preprocessor.

To use mcpp with a one-pass compiler, the procedure must be written in makefile. For sample procedures, refer to the makefile re-compilation settings used to compile mcpp itself, such as visualc.mak, borlandc.mak, and lcc_w32.mak.

Although GCC 3 or 4 compiler now integrates its preprocessing facility into itself, gcc provides an option to use an external preprocessor. Use this option when mcpp is used. (See 3.9.7.)

## 2.10. How to Use mcpp in IDE

It is difficult to use mcpp in Integrated Development Environment (IDE) because IDE's GUI follows compiler-system-specific specifications and internal interfaces are not usually made available to third parties. Furthermore, one-pass compilers make it more difficult to insert a phase to use mcpp.

This subsection describes how to make mcpp available in Windows / Visual C++ 2003, 2005, 2008 IDE. Use the compiler-specific-build for Borland C and LCC-Win32 on command lines.

Also, it is described here how to make mcpp available in Mac OS X / Xcode.app / Apple-GCC.

### 2.10.1. How to Make mcpp Available in Visual C++ IDE

mcpp cannot be used in a normal "project" since the internal specifications of Visual C++'s IDE are not made available to third parties and the compiler is a one-pass compiler. However, once a makefile that uses mcpp is created, Visual C++'s IDE can recognize the makefile and you can create a "makefile project" using that file. This allows you to utilize most of the IDE functions, including source editing, search, and source level debugging.

"Creating a Makefile Project" of a Visual C++ 2003 document, Visual C++ 2005 Express Edition Help and Visual C++ 2008 Express Edition Help describe how to make a makefile project. Perform the following procedure to create a makefile project.

1. Login as a user with debugging privilege. *1
2. Write a makefile that specifies mcpp. (Refer to noconfig/visualc.mak.) *2
3. Start Visual Studio. *3
4. Click "New Project" to display the "New Project" window. Select "Makefile Project" and specify "Name" and "Location", and then click "OK".
5. Then the "Makefile Application Wizard" windows appears. Click "Application settings", and enter appropriate values in the "Build command line", "Output", "Clean commands", and "Rebuild command line" fields.
   Let me explain the appropriate values for these fields by taking an example of making the compiler-independent-build of mcpp itself. (Assuming the name of mcpp executable as mcpp.exe.)

       "Build command line":   nmake
       "Output":               mcpp.exe
       "Clean command":        nmake clean
       "Rebuild command line": nmake PREPROCESSED=1

   To make the Visual C-specific-build of mcpp, add an option COMPILER=MSC as:

       "Build command line":   nmake COMPILER=MSC
       "Output":               mcpp.exe
       "Clean command":        nmake clean
       "Rebuild command line": nmake COMPILER=MSC PREPROCESSED=1

   Since a Makefile project does not provide a 'make install' equivalent command, you must write the makefile in such a way that the commands you specify in "Build command line" and "Rebuild command line" also perform installation. *4
   If you do not compile mcpp, "Build command line" and "Rebuild command line" can be the same.
   When completed, click "Finish".
6. Then the Makefile project appears in "Solution Explorer". Click the "Source Files" folder, choose "Add Existing Solution Item" from the "Project" menu, select all the source files, and then click "OK". Then the source file names appear in Solution Explorer.

You can now use every functions, including Edit, Build, Rebuild and Debugging.

Note:

*1 On VC 2003 and 2005, to use the debugging function under Windows XP pro or Windows 2000, a user must belong to a group called "Debugger users". However, Windows XP HE does not provide such a group, so one has to login as an administrator. On VC 2008, such a limitation on users group was lifted.

*2 In order to perform the source level debugging function, makefile must be written in such a way that cl.exe is called with the -Zi option appended to generate debugging information.

*3 If you start Visual Studio by selecting "Start" -> "Programs", environment variables, such as for include directories, are not set. In order to have these variables set, you should open the 'Visual Studio command prompt' to start Visual Studio by typing on VC 2003:

    devenv <Project File> /useenv

On VC 2005 express edition and VC 2008 express edition:

    vcexpress <Project File> /useenv

*4 You must have a writing permission to the directory into which you install mcpp. If you try to install into 'bin' or 'lib' directories of the compiler system, the permission should be carefully set by an administrator account. It is recommended to make the user account belong to "Power users" or "Authenticated users" group and set "write" and "modify" permissions to the directory for the group. Another way of controlling the permission is to install the compiler system into a directory which the user has wrinting permission on, such as a shared directory.

### 2.10.2. How to Make mcpp available in Mac OS X / Xcode.app

You can use Xcode.app, which is an IDE on Mac OS X, with mcpp without problems. *1

Xcode.app uses gcc (g++) in /Developer/usr/bin rather than /usr/bin for some reason. (/Developer is the default install directory for Xcode.) To use mcpp in Xcode.app, you must install GCC-specific-build for the gcc (g++) in that directory. You should do as follows to install it. (${mcpp_dir} means the directory where the source of mcpp is placed.)

    export PATH=/Developer/usr/bin:$PATH
    configure ${mcpp_dir}/configure --enable-replace-cpp
    make
    sudo make install

The installation method is the same with that for gcc in /usr/bin, except PATH setting. So, please refer to INSTALL for installation to cross-compiler or installation of universal binary.

After installing mcpp in such a way, you can use Xcode.app without any special setting for mcpp. Also the Apple-GCC-specific *.hmap files, which are "header map" files generated by Xcode.app, are read and processed by mcpp. However, mcpp does not process precompiled-header. It processes '`#include "header.pch"`' as an ordinary #include. Also, mcpp does not preprocess Objective-C and Objective-C++, so *.m and *.mm source files are directly handed on to cc1obj and cc1objplus, bypassing mcpp.

When you use mcpp-specific options, specify them as follows:
From screen top menu bar of Xcode.app, select "Project" > "Edit Project Settings". The "project editor" window will appear. Then, select "Build" pane of it, and edit "Other C flags" item. The options should be specified following '-Wp,' and separated by commas, for example:

    -Wp,-23,-W3

Note:

*1 Here we refer to Mac OS X Leopard / Xcode 3.0.

# 3. Enhancements and Compatibility

mcpp has its own enhancements. Each compiler-system-resident preprocessor has its own enhancements, some of which are not available in mcpp. This section covers these enhancements and their compatibility problems.

Principally, mcpp outputs #pragma lines as they are. This principle is applied to the #pragma lines processed by mcpp itself. This is because the compiler-proper may interpret the same #pragma for itself.

However, mcpp does not outputs the lines beginning with '#pragma MCPP', since these are for mcpp only. Also, mcpp does not outputs lines of '#pragma GCC' followed by either 'poison', 'dependency' or 'system_header'. Moreover, mcpp outputs neither of '#pragma once', '#pragma push_macro', nor '#pragma pop_macro' because they are useless on the later phases. On the other hand, '#pragma GCC visibility *' is outputted, because it is for the compiler and the linker. *1

mcpp compiled with EXPAND_PRAGMA == TRUE expands macros in #pragma line (in actual, EXPAND_PRAGMA is set TRUE only for Visual C-specific-build and Borland C-specific-build). However, #pragma lines followed by STDC, MCPP or GCC are never expanded.

#pragma sub-directives are implementation-defined, hence there are risks of same name sub-directive having different meanings to different compiler-systems. Some device is necessary to avoid name collision. Moreover, when EXPAND_PRAGMA == TRUE, there should be a device to avoid the name of #pragma sub-directive itself being macro expanded. This is why mcpp-specific sub-directives begin with '#pragma MCPP' and are not subject to macro expansion. This device is adopted from '#pragma STDC' of C99 and '#pragma GCC' of GCC 3.

'#pragma once' is, however, implemented as it is, since this pragma has been implemented in many preprocessors and has now no risk of name collision. '#pragma __setlocale' is prefixed with "__" instead of MCPP, because it has also meaning for compiler-proper, and because the prefix avoids user-name-space.

Note:

*1 The GCC-specific-build of mcpp only supports '#pragma GCC system_header' of the pragmas starting with GCC. It does not support '#pragma GCC poison' and '#pragma GCC dependency'.

## 3.1. #pragma MCPP put_defines, #pragma MCPP preprocess and others

mcpp in Standard mode uses '#pragma MCPP put_defines', '#pragma MCPP preprocess' and '#pragma MCPP preprocessed'. Pre-Standard mode uses #put_defines, #preprocess and #preprocessed. Let me explain by taking an example of #pragma.

When mcpp encounters '#pragma MCPP put_defines' directive, it outputs all the macros defined at that time in the form of #define lines. Of course, the #undef-ed macros are not output. The macros that cannot be #defined or #undef-ed, such `__STDC__` and etc, are output in the form of #define lines, but are enclosed with comment marks. (Since `__FILE__` and `__LINE__` are special macros defined dynamically on a macro invocation, the replacement list output here means nothing.)

In pre-Standard mode and POSTSTD mode mcpp do not memorize parameter names of function-like macro definitions. So, these directives mechanically represent names of the first, second, third parameters as a, b, c, ... and so on. If it reaches the 27th parameter, it begins with a1, b1, c1, ..., a2, b2, c2, ... and so on.

If you enter the following directive after invoking mcpp from keyboard without specifying input and output files, all the predefined macros are listed.

    #pragma MCPP put_defines

It also outputs a comment to indicate the source file name where each macro definition is found, as well as its line number. If you invoke mcpp with options such as -S1 or -N, you will see a different set of predefined macros.

When mcpp encounters '#pragma MCPP preprocess' directive, it outputs the following line:

    #pragma MCPP preprocessed

This indicates that the source file has been already preprocessed by mcpp.

When mcpp encounters a '#pragma MCPP preprocessed' directive, it determines that the source file has been preprocessed by mcpp and continues to output the code it reads as it is, until it encounters a #define line. When mcpp does encounter a #define directive, mcpp determines that the rest of the source file are all #define lines and defines macros. At this time, mcpp would memorize the source filename and line number in the comment. *1, *2

A '#pragma MCPP preprocessed' is applied only to the lines that follow the directive in the source file where the '#pragma MCPP preprocessed' directive is found. If the source file is an #included one, when control is returned to the #including file, '#pragma MCPP preprocessed' is no longer applied.

Note:

*1 Actual processing is a little more complex. When mcpp encounters a '#pragma MCPP preprocessed', mcpp outputs lines it has read just as they are, except for #line lines, which compiler-specific-build of mcpp converts and outputs into a format that the compiler-proper can accept. mcpp disregards predefined standard macro because its #define line is enclosed with comment marks.

*2 Therefore, information on where a macro definition is found is not lost during pre-preprocessing.

### 3.1.1. Pre-preprocessing of Header File

With above directives, you can "pre-preprocess" header files. Pre-preprocessing considerably saves the entire preprocessing time. I think the explanation so far has already given you an understanding of how to pre-preprocess header files, but to deepen your understanding, let me explain it by taking an example of mcpp's own source code.

mcpp source consists of eight *.c files, of which seven files include "system.H" and "internal.H". No other headers are included. The source looks like this:

    #if PREPROCESSED
    #include  "mcpp.H"
    #else
    #include  "system.H"
    #include  "internal.H"
    #endif

The system.H includes noconfig.H or configed.H, as well as several standard header files. mcpp.H is not a source file I provide and is a "pre-preprocessed" header file I am going to generate.

To generate mcpp.H (of course, after setting up noconfig.H and other headers), invoke mcpp as follows:

    mcpp > mcpp.H

For compiler systems, such as GCC, also specify the -b option.

Enter the following directives from the keyboard:

    #pragma MCPP preprocess
    #include "system.H"
    #include "internal.H"
    #pragma MCPP put_defines

Enter "end-of-file" to terminate mcpp.

This has accomplished mcpp.H, which consists of the preprocessed system.H and internal.H and a set of #define lines following them. Including mcpp.H gives the same effect as including system.H and internal.H, but its size is one-nth of the original header files including the standard ones. This is because #if and comments are eliminated. It takes far less time to include mcpp.H in seven *.c files than to include system.H and internal.H seven times. By using '#pragma MCPP preprocess', much more time can be saved.

On compilation, use the -DPREPROCESSED=1 option.

It is recommended that the above procedure should be written in a file and the makefile should refer to it. The makefile and preproc.c appended to mcpp sources contain the procedure. Please refer to it.

Although the usage of independent preprocessor is limited for one-pass compilers like Visual C, Borland C or LCC-Win32, the pre-preprocessing facility is useful even for those.

The pre-preprocessing facility of header files is similar to that of the -dD option of GCC, but it differs from it in that:

1. GCC outputs line number information not in the form of '#line 123 "filename"', but in the form of '# 123 "filename"', which allows GCC to reprocess the information, but the Standard C preprocessor cannot.
2. GCC/cpp of older version outputs a #define line whenever it encounters it, but does not output a #undef line. Therefore, reprocessing the preprocessed result may produce a different result from what the original source intends.
3. By using '#pragma MCPP preprocess', which is not provided by GCC, mcpp can provides a higher processing speed.

As far as the pre-preprocessing facility is concerned, mcpp is more accurate and practical than GCC.

## 3.2. #pragma once

#pragma once directive is available in Standard mode.

#pragma once is also available for GCC, Visual C, LCC-Win32 and compiler-independent preprocessor called Wave.

This directive is used when you want to include a header file only once. With the following directive in a header file, mcpp includes the header file only once even if a #include line for that file appears many times.

    #pragma once

Usually, compiler-system-specific standard header files prevent duplicate definitions by using the following code:

    #ifndef __STDIO_H
    #define __STDIO_H
    /* Contents of stdio.h */
    #endif

#pragma once provides similar functionality to this. Using macros always involves reading a header file. (The preprocessor cannot skip reading the code as people do and must read the entire header file for #if's or #endif's; It must read a comment before it can determine whether a line is a directive line, that is, a line with # at the beginning followed by a preprocessing directive; To do so, the preprocessor must identify a string literal; After all, it must read through the entire header file and perform most of tokenization.) #pragma once eliminates the need of even accessing to a header file, resulting in a improved processing speed for multiple includes.

To determine whether two header files are identical, file name characters, including directory names in a search path, are compared. Windows is not case sensitive. Therefore, "/DIR1/header.h" and "/DIR2/header.h" are regarded as distinct, but "header.h" and "HEADER.H" are regarded as the same on Windows, but distinct on UNIX-like systems. A directory is memorized after converting to absolute path, and a symbolic link in UNIX systems is memorized after dereferencing. Moreover, path-list is normalized by removing redundant part such as `"foo/../"`. So, the identical files are determined always correctly. *1, *2, *3

I borrowed the idea of #pragma once from GCC V.1.*/cpp. GCC V.2.*, and V.3.* still has this functionality but it is regarded as obsolete. The specification of GCC V.2.*/cpp has been changed as follows: If the entire header file is enclosed with #ifndef _MACRO, #define _MACRO, and #endif, the cpp memorizes it and inclusion occurs only once, even without #pragma once.

However, this GCC V.2 and V.3 specification sometimes does not work for commercially available compiler systems that are not based on the GCC specification, due to a difference in the standard header file notation. In addition, the GCC V.2 and V.3 specification is more complex to implement. For this reason, I decided to implement only #pragma once.

As with other preprocessors, it is not advisable to rely only on #pragma once when the same header files are used. It is recommended that #pragma once should be combined with macros as follows:

    #ifndef __STDIO_H
    #define __STDIO_H
    #pragma once
    /* Contents of stdio.h */
    #endif

Note that #pragma once must not be written in <assert.h>. For the reason, see cpp-test.html#5.1.2. The same thing can be said with <cassert> and <cassert.h> of C++.

Another problem is that the recent GCC/GLIBC system has header files, like <stddef.h>, which are repeatedly #included by other system headers. They define macros, such as `__need_NULL`, `__need_size_t`, and `__need_ptrdiff_t`, and then #include <stddef.h>. Each time they do so, definitions such as `NULL`, size_t, and ptrdiff_t are defined in the <stddef.h>. The same thing can be said with <errno.h> and <signal.h>, and even with <stdio.h>. Other system headers define macros, such as `__need_FILE, __need___FILE`, and then #include <stdio.h>. Each time they do so, definitions such as FILE may be defined in <stdio.h>. #pragma once can not be used in such header files. *4

Note:

*1 The normalized result can be seen by `'#pragma MCPP debug path'`. See 3.5.1. `'#pragma MCPP put_defines'` and diagnostics use the same result, too.
However, the path-list is not normalized usually in #line line. By default, the #line line is output as specified by #include line, prepending the normalized include path, if any. But, if -K option is specified, it is normalized so as to be easily utilized by some other tools.

*2 On CygWIN, /bin and /usr/bin are the same directory in real, also /lib and /usr/lib are the same, and supposing / is C:/dir/cygwin on Windows, /cygdrive/c/dir/cygwin is the same as /. mcpp treats these directories as the same, converting the path-list to the format of /cygdrive/c/dir/cygwin/dir-list/file.

*3 On MinGW, / and /usr are the same directory in real. Supposing / is C:/dir/msys/1.0, /c/dir/msys/1.0 is the same as /, and supposing /mingw is C:/dir/mingw, /c/dir/mingw is the same with /mingw. mcpp treats each of these as the same directories, converting the path-list to the format of c:/dir/msys/1.0/dir-list/file or c:/dir/mingw/dir-list/file.

*4 This is applied at least to Linux/GCC 2.9x, 3.* and 4.*/glibc 2.1, 2.2 and 2.3. FreeBSD 4, 5, 6 has much simpler system headers because it does not use glibc.

### 3.2.1. Tool to Write #pragma once to Header Files

With a small number of header files, writing #pragma once to them does not require much effort, but it would be tremendous work if there are many header files. I wrote a simple tool to write it automatically to header files.

tool/ins_once.c is a tool written for old versions of GCC. As Borland 5.5 conform to the same standard header file notation with GCC, this tool can be used. However, it is advisable that this tool should not be used in the systems like Glibc 2 that has many exceptions shown above.

Even in the compiler systems that can use the tool, some header files do not strictly conform to the GCC notation. GCC's read-once functionality also does not work properly for these header files.

Compile ins_once.c and perform the following command in a directory, such as /usr/include or /usr/local/include, under UNIX.

    chmod -R u+w *

and then execute ins_once as follows:

    ins_once -t *.h */*.h */*/*.h

Ins_once reports header files that do not begin with #ifndef or #if !defined. Manually modify these files. Then, execute ins_once as follows:

    ins_once *.h */*.h */*/*.h

If the first directive in each header file is #ifndef or #if !defined, a #pragma once line is inserted immediate below the line. Only a root user or a user with an appropriate permission is eligible for this modification. When you modified access permission, use 'chmod -R u-w *' to restore to original permission.

Ins_once provides the following options. Select the most appropriate one for your system.

- -t: Check whether a header file begins with #ifndef or #if !defined, excluding a comment. This option does not modify the file.
- -p: Insert a #pragma once line at the beginning of file. By default, this line is inserted immediate below the #ifndef or #if !defined line.
- -g: For GCC system, <stddef.h>, <stdio.h>, <signal.h>, <errno.h> are also excluded. By default, only <assert.h>, <cassert> and <cassert.h> are excluded.

ins_once roughly checks to write a #pragma once line only once in the same header file even if it is executed several times, but the check is not very strict. As this ins_once is of temporary and tentative nature, it scarcely performs tokenization. It worked as I expected with FreeBSD 2.0 and 2.2.7, Borland C 5.5, but it may not work properly for special header files. So before executing this tool, be sure to make a backup of an original file.

Have the shell expand a wild-card. (In case of buffer overflow, execute ins_once several times by specifying some of your system header files.)

## 3.3. #pragma MCPP warning, #include_next, #warning

These directives are provided for compatibility with GCC. GCC provides the #include_next and #warning directives. Although these directives are non-conforming, not only some source programs sometimes use them but also some Glibc2 system header files do. Taking this situation into consideration, I implemented the #include_next and #warning directives in GCC-specific-build to allow compilation of such source programs, however, mcpp issues a warning when it finds the directives. Regardless of the compiler systems mcpp is ported to, mcpp in Standard mode also implements #pragma MCPP warning.

With the following directive, mcpp skips the current file's directory and start searching header.h from the next directory of search path.

    #include_next  <header.h>

CygWIN and MinGW ignores the distinctions of alphabetical case of header names.

The following code outputs 'any message' to stderr as a warning message:

    #pragma MCPP warning    any message

    #warning  any message

Different from #error, this is not counted as an error.

## 3.4. #pragma MCPP push_macro, #pragma __setlocale and others

When I ported mcpp to Visual C, I implemented these directives in mcpp, and then made them available for other systems.

'#pragma MCPP push_macro( "MACRO")' and '#pragma MCPP pop_macro( "MACRO")' are used to "push" or "pop" a macro definition (MACRO) to the current macro definition stack.

'#pragma push_macro( "MACRO")' and '#pragma pop_macro( "MACRO")' are also available for Visual C.

push_macro saves a macro definition to the stack, and pop_macro retrieves the macro definition. The pushed macro definition remains valid after push_macro. To invalidate it, use #undef or redefine the macro with a new definition. push_macro can be used multiple times for a same name macro.

'#pragma __setlocale( "<encoding>")' changes the current multi-byte character encoding to <encoding>. The argument of setlocale must be a string literal. For <encoding>, refer to 2.8. This directive allows you to use several encodings in one translation unit.

In Visual C++, '#pragma __setlocale' cannot be used. Use '#pragma setlocale' instead. Encoding specification must be conveyed not only to mcpp but also to the compiler-proper. The latter can recognize only #pragma setlocale. For other compiler systems, when the compiler-proper cannot recognize an encoding, mcpp complements it.

There is not yet any compiler-proper which can recognize '#pragma __setlocale'.

## 3.5. #pragma MCPP debug, #pragma MCPP end_debug, #debug, #end_debug

'#pragma MCPP debug' and '#pragma MCPP end_debug' are for Standard mode. #debug and #end_debug are for pre-Standard mode.

The '#pragma MCPP debug <args>' directive can be written anywhere in a source program. <args> specifies a debug information type. One #pragma MCPP debug directive can take several <arg>. One or more <arg> must be specified for each directive. mcpp begins to output debug information when it finds this directive, and stops it when it encounters '#pragma MCPP end_debug <args>'. The <args> can be omitted, in which case all types of debug information is reset. If <args> contains an argument that is not supported by mcpp, mcpp issues a warning, but all the preceding arguments are regarded as valid.

All the debug information is output to the same path with the preprocessing output to synchronize with it. Therefore, this directive usually prevents compilation. Nevertheless, `#pragma MCPP debug macro_call` outputs informations embedding into comments, and can be re-preprocessed and compiled.

When you noticed something was wrong with the preprocessing result, enclose the coding you want to debug with the following directives, for example:

    #pragma MCPP debug token expand
    /* Coding you want to debug  */
    #pragma MCPP end_debug

As this directive was originally used for debugging mcpp itself, it was not developed with end users in mind. So, you may not understand its behavior unless you read its source code, and you may sometimes feel it outputs too much information, but it is useful for tracing the preprocessing process. Be patient.

The following debug information types can be specified with <arg>.

> path | Displays the include file search path.
> token | Parses tokens one by one and displays its type.
> expand | Traces a macro expansion process.
> macro_call | Embed macro notifications into comments on each macro definition and macro expansion.
> if | Displays the result (true or false) of #if, #elif, #ifdef and #ifndef.
> expression | Traces #if expression evaluation.
> getc | Traces preprocess 1-byte by 1-byte.
> memory | Displays the status of heap memory used by mcpp.

### 3.5.1. #pragma MCPP debug path, #debug path

With these directives, mcpp displays include directories in the search path (excluding the current and source directories with which search begins) in the order of priority, starting with the highest one first.

In addition, with a #include directive, mcpp displays all the directories, including the current one, it actually searched for the #include file.
When a header file with #pragma once specified is #included again, the message to that effect is displayed.
Moreover, mcpp normalizes the path-list removing the redundant part such as `"foo/../"`, and displays the result when the normalized path-list differs from the original one.
Also mcpp dereferences the symbolic link to its linked-file, and displays the result when conversion is occurred.

### 3.5.2. #pragma MCPP debug token, #debug token

With these directives, mcpp displays a source line it has read, and then displays a token and its type on the source line each time it has read. This token, more specifically, is a preprocessing-token (pp-token). Not only pp-tokens on a source line but also ones mcpp reads again internally during macro expansion are displayed repeatedly.

However, the following 1-byte tokens are not displayed for mcpp program's convenience sake:

1. 1. '#' at the beginning of a preprocessing directive line.
2. 2. '(' at the beginning of a parameter list of a function-like macro definition.
3. 3. ',' delimiting between function-like macro definition parameters.
4. 4. '(' at the beginning of an argument list used for a function-like macro invocation.

A pp-token has the following types:

> NAM | Identifier
> NUM | Preprocessing-number
> OPE | Operator or punctuator
> STR | String literal
> WSTR | Wide string literal
> CHR | Character constant
> WCHR | Wide character constant
> SPE | Special pp-tokens, such as $ and @
> SEP | Token separator white space

Of SEP, other than <newline> are not normally displayed. Control codes such as <newline> are displayed as <^J> or <^M>.

### 3.5.3. #pragma MCPP debug expand, #debug expand

With these directives, mcpp traces the expansion process of a macro invocation. When mcpp in Standard mode encounters a #pragma MCPP debug, it behaves as follows:

If there is a macro invocation, mcpp displays the macro definition. Each argument is read, the argument is substituted for the corresponding parameter in the replacement list and the replacement list is rescanned. mcpp displays this whole process. In case of nested macro definitions, they are rescanned and expanded one by one. If an argument has a macro, mcpp traces the above process recursively before parameter substitution.

Each time control is passed to and returned from a certain set of mcpp internal functions, mcpp displays the trace information along with the function name. The following table shows the role of these functions. Reading mcpp source code will gives you a concrete idea on what each function is doing.

> expand_macro | Entrance routine for macro expansion
> replace | Expands a macro one level down.
> collect_args | Collects arguments.
> prescan | Scans a replacement list and processes # and ## operator.
> substitute | Substitutes parameters with arguments.
> rescan | Rescans a replacement list.

Except for expand_macro, above functions are indirectly recursive with each other.

For replace and collect_args, mcpp displays data it internally stacks during macro expansion. This data is displayed using the following internal codes:

> <n> | Nth parameter
> <TSEP> | Token delimiter inserted by mcpp
> <MAGIC> | Code that inhibits re-replacement of the macro of the same name
> <RT_END> | Code that indicates the end of a replacement list
> <SRC> | Code that indicates an identifier taken from source file while rescanning

<SRC> is used only in STD mode, and is not used in POSTSTD mode nor in COMPAT mode.

It is recommended that '`#pragma MCPP debug token`' should be also used.

If you specify also '`#pragma MCPP debug macro_call`' or -K option, macro notifications are output embedded in comments. However, in replace() and its subordinate routines some magic characters (internal codes) are written or removed in the input stream instead of comment. These magic characters are displayed as:

> <MACm> | Call of the m'th macro contained in one macro call
> <MAC_END> | The end of the macro call started by previous MACm
> <MACm:ARGn> | The n'th argument of the m'th macro call
> <ARG_END> | The end of the argument started by previous MACm:ARGn

If you specify -v option too, the MAC_END and the ARG_END markers also display the same numbers with corresponding starting markers.

For #debug expand, mcpp uses internal routines considerably different from those used for Standard mode. The explanations are omitted.

### 3.5.4. #pragma MCPP debug if, #debug if

With these directives, mcpp displays #if, #elif, #ifdef and #ifndef lines and reports their evaluation result (true or false). As for a skipped #if section, no report is made.

### 3.5.5. #pragma MCPP debug expression, #debug expression

With these directives, mcpp traces evaluation of a #if or #elif expression. DECUS cpp, based on which mcpp has been developed, provides these directives for the purpose of debugging cpp itself. I scarcely modified them. This directive outputs a very long list of internal functions, as well as variable names and their values. Unless you read the mcpp source code, you may not understand these variables. However, without the source code, you can manage to understand how the mcpp pushes onto and takes out of a evaluation stack a complex expression value.

### 3.5.6. #pragma MCPP debug getc, #debug getc

With these directives, mcpp outputs detailed data each time it calls get_ch(), a function to read one byte. When mcpp in Standard mode scans a pp-token, this routine is called to read only the first byte of the pp-token.

With a #debug getc, mcpp calls this routine during token scan, resulting in a tremendous amount of data output.

In any way, using these directives outputs a huge amount of data, so you scarcely need to use them.

### 3.5.7. #pragma MCPP debug memory, #debug memory

With these directives, mcpp reports the status of the heap memory it has internally allocated or released using malloc(), realloc() or free() only once. Only the kmmalloc I developed and some other types of malloc() provide this functionality. Refer to mcpp-porting.html#4.extra. In case of other malloc(), mcpp will neither cause an error nor report a status.

mcpp reports the heap memory status again when it terminates with these directives on. The same thing happens when mcpp terminates due to out of memory.

### 3.5.8. #pragma MCPP debug macro_call

With this directive, mcpp starts macro notification mode. In this mode, on each macro definition and macro expansion, its line and column information on source file are output embedded in comments. On a macro call with arguments, location information on each arguments are reported too. Token concatenation by macro, however, may cause loss of macro information about the tokens before concatenation.
In addition, some informations are output on #undef, #if (#elif, #ifdef, #ifndef) and #endif, too.
This mode is specified also by -K option.

Macro notification mode is designed to allow reconstruction of the original source position from the preprocessed output. The primary purpose of this mode is to allow C/C++ refactoring tools to refactor source code without having to implement a special-purpose C preprocessor. This mode is also handy for debugging macro expansions. *1

The goal for macro expansion mode is to annotate every macro expansion, while still allowing the output to be compiled. On the other hand, '`#pragma MCPP debug expand`' is to trace macro expansion and outputs detailed informations, but its output is not compilable.

Note:

*1 Most of the specifications of macro notification mode were proposed by Taras Glek. He is working on refactoring of sources at mozilla project:

http://blog.mozilla.com/tglek/

#### 3.5.8.1. Comment on #define

For example, macro definition directives such as:

    #define NULL 0L
    #define BAR(x, y) x ## y
    #define BAZ(a, b) a + b

produce the following output:

    /*mNULL 1:9-1:16*/
    /*mBAR 2:9-2:25*/
    /*mBAZ 3:9-3:24*/

where the format means:

`/*m[NAME] [start line]:[start column]-[end line]:[end column]*/`

Line and column numbers start from 1. When you specify -K option, predefined macros are output too, which have no location information.

#### 3.5.8.2. Comment on #undef

    #undef  BAZ

This line produces the output:

    /*undef 10*//*BAZ*/

The [lnum] and [NAME] in the format of /*undef [lnum]*//*[NAME]*/ indicate line number of the line and the undefined MACRO name.

#### 3.5.8.3. Comment on Macro Expansion

Within source code other than directives, macros are expanded with markers indicating start and stop of the macro expansion. The format allows for HTML-like nesting. `/*<...*/` signals start of macro expansion and `/*>*/` the end. The start of macro expansion takes the following format replacing `/*m` of start of macro definition format to `/*<`:

`/*<[NAME] [start line]:[start column]-[end line]:[end column]*/`

On macro with arguments, markers indicating source location of each argument and markers indicating start and end of each argument expansion are output too. The marker for argument location takes the format of `/*!...*/`. When a macro is found in an argument, informations on that macro is output recursively, with its location information if it is on the source file. Macro argument marker also have a disambiguating naming scheme. An argument name is of the format:

`[func-like-macro-name]:[nesting level]-[argument number]`

This way, if someone calls '`BAZ(BAZ(a,b), c)`', it would possible to distinguish nested macros of the same name and their arguments from each other. The argument number starts from 0. Then the location format follows it as:

`[start line]:[start column]-[end line]:[end column]`

The marker for start of an argument also takes the format:

`/*<[func-like-macro-name]:[nesting level]-[argument number]*/`

The marker for end of an argument is the same with the one for end of a macro expansion: `/*>*/`.

The following lines:

    foo(NULL);
    foo(BAR(some_, var));
    foo = BAZ(NULL, 2);
    bar = BAZ(BAZ(a,b), c);

expand to:

    foo(/*<NULL 4:5-4:9*/0L/*>*/);
    foo(/*<BAR 5:5-5:20*//*!BAR:0-0 5:9-5:14*//*!BAR:0-1 5:16-5:19*/some_var/*>*/);
    foo = /*<BAZ 6:7-6:19*//*!BAZ:0-0 6:11-6:15*//*!BAZ:0-1 6:17-6:18*//*<BAZ:0-0*//*<NULL 6:11-6:15*/0L/*>*//*>*/ + /*<BAZ:0-1*/2/*>*//*>*/;
    bar = /*<BAZ 7:7-7:23*//*!BAZ:0-0 7:11-7:19*//*!BAZ:0-1 7:21-7:22*//*<BAZ:0-0*//*<BAZ 7:11-7:19*//*!BAZ:1-0*//*!BAZ:1-1*//*<BAZ:1-0*/a/*>*/ + /*<BAZ:1-1*/b/*>*//*>*//*>*/ + /*<BAZ:0-1*/c/*>*//*>*/;

Moreover, when -v option is specified along with -K option, the marker for end of macro expansion and the marker for end of an argument expansion also output the macro name and its number same with their starting markers as:

    foo(/*<NULL 4:5-4:9*/0L/*NULL>*/);
    foo(/*<BAR 5:5-5:20*//*!BAR:0-0 5:9-5:14*//*!BAR:0-1 5:16-5:19*/some_var/*BAR>*/);
    foo = /*<BAZ 6:7-6:19*//*!BAZ:0-0 6:11-6:15*//*!BAZ:0-1 6:17-6:18*//*<BAZ:0-0*//*<NULL 6:11-6:15*/0L/*NULL>*//*BAZ:0-0>*/ + /*<BAZ:0-1*/2/*BAZ:0-1>*//*BAZ>*/;
    bar = /*<BAZ 7:7-7:23*//*!BAZ:0-0 7:11-7:19*//*!BAZ:0-1 7:21-7:22*//*<BAZ:0-0*//*<BAZ 7:11-7:19*//*!BAZ:1-0*//*!BAZ:1-1*//*<BAZ:1-0*/a/*BAZ:1-0>*/ + /*<BAZ:1-1*/b/*BAZ:1-1>*//*BAZ>*//*BAZ:0-0>*/ + /*<BAZ:0-1*/c/*BAZ:0-1>*//*BAZ>*/;

As you see in this example, all the ending markers correspond to the last preceding starting markers of the same nesting level. Hence, you can judge their correspondence automatically even without -v option.

#### 3.5.8.4. Comment on #if (#elif, #ifdef, #ifndef)

On #if (#elif, #ifdef, #ifndef) line, informations on the macros in the line are shown.

For example, this is bar.h:

    #define NULL 0L
    #define BAR(x, y) x ## y
    #define BAZ(a, b) a + b

And here is foo.c:

    #include "bar.h"
    #ifdef  BAR
    #ifndef BAZ
    #if 1 + BAR( 2, 3)
    #endif
    #else
    #if 1
    #endif
    #if BAZ( 1, BAR( 2, 3))
    #undef  BAZ
    #endif
    #endif
    #endif

Then, foo.c produces the following output:

    #line 1 "/dir/foo.c"
    #line 1 "/dir/bar.h"
    /*mNULL 1:9-1:16*/
    /*mBAR 2:9-2:25*/
    /*mBAZ 3:9-3:24*/
    #line 2 "/dir/foo.c"
    /*ifdef 2*//*BAR*//*i T*/
    /*ifndef 3*//*BAZ*//*i F*/

    /*else 6:T*/
    /*if 7*//*i T*/
    /*endif 8*/
    /*if 9*//*BAZ*//*BAR*//*i T*/
    /*undef 10*//*BAZ*/
    #line 11 "/dir/foo.c"
    /*endif 11*/
    /*endif 12*/
    /*endif 13*/

As you see, on #if line, an annotation starts with a /*if [lnum]*/ format where [lnum] indicates the current line number. Then one or more /*[NAME]*/ markers follow, if some macros are found, a /*[NAME]*/ for each macro. The annotation terminates with /*i T*/ or /*i F*/ which indicates that the directive is evaluated true or false, respectively. The expansion result is not displayed, unlike a macro on lines other than directives. On a line such as '`#if 1`' which has no macro, no /*[NAME]*/ is displayed.

Also annotations on `#elif, #ifdef` and `#ifndef` start with /*elif [lnum]*/, /*ifdef [lnum]*/ and /*ifndef [lnum]*/, respectively, followed by /*[NAME]*/, if some macros are found, and terminate with /*i T*/ or /*i F*/.

In any blocks where compilation is to be skipped, no annotation is displayed.

#### 3.5.8.5. Comment on #else and #endif

On #else line, as the above examples, an information is displayed in /*else [lnum]:[C]*/ format where [lnum] is the current line number and [C] is 'T' or 'F' which indicates that the #else - #endif block is to be compiled or to be skipped.

On #endif line, as the above examples, an information is displayed in /*endif [lnum]*/ format where [lnum] indicates the current line number. Of course, the #endif corresponds to the last #if (#ifdef, #ifndef) which is not yet closed.

#### 3.5.8.6. #line Output

In addition, on the macro notification mode, the output format of filename in #line line differs from the default. It outputs the filename in the "normalized" full-path-list. See 3.2. This is for the convenience of refactoring tool making.

## 3.6. #assert, #asm, #endasm

#assert is available in pre-Standard mode, except the GCC-specific-build. #assert provides the functionality equivalent to the #error directive in the Standard C. The following code in the Standard C:

    #if ULONG_MAX/2 < LONG_MAX
    #error Bad unsigned long handling.
    #endif

can be expressed as:

    #assert LONG_MAX <= ULONG_MAX/2

The argument of #assert is evaluated as a #if expression. If it evaluates to true (non-zero), mcpp does nothing and if false (0), it displays the following message and then the argument line (after processing line splicing and comments):

    Preprocessing assertion failed

mcpp counts this as error but continues processing.

This #assert is quite different from that of System V or GCC.

mcpp in pre-Standard mode regards a block enclosed with the #asm and #endasm directives as assembler coding. mcpp implements this functionality for Microware C/6809 only. To implement this functionality in other compiler systems, do_old() and put_asm() in system.c must be modified.

For a #asm block, mcpp performs trigraphs conversion and deletes <backslash><newline> sequence, but it neither performs comment processing, checks tokens or characters, nor deletes white-space characters at the beginning of a line. Also, it does not expand a token that happens to have the same name with a macro and outputs it as it is. Other directive lines have no meaning within the #asm block.

These #asm and #endasm directives do not conform to Standard C. In the first place, extension directives in the form other than "#pragma sub-directive" are not Standard C conforming. Changing their directive names to #pragma asm and #pragma endasm does not solve this problem. In Standard C, the source code must consist of a C token sequence (more precisely, a preprocessing token sequence), however, an assembler program is not a C token sequence. To use assembly code in the Standard C, there is no other way but to embed it in a string literal token. Then, you have to implement a built-in function that processes that string literal in the compiler-proper and call it as follows:

    asm (
        " leax _iob+13,y\n"
        " pshs x\n"
    );

However, this is not suitable for a longer assembly code, in which case, you had better write the assembly code as a separate file like a library function, and assemble and link the program. This seems to be inconvenient, but it is necessary to separate the assembler portion completely to write a portable C program. It is recommended that you should write assembly code in a separate file rather than using #asm.

## 3.7. New C99 Features (_Pragma() operator, Variadic Macro and others)

These features are available in Standard mode. The -V199901L option with `__STDC_VERSION__` set to 199901L enables the following C99's features. The same thing can be said with C++ for the -V199901L option with `__cplusplus` set to 199901L or more. Although C++ Standard does not provides for the features other than 1 or 7, mcpp in Standard mode provides them for better compatibility with C99. Standard mode also allows variable argument macros even in the C90 and C++ modes. *1

1. Treats the text from // to the end of a line as a comment.
2. Enables variable argument macros.
3. Allows the sequence of p+, P+, p-, and P-, as well as e+, E+, e-, and E-, in the preprocessing-number. This is to represent a bit pattern of a floating-point number in Hex, like 0x1.FFFFFEp+128.
4. Enables the _Pragma() operator.
5. mcpp compiled with the EXPAND_PRAGMA macro set to TRUE macro-expands the argument of #pragma line that do not begin with STDC, MCPP nor GCC. (By default, mcpp is compiled with EXPAND_PRAGMA == FALSE, so it is not subject to macro expansion. It is macro expanded only in Visual C-specific-build and Borland C-specific-build.)
6. For compiler-systems with long long, a #if expression is evaluated in long long or unsigned long long.
7. Allows an escape sequence named UCN for Unicode in the forms of \unnnn and \Unnnnnnnn in identifiers, character constants, string literals and pp-numbers. The value of a UCN in #if expression is evaluated as a hexadecimal representation. (UCN cannot be used in POSTSTD mode.)

A variable argument macro takes a form of:

    #define debug(...)  fprintf(stderr, __VA_ARGS__)

Here is a macro invocation:

    debug( "X = %d\n", x);

This macro is expanded as follows:

    fprintf(stderr, "X = %d\n", x);

`...` in the parameter list corresponds to one or more parameters. In the above example, `...` corresponds to `__VA_ARGS__` in the replacement list. During a macro invocation, several arguments that correspond to the `...`, including ",", are concatenated to be treated as one argument.

_Pragma( "foo bar") has the same effect as specifying #pragma foo bar. The argument of the _Pragma() operator must be one string literal or wide string literal. For a wide string, the prefix (L) is deleted and treated as same as a string literal. For a string literal, " enclosing that string literal is deleted, and \" and \\ in that literal is replaced with " and \, respectively, before it is treated as a #pragma argument.

#pragma must be written somewhere in one logical line and its argument is not macro-expanded at least for C90. On the other hand, the _Pragma() operator can be written anywhere in source code (even in a replacement list), which gives the same effect with #pragma written in a logical line. The _Pragma() operator generated during macro expansion is also valid. This flexibility provides the pragma directive with a wide range of portability and allows a header file to absorb the difference in #pragma among compiler systems. (For this sample, see pragmas.h and pragmas.t of "Validation Suite".) *2

C99 stipulates a #if expression is of maximum integer type. As "long long" and "unsigned long long" are required types, the type of an #if expression is "long long / unsigned long long" or larger. C90 and C++98 stipulate the type is long / unsigned long. mcpp, however, evaluates it by long long / unsigned long long even in C90 and C++98, and issues a warning when the value is out of range of long / unsigned long. *1

Note:

*1 This is for compatibility with GCC and Visual C++ 2005, 2008. It is difficult also for other compiler systems to implement C99 specifications all at once. Probably, they will begin to implement them little by little with `__STDC_VERSION__` set to 199409L or so.

*2 C99 says that a #pragma argument that begins with STDC is not macro-expanded. For other #pragma arguments, whether macro is expanded is implementation-defined.

## 3.8. Particular specifications for certain compiler systems

mcpp of compiler-specific-builds have some specifications peculiar to each compiler system. Such particular specifications, other than execution option and #pragma, are explained in this section.

### 3.8.1. Variadic macro of GCC and Visual C

GCC has variadic macro of its own specification from V.2 as shown in 3.9.1.6. In this manual we call this as GCC2-spec variadic macro. Moreover, GCC implemented one more spec of variadic from V.3 as shown in 3.9.6.3, which we call GCC3-spec variadic macro. GCC V.2.95 and later implements C99 variadic, too. Nevertheless, softwares such as glibc or Linux system headers do not use C99 variadic, nor even GCC3-spec one, and still use that of GCC2-spec.

mcpp of GCC-specific-build on STD mode implemented GCC3-spec variadic from V.2.6.3, and GCC2-spec one from V.2.7, in order to avoid inconveniences on Linux or some other softwares. Yet, mcpp warns at use of them. GCC-spec variadics, especially GCC2-spec one, are not only unportable, but also syntactically unclean. Use of them in sources to write in future is not recommendable.

Visual C had not implemented variadic macro up to 2003. But, Visual C 2005 finally implemented it. Its specification is C99 one with a modification like GCC3-spec one. When variable arguments are absent, Visual C removes their immediately preceding comma. It does not use '##' token used in GCC3-spec. The specification is illustrated as below. Visual C document says that in the third example, a comma is not removed. In actual, however, it removes even the comma in this case.

    #define EMPTY
    #define VC_VA( format, ...)     printf( format, __VA_ARGS__)
    VC_VA( "var_args: %s %d\n", "Hello", 2005);     /* printf( "var_args: %s %d\n", "Hello", 2005); */
    VC_VA( "absence of var_args:\n");               /* printf( "absence of var_args:\n");   */
    VC_VA( "empty var_args:\n", EMPTY);             /* printf( "empty var_args:\n", );  */  /* trailing comma   */

Visual C-specific-build of mcpp implemented in STD mode this special handling from V.2.7. Still, it warns at use of the spec. mcpp implements the behavior on the above third example as its spec, and does not remove the comma.

### 3.8.2. Handling of 'defined' by GCC

On a macro with 'defined' token in it, GCC expands it differently from usual when it is in #if line. I explain this problem at 3.9.4.6.

mcpp of GCC-specific-build from V.2.7 onward handles this sort of macro like GCC in STD mode. This behavior was implemented to cope with a few wrong macros used in Linux system headers. Yet, it warns at use of 'defined' token in macro on #if line. You should write correct #if expression.

### 3.8.3. Asm Statement in Borland C and Other Special Syntaxes

Borland C has the `asm` keyword. This keyword is used to write assembly code as follows:

    asm {
        mov x,4;
        ...;
    }

This is quite irregular and deviates from the C grammar. If there happen to be a token with the same name as a macro, it will be macro-expanded. The same can be said with Borland C itself and mcpp. It is recommended that an assembler program should be written in a separate `.asm` file. mcpp does not treat this specially.

Visual C++ also has the `__asm` keyword, which provides the similar functionality to this.

GCC provide a Standard-conforming built-in function `asm()` which is used as `asm( " mov x,4\n")`.

### 3.8.4. #import and Others

#### 3.8.4.1. #import of Mac OS X / GCC

GCC has `#import` directive, which is a feature of Objective-C and imported to C/C++. `#import` is a `#include` with an implicit '`#pragma once`'. It is occasionally used in C/C++ sources on Mac OS X.

mcpp V.2.7 and later implements this directive only on Mac OS X, in both of GCC-specific-build and compiler-independent-build.

#### 3.8.4.2. #import and #using of Visual C

Visual C has peculiar directives named `#import` and `#using`, which have form of preprocessing-directive, in fact, they are directives for compiler and linker. The `#import` of Visual C has no relation to that of GCC.

mcpp of Visual-C-specific-build outputs these lines as they are.

## 3.9. Problems of GCC and Compatibility with GCC

Although I tried to develop mcpp in such manner that the GCC-specific-build provides compatibility with GCC / cpp (cc1) to the extent that it does not hinder practical use, it is still incompatible in many aspects.

First of all, as shown in Chapter 2, there are many differences in execution options. mcpp implements neither -A option nor non-conforming directives, including #assert and #ident. *1

Fortunately, there seems to be quite few sources that cannot be compiled due to a lack of this compatibility.

It is more problematic that there are some sources that assume special behaviors of old preprocessors. Most of such source code receives a warning when -pedantic is specified in GCC. mcpp in Standard mode, by default, provides almost the same behavior as GCC's -pedantic since it implements Standard conforming error checking. However, since GCC/cpp, by default, allows such Standard violations without issuing a diagnostic, there are some sources that take advantage of this.

It is very easy to rewrite such non-conforming code to Standard-conforming code in most cases, so it is meaningless to take the trouble to write non-conforming code only to impair portability and, what is worse, to provide a hotbed of bugs. When you find such code, do not hesitate to correct it. *2

Note:

*1 The functionality of #assert and #ident should be implemented using #pragma, if necessary. The same can be said with #include_next and #warning, but these directives seem to be sometimes used in GCC system, so I grudgingly implemented them in GCC-specific-build, however, a warning is issued when they are used.

*2 From 3.9 through 3.9.3 sections of this document was written in 1998, when the sources depending on traditional preprocessors were frequently found. After that time, such sources have greatly decreased, and on the other hand, sources depending on the local features and implementation trivialities of GCC have much increased. The 3.9.4 and later, especially 3.9.8 and later sections describe mainly such problems. (2008/03)

### 3.9.1. Preprocessing FreeBSD 2/Kernel Source

Taking FreeBSD 2.2.2-R (1997/05) kernel source code as an example, this section explains some preprocessing problems. All the directories that appear in this section are installed in /sys (/usr/src/sys). Of the items I point out below, 3.9.1.7 and 3.9.1.8 are not necessarily Standard violations and work as expected in mcpp, but mcpp issues a warning because their coding is confusing. 3.9.1.6 is an enhancement and C99 provides the same functionality, but it differs from GNUC/cpp in notation.

#### 3.9.1.1. Multi-Line String Literal

Assembly codes are embedded by the following manner in `i386/apm/apm.c, i386/isa/npx.c, i386/isa/seagate.c, i386/scsi/aic7xxx.h, dev/aic7xxx/aic7xxx_asm.c, dev/aic7xxx/symbol.c, gnu/ext2fs/i386- bitops.h, pc98/pc98/npx.c`:

    asm("
        asm code0
    #ifdef PC98
        asm code1
    #else
        asm code2
    #endif
        ...
    ");

When no " closing a string literal appears by the end of line, GCC/cpp, by default, interprets that the string literal ends at the end of line. The above coding is based on this specification. In addition, the compiler-proper seems to interpret the whole content of asm() as a string literal spreading across lines.

I think that assembler source code should be written in a separate file, but if you want to embed it in ".c" file by all means, write it in the following manner, instead of using the confusing coding shown above.

    asm(
        "  asm code0\n"
    #ifdef PC98
        "  asm code1\n"
    #else
        "  asm code2\n"
    #endif
        "  ...\n"
    );

Standard C conforming preprocessors will accept it.

#### 3.9.1.2. #else junk, #endif junk

The following line appears in `ddb/db_run.c, netatalk/at.h, netatalk/aarp.c, net/if-ethersubr.c, i386/isa/isa.h, i386/isa/wdreg.h, i386/isa/tw.c, i386/isa/b004.c, i386/isa/matcd/matcd.c, i386/isa/sound/sound_calls.h, i386/isa/pcvt/pcvt_drv.c, pci/meteor.c, and pc98/pc98/pc98.h`:

    #endif MACRO

This line should be changed to:

    #endif /* MACRO */

#### 3.9.1.3. #ifdef 0

To my surprise, `i386/apm/apm.c` contains the following strange line:

    #ifdef 0

Of course, this should be written as:

    #if 0

This code must have been neither debugged nor used.

#### 3.9.1.4. Duplicate Definition of Macro

`gnu/i386/isa/dgb.c` has a duplicate definition of the following macro:

    #define DEBUG

Some of header files have a macro definition conflicting with this.

The Standard C regards duplicate definitions as "violation of constraint", but how they are treated depends on compiler systems; some make the first definition valid after issuing an error message and others, like GCC 2/cpp, make the last definition valid without issuing any message by default. To make the last definition valid, the following code should be added immediately before the last definition.

    #undef DEBUG

#### 3.9.1.5. #warning

`i386/isa/if_ze.c, and i386/isa/if_zp.c` have the #warning directive. This is the only Standard violation directive I found in the kernel source. To conform to the Standard C, there is no way but to comment out this line.

mcpp accepts #warning.

#### 3.9.1.6. Variable Argument Macros

`gnu/ext2fs/ext2_fs.h and i386/isa/mcd.c` have the following macro that takes variable number of arguments:

    #define MCD_TRACE(fmt, a...)        \
    {                                   \
        if (mcd_data[unit].debug) {     \
            printf("mcd%d: status=0x%02x: ",    \
                unit, mcd_data[unit].status);   \
            printf(fmt, ## a);          \
        }                               \
    }

    #   define ext2_debug(fmt, a...)  { \
            printf("EXT2-fs DEBUG (%s, %d): %s:",   \
                __FILE__, __LINE__, __FUNCTION__);  \
            printf(fmt, ## a);          \
            }

This is a GCC-specific enhanced specification and cannot be applied to other compiler systems. The above "## a" can be simply written as "a". With ## and in the absence of an argument corresponding to "`a...`" in a macro invocation, the preceding comma is deleted. C99 also provides for variable argument macros, but their notation differs from that of GCC. The above example is written as follows in C99:

    #define MCD_TRACE( ...)             \
    {                                   \
        if (mcd_data[unit].debug) {     \
            printf("mcd%d: status=0x%02x: ",    \
                unit, mcd_data[unit].status);   \
            printf( __VA_ARGS__);       \
        }                               \
    }

    #  define ext2_debug( ...)     {    \
           printf("EXT2-fs DEBUG (%s, %d): %s:",   \
               __FILE__, __LINE__, __FUNCTION__);  \
           printf( __VA_ARGS__);   \
           }

The most annoying difference is that in C99 requires one or more arguments on a macro invocation corresponding to "`...`" while GNUC/cpp requires 0 or more arguments corresponding to "`a...`". To handle this, when there is no argument corresponding to "`...`", mcpp issues a warning, instead of making it an error. Therefore, you can change the above code as follows:

    #define MCD_TRACE(fmt, ...)         \
    {                                   \
        if (mcd_data[unit].debug) {     \
            printf("mcd%d: status=0x%02x: ",    \
                unit, mcd_data[unit].status);   \
            printf(fmt, __VA_ARGS__);   \
        }                               \
    }

    #  define ext2_debug(fmt, ...)     {    \
           printf("EXT2-fs DEBUG (%s, %d): %s:",   \
               __FILE__, __LINE__, __FUNCTION__);  \
           printf(fmt, __VA_ARGS__);   \
           }

This is simpler with one-to-one correspondence. However, this way of writing has a disadvantage that a comma immediately before an empty argument remains, resulting in, for example, printf( fmt, ). In this case, there is no other way but to write a macro definition in accordance with C99 specifications, or avoid using an empty argument in a macro invocation. Harmless tokens, such as NULL or 0, are used to write, for example, `MCD_TRACE(fmt, NULL)`. *1

Note:

*1

GCC 2.95.3 or later also implements variable argument macros based on the C99 syntax. It is recommended to use this syntax. GCC specific one provides the flexibility of allowing for zero number of variable argument, but its notation is bad in that (1) for the "`args...`" parameter, a white space must not be inserted between "`args`" and "`...`", but such a pp-token is not permitted in C/C++, and that (2) it is not desirable that the notation for a token concatenation operator is used for different meaning in a replacement list. It is desirable to allow zero number of variable arguments based on the C99 notation. GCC 3 introduced a notation for variable argument macros that is a mixture of GCC 2's traditional notation and C99 one. For details, refer to 3.9.6.3.

#### 3.9.1.7. Empty Argument in Macro Call

The following macro invocations appear in `nfs/nfs.h, nfs/nfsmount.h, nfs/nfsmode.h, netinet/if_ether.c, netinet/in.c, sys/proc.h, sys/socketvars.h, i386/scsi/aic7xxx.h, i386/include/pmap.h, dev/aic7xxx/scan.l, dev/aic7xxx/aic7xxx_asm.c, kern/vfs_cache.c, pci/wd82371.c, vm/vm_object.h, and vm/device/pager.c`. So do in `/usr/include/nfs/nfs.h`.

    LIST_HEAD(, arg2)
    TAILQ_HEAD(, arg2)
    CIRCLEQ_HEAD(, arg2)
    SLIST_HEAD(, arg2)
    STAILQ_HAED(, arg2)

The first argument is empty. C99 approved empty arguments but C90 regarded them as undefined. Taking it consideration that an argument may happen to be empty during a nested macro invocation, empty arguments should be approved, however, it is neither necessary nor desirable to write an empty argument in source code. Note that for a one-argument macro, there is syntax ambiguity between an empty argument and a lack of argument.

Taking everything into consideration, the following notation is recommended:

    #define EMPTY

    LIST_HEAD(EMPTY, arg2)
    TAILQ_HEAD(EMPTY, arg2)
    CIRCLEQ_HEAD(EMPTY, arg2)
    SLIST_HEAD(EMPTY, arg2)
    STAILQ_HAED(EMPTY, arg2)

Any Standard C conforming preprocessor will accept this notation.

By the way, some of the header files (in the nfs directory) shown above neither have the macro definitions shown above nor #include any other header files. This is because such header files assume that these macro definitions exist in sys/queue.h and that *.c programs will #include sys/queue.h first. These files arise ambiguity.

`kern/kern_mib.c` has the following macro definitions:

    SYSCTL_NODE(, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)

In this case, the first argument cannot be changed to `EMPTY`. Because the corresponding macro definition in the `sys/sysctl.h` is as follows:

    #define SYSCTL_NODE(parent, nbr, name, access, handler, descr)      \
        extern struct linker_set sysctl_##parent##_##name;              \
        SYSCTL_OID(parent, nbr, name, CTLTYPE_NODE|access,              \
            (void*)&sysctl_##parent##_##name, 0, handler, "N", descr);  \
        TEXT_SET(sysctl_##parent##_##name, sysctl__##parent##_##name);

In other words, these arguments are not macro-expanded. The arguments of the `SYSCTL_OID` macro shown above, including the first one, are not macro expanded. In this case, there is no way but to leave the empty argument as it is. *1

Note:

*1 C99 approves empty arguments as legitimate. Taking macros, such as `SYSCTL_NODE`() and `SYSCTL_OID`(), into consideration, the `EMPTY` macro is not almighty and using empty arguments has some reason. In addition, even if `EMPTY` is used, a nested macro invocation may cause empty arguments. However, for source readability, using `EMPTY` is recommended whenever possible.

#### 3.9.1.8. Object-Like Macros Replaced with Function-like Macro Name

`i386/include/endian.h`, as well as `/usr/include/machine/endian.h`, has the following macro definitions. (There are four same kinds of definitions.)

    #define __byte_swap_long(x) (replacement text)
    #define NTOHL(x)            (x) = ntohl ((u_long)x)
    #define ntohl               __byte_swap_long

The problem is the `ntohl` definition. Although `ntohl` is an object-like macro, it is expanded to a function-like macro name, then rescanned with subsequent text, and is expanded as if it were a function-like macro. This way of macro-expansion has been regarded as an implicit specification since K&R 1st, and the Standard C somehow approved it as legitimate. However, as I discuss in other documents, it is this specification that makes macro-expansion unnecessarily complicated and brings confusion to Standard documents. This is a bug specification. *1

This `ntohl` is actually a function-like macro, written as an object-like macro omitting the parameter list. You had better define this like a function-like macro that it is:

    #define ntohl(x)    __byte_swap_long(x)

This causes no problem.

`i386/isa/sound/os.h` has the same kind of macro definitions:

    #define INB         inb
    #define INW         inb

This should be written as follows:

    #define INB(x)      inb(x)
    #define INW(x)      inb(x)

Note:

*1 ISO 9899:1990 Corrigendum 1:1994 regarded the notation as undefined. C99 replaced this article with other. However, Standard documents are still confusing about this. For details, see cpp-test.html#2.7.6.

#### 3.9.1.9. Preprocessing .S File

Some kernel sources are contained in several ".S" files, that is, they are written in assembler. These sources contain #include's or #ifdef's, which require preprocessing. To preprocess them, in FreeBSD 2.2.2-R, 'cc' is called with the '-x assembler-with-cpp' option, and 'cc' calls '/usr/libexec/cpp' with the '-lang-asm' option and then calls 'as'.

Of course, this ways of using .S files is non-conforming. This assembler source code must not contain a token that happens to have the same name with a macro. White spaces between tokens and at the beginning of a line must be retained during preprocessing. In addition, if the first token at the beginning of a line is a # indicating an assembler comment, special processing is required on the preprocessor side. This not only considerably limits available preprocessors but also increases the possibility of unknowingly introducing bugs. So, using .S files in this way is not recommended. *1

To preprocess source code for use with several types of machines, the code should be written in the following manner and be saved in not ".S" but ".c" file. 4.4BSD-Lite actually adopts this way of coding.

    asm(
        "  asm code0\n"
    #ifdef Machine_A
        "  asm code1\n"
    #else
        "  asm code2\n"
    #endif
        "  ...\n"
    );

Note:

*1 In FreeBSD 2.0-R, these kernel sources are contained not in *.S but in *.s file. The Makefile is so defined as to call 'cpp', instead of 'cc', to process them. Then the 'cc' calls 'as'. When the 'cpp' is called, '/usr/bin/cpp' is invoked. '/usr/bin/cpp' is a shell-script that calls '/usr/libexec/cpp -traditional'. This method was more convenient in that it provides a way to change preprocessors to be used by modifying the script.

### 3.9.2. Preprocessing FreeBSD 2/libc Source

I compiled all the source files in `/usr/src/lib/libc` of FreeBSD 2.2.2R. There was no problem, probably because most of them comes from 4.4BSD-Lite without much modification. It is quite rare and surprising that a huge amount of source files in excellent quality is gathered together.

Only at one place, I found the following coding in gen/getgrent.c. Of course, ";" at the end of line is surplus.

    #endif;

### 3.9.3. Problems Concerning GCC 2/cpp

As seen so far, writing a Standard-conforming source code with better portability in a more secure manner neither requires much effort nor provides any demerits. In spite of it, why does source code less conforming to Standards still exist at all?

When comparing the FreeBSD 2.0-R kernel sources with those of 2.2.2-R, non-conforming ones do not decrease in number. The problem is that newer sources are not necessarily more conforming to the Standards. There are few non-conforming sources in 4.4BSD-Lite. This is probably because the 4.4BSD sources were rewritten to become conforming to the Standard C and POSIX. However, during the process of implementing these sources to FreeBSD, the old writing style revived in some sources. For example, although the ntohl shown above is written as `ntohl(x)` in 4.4BSD-Lite, it is written as `ntohl` in FreeBSD. Why did the notation once put away revive?

I blame GCC/cpp for this revival, which passes these non-conforming sources without issuing a diagnostic. If -pedantic had been a default behavior, the old style source would have never revived. If -pedantic-errors had been a default behavior, although, GCC/cpp would not have been put into practical use because too many sources failed to be compiled. The gcc's man page describes the -pedantic option as: "There is no reason to use this option except for satisfying pedants." Now that eight years have already passed since Standard C was established, it is a high time that GCC/cpp should set -pedantic as default, not go so far as to set -pedantic-errors. *1

In FreeBSD 2.0-R, nested comments were sometimes found, but in 2.2.2-R, they disappeared. This is because GCC/cpp no longer allowed them. This has nothing to do with -pedantic, but I want to say how influential preprocessor's source checking is.

Note:

*1 I wrote 3.9.3 subsection in 1998. After that, gcc's man page or info deleted this expression, however, the specification remains almost the same.

### 3.9.4. Preprocessing Linux/glibc 2.1

I compiled glibc (GNU LIBC) 2.1.3 sources (February, 2000). Different from those of FreeBSD libc, I found many problems. Some sources are written based on GCC/cpp's undocumented specifications, in which case it took me a lot of time to identify them.

#### 3.9.4.1. Multi-Line String Literal

`sysdeps/i386/dl-machine.h and stdlib/longlong.h` have many multi-line string literals as shown below:

    #define MACRO asm("
        instr 0
        instr 1
        instr 2
    ")

Some string literals are very long. `compile/csu/version-info.h` created by make also has a multi-line string literal. Of course, it is non-conforming, but GCC treats it as a string literal with embedded <newline>.

The -lang-asm (-x assembler-with-cpp, -a) option allows mcpp to convert a multi-line string literal into the following code:

    #define MACRO asm("\n  instr 0\n  instr 1\n  instr 2\n")

However, this option cannot work properly for a string literal with a directive inserted in the middle as shown in 3.9.1.1, in which case there is no way but to rewrite the source.

#### 3.9.4.2. #include_next, #warning

#include_next appears in the following files:

`catgets/config.h, db2/config.h, include/fpu_control.h, include/limits.h, include/bits/ipc.h, include/sys/sysinfo.h, locale/programs/config.h, and sysdeps/unix/sysv/linux/a.out.h`

`sysvipc/sys/ipc.h` has #warning.

Although these directives are not approved by the Standard C, #include_next, in particular, becomes indispensable for glibc 2. So, mcpp for GCC implements #include_next and #warning.

The problems concerning #include_next is that it is not only a standard violation but also that what headers are actually included depends on the setting of include directories and a search order, which are changed by users via environment variables.

When glibc is installed, some files in glibc's include directory are copied to the /usr/include directory. These files are used as system header files. That these header files contain #include_next means system headers become patchy. It seems to be time to reorganize them.

#### 3.9.4.3. Variable Argument Macros

The following files contain definitions of macros with variable number of arguments based on the GCC specification, as well as macro invocations:

`elf/dl-lookup.c, elf/dl-version.c, elf/ldsodefs.h, glibc-compat/nss_db/db-XXX.c, glibc-compat/nss_files/files-XXX.c, linuxthreads/internals.h, locale/loadlocale.c, locale/programs/linereader.h, locale/programs/locale.c, nss/nss_db/db-XXX.c, nss/nss_files/files-XXX.c, sysdeps/unix/sysdep.h, sysdeps/unix/sysv/linux/i386/sysdep.h, and sysdeps/i386/fpu/bits/mathinline.h`

This is a deviation from the C99 Standard. You must rewrite the source code before you can use mcpp. *1

Note:

*1 This is a spec since GCC2. There is another spec of GCC3 which is a compromise of GCC2 and C99 specs. See 3.9.6.3.

#### 3.9.4.4. Empty Argument During Macro Calls

The following files have macro invocations with empty arguments:

`catgets/catgetsinfo.h, elf/dl-open.c, grp/fgetgrent_r.c, libio/clearerr_u.c, libio/rewind.c, libio/clearerr.c, libio/iosetbuffer.c, locale/programs/ld-ctype.c, locale/setlocale.c, login/getutent_r.c, malloc/thread-m.h, math/bits/mathcalls.h, misc/efgcvt_r.c, nss/nss_files/files-rpc.c, nss/nss_files/files-network.c, nss/nss_files/files-hosts.c, nss/nss_files/files-proto.c, pwd/fgetpwent_r.c, shadow/sgetspent_r.c, sysdeps/unix/sysv/linux/bits/sigset.h, sysdeps/unix/dirstream.h`

`math/bits/mathcalls.h`, in particular, contains as much as 79 empty arguments. This header file is installed in `/usr/include/bits/mathcalls.h` and is #included by `/usr/include/math.h`. Even with an `EMPTY` macro, nested macro invocations generate a lot of empty arguments. Are there any other ways to write macros more clearly?

#### 3.9.4.5. Object-Like Macros Replaced with Function-like Macro Name

The following files contain object-like macro definitions replaced with function-like macro names:

`argp/argp-fmtstream.h, ctype/ctype.h, elf/sprof.c, elf/dl-runtime.c, elf/do-rel.h, elf/do-lookup.h, elf/dl-addr.c, io/ftw.c, io/ftw64.c, io/sys/stat.h, locale/programs/ld-ctype.c, malloc/mcheck.c, math/test-*.c, nss/nss_files/files-*.c, posix/regex.c, posix/getopt.c, stdlib/gmp-impl.h, string/bits/string2.h, string/strcoll.c, sysdeps/i386/i486/bits/string.h, sysdeps/generic/_G_config.h, sysdeps/unix/sysv/linux/_G_config.h`

Of these, some function-like macros, like the ones in math/test-*.c , are first replaced with an object-like macro name and then further replaced with a function-like macro name. Why did these macros have to be written in this way?

#### 3.9.4.6. Macros Expanded to 'defined'

`sysdeps/generic/_G_config.h, sysdeps/unix/sysv/linux/_G_config.h, and malloc/malloc.c` contain the following macro definition expanded to the "defined" pp-token.

    #define HAVE_MREMAP defined(__linux__) && !defined(__arm__)

The intention of this macro definition is that with the following directive,

    #if HAVE_MREMAP

the above line is expected to be expanded as follows:

    #if defined(__linux__) && !defined(__arm__)

However, the behavior is undefined in Standard C when a #if line has a "defined" pp-token in a macro expansion result. Apart from it, this macro definition is strange in the first place.

The `HAVE_MREMAP` macro is first replaced with the following,

    defined(__linux__) && !defined(__arm__)             (1)

and then the identifiers `defined, __linux__` and `__arm__` are rescanned for more macro replacement. If any of them is a macro, it is expanded. In this case, `defined` cannot be defined as a macro (Otherwise, it causes another undefined result), and if `__linux__` is defined as 1 and `__arm__` is not defined, this macro is finally expanded as follows:

    defined(1) && !defined(__arm__)

defined(1), of course, is a syntax error of a #if expression.

However, GCC/cpp stops macro expansion at (1) and regards it as the final macro expansion result of the #if line. Since this is "undefined" anyhow, this GNU specification cannot be described as wrong, but it lacks of consistency in that how to expand a macro differs between macros in a #if line and in other lines. At least, it lacks of portability. *1

The above code should be written as follows:

    #if defined(__linux__) && !defined(__arm__)
    #define HAVE_MREMAP 1
    #endif

I hope this kind of confusing code be eliminated as early as possible. *2

Note:

*1 GCC 2/cpp internally treats `defined` in a #if line as a special macro. For this reason, when GCC/cpp rescans the following sequence of tokens for macro expansion, it evaluates it as a #if expression, as a result of special handling of `defined` pseudo-macro, instead of expanding the original macro. In other words, distinction between macro expansion and #if expression evaluation is ambiguous.

> `defined(__linux__) && !defined(__arm__)`

This problem relates to GCC/cpp' own program structure. GCC 2/cpp has a de facto main routine rescan(), which is a macro rescanning routine. This routine reads and processes source file from the beginning to the end, during the course of which, it calls a preprocessing directive processing routine. Although implementing everything using macros is a traditional program structure of a macro processor, this structure can be thought to cause mixture of macro expansion and other processing.

*2 In glibc 2.4, this macro was corrected. Nevertheless, many other macros of the same sort were newly defined.

#### 3.9.4.7. Preprocessing .S File

The files named *.S contain assembler source code requiring preprocessing. Some of these files have preprocessing directives, such as #include, #define, and #if. In addition, the file named `compile/csu/crti.S` generated by Make contains the following lines:

    #APP

or

    #NO_APP

From a syntax point of view, preprocessors cannot tell whether these lines are invalid preprocessing directives or valid assembler comments. GCC seems to leave these lines as they are during preprocessing and treat it as assembler comments.

Concatenation of pp-tokens using the ## operator sometimes generates an invalid pp-token. GCC/cpp outputs these pp-tokens without issuing a diagnostic.

For compatibility with GCC, I reluctantly decided that, with the -lang-asm (-x assembler-with-cpp, -a) option, mcpp does not treat these non-conforming directives and invalid pp-tokens generated by ## as error, and outputs them as they are and issues a warning.

Essentially, these sources should be processed with an assembler macro processor. GNU seems to provide a macro processor called gasp, but it seems to be scarcely used for some reason.

#### 3.9.4.8. Problems of rpcgen and -dM Option

When invoked with the -dM option, GCC outputs only macro definitions, which is used by stdlib/isomac.c in 'make check' routine.

The problem of the isomac.c is that it accepts only GCC/cpp's macro definition file format and regards a comment or a blank line as an error.

Glibc make sometimes uses a program called rpcgen. The problem of rpcgen is that it accepts only GCC/cpp's output format of preprocessor line number information as follows:

    #123 "filename"

Rpcgen does accept neither:

    #line 123

nor

    #line 123 "filename"

Rpcgen regards them as error.

I reluctantly decided that GCC-specific-mcpp uses the GCC format by default. Rpcgen's specification is poor in that it is based on a particular compiler system's format and cannot accept the standard one.

#### 3.9.4.9. -include, -isystem and -I- Options

Glibc 2.1 'makefile' often uses the -include option and sometimes uses -isystem and -I- options. The former can be substituted with #include at the beginning of source code. The latter two are less necessary; these are only necessary to update system headers.

Only GCC-specific-build of mcpp implements these two options, but I would like these less necessary options to be made obsolete. *1

Note:

*1 GCC/cpp provides several more options that specify include directories and their search orders, such as -iprefix, -iwithprefix, and -idirafter. It also provides the -remap option that specifies mapping between long-file-names and MS-DOS 8+3 format filenames. On CygWIN systems, specs files contain these options, but it is not necessary to use these options because include directories can be specified with environment variables and because such mapping is no longer necessary on CygWIN.

#### 3.9.4.10. Undocumented Predefined Macros

This is not a problem of glibc, but of GCC. The following macros are GCC/cpp predefined macros although their names do not appear in documentation.

    __VERSION__,  __SIZE_TYPE__,  __PTRDIFF_TYPE__, __WCHAR_TYPE__

On Vine Linux 2.1 (egcs-1.1.2) systems, `__VERSION__` is set to "egcs-2.91.66 19990314/Linux (egcs-1.1.2 release)". On many systems, including Linux/i386, the values of other three macros have types unsigned int, int, and long int, respectively. However, on FreeBSD and CygWIN systems, their types are slightly different from them (I do not know why). Why does those predefines macros remain undocumented?

#### 3.9.4.11. Undocumented Environment Variables

The most strange thing is the undocumented environment variable named `SUNPRO_DEPENDENCIES`. `sysdeps/unix/sysv/linux/Makefile` contains the following script:

    SUNPRO_DEPENDENCIES='$ (@:.h=.d)-t $@' \
    $ (CC) -E -x c $ (sysinclude) $< -D_LIBC -dM | \
    ... \
    etc.

The intent of this script is to specify a file name with the environment variable `SUNPRO_DEPENDENCIES`, and to have cpp output macro definitions in source code and dependency description lines between source files to that file.

I had no other way but to read the GCC/cpp source code (egcs-1.1.2/gcc/cccp.c) to know how this environment variable works.

In addition, there is another environment variable, `DEPENDENCIES_OUTPUT`, which has a similar function. The difference between the two is that `SUNPRO_DEPENDENCIES` also outputs dependency description lines among system headers, but `DEPENDENCIES_OUTPUT` does not.

Only GCC-specific-build of mcpp enables these two environment variables, but I would like these undocumented specifications to be made obsolete as early as possible.

#### 3.9.4.12. Other Problems

Linux (i386)/GCC 2 appends the -Asystem(unix), -Acpu(i386) or -Amachine(i386) to cpp invocation options by using specs file. As long as the glibc 2.1.3 for Linux/x86 is concerned, there seems to be no source code that utilizes this functionality.

It is a big problem that glibc's system headers have become patchy and very complicated. A small difference in settings may result in a big difference in preprocessing results.

On the other hand, Glibc 2.1.3 did not contain #else junk, #endif junk, or duplicate macro definitions that were found in FreeBSD 2.2.2/kernel sources. In some aspects, Glibc 2.1 source is better organized than FreeBSD 2/kernel source.

However, as a whole, there were not a few sources that are based on GCC-specific specifications in glibc 2.1, which impairs portability to other compiler systems although such sources form only a small portion of several thousand source files. Dependence on GCC local specifications is not desirable for program readability and maintainability. I hope that GCC V.3 will make obsolete these local specifications and that all the source code based on them will be completely rewritten.

### 3.9.5. To Use mcpp with GCC 2

You must modify some source code as follows before you can use mcpp to compile glibc 2.1 sources: *1

1. Macro definitions with variable number of arguments: Modify the 14 files in 3.9.4.3 as shown in 3.9.1.6. Of course, you had better save the original files.
2. Macros contained in the three files shown in 3.9.4.6 that has `defined` in its replacement list: `/usr/include/_G_config.h` is a file generated when `sysdeps/unix/sysv/linux/_G_config.h` is installed and has the same contents with this. You had better modify `/usr/include/_G_config.h.`

In addition to the options specified in Makefile or specs file, you must specify the -lang-asm (-xassembler-with-cpp) option to process *.S files containing multi-line string literals or assembler comments before you can invoke mcpp. Usually, you can leave this option specified when preprocessing other files.

When you want to use GCC/cpp or mcpp, or change the default options, you had better perform the following steps:

1. Become a super-user to move to the directory where cpp resides (here assuming `/usr/lib/gcc-lib/i386-redhat-linux/egcs-2.91.66`). Let me assume that this directory has GCC/cpp installed under the name of cpp and mcpp as mcpp.
2. Create a file called mcpp.sh with the following contents. *2

       #!/bin/sh
       /usr/lib/gcc-lib/i386-redhat-linux/egcs-2.91.66/mcpp -Q -lang-asm "$@"

   The -Q options are optional, however, I recommend that you should use -Q to record a large amount of diagnostic messages.
3. Enter the following commands:

       chmod a+x mcpp.sh
       mv cpp cpp_gnuc
       ln -sf mcpp.sh cpp

   These commands execute mcpp.sh linked to cpp when gcc calls cpp, and mcpp.sh calls mcpp using the above options before the ones specified by gcc.
4. To change default options, modify mcpp.sh or call mcpp directly. To use GCC/cpp do:

       ln -sf cpp_gnuc cpp

Note:

*1 mcpp V.2.7 implemented these specs. Hence, editing of sources are not necessarily required.

*2 If you use 'configure' and 'make' to compile GCC-specific-build of mcpp, the 'make install' command will set the script appropriately. The only thing left for you here is to add '-Q -lang-asm' options to the script.

#### 3.9.5.1. To Sort mcpp's Warnings

Another problem of using mcpp is that it issues a huge amount of warning messages. You can redirect them to a file using the -Q option, but when you preprocess a large amount of source code, such as glibc, total of several hundred MB or more of 'mcpp.err' are created, so it is impossible for you to look through the whole files.

Taking a close look at mcpp.err, you will find same warnings being issued repeatedly. This is because the same *.h files are #included by many source programs. To make the files more readable, perform the following procedure:

1. To find error messages, enter the following command:

       grep 'fatal:' `find . -name mcpp.err`
       grep 'error:' `find . -name mcpp.err`

2. To sort warning messages, enter the following command:

       grep 'warning:' `find . -name mcpp.err` | sort -k3 -u > mcpp-warnings-sorted

3. To find all the source lines causing a 'warning:', enter the following command:

       grep 'warning:' `find . -name mcpp.err` | sort -k3 | uniq > mcpp-warnings-all

4. To find a particular type of 'warning:'s, enter the following command, for example:

       grep 'warning: Replacement' `find . -name mcpp.err` | sort -k3 | uniq | less

   After you get an overall idea of what source lines are causing what kinds of errors or warnings, you can see a particular mcpp.err by "less" and then, if necessary, see the source file in question.
   In addition, you can sandwich the source code in question with '#pragma MCPP debug expand' and '#pragma MCPP end_debug' and preprocess it again to see the output, in which case I recommend you to invoke mcpp in the following manner so that preprocessing results and diagnostic messages are output to the same file:

       mcpp <-opts> in-file.c > in-file.i 2>&1

   When you use "make", you must temporarily change the above shell-script.

### 3.9.6. Preprocessing GCC 3.2 Source

I first compiled GCC 3.2 sources on Linux and FreeBSD, then I used the generated gcc to compile mcpp and then I recompiled GCC 3.2 sources using mcpp for preprocessing.

New GCC compilers are bootstrapped during various phases of make; gcc and cc1, etc generated in an earlier phase are used to recompile themselves, and those generated compiler drivers and compiler-propers are used again to recompile themselves, and so on. During the bootstrap, gcc exists under the name of xgcc.

Other than cc1 and cc1plus, GCC 2 has a separate preprocessor called cpp. In GCC 3, cpp was absorbed into cc1 and cc1plus. However, there still exists a separate preprocessor cpp0. To have cpp0 preprocess, the -no-integrated-cpp option must be specified when you invoke gcc or g++. Therefore, to have mcpp preprocess, you must use a shell-script that have gcc (xgcc) or g++ invoke mcpp first then invoke cc1 or cc1plus. *1

In the GCC compiler system, the settings of system headers and their search order are becoming very complex. So, a small difference in settings may result in a difference in preprocessing results. Even successful compilation was often difficult to attain. In addition, compilation and tests require a lot of other software. Older versions of such software may cause failure in compilation or tests. Actually, compilation sometimes failed due to some hardware problems on my machine.

Actually, I failed to compile GCC 3.2 source under FreeBSD 4.4R. I had to upgrade FreeBSD to 4.7R and changed software packages to those for FreeBSD 4.7R before I was able to succeed in compilation. *2

I used VineLinux 2.5 on two PCs. Although compilation of GCC 3.2 sources using GCC 2.95.3 was successful on one PC (K6/200MHz), recompilation of GCC 3.2 sources using the generated GCC 3.2/cc1 failed, and caused many segmentation faults. Then I changed CPU from K6 to AthlonXP. This time, recompilation was successful; no segmentation faults occurred. Hardware may have caused the problem.

When I compiled GCC 3.2 sources using GCC 2.95.4 under FreeBSD on K6, "make -k check" of the generated gcc was almost successful. When I recompiled GCC 3.2 itself using the generated GCC 3.2, in "make -k check" of g++ and libstdc++-v3, about 20 percent of testsuite was unsuccessful. However, when using AthlonXP, instead of K6, everything went OK. Hardware may have caused the problem.

On both VineLinux PCs, when I recompiled GCC 3.2 sources using GCC 3.2 itself and mcpp, "make -k check" of the generated gcc was successful. However, in "make -k check" of g++ and libstdc++-v3, 20 percent of testsuite failed. *3, *4, *5

In anyway, the cause of this testsuite failure seems to lie not in the generated compilers themselves, such as gcc, g++, cc1 and cc1plus, but in the header files or some other settings.

mcpp cannot be described as completely compatible with GCC/cpp, but is highly compatible. So, mcpp and GCC/cpp can be used interchangeably.

GCC 3.2 sources were compiled in the following environment:

> OS | make | library | CPU
> VineLinux 2.5 | GNU make | glibc 2.2.4 | Celeron/1060MHz
> VineLinux 2.5 | GNU make | glibc 2.2.4 | K6/200MHz, AthlonXP/2.0GHz
> FreeBSD 4.7R | UCB make | libc.so.4 | K6/200MHz, AthlonXP/2.0GHz

Only C and C++ were compiled.

Note:

*1 I had to do this for each bootstrap stage. Since makefile is too large and too complex to change, I employed an inelegant method; I kept on sitting in front of PC screen during the entire process of bootstrap. At each end of the stages, I entered ^C and replaced xgcc and others with shell-scripts.

*2 Due to dependency between packages, the system falls into confusion unless appropriate versions are installed. Actually, for this reason, my FreeBSD temporarily failed to invoke kterm.

*3 "make -k check" cannot be used with mcpp because diagnostics of mcpp are different from those of GCC.

*4 "make -k check" seems to require an English environment, so the LANG environment variable should be set to C.

*5 All the testsuite failures were caused by inability of the pthread_* functions, such as pthread_getspecific and pthread_setspecific, to be linked in the library `i686-pc-linux-gnu/libstdc++-v3/src/.libs/libstdc++.so.5.0.0`. When a correctly generated library was installed, "make -k check" was successful. On FreeBSD, this problem never happened. This is probably because of small differences in settings.

#### 3.9.6.1. Multi-Line String Literal

This very old way of coding was no longer found in GCC 3.2 sources. Multi-line string literals were made obsolete as late as at GCC 3.2. GCC 3.2 processes a source with a multi-line string literal as you expect, but issues a warning.

#### 3.9.6.2. #include_next and #warning

limits.h and syslimits.h in `build/gcc/include` generated during the course of make have #include_next. When GCC 3.2 is installed, these header files are copied to limits.h and syslimits.h in `lib/gcc-lib/i686-pc-linux-gnu/3.2/include`.

GCC 3.2 sources does not have #warnings.

#### 3.9.6.3. Variable Argument Macros

GCC 3.2 sources have some variable argument macros, but most of them are found in testsuite and they are nothing but test samples. Although GCC 3.2 still supports variable argument macros in GCC 2 notation, the ones using `__VA_ARGS__` (in C99 notation) are more frequently found in GCC 3.2 sources.

In GCC 3, variable argument macros in a mixed notation of GCC 2 and C99 are found: *1

    #define eprintf( fmt, ...)   fprintf( stderr, fmt, ##__VA_ARGS__)

This definition corresponds to the following one of GCC 2 spec.

    #define eprintf( fmt, args...)   fprintf( stderr, fmt, ##args)

According to the GCC specifications, in the absence of an argument corresponding to "`...`", the comma immediately before "`##`" is deleted. So, this is expanded as follows:

    eprintf( "success!\n")  ==>  fprintf( stderr, "success!\n")

As far as this example is concerned, this specification seems to be convenient, but is not desirable in that (1) a comma in a replacement list of a macro definition is not always used to delimit parameters, (2) it allows a token concatenation operator (##) to have other functionality, (3) it makes rules more complex by allowing exceptions. *2, *3, *4

Note:

*1 This manual calls the variadic macro of specification since GCC 2 as GCC2 spec, and that of created in GCC 3 as GCC3 spec.

*2 While on GCC 2.* `'args...'` in definition of GCC2 spec variadic macro should not be separated as `'args ...'`, on GCC 3 the intervening spaces are allowed.

*3 When -ansi option (or any of -std=c* or -std=iso* option) is specified, GCC, however, does not remove the comma even if the variable argument is absent. Nevertheless, the '##' disappears silently.

*4 mcpp V.2.6.3 implemented variadic macro of GCC3 spec for STD mode on GCC-specific-build only. V.2.7 even implemented GCC2 spec one.

#### 3.9.6.4. Empty Arguments in Macro Invocation

Apart from #include-ed system headers, such as `/usr/include/bits/mathcalls.h and /usr/include/bits/sigset.h`, empty arguments in a macro invocation are found only in gcc/libgcc2.h of GCC 3.2 sources themselves. *1

Note:

*1 These two header files are copied into the system header directory when glibc is installed. They do not exist on FreeBSD because glibc is not used.

#### 3.9.6.5. Object-Like Macros Replaced with Function-Like Macros

`gcc/fixinc/gnu-regex.c and libiberty/regex.c` have object-like macros that are replaced with function-like macro name. `/usr/lib/bison.simple`, a #included file, also has such macros. These macros are all relevant to alloca. For example, `libiberty/regex.c` has the following macro definitions.

    #define REGEX_ALLOCATE  alloca
    #define alloca( size)   __builtin_alloca( size)

This should be written as follows:

    #define REGEX_ALLOCATE( size)   alloca( size)

Why did they omit (size)?

In addition, regex.c also has another alloca, which is defined as follows:

    #define alloca  __builtin_alloc

Their writing style is inconsistent.

Furthermore, regex.c has a #include "regex.c" line, which is including itself. regex.c is a strange and unnecessarily complicated source.

#### 3.9.6.6. Macros Expanded to 'defined'

GCC 3.2 sources do not have macros expanded to 'defined'. According to GCC 3.2 documents, this type of macro is preprocessed in the same way as GCC 2/cpp, but GCC 3.2 issues a warning to indicate "may not portable". However, GCC 3.2 does not issue a warning to an example shown in 3.9.4.6.

#### 3.9.6.7. Preprocessing of .S Files

cpp.info of GCC 3 says:

> Wherever possible, you should use a preprocessor geared to the language you are writing in. Modern versions of the GNU assembler have macro facilities.

However, the `gcc/config` directory has several *.S files.

#### 3.9.6.8. rpcgen and -dM Option

Make of GCC 3.2 uses neither rpcgen nor -dM option. However, specifications of rpcgen and the -dM option do not seem to change from the previous versions.

#### 3.9.6.9. -include, -isystem and -I- Options

These options are frequently used in make of GCC 3.2. Sometimes, the -isystem option is used to specify several system include directories at one time. Is it inevitable to use the option during software compilation that updates system headers themselves? I think they had better use an environment variable to specify all the system include directories.

On the other hand, GCC 3/cpp documents discourage to use the -iwithprefix and -iwithprefixbefore options. GCC provides many options to specify include directories. Does GCC 3.2 move toward reorganization or reduction in number of them? *1

Note:

*1 GCC 3.2 Makefile uses the -iprefix option in a stand alone manner (without using -iwithprefix or -iwithprefixbefore), although the -iprefix option makes sense only when used with one of these two options following it.

#### 3.9.6.10. Undocumented Predefined Macros

GCC 2 did not document predefined macros, such as `__VERSION__`, `__SIZE_TYPE__`, `__PTRDIFF_TYPE__` and `__WCHAR_TYPE__`. Even with the -dM option, their existence was unknown. GCC 3 not only documents them but also enhances -dM to show their definitions.

#### 3.9.6.11. Undocumented Environment Variables

GCC 3 documents the `SUNPRO_DEPENDENCIES` environment variable GCC 2 did not. (I do not know why this environment variable is needed.)

#### 3.9.6.12. Other Problems

GCC 3 implements following #pragmas:

    #pragma GCC poison
    #pragma GCC dependency
    #pragma GCC system_header

Of these, GCC 3.2 sources use poison and system_header. mcpp does not support these #pragmas because I do not think them necessary. (I omit explanation of their specifications.) *1

GCC 3 deprecates assertion directives, such as #assert, although gcc, by default, specifies the -A option.

In GCC 2, the -traditional option is implemented in one and the same cpp, result in a strange mixture of very old specifications and C99 ones. In GCC 3, its preprocessor was divided into two: non-traditional cpp0 and tradcpp0. The -traditional option is valid only for gcc. cpp0 does not provides it. gcc -traditional invokes tradcpp0 for preprocessing.

tradcpp0 is getting closer to a true traditional preprocessor before C90. They say that they no longer maintain tradcpp0 except for serious bugs.

The strange specifications of GCC 2/cpp seem to have been significantly revised.

Note:

*1 mcpp V.2.7 onward supports `#pragma GCC system_header` on GCC-specific-build.

### 3.9.7. To Use mcpp with GCC 3 or 4

As seen above, as far as preprocessing is concerned, GCC 3.2 sources have been much improved than glibc 2.1.3 sources in that the traditional way of writing has been almost eliminated and that meaningless options are no longer used.

GCC 3.2/cpp0 itself is also much superior to GCC 2/cpp in that it regards traditional specifications as obsolete and articulates the token-based principle. Undocumented specifications have been significantly reduced. Although these improvements are not still sufficient, GCC is certainly moving toward the right direction.

However, GNU / Linux system headers become so complex that it is difficult to grasp their entire structure, which may one of the biggest causes of problems in the GNU / Linux system.

Another pitiful fact is that the preprocessor is absorbed into the compiler-proper. Therefore, to use mcpp, the -no-integrated-cpp option must be specified when invoking gcc or g++. If you compile a large amount of source files with complicated or many makefiles, or if some program automatically invoke gcc, you should create a shell-script that invokes gcc or g++ with the -no-integrated-cpp option automatically specified.

Let me take an example of this. Place the following shell-scripts in the directory where gcc and g++ reside (on my Linux, `/usr/local/gcc-3.2/bin`), under the names of gcc.sh and g++.sh, respectively.

    #!/bin/sh
    /usr/local/gcc-3.2/bin/gcc_proper -no-integrated-cpp "$@"

    #!/bin/sh
    /usr/local/gcc-3.2/bin/g++_proper -no-integrated-cpp "$@"

Move to this directory and enter the following commands:

    chmod a+x gcc.sh g++.sh
    mv gcc gcc_proper
    mv g++ g++_proper
    ln -sf gcc.sh gcc
    ln -sf g++.sh g++

In the directory where cpp is located (on my Linux, `/usr/local/gcc-3.2/lib/gcc-lib/i686-pc-linux-gnu/3.2`), create a script that executes mcpp when cpp0 is invoked, as you did for GCC 2 (See 3.9.5). By doing this, gcc or g++ first invokes mcpp and then invokes cc1 or cc1plus with the -fpreprocessed option appended. -fpreprocessed indicates the source has been preprocessed already. *1

Note that when a GCC version other than the system standard one is installed, additional include directory settings may be required. mcpp embeds these settings when mcpp itself is compiled, thus eliminating the need to set them with environment variables.

If possible, I want to replace the cpplib source, the preprocessing part of cc1 or cc1plus, with mcpp. The source files that define the internal interface between cpplib and ccl or cc1plus, as well as the external interface between cpplib and user programs that use it, amount to as much as 46KB. It is impossible to replace. Why is the interfaces so complex? It is a pity.

Note:

*1 mcpp gets all the necessary informations by 'configure' and sets these scripts by 'make install'.

#### 3.9.7.1. To Use mcpp with GCC 3.3 and 3.4-4.1

Although GCC 3.2 seemed to go in the direction of better portability, GCC turned its direction to a different goal on 3.3 and 3.4. V.3.3 and 3.4 differ from 3.2 in the following points.

1. Independent preprocessor cpp0 was abolished. The execution option '-no-integrated-cpp' changed its meaning, gcc invokes cc1 (cc1plus) instead of cpp0 as a preprocessor even if this option is specified, and gcc passes to the preprocessor some options which are irrelevant to preprocessing. (What a dirty implementation!)
2. Many (several dozen of) macros are predefined. The relationship between the system headers and GCC became more complicated.
3. Tradcpp was also abolished and absorbed to an execution option of cc1. Some old specifications, which were obsoleted or deprecated in V.3.2, were restored.

GCC / cc1 is becoming one huge and complex compiler absorbing preprocessor and some system header's contents. I doubt whether this is a better way of compiler construction, especially of developing open source one.

As regards mcpp, it is a nuisance that gcc arbitrarily hands to preprocessor some irrelevant options. Since it is risky to ignore all the options unrecognized by mcpp, I didn't adopt this. Although mcpp ignores the wrong options such as -c or -m* which are frequently handed from gcc, it will get an error if other unexpected options are passed on.

In order to avoid conflicts with those wrong options, mcpp V.2.5 changed some options, -c to -@compat, -m to -e, and some others.

To use mcpp with GCC 3.2 or former, it is necessary only to replace invoking of cpp0 by mcpp. To use mcpp with GCC 3.3 or later, it is necessary to divide invoking of cc1 to mcpp and cc1. src/set_mcpp.sh will write shell-scripts for this purpose in the GCC libexec directory on mcpp installation. The 'make install' command will also get GCC predefined macros using -dM option and set those for mcpp. *1, *2, *3

In addition, GCC 3.4 changed processing of multi-byte characters. Its document says as: *4

1. It converts every encodings of multi-byte characters to UTF-8 at the first phase of preprocessing.
2. It uses libiconv functions for the conversion, therefore it can handle all the encodings iconv can do.
3. It has '-finput-charset=<encoding>' option to specify the source file's encoding. (In other words, the encoding is not converted without this option.)
4. It has also '-fexec-charset=<encoding>' option to specify the output encoding which defaults to UTF-8. *5

There is a trend to identify "internationalization" with "unicodization", especially in the Western people who do not use multi-byte characters. It seems that this trend has reached to GCC.

What is worse, GCC 3.4 or later does not implement their specification sufficiently. In actual, it behaves as:

1. As for EUC-JP, GB2312, KSC-5601 and Big5, it converts these encodings to UTF-8 correctly with -finput-charset option, and it passes them as they are without this option. *6
2. The -fexec-charset option has no effect on V.3.4 nor V.4.0. On V.4.1-4.3, the option has effect, and works correctly.
3. With ISO2022-JP, GCC cannot preprocess on V.3.4 or 4.0, whereas on V.4.1-4.3 it can preprocess the encoding.
4. As for shift-JIS, all the versions confuse in preprocessing when -finput-charset is specified.

mcpp takes -e <encoding> option to specify an encoding, and the GCC-specific-build inserts <backslash> to the byte in multi-byte character which has the same value with <backslash>, '"' or '\'', when the encoding is one of BIG-5, shift-JIS or ISO2022-JP, in order to complement GCC's inability. However, it does not convert the encoding to UTF-8. mcpp also treats -finput-charset as the same option as -e. I adopted these specifications because: *7

1. As for shift-JIS, GCC of any version cannot process it if -f*-charset options are specified. But, as for shift-JIS, ISO2022-JP and Big5, if the encodings are not converted but supplemented with <backslash>es, the multi-byte characters are output as they are by cc1 on any version of GCC. Also EUC-JP, GB2312, KSC-5601 and UTF-8 are passed as they are, if -f*-charset are not specified. That is to say, the multi-byte characters are treated as single-byte character sequences.
2. GCC up to V.4.0 / cc1 does not convert back from UTF-8 to the original encodings.
3. I hope that GCC will change the multi-byte character handling in the near future.

Note:

*1 The output of -dM option, however, slightly differs each other depending on other options. What is worse, most of the predefined macros are undocumented ones. As a result, the whole picture cannot be grasped easily.

*2 MinGW does not support symbolic link. Though the 'ln -s' command exists, it does not link but only copy. Moreover, MinGW's GCC rejects to invoke a shell-script even if it is named cc1. To cope with this, mcpp's MinGW GCC-specific-build generates a binary executable named cc1.exe (copied also to cc1plus.exe) which invokes mcpp.exe or GCC's cc1.exe/cc1plus.exe.

*3 CygWIN / GCC has -mno-cygwin option which alters system include directory and alters GCC's predefined macros. mcpp V.2.6.1 onward, CygWIN GCC-specific-build supports this option and generates two sets of header files for the predefined macros.

*4 On GCC in my FreeBSD 6.3, multi-byte character conversion to UTF-8 does not work at all, though libiconv seems to be linked to them. It was the same with FreeBSD 5.3 and 6.2, too.

*5 This conversion seems not to be done in preprocessing phase, but in compilation phase. Output of -E option is still UTF-8.

*6 GCC V.4.1-4.3 fail to compile due to a bug of GCC, if -save-temps or -no-integrated-cpp option is specified at the same time with -f*-charset option.

*7 When you pass the output of mcpp to cc1, you should not specify -fexec-charset option nor -finput-charset option.

### 3.9.8. Preprocessing Linux/glibc 2.4

I compiled glibc 2.4 (March, 2006) source, and checked preprocessing problems in it. As a compiler system, I used GCC 4.1.1 with mcpp 2.6.3. Since my machine is x86 type, I did not check the codes for other CPUs.

This is a six years newer version than glibc 2.1.3 (February, 2000) which I checked formerly, so it has naturally some parts largely changed from the old version. However, It has remarkably many parts unchanged. On the whole, most of the problems I noticed in the old version have not been revised, on the contrary, unportable sources have increased.

#### 3.9.8.1. Multi-Line String Literal

The old-fashioned "multi-line string literal" has disappeared.

#### 3.9.8.2. #include_next, #warning

#include_next is found in the following source files. Its occurrence has increased as compared with the six years older version.

`catgets/config.h, elf/tls-macros.h, include/bits/dlfcn.h, include/bits/ipc.h, include/fpu_control.h, include/limits.h, include/net/if.h, include/pthread.h, include/sys/sysctl.h, include/sys/sysinfo.h, include/tls.h, locale/programs/config.h, nptl/sysdeps/pthread/aio_misc.h, nptl/sysdeps/unix/sysv/linux/aio_misc.h, nptl/sysdeps/unix/sysv/linux/i386/clone.S, nptl/sysdeps/unix/sysv/linux/i386/vfork.S, nptl/sysdeps/unix/sysv/linux/sleep.c, sysdeps/unix/sysv/linux/ldsodefs.h, sysdeps/unix/sysv/linux/siglist.h`

Though the following is not a part of glibc itself but a testcase file to test glibc by 'make check', #include_next is found also in it.

`sysdeps/i386/i686/tst-stack-align.h`

#warning appears in `sysvipc/sys/ipc.h`. This directive is in a block to be skipped in normal processing, and does not cause any problem.

#### 3.9.8.3. Variable Argument Macros

There are definitions of variable argument macros in the following files. All of these are that of the old spec since GCC2. There is not any macro of C99 spec, nor even GCC3 spec one.

`elf/dl-lookup.c, elf/dl-version.c, include/libc-symbols.h, include/stdio.h, locale/loadlocale.c, locale/programs/ld-time.c, locale/programs/linereader.h, locale/programs/locale.c, locale/programs/locfile.h, nptl/sysdeps/pthread/setxid.h, nss/nss_files/files-XXX.c, nss/nss_files/files-hosts.c, sysdeps/generic/ldsodefs.h, sysdeps/i386/fpu/bits/mathinline.h, sysdeps/unix/sysdep.h, sysdeps/unix/sysv/linux/i386/sysdep.h`

The following testcase files also have variadic macro definitions of GCC2 spec.

`localedata/tst-ctype.c, posix/bug-glob2.c, posix/tst-gnuglob.c, stdio-common/bug13.c`

Moreover, many of the calls of these macros lack actual argument for variable argument. As much as 142 files have such macro calls lacking variable argument, and 120 files of them have such unusual macro calls as the replacement list of which have ", ##" sequence immediately preceding variable argument and hence removal of the ',' happen.

As a variable argument macro specification, C99 one is portable and is recommendable. However, it is not so easy to rewrite GCC specs macro to C99 one. Both of GCC2 spec and GCC3 spec variadic macros do not necessarily correspond to C99 spec one-to-one, because GCC specs cause removal of the preceding comma in case of absence of variable argument. If you rewrite GCC spec macro definition to C99 one, you also need to rewrite macro calls of absent variable argument and supplement an argument.

In glibc 2.1.3, GCC2 spec macros were not so many, and it was not a heavy work for a user to rewrite them with an editor. In glibc 2.4, however, such macro definitions increased and especially their calls vastly increased. As a consequence, it is impossible now for a user to rewrite them.

To cope with this situation, mcpp V.2.6.3 onward implemented GCC3 spec variadic macro for GCC-specific-build only. Furthermore, mcpp V.2.7 implemented GCC2 spec one, too. However, you should not write GCC2 spec macro in your sources, because the spec is too deviant from token-based principle. Since GCC2 spec corresponds to GCC3 spec one-to-one, it is easy to rewrite a macro definition to GCC3 spec, and call of that macro need not be rewritten. The already written macros with GCC2 spec will become a little clearer, if rewritten this way. *1

To rewrite a GCC2 spec variadic macro to GCC3 spec one, for example, change:

    #define libc_hidden_proto(name, attrs...)   hidden_proto (name, ##attrs)

to:

    #define libc_hidden_proto(name, ...)    hidden_proto (name, ## __VA_ARGS__)

That is, change the parameter `attrs...` to `...`, and change `attrs` in the replacement-list to `__VA_ARGS__`.

Note:

*1 As for variadic macro of GCC2 spec and GCC3 spec, see 3.9.1.6, 3.9.6.3 respectively.

#### 3.9.8.4. Empty Argument During Macro Calls

The macro calls with any empty argument are found in as many as 488 source files. They have greatly increased since the old version. C99 approval of empty macro argument may have influenced the tendency.

In particular, `math/bits/mathcalls.h` has as many as 79 macro calls with empty argument. That is the same with the old version.

#### 3.9.8.5. Object-Like Macros Replaced with Function-like Macro Name

The following files have object-like macro definitions replaced to function-like macro names:

`argp/argp-fmtstream.h, hesiod/nss_hesiod/hesiod-proto.c, intl/plural.c, libio/iopopen.c, nis/nss_nis/nis-hosts.c, nss/nss_files/files-hosts.c, nss/nss_files/files-network.c, nss/nss_files/files-proto.c, nss/nss_files/files-rpc.c, nss/nss_files/files-service.c, resolv/arpa/nameser_compat.h, stdlib/gmp-impl.h, string/strcoll_l.c, sysdeps/unix/sysv/linux/clock_getres.c, sysdeps/unix/sysv/linux/clock_gettime.c`

`elf/link.h` has function-like macro definitions replaced to function-like macro names. For example,:

    #define ELFW(type) _ElfW (ELF, __ELF_NATIVE_CLASS, type)
                                            /* sysdeps/generic/ldsodefs.h:46    */
    #define _ElfW(e,w,t)    _ElfW_1 (e, w, _##t)            /* elf/link.h:32    */
    #define _ElfW_1(e,w,t)  e##w##t                         /* elf/link.h:33    */
    #define __ELF_NATIVE_CLASS __WORDSIZE               /* bits/elfclass.h:11   */
    #define __WORDSIZE 32           /* sysdeps/wordsize-32/bits/wordsize.h:19   */
    #define ELF32_ST_TYPE(val) ((val) & 0xf)                /* elf/elf.h:429    */

with the above macro definitions,

        && ELFW(ST_TYPE) (sym->st_info) != STT_TLS      /* elf/do-lookup.h:81   */

in this macro call, ``ELFW`(ST_TYPE)` is expanded with the following steps:

        ELFW(ST_TYPE)
        _ElfW(ELF, __ELF_NATIVE_CLASS, ST_TYPE)
        _ElfW_1(ELF, 32, _ST_TYPE)
        ELF32_ST_TYPE

Then, `ELF32_ST_TYPE` with the subsequent sequence `(sym->st_info)` is expanded to `((sym->st_info) & 0xf)`. That is to say, a function-like macro call of ``_ElfW_1`(ELF, 32, _ST_TYPE)` is expanded to name of another function-like macro `ELF32_ST_TYPE`.

These macros become more clear, if the 3 definitions of above 6 are written as:

    #define ELFW( type, val)        _ElfW( ELF, __ELF_NATIVE_CLASS, type, val)
    #define _ElfW( e, w, t, val)    _ElfW_1( e, w, _##t, val)
    #define _ElfW_1( e, w, t, val)  e##w##t( val)

and if they are used as:

        && ELFW(ST_TYPE, sym->st_info) != STT_TLS

Although these arguments may seem to be a little redundant, these are more natural than the original ones, if we think of function call syntax.

#### 3.9.8.6. Macros Expanded to 'defined'

The following files contain macro definitions whose replacement-lists have the `'defined'` token. *1

`iconv/skeleton.c, sysdeps/generic/_G_config.h, sysdeps/gnu/_G_config.h, sysdeps/i386/dl-machine.h, sysdeps/i386/i686/memset.S, sysdeps/mach/hurd/_G_config.h, sysdeps/posix/sysconf.c`

Those macros are used in some #if lines of the following files, and also some of the above files themselves.

`elf/dl-conflict.c, elf/dl-runtime.c, elf/dynamic-link.h`

In glibc 2.1.3, `malloc/malloc.c` had a macro definition of `HAVE_MREMAP` whose replacement-list contained the `'defined'` token. In glibc 2.4, that macro definition has been revised to portable one, nevertheless the unportable macros of the same sort have increased in other source files.

In a #if expression, the result of a macro expansion whose replacement-list has the `'defined'` token is undefined according to the Standards, and it is only self-satisfaction of GCC to preprocess the expression plausibly and arbitrarily. In order to make these sources portable among other preprocessors, at least the definitions of these macros should be rewritten, and in some cases the calls of the macros should be rewritten, too. *2

In most cases, the simple rewriting is sufficient as seen in 3.9.4.6. In some cases, however, this method does not work. Those are the cases where evaluation result of `'defined MACRO'` differs depending on its timing. For example, `sysdeps/i386/dl-machine.h` has the following macro definition, which is used in some #if expressions on other files.

    #define ELF_MACHINE_NO_RELA defined RTLD_BOOTSTRAP

Rewriting the definition as follows will not do.

    #if defined RTLD_BOOTSTRAP
    #define ELF_MACHINE_NO_RELA 1
    #endif

The macro `RTLD_BOOTSTRAP` is defined in `elf/rtld.c`, if and only that file is included before `dl-machine.h`. In other words, the evaluation result of `'defined RTLD_BOOTSTRAP'` depends on the order of including the two files. In order to rewrite these sources portable, the macro `ELF_MACHINE_NO_RELA` should be abandoned since it is useless macro found only in #if lines, and the #if line:

    #if ELF_MACHINE_NO_RELA

should be rewritten as:

    #if defined RTLD_BOOTSTRAP

In glibc, this portable style of #if lines are found on many places, at the same time, the undefined style as above example are also found on some places.

Note:

*1 On Linux, /usr/include/_G_config.h is the header file installed from glibc's sysdeps/gnu/_G_config.h, therefore it has the same macro definition as:

    #define _G_HAVE_ST_BLKSIZE defined (_STATBUF_ST_BLKSIZE)

This should be rewritten to:

    #if defined (_STATBUF_ST_BLKSIZE)
    #define _G_HAVE_ST_BLKSIZE 1
    #endif

*2 mcpp V.2.7 and later in STD mode on GCC-specific-build handles '`defined`' token generated by macro expansion in #if line like GCC. Yet, such a bug-to-bug handling should not be depended on.

#### 3.9.8.7. Preprocessing .S File

*.S files are provided for each CPU type, so their number is very large and amounts to more than 1000. The files for one CPU type as x86 are some portion of them.

*.S file is an assembler source with inserted preprocessing directives such as #if or #include, comments or macros of C. Since assembler source is not consisted of C token sequence, it accompanies some risks to preprocess it by C preprocessor. To process an assembler source, the preprocessor must pass such characters as % or $ (which are not used in C except in string literal or in character constant) as they are, and retain existence or non-existence of spaces as they are. Furthermore, the preprocessor must relax syntax checking to pass a sequence which would be an error if it was in C source. On the other hand, it must process #if lines or macros like C, and must do some sort of error checking, too. What a nuisance! These specifications have not any logical basis at all, these are GCC's local and mostly undocumented behaviors and no more.

To illustrate the problems, let me take an example of the following fragment from `nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_wait.S`.

        .byte   8               # Return address register
                                # column.
    #ifdef SHARED
        .uleb128 7              # Augmentation value length.
        .byte   0x9b            # Personality: DW_EH_PE_pcrel
                                # + DW_EH_PE_sdata4

`'#ifdef SHARED'` intends to be a directive of C. On the other hand, the latter part of each line starting with # are supposed to be comments. `'# column.'` is, however, syntactically indistinguishable from invalid directive, since the # is the first non-white-space-character of the line. `'# + DW_EH_PE_sdata4'` causes even syntax error in C.
Another file has the following line, where a single character appears singly. In C, a pair of the single quote is used to quote a character constant, and unmatched single quote causes a tokenization error.

        movl 12(%esp), %eax     # that `fixup' takes its parameters in regs.

The above pthread_cond_wait.S also has the following line which is a macro call.

    versioned_symbol (libpthread, __pthread_cond_wait, pthread_cond_wait,
              GLIBC_2_3_2)

The macros are defined as:

    # define versioned_symbol(lib, local, symbol, version) \
      versioned_symbol_1 (local, symbol, VERSION_##lib##_##version)
                                        /* include/shlib-compat.h:65    */
    # define versioned_symbol_1(local, symbol, name) \
      default_symbol_version (local, symbol, name)
                                        /* include/shlib-compat.h:67    */
    # define default_symbol_version(real, name, version) \
         _default_symbol_version(real, name, version)
                                        /* include/libc-symbols.h:398   */
    #   define _default_symbol_version(real, name, version) \
         .symver real, name##@##@##version
                                        /* include/libc-symbols.h:411   */
    #define VERSION_libpthread_GLIBC_2_3_2  GLIBC_2.3.2
                                /* Created by make: abi-versions.h:145  */

The line is expected to be expanded as:

    .symver __pthread_cond_wait, pthread_cond_wait@@GLIBC_2.3.2

The problem is the definition of `_default_symbol_version`. There is no C token containing '@' (except string-literal or character-constant). Though `pthread_cond_wait@@GLIBC_2.3.2` is a sequence generated by concatenating some parts with `##` operator, this is not a C token. The concatenation generates illegal tokens also in midst of its processing. The macro uses `##` operator of C, nevertheless its syntax is far from C.

In order to do a sort of preprocessing on an assembler source, essentially an assembler macro processor should be used. To process assembler codes with C, it is recommended that the asm() or __asm__() function should be used whenever possible, to embed the assembler code in a string literal, and that not *.S but *.c should be used as a file name.
`libc-symbols.h` has another version of the above macro as follows which is used for *.c. This macro can be processed by Standard-conforming C preprocessor without problem.

    #   define _default_symbol_version(real, name, version) \
         __asm__ (".symver " #real "," #name "@@" #version)

glibc also has many *.c or *.h files which use asm() or __asm()__. Nevertheless, it has much more *.S files.

If you process an assembler source by C preprocessor in any way, at least you should use /* */ or // as comment notation instead of #. In actual, many sources of glibc use /* */ or //, whereas some sources use #.

Having said so, mcpp V.2.6.3 onward relaxed grammar checking largely in lang-asm mode to process these unusual sources, considering that glibc 2.4 has too many *.S files and out-of-C-grammar-sources has increased since 2.1.3.

#### 3.9.8.8. Problems of versions.awk, rpcgen and -dM Option

The problem of `stdlib/isomac.c` which I referred to at 3.9.4.8 is the same in glibc 2.4.

Also the problem of rpcgen is unchanged.

In addition, glibc 2.4 has `scripts/versions.awk` file, which presupposes GCC's peculiar behavior about the number of line top spaces of preprocessed output. In order to use mcpp or other preprocessors, this file should be revised as follows.

    $ diff -c versions.awk*
    *** versions.awk        2006-12-13 00:59:56.000000000 +0900
    --- versions.awk.orig   2005-03-23 10:46:29.000000000 +0900
    ***************
    *** 50,56 ****
      }

      # This matches the beginning of a new version for the current library.
    ! /^ *[A-Z]/ {
        if (renamed[actlib "::" $1])
          actver = renamed[actlib "::" $1];
        else if (!versions[actlib "::" $1] && $1 != "GLIBC_PRIVATE") {
    --- 50,56 ----
      }

      # This matches the beginning of a new version for the current library.
    ! /^  [A-Za-z_]/ {
        if (renamed[actlib "::" $1])
          actver = renamed[actlib "::" $1];
        else if (!versions[actlib "::" $1] && $1 != "GLIBC_PRIVATE") {
    ***************
    *** 65,71 ****
      # This matches lines with names to be added to the current version in the
      # current library.  This is the only place where we print something to
      # the intermediate file.
    ! /^ *[a-z_]/ {
        sortver=actver
        # Ensure GLIBC_ versions come always first
        sub(/^GLIBC_/," GLIBC_",sortver)
    --- 65,71 ----
      # This matches lines with names to be added to the current version in the
      # current library.  This is the only place where we print something to
      # the intermediate file.
    ! /^   / {
        sortver=actver
        # Ensure GLIBC_ versions come always first
        sub(/^GLIBC_/," GLIBC_",sortver)

#### 3.9.8.9. -include, -isystem, -I- Options

`-isystem` and `-I-` options are no longer used.

On the other hand, `-include` option is used extremely frequently. A header file `include/libc-symbols.h` is included by this option as many as 7000 times. This `-include` is an option to push out a `#include` line from source to makefile. It makes source incomplete, and is not recommendable.

#### 3.9.8.10. Undocumented Predefined Macros

This is not a problem of glibc but of GCC. While a few important predefined macros were undocumented in GCC 2, they got documented in GCC 3. On the other hand, GCC 3.3 and later predefines many macros, and most of them are undocumented.

#### 3.9.8.11. Other Problems

`debug/tst-chk1.c` has a queer part which is not processed as its intension by other preprocessor than GCC, unless revised as follows.

    $ diff -cw tst-chk1.c*
    *** tst-chk1.c  2007-01-11 00:31:45.000000000 +0900
    --- tst-chk1.c.orig     2005-08-23 00:12:34.000000000 +0900
    ***************
    *** 113,119 ****
      static int
      do_test (void)
      {
    -   int   arg;
        struct sigaction sa;
        sa.sa_handler = handler;
        sa.sa_flags = 0;
    --- 113,118 ----
    ***************
    *** 135,146 ****
        struct A { char buf1[9]; char buf2[1]; } a;
        struct wA { wchar_t buf1[9]; wchar_t buf2[1]; } wa;

      #ifdef __USE_FORTIFY_LEVEL
    !   arg = (int) __USE_FORTIFY_LEVEL;
      #else
    !   arg = 0;
      #endif
    !   printf ("Test checking routines at fortify level %d\n", arg);

        /* These ops can be done without runtime checking of object size.  */
        memcpy (buf, "abcdefghij", 10);
    --- 134,146 ----
        struct A { char buf1[9]; char buf2[1]; } a;
        struct wA { wchar_t buf1[9]; wchar_t buf2[1]; } wa;

    +   printf ("Test checking routines at fortify level %d\n",
      #ifdef __USE_FORTIFY_LEVEL
    !         (int) __USE_FORTIFY_LEVEL
      #else
    !         0
      #endif
    !         );

        /* These ops can be done without runtime checking of object size.  */
        memcpy (buf, "abcdefghij", 10);

Contrary to its innocent looking, the original source defines printf() as a macro, and as its consequence, `#ifdef` and other directive-like lines are usually eaten as an argument of the macro call. According to the Standards, the result is undefined when there is a line in an argument of a macro which would otherwise act as a directive. Since directive processing and macro expansion should be done in the same translation phase, it is an arbitrariness of GCC to process directive first. In the first place, processing of `#ifdef __USE_FORTIFY_LEVEL` line also contains macro processing, therefore it is extremely arbitrary to process this line and the other directive-like lines first then expand printf() macro. C preprocessing should be done sequentially from the top.

The configure script of glibc also has a portion to use GCC's peculiar help message. The script searches help message of compiler for `"-z relro"` option. If you use mcpp as a preprocessor, this portion does not yield the expected result. In spite of this problem, fortunately, compiling and test of glibc is done normally.

By the way, while GCC up to 3.2 appended many useless -A options by default on its invocation, GCC 3.3 onward ceased to do it.

#### 3.9.8.12. Increasing Dependency on GCC

Most of the portability problems I had found in glibc 2.1.3 have not been cleared in glibc 2.4 the six years newer version. On the contrary, number of sources lacking portability has increased.

There have been a few improvements such as disappearance of multi-line-string-literal, `-isystem, -I-` options and `-A` options on GCC side.

Meanwhile, sources with such unportable features have largely increased as #include_next, variadic macro of GCC2 spec, its call without variable argument, macro definition with 'defined' token in its replacement-list, *.S file and `-include` option. Macro calls with an empty argument have also increased. Above all it is most annoying that the writings which do not correspond to Standard C one-to-one, and hence cannot be easily converted to portable one, have increased.

All of these are problems of dependency on GCC's local specification and undocumented behavior. In a large scale software as glibc, once such unportable sources are created, it becomes difficult to revise them because many source files are interrelated. As a consequence, the same writings tend to be inherited for years, and even new sources are written so as to suit the old interfaces. For example, it shows this relationship directly that only the variadic macros of GCC2 spec are used, and neither of C99 spec nor GCC3 spec are not used at all. Besides, even if some unportable parts in a few sources are revised, at the same time the old unportable codings often appear newly in other sources. The old style writings are not easily cleared.

On the other hand, change of GCC behavior breaks many sources, and the possible influence becomes greater with time, therefore GCC becomes difficult to change its behavior. I think that both of GCC and glibc need to tidy up their old local specifications and old interfaces drastically in the near future.

### 3.9.9. The Problems of Linux / stddef.h, limits.h and #include_next

On Linux, the system compiler is GCC, and the standard library is glibc. In these circumstances, there are some system headers which presuppose only GCC. Those are the obstacles to use other compiling tools than GCC such as mcpp of compiler-independent-build. For example, `stddef.h` and some other Standard header files are located only in GCC's version specific include directory, and are not found in `/usr/include`. These are rude deficiencies of the system header structure, and mcpp needs some workarounds for them.

On Linux, GCC installs a version specific include directory such as `/usr/lib/gcc-lib/SYSTEM/VERSION/include` where the Standard headers stddef.h, limits.h and some others are located. These headers and GCC behavior on them are queer. The problems are the same on CygWIN as on Linux. Mac OS X also has a few problems on some Standard headers.

#### 3.9.9.1. /usr/include Lacks Standard Headers

In the first place, on Linux, five of the Standard C header files `float.h, iso646.h, stdarg.h, stdbool.h, stddef.h` are located only in the GCC version specific directory, not in `/usr/include` nor `/usr/local/include`. The system headers on Linux seem to more or less intend that compiler systems other than GCC use only `/usr/include` and GCC uses its version specific directory in addition to `/usr/include`. In fact, /usr/include lacks some Standard headers, that is the problem for non-GCC compilers or preprocessors.

If non-GCC preprocessor uses also GCC version specific directory, then on limits.h in this directory, the preprocessor encounters #include_next which is a GCC specific directive. If that is the case, why doesn't the preprocessor implement #include_next? Then, the limits.h causes a problem, because it is not cleanly written. What is worse, GCC V.3.3 or later predefines practically by itself the macros to be defined by limits.h, hence the header is useless for other preprocessors.

Besides, as for GCC itself, it shows queer behavior with #include_next in this header.

Although these problems are complicated to explain, I will describe them here, because they have been neglected for years for some reason.

Note that only mcpp of compiler-independent-build suffers this problem. GCC-specific-build is not affected.

#### 3.9.9.2. Queer Handling of #include_next

The include directories for GCC are typically set as:

    /usr/local/include
    /usr/lib/gcc-lib/SYSTEM/VERSION/include
    /usr/include

These are searched from upper to lower. The second is the GCC specific include directory. SYSTEM is i386-vine-linux, i368-redhat-linux or such, VERSION is 3.3.2, 3.4.3 or such. If you install another version of GCC into `/usr/local`, the `/usr/lib/gcc-lib` part above will become `/usr/local/lib/gcc`. In C++, some other directories are set with higher priority than `/usr/local/include`. For GCC V.3.* and 4.*, those are:

    /usr/include/c++/VERSION
    /usr/include/c++/VERSION/SYSTEM
    /usr/include/c++/VERSION/backward

The name of these directories seem GCC specific, nevertheless no other C++ standard directories do not exist, so the other preprocessors can use no directories but these. For GCC 2.95, the include directory in C++ was:

    /usr/include/g++-3

In addition, the directories specified by -I option or by environment variables are prepended to the list.

Let me take an example of limits.h in C on GCC V.3.3 or later focusing on definition of `LONG_MAX`, in order to make the explanations below simple. There are two limits.h: one in `/usr/include` and another in the version specific directory.

    #include <limits.h>

By this line, GCC includes `/usr/lib/gcc-lib/SYSTEM/VERSION/include/limits.h`. This header file starts as:

    #ifndef _GCC_LIMITS_H_
    #define _GCC_LIMITS_H_
    #ifndef _LIBC_LIMITS_H_
    #include "syslimits.h"
    #endif

Then, GCC includes `/usr/lib/gcc-lib/SYSTEM/VERSION/include/syslimits.h` which is a short file as:

    #define _GCC_NEXT_LIMITS_H
    #include_next <limits.h>
    #undef _GCC_NEXT_LIMITS_H

Now, limits.h is included again. Which limits.h? Since this directive is #include_next, it would skip the `/usr/lib/gcc-lib/SYSTEM/VERSION/include`, and would search `/usr/include`. GCC's cpp.info says:

> This directive works like `#include' except in searching for the specified file: it starts searching the list of header file directories _after_ the directory in which the current file was found.

In fact, however, GCC does not include `/usr/include/limits.h`, but includes `/usr/lib/gcc-lib/SYSTEM/VERSION/include/limits.h` again somehow.
This time `_GCC_LIMITS_H_` has been defined already, so the block beginning with the line:

    #ifndef _GCC_LIMITS_H_

is skipped, and the next block is evaluated:

    #else
    #ifdef _GCC_NEXT_LIMITS_H
    #include_next <limits.h>
    #endif
    #endif

Again, just the same #include_next <limits.h> which were found in `/usr/lib/gcc-lib/SYSTEM/VERSION/include/syslimits.h`. Does GCC include `/usr/lib/gcc-lib/SYSTEM/VERSION/include/limits.h` again as the previous time, which is the current file, and run into infinite recursion? No, it does not, but it includes `/usr/include/limits.h` this time. The behavior of GCC is beyond my understanding.

In `/usr/include/limits.h`, <features.h> and some other headers are included. Also, `/usr/include/limits.h` has a block beginning with the line:

    #if !defined __GNUC__ || __GNUC__ < 2

In this block, <bits/wordsize.h> is included, and the Standard required macros are defined depending whether wordsize is 32 bit or 64 bit. For example, if wordsize is 32 bit, `LONG_MAX` is defined as:

    #define LONG_MAX     2147483647L

Of course, GCC skips this block. Then, going to the end of this file, it returns to `/usr/lib/gcc-lib/SYSTEM/VERSION/include/limits.h`. Then, ending this file of the second inclusion, it returns to `/usr/lib/gcc-lib/SYSTEM/VERSION/include/syslimits.h`. Then, this file ends too, and GCC returns to the first inclusion of `/usr/lib/gcc-lib/SYSTEM/VERSION/include/limits.h`. In this file, after the above cited part, there are definitions of the Standard required macros. For instance, `LONG_MAX` is defined as:

    #undef LONG_MAX
    #define LONG_MAX __LONG_MAX__

Then, the file ends.

    #include <limits.h>

The processing of this line has ended. After all, `LONG_MAX` is defined to `__LONG_MAX__` and it is the end. What is `__LONG_MAX__`? As a matter of fact, GCC V.3.3 or later predefines many macros including `__LONG_MAX__` which is predefined to 2147483647L for 32 bit system. As with the other Standard required macros, the situations are almost the same as `LONG_MAX`, because they are defined using the predefined ones. If so, what is the purpose of these complicated header files and #include_next handling at all?

The behavior of GCC V.2.95, V.3.2, V.3.4, V.4.0 and V.4.1 on #include_next is the same as V.3.3. That is to say:

    #include_next <limits.h>

by this line in `/usr/lib/gcc-lib/SYSTEM/VERSION/include/syslimits.h`, GCC includes `/usr/lib/gcc-lib/SYSTEM/VERSION/include/limits.h`, and by the same line in this file:

    #include_next <limits.h>

it includes `/usr/include/limits.h`. As a result, in processing the line:

    #include <limits.h>

`/usr/lib/gcc-lib/SYSTEM/VERSION/include/limits.h` is included twice. This duplicate inclusion happens to produce the same result, nevertheless it is redundant, and first of all, the behavior differs from the specification and is not consistent. In addition, this part of the file is redundant if the behavior accords to the specification.

    #else
    #ifdef _GCC_NEXT_LIMITS_H
    #include_next <limits.h>
    #endif

#### 3.9.9.3. Standard Headers not Available for Preprocessors other than GCC

Now, what happens to compiler or preprocessor other than GCC using Linux standard headers? stddef.h and some other Standard headers are not found in `/usr/include` nor `/usr/local/include`. If so, how about using also GCC version specific directory?

    #include <limits.h>

By this line, the preprocessor includes `/usr/lib/gcc-lib/SYSTEM/VERSION/include/limits.h`, and from this file it includes `/usr/lib/gcc-lib/SYSTEM/VERSION/include/syslimits.h`, and in this file, it sees the line:

    #include_next <limits.h>

Then, how about implementing #include_next? If the #include_next is implemented as its specification, the preprocessor searches by this line the "next" include directory `/usr/include`, and includes `/usr/include/limits.h`. Then, this non-GCC preprocessor processes the block beginning with this line:

    #if !defined __GNUC__ || __GNUC__ < 2

In this block it defines `LONG_MAX` as:

    #define LONG_MAX     2147483647L

and defines also the other macros appropriately. Then, it ends this file, and returns to `/usr/lib/gcc-lib/SYSTEM/VERSION/include/syslimits.h`. Then, it ends this file, and returns to `/usr/lib/gcc-lib/SYSTEM/VERSION/include/limits.h`. And it encounters these lines:

    #undef LONG_MAX
    #define LONG_MAX __LONG_MAX__

At the end of the long run, all the correct definitions are canceled, and they become the undefined name `__LONG_MAX__` or such!

Up to GCC V.3.2, the corresponding part of version specific limits.h had the lines like:

    #define __LONG_MAX__ 2147483647L

Hence, the canceled macros are redefined correctly. Although the most part of the processing is useless, the results were correct. With the header files of V.3.3 or later, a non-GCC preprocessor is taken around here and there to get vain results.

#### 3.9.9.4. Workarounds for the Present

The problems are summarized as below: *1, *2, *3, *4

1. `/usr/include` lacks Standard C headers `float.h, iso646.h, stdarg.h, stdbool.h` and `stddef.h` which are necessary to make Linux system headers usable to non-GCC compiler system.
2. C++ include directories do not exist other than `/usr/include/c++/VERSION/*`. In order to make C++ standard include directories independent on GCC version, `/usr/include/c++` should be used instead of `/usr/include/c++/VERSION` which should be limited to GCC specific headers. Though, having said that, this is a difficult task, since the C++ standard library is libstdc++ distributed with GCC on all of FreeBSD, Linux and Mac OS X.
3. The behavior of GCC on #include_next differs from its specification and is inconsistent.
4. It is meaningless to process the complicated limits.h headers, since GCC predefines the Standard required macros by itself in effect. It is doubly meaningless, since `/usr/lib/gcc-lib/SYSTEM/VERSION/include/limits.h` does #undef all. As far as Linux and CygWIN are concerned, there seems to be no necessity for splitting limits.h to two. Since these headers in this directory are auto-generated ones by GCC installation, some redundancies are inevitable. Yet, these are too dirty to install as system headers.

Under these problems lies the excessively complicated system header structure. The extension directive #include_next enhances the complication. The use of this directive is very limited. Though GCC and glibc use it in compiling and installing of themselves, it does not exist in the installed system headers except for limits.h. The rare example in limits.h causes GCC above mentioned confusion. This presents a question on the reason of its existence.

Anyway, the compiler-independent-build of mcpp needs the following workarounds for the present. In order to avoid confusion, the compiler-independent-build does not implement #include_next nor uses GCC specific include directories.

1. Link `/usr/include/stddef.h` to `/usr/lib/gcc-lib/SYSTEM/VERSION/include/stddef.h`. In case of multiple versions of GCC have been installed, a link to any of them will work for mere preprocessing. This setting does no harm on GCC nor GCC-specific-build of mcpp. The same can be said about stdarg.h, though it expands macros to GCC built-in functions.
2. Copy or move iso646.h and stdbool.h from one of the GCC specific directories to `/usr/include`, since these are quite simple headers and independent on any system. As for limits.h, the existing `/usr/include/limits.h` is enough for non-GCC preprocessor.
3. float.h is useless for other preprocessor, such as `DBL_MAX_EXP` is defined to `__DBL_MAX_EXP__`. If required, you must write the header referring to the internal setting of GCC or some other source. *5
4. Do not set GCC specific include directory in C include directories list by environment variable.
5. Set C++ include directories by environment variable CPLUS_INCLUDE as `/usr/include/c++/VERSION:/usr/include/c++/VERSION/SYSTEM:/usr/include/c++/VERSION/backward`.

For the GCC-specific-build of mcpp, no special setting is required, because it has GCC specific include directories list, implements #include_next as its specification, and predefines the macros as GCC does.

Note:

*1 I have checked the descriptions of this 3.9.9 section on Linux / GCC 2.95.3, 3.2, 3.3.2, 3.4.3, 4.0.2, 4.1.1, 4.3.0 and on CygWIN / GCC 2.95.3, 3.4.4. As with CygWIN, the behavior on #include_next was as its specification on GCC 2.95.3, but on 3.4.4 it changed to the same behavior as Linux. The C++ include directories in CygWIN was `/usr/include/g++-3` on 2.95.3, while they are `/usr/lib/gcc/i686-pc-cygwin/3.4.4/include/c++` and its sub-directories on 3.4.4.

*2 On FreeBSD 6.2 or 6.3 and its bundled GCC 3.4.6, all the Standard C headers are present in `/usr/include`, #include_next is not used in any system headers, and GCC specific C include directory does not exist. However, C++ include directories are GCC version dependent as `/usr/include/c++/3.4, /usr/include/c++/3.4/backward`.
Even on FreeBSD, an installation of another version of GCC makes GCC-version-specific include directory. Most of the headers in the directory are redundant. However, the headers in `/usr/include` remain unchanged.

*3 On Mac OS X Leopard / Apple-GCC 4.0.1, as on Linux, there is a GCC-version-specific include directory, #include_next is used in `limits.h` and a few other headers, also two `limits.h` are found. However, #include_next in `syslimits.h` has been deleted by Apple. `float.h, iso646.h, stdarg.h, stdbool.h, stddef.h` are all found in `/usr/include`, hence so much special settings are not necessary for mcpp. But, `float.h, stdarg.h` are only for GCC and Metrowerks (for powerpc), so if you use them with mcpp, you must rewrite `float.h` yourself and make `stdarg.h` to include GCC-version-specific one. Note that some definitions in `float.h` are different between x86 and powerpc.

*4 On MinGW / GCC 3.4.*, though the include directories and their precedence differ from the other systems, the behavior of GCC on #include_next is the same, and also some Standard headers are not in the standard include directory `/mingw/include` but in its version-specific-directory.

*5 float.h for i386 system can be written as follows referring to GCC's setting:

    /* float.h  */

    #ifndef _FLOAT_H___
    #define _FLOAT_H___

    #define FLT_ROUNDS      1
    #define FLT_RADIX       2

    #define FLT_MANT_DIG    24
    #define DBL_MANT_DIG    53
    #define LDBL_MANT_DIG   64

    #define FLT_DIG         6
    #define DBL_DIG         15
    #define LDBL_DIG        18

    #define FLT_MIN_EXP     (-125)
    #define DBL_MIN_EXP     (-1021)
    #define LDBL_MIN_EXP    (-16381)

    #define FLT_MIN_10_EXP  (-37)
    #define DBL_MIN_10_EXP  (-307)
    #define LDBL_MIN_10_EXP (-4931)

    #define FLT_MAX_EXP     128
    #define DBL_MAX_EXP     1024
    #define LDBL_MAX_EXP    16384

    #define FLT_MAX_10_EXP  38
    #define DBL_MAX_10_EXP  308
    #define LDBL_MAX_10_EXP 4932

    #define FLT_MAX         3.40282347e+38F
    #define DBL_MAX         1.7976931348623157e+308
    #define LDBL_MAX        1.18973149535723176502e+4932L

    #define FLT_EPSILON     1.19209290e-7F
    #define DBL_EPSILON     2.2204460492503131e-16
    #define LDBL_EPSILON    1.08420217248550443401e-19L

    #define FLT_MIN         1.17549435e-38F
    #define DBL_MIN         2.2250738585072014e-308
    #define LDBL_MIN        3.36210314311209350626e-4932L

    #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define FLT_EVAL_METHOD 2
    #define DECIMAL_DIG     21
    #endif /* C99 */

    #endif /* _FLOAT_H___ */

### 3.9.10. Problems of Mac OS X / Apple-GCC and its System Headers

On V.2.7, mcpp began to support Max OS X / GCC. This section describes the problems of the system found by mcpp. The author, however, does not know the system so much yet. He has only compiled mcpp itself and firefox on the system. He knows nothing about Objective C nor Objective C++.

Since GCC is practically the only compiler on this system now, some dependencies on GCC-local specs are found in some of its system headers. Such dependencies are not so much as Linux, maybe because its standard library is not glibc. But, they are not so few as FreeBSD. Some tidy-ups are desirable.

Another characteristic of this system is that the system compiler is a GCC largely modified and extended by Apple. In the system headers and some sources of Apple on Max OS X, dependencies on Apple-GCC-local specs are more conspicuous than those on general-GCC-local specs. In particular, the extended specs to support both of Intel-Mac and PowerPC-Mac on a machine are the most characteristic.

Here, we refer to the system of Mac OS X Leopard / Apple-GCC 4.0.1.

#### 3.9.10.1. #include_next, #warning

The GCC-local directive #include_next are not many, but found in `float.h, stdarg.h, varargs.h` in `/usr/include/` and the files of the same name in `/Developer/SDKs/MacOSX10.*.sdk/usr/include/`. All of them are to include different real header files depending on whether the compiler is GCC or Metrowerks. When the compiler is GCC, `stdarg.h`, for example, does '#include_next <stdarg.h>'.
The `limits.h` in GCC-version-specific include directory has #include_next as Linux, but the one in `syslimits.h` has been removed and a bit tidied up.

Though this directive is used modestly, it is a problem that `float.h, stdarg.h` presuppose only GCC and Metrowerks. Those can be written more portable as on FreeBSD. *1
In addition, #include_next for GCC on a header in `/usr/include` is a nonsense, because the priority of that include directory is lower than GCC-version-specific one. Consequently this #include_next is never executed.

Another GCC-local directive #warning is sometimes found in `objc/, wx-2.8/wx/` and a few other directories in `/usr/include/`, and their corresponding directories in `/Developer/SDKs/MacOSX*.sdk/usr/include/`. Most of the directives are warnings against obsolete or deprecated files or usages.
`backward_warning.h` in `/usr/include/c++/VERSION/backward/` and its corresponding file in `/Developer/SDKs/MacOSX*.sdk/` are to execute #warning against these deprecated headers. And all the headers in the directories include this header. This is the same with Linux or FreeBSD.

Note:

*1 About how to use these headers with compiler-independent-build of mcpp, refer 3.9.9.4 and its note 3.

#### 3.9.10.2. A Macro Expanded to 'defined'

`/usr/include/sys/cdefs.h` and its corresponding file of the same name in `/Developer/SDKs/MacOSX*.sdk/` have a macro definition as:

    #define __DARWIN_NO_LONG_LONG   (defined(__STRICT_ANSI__) \
                    && (__STDC_VERSION__-0 < 199901L) \
                    && !defined(__GNUG__))

And it is used in `stdlib.h` and a few others as:

    #if __DARWIN_NO_LONG_LONG

This macro should be defined as: *1

    #if     defined(__STRICT_ANSI__) \
                    && (__STDC_VERSION__-0 < 199901L) \
                    && !defined(__GNUG__)
    #define __DARWIN_NO_LONG_LONG   1
    #endif

Note:

*1 As for its reason, see 3.9.4.6 and 3.9.8.6.

#### 3.9.10.3. Tokens in #endif line

`gssapi.h, krb5.h, profile.h` in `/System/Library/Frameworks/Kerberos.framework/Headers` have queer #endif lines like:

    #endif \* __KERBEROS5__ */

This `\* __KERBEROS5__ */` seems to intend to be a comment. I cannot understand why they must invent such a writing. Though GCC usually warns at it, Apple-GCC does not issue any warning even if `-pedantic` or any other options are specified. Apple-GCC does not warn at the following case, too. It still trails a sense of pre-C90.

    #endif __KERBEROS5__

#### 3.9.10.4. Some Special Usages of Macro

As far as a compilation of firefox 3.0b3pre source is concerned, any of the following special usages of macro, which are frequently found in glibc sources and Linux system headers, is not found in the Mac OS X system headers included from the firefox source.

- GCC-specific variable argument macro.
  While a few variadics of C99-spec are found, no GCC-specific one is found.
- Empty argument of macro call.
- Object-like macro replaced with a function-like macro name.

#### 3.9.10.5. Apple-GCC's Peculiar Specifications

Apple-GCC has some peculiar specifications different from the general GCC.

- Specs to generate binaries for both of Intel-Mac and PowerPC-Mac on either machine

  Mac OS X has a pair of compilers for x86 and ppc. (One is a native compiler, and other is a cross compiler.) This pair of Apple-GCCs have their own option `-arch`. If you specify multiple CPUs as '`-arch i386 -arch ppc`', gcc will be repeatedly invoked, binaries for the specified CPUs will be generated, and a "universal binary" which bundles all the binaries will be created. Also they have another peculiar option `-mmacosx-version-min=`. You can use this option along with `-isysroot` or `--sysroot` option, and widen the range of compatibility of the binary to the older versions of Mac OS X to some extent. These specs are convenient to make a binary package for Mac OS X.

  As for preprocessing, you should remember that some predefined macros differ depending on the CPU specified.

- "framework" directories

  Mac OS X has "framework" directories inherited from NeXTstep. Framework is a hierarchical directory that contains shared resources such as header files, library, documents, and some other resources. To include a header file in these directories, such a directive is used as:

      #include <Kerberos/Kerberos.h>

  This format is the same with:

      #include <sys/stat.h>

  However, these two have quite different meanings. While the latter includes the file `sys/stat.h` in some include directory (in this case `/usr/include`), `<Kerberos/Kerberos.h>` is not a path-list, and `Kerberos` is not even a directory name. This is a file `Kerberos.framework/Headers/Kerberos.h` in a framework directory `/System/Library/Frameworks`. And in actual, `Kerberos.framework/Headers` is a symbolic-link to `Kerberos.framework/Versions/Current/Headers`. This is the most simple case of framework header file location. There are many other far more complex cases.

  Who has invented such a complex system? This system burdens a preprocessor, because it needs to search system headers in framework directories repeatedly building and rebuilding path-list. Some headers further include many other headers.

- "header map" file

  Xcode.app is an IDE on Max OS X. It uses "header map" file, which is a list of include files. One of the tools of Xcode checks source files, searches the files to be included, and records the path-list of the files into a file named *.hmap, and Apple-GCC refers to it instead of include directories. This is an extended feature of Apple-GCC.

  Header map file is a device to lessen burdens of header file searching. However, it is a binary file of a peculiar specification and lacks transparency. In order to lessen heavy burdens of framework header searching, it is more desired to reorganize the framework system.

- Tokens in #endif line

  As shown in the previous section, Apple-GCC does not issue even a warning whatever junks are on a #endif line, regardless of whatever options specified. It is quite an anachronism.

- Non-ASCII characters in comments

  This is not a problem of GCC, but a problem of system headers in framework directory. In many headers, some non-ASCII characters are frequently found in comments, such as the copyright mark (0xA9) and others of ISO-8859-* (?). They are nuisances on an environment of multibyte characters, even if in comments. A little bit of character encoding consciousness is desired. Though the characters of this kind are sometimes found also in /usr/include of Linux, they are far more often found in framework headers of Mac OS.

### 3.9.11. Preprocessing firefox 3.0b3pre

I compiled source of firefox developing version 3.0b3pre (January, 2008), or 3.0-beta3-prerelease, by GCC replacing its preprocessor with mcpp V.2.7 on Linux/x86 + GCC 4.1.2 and Mac OS X + GCC 4.0.1. mcpp were executed with -Kv option passing its output to cc1 (cc1plus). As its results, the compilations successfully completed, and the firefox binaries were generated. *1

The preprocessing portability of firefox source on the whole is rather high. The dependencies on GCC-local specifications, such as frequently found in glibc sources, are not found so many. It is portable enough to officially support both of GCC on Linux, Mac OS X and Visual C++ on Windows.

Preprocessing portability of a source is, however, not necessarily sufficient, even if GCC and Visual C pass it. In the sections below, I will check some problems, sometimes comparing them with glibc sources. I omit explanations on GCC's problems here to avoid duplication. For GCC's problems, refer to 3.9.4, 3.9.8 , which also comment on glibc sources. *2

Note:

*1 I checked out the sources from CVS repository of mozilla.org. One of the motivations to compile firefox source was to test -K option of mcpp. This option was proposed by Taras Glek, and he was working on refactoring of C/C++ source at mozilla.com. So, I also used firefox source to test -K option and other behaviors of mcpp. About -K (-Kv) option, refer to 2.4.

*2 There is a list of coding-guidelines for firefox as below. But, its content is too old.
portable-cpp

#### 3.9.11.1. GCC-local specifications are rarely used

The following GCC-local-specs, which are sometimes used in glibc sources, are not used in firefox sources. Though compiling firefox on Linux includes system headers, and some of which contain such as GCC2-spec variadic macros, they are not firefox sources themselves.

- GCC-local variadic macro
  Even C99 spec variadic macro is not yet used, too.

The following features are not used even in recent glibc, and not used in firefox at all.

- Multi-line string-literal
- #warning
- -isystem, -I- options

#### 3.9.11.2. #include_next

However, a lot of #include_next are found only in one directory: `config/system_wrappers/`, which is generated by configure. All of the 900 files generated in the directory are short header files of the same pattern. For example, `stdio.h` is:

    #pragma GCC system_header
    #pragma GCC visibility push(default)
    #include_next <stdio.h>
    #pragma GCC visibility pop

This is a code to utilize '`#pragma GCC visibility *`' directive implemented in GCC 4.*. At the same time, there is a file '`config/gcc_hidden.h`' as below. The file is specified by -include option for most of the translation units, and read in at the start of the units.

    #pragma GCC visibility push(hidden)

`system_wrappers` directory should be the include directory with the highest priority, so you should specify it as a first argument of -I option. In spite of such a constraint, this usage of #include_next is simple and seems to has no problem.

On the other hand, for many sources in `nsprpub` directory, '`-fvisibility=hidden`' option is used instead of '`-include gcc_hidden.h`', and the headers in `system_wrappers` are not used. This `nsprpub` directory seems still to be reorganized.

#### 3.9.11.3. Using C99 specs without specifying C99

Many sources use C99 specifications without specifying C99. GCC use "gnu89" spec by default on *.c source, which is a compromising spec of C90 plus some of C99 specs and GCC-local specs. Some of firefox sources use the following C99 specs implicitly, depending on GCC's default behavior.

- Empty argument in macro call

  Though empty argument in macro call is rare in firefox, these 3 files have it. The actual macro called with any empty argument is only one named `NS_ENSURE_TRUE`.

  `layout/style/nsHTMLStyleSheet.cpp, layout/generic/nsObjectFrame.cpp, intl/uconv/src/nsGREResProperties.cpp`

  Also the following files in `gfx/cairo/cairo/src/` have it. The actual macro is only one: `slim_hidden_ulp2`.

  `cairoint.h, cairo-font-face.c, cairo-font-options.c, cairo-ft-font.c, cairo-ft-private.h, cairo-image-surface.c, cairo-matrix.c, cairo-matrix.c, cairo-pattern.c, cairo-scaled-font.c, cairo-surface.c, cairo-xlib-surface.c, cairo.c`

  Though these empty macro arguments are used on Linux, they are not used on Mac OS X. Anyway, these are not tricky ones.

- Translation limits beyond C90

  Length of an identifier, nesting level of #include, number of macro definitions and so forth often exceed C90 translation limits.
  Identifiers longer than 31 bytes are found especially frequently in the directory `gfx/cairo/cairo/src/`. Nesting of #include over than 8 level and macro definitions over than 1024 are often found, too. These are almost inevitable on Linux and Mac OS X, since only inclusion of some system headers often reaches these limits.

- Using `//` comment in C source

  Some C sources have this type of comments. The list of guidelines prohibits this. However, this causes few problem nowadays.

Above specifications are also available on Visual C 2005, 2008. Since GCC has `-std=c99` option, we might use this to specify C99 explicitly. Visual C, however, has no option to specify a version of Standard. We cannot help to use C99 specs implicitly. Therefore, firefox sources cannot be blamed for using C99 specs implicitly, in the current states of the major compiler-systems. *1

By the way, firefox sources do not use variadic macro for some reason, in spite of using some other C99 specs implicitly. Visual C up to 2003 did not implement variadic macro. Is that why firefox did not use the feature? The circumstances has changed since Visual C 2005 implemented it.

Note:

*1 On C++, GCC defaults to "gnu++98" spec, which is explained as "C++98 plus GCC extensions". It has in actual, however, some C99 specs mixed. Meanwhile, Visual C says that it is based on C90 and C++98 for C and C++ respectively. In actual, both of C and C++ of Visual C have C99 features mixed in it as well as a few Visual C extensions, especially in Visual C 2005 and 2008. Both of GCC and Visual C have such mixture of versions of Standard and their own extensions and modifications, thus bring about some ambiguities. The absence of option in Visual C to specify a version of Standard is the most inconvenient problem.

#### 3.9.11.4. Object-like macro replaced with function-like macro name

Object-like macro replaced with function-like macro name is found sometimes in many other programs, and is found also in firefox sources below, though not frequently.

`content/base/src/nsTextFragment.h, modules/libimg/png/mozpngconf.h, modules/libjar/zipstub.h, modules/libpr0n/src/imgLoader.h, nsprpub/pr/include/obsolete/protypes.h, nsprpub/pr/include/private/primpl.h, nsprpub/pr/include/prtypes.h, parser/expat/lib/xmlparse.c, security/nss/lib/jar/jarver.c security/nss/lib/util/secport.h, xpcom/glue/nsISupportsImpl.h`

In addition, building of firefox creates, in a directory for developing environment, many links to header files, which are copied into /usr/include/firefox-VERSION/ when you install developing environment for firefox. Some of these header files have symbolic links to the above files. `mozilla-confic.h`, that is created by configure, has a macro definition of this kind, too.

These macros should be written as function-like macro to improve readability. In actual, many other macros in firefox sources are defined as function-like macro replacing to another function-like macro with the same arguments. There are coding style differences among the authors. It would be better to set a coding guideline on this matter.

#### 3.9.11.5. Macro expanded to 'defined'

A Macro with 'defined' token in its replacement text, sometimes found in glibc, is found in firefox only once.

`modules/oji/src/nsJVMConfigManagerUnix.cpp` defines a macro as:

    #define NS_COMPILER_GNUC3 defined(__GXX_ABI_VERSION) && \
                              (__GXX_ABI_VERSION >= 102) /* G++ V3 ABI */

and uses it in itself as:

    #if (NS_COMPILER_GNUC3)

This macro should be removed and the #if line should be rewritten as:

    #if defined(__GXX_ABI_VERSION) && (__GXX_ABI_VERSION >= 102) /* G++ V3 ABI */

Maybe this file is to be compiled only by GCC, nevertheless it is not good practice to depend on preprocessor's wrong implementation.

Note:

*1 GCC-specific-build of mcpp V.2.7 enabled GCC-like handling of 'defined' in macro on #if line. But mcpp warns at it, and you would better to revise the code.

#### 3.9.11.6. Tokens in #endif line

The following files in `jpeg` directory have #endif lines with comments without comment mark. All of the lines has appeared by some recent updates.

    jmorecfg.h, jconfig.h, jdapimin.c, jdcolor.c, jdmaster.c

Though this style of writing was frequently seen in some sources for UNIX-like systems up until middle of 1990s, it has almost completely disappeared nowadays, and cannot be found even in that glibc sources. GCC usually warns at it as expected. For all that, these sources take such a writing style. Only Apple-GCC does not warn at it. Have these sources been edited on Mac OS?

#### 3.9.11.7. Assembler Source Which Needs Preprocessing

The assembler sources are written as *.s (*.asm) files, and some of which contain macros, but in principle, they do not call for preprocessor.

On Mac OS X / ppc, however, there is only one exception. `xpcom/reflect/xptcall/src/md/unix/xptcinvoke_asm_ppc_rhapsody.s` calls for preprocessor, because it has a #if block containing only one line. The block seems to be unnecessary already.

#### 3.9.11.8. -include option

Compilation of firefox begins with `configure`, which generates `mozilla-config.h`. In compilation of most of the sources, this header file is specified by -include option. `config/gcc_hidden.h` is also specified similarly. Why don't the sources #include these headers at their top?

#### 3.9.11.9. Redefinition of macro

Some silent redefinition of macros are found, though they are rare.

- In compilation of most of the sources, `-DZLIB_INTERNAL` option is specified. In other words, the macro is defined as 1. It is, however, defined by some sources in `modules/zlib/src/` as:

      #define ZLIB_INTERNAL

  It is defined to zero token. And it is used as:

      #    ifdef ZLIB_INTERNAL

  Though the difference does not make different result in this case, different definitions of the same macro is not recommended. Maybe the option by Makefile is redundant.

- `xpcom/build/nsXPCOMPrivate.h` defines a macro `MAXPATHLEN` differently from `/usr/include/sys/param.h`. This discrepancy stems from an inconsistency among the related header files about whether include `/usr/include/sys/param.h` or not. The related header files should be reorganized.

- On Mac OS X, `assert` macro, once defined in `/usr/include/assert.h`, is redefined in `netwerk/dns/src/nsIDNKitInterface.h`. '`#undef assert`' should precede it.

- On Mac OS X, in `modules/libreg/src/VerReg.c`, queer redefinition of macro `VR_FILE_SEP` occurs as:

      #if defined(XP_MAC) || defined(XP_MACOSX)
      #define VR_FILE_SEP ':'
      #endif
      #ifdef XP_UNIX
      #define VR_FILE_SEP '/'
      #endif

  , because on Mac OS X, configure defines both of `XP_MACOSX` and `XP_UNIX`. This redefinition may be an intended one. Anyway, it is misleading. It would be better to write as below, clearly showing the priority of `XP_UNIX`.

      #ifdef XP_UNIX
      #define VR_FILE_SEP '/'
      #elif defined(XP_MAC) || defined(XP_MACOSX)
      #define VR_FILE_SEP ':'
      #endif

#### 3.9.11.10. Too long comments

The following files have too long comments crossing over several hundred lines or more.

`extensions/universalchardet/src/base/Big5Freq.tab, extensions/universalchardet/src/base/EUCKRFreq.tab,intl/unicharutil/src/ignorables_abjadpoints.x-ccmap, layout/generic/punct_marks.ccmap`

Especially, in the directories `intl/uconv/ucv*/`, there are many files with too long comments. There is even a case of single comment crossing over 8000 lines! All of these files have name of *.uf or *.ut, and are mapping tables between Unicode and each Asian encodings, generated automatically by some tool. They do not seem to be source of C/C++, but they are included from other C++ sources. Most part of these files are comments, which seem to be a sort of document or table for some other tool.

It is not recommendable to include long documents or tables in source files. They should be separated from source files, even if placed in source tree.

Though these files are used in Linux, they are not used in Mac OS X. On the other hand, on Mac OS X, system headers in framework directories are frequently used, and some of them are queer files mostly occupied with comments.

#### 3.9.11.11. Mixed encodings of newline

The encoding of newline in firefox source is [LF]. A few files, however, have a small block of lines ending with [CR][LF]. All of these [CR][LF] lines seem to be fragments inserted as patches. Some conversion tools should be used when one edit source file on Windows.

## 3.10. Visual C++ System Header Problems

I used mcpp to preprocess some sample programs provided by Visual C++ 2003, 2005 and 2008. The system headers seem to have only a few compatibility problems shown below. These problems are often seen in other compile systems and do not have a serious impact on preprocessing.

1. Since when Visual C++ scarcely implemented the C99 specifications, // comments have often been used in C source code.
2. Object-like macro definitions that are expanded into function-like macro names are sometimes found.
3. On Visual C++ 2003, there was one wrong macro definition in limits.h. (It was revised on Visual C++ 2005. See Note 2 in cpp-test.html#5.1.3.1)

Although the Linux system-headers and glibc sources often contain GCC local specification based coding, Visual C++ system headers has only a few Visual C++ local coding.

### 3.10.1. Comment Generating Macro?

I found only one outrageous macro in Visual C++. `Vc7/PlatformSDK/Include/WTypes.h` has the following macro definition: *1

    #define _VARIANT_BOOL   /##/

This macro definition is used in oaidl.h and propidl.h in `Vc7/PlatformSDK/Include/` as follows:

    _VARIANT_BOOL bool;

What does this macro aim at?

This macro seems to expect `_VARIANT_BOOL` to be expanded into // and the line to be commented out. Actually, this expectation is met in Visual C cl.exe !

In the first place, // is not a token (preprocessing-token). Macro definitions should be processed and expanded after source are parsed into tokens and a comment is converted into one space. Therefore, it is irrational for a macro to generate comments. When this macro is expanded into //, the result is undefined because // is not a valid preprocessing-token.

In order to use these header files with mcpp, comment out these macro definitions and change many `_VARIANT_BOOL` occurrences as follows:

    #if !__STDC__ && (_MSC_VER <= 1000)
        _VARIANT_BOOL bool;
    #endif

If you use only Visual C 5.0 or later, this line can be simply commented out as follows:

    // _VARIANT_BOOL bool;

This macro is, indeed, out of question, however, it is Visual C/cl.exe, which allows such an outrageous macro to be preprocessed as a comment, should be blamed. This example reveals the following serious problems this preprocessor has:

1. Preprocessing is not token-based but character-based at least in this example.
2. The macro expansion result is treated as comment, which indicates the translation phases are confusing.

Probably, the cl.exe preprocessor was developed based on a very old somewhat character-based preprocessor. It is easy to presume that the preprocessor has been upgraded by repeating partial revision to the old preprocessor.

There are many preprocessors which presumably have a very old program structure. GCC 2/cpp, shown in 3.9, is one of such preprocessors. Repeated partial revision of such a preprocessor will only makes its program structure more complicated. However much such revision may be made, there are limits to quality such preprocessor can achieve. Unless a old source is given up and completely rewritten, a clear and well-structured preprocessor cannot be obtained.

At GCC 3/cpp0, a total revision was made to GCC 2; the entire source code was rewritten. So, GCC 3/cpp0 has become quite different from GCC 2. Although mcpp was initially developed based on the source of an old preprocessor, DECUS cpp, the source code was totally rewritten soon.

Note:

*1 Visual C++ 2005 Express Edition does not contain Platform SDK. However, you can download "Platform SDK for Windows 2003", and use it with VC2005. `wtypes.h, oaidl.h, propidl.h` in this `PlatformSDK/Include` directory also have the same macro definition and its usage as VC2003 Platform SDK.
Also on Visual C++ 2008, in the header files of the same name in '`Microsoft SDKs/Windows/v6.0A/Include`' directory, that macro definition and its usage are quite the same.

### 3.10.2. '$' in Identifiers

Another problem is use of '$' in identifiers. Its use in macro names suddenly increased in the system headers on Visual C++ 2008. Though such macros were also found on Visual C++ 2005, they were rare. But, on Visual C++ 2008, they are found here and there.

'`Microsoft Visual Studio 9.0/VC/include/sal.h`' is the most conspicuous one. This header defines macros for so-called SAL (standard source code annotation language) of Microsoft, and has many names containing '$'. This file is included from many standard headers via '`Microsoft Visual Studio 9.0/VC/include/crtdefs.h`', so most sources are compiled with these macros without knowing it.

If you specify -Za option to invoke the compiler cl, the SAL is disabled and all of the names with '$' in the `sal.h` disappear. The necessity of this notation is, however, hard to understand. Though GCC also enables '$' in identifiers by default, its actual use is rarely found nowadays.

This kind of names are also found in the system headers named `specstrings*.h` in '`Microsoft SDKs/Windows/v6.0A/Include`' directory. They are included from `Windows.h` via `WinDef.h`, and the names with '$' do not disappear even -Za option is specified. The option causes only errors. So, you cannot use the -Za option to compile a source which includes `Windows.h`.

# 4. Implementation-defined Behaviors

This chapter does not contain all the C preprocessor specifications. For details on Standard C preprocessing, refer to cpp-test.html. For mcpp behaviors in each mode, refer to 2.1. This chapter covers several preprocessor-related specifications, including those called implementation-defined by Standards. For more details on mcpp implementation-defined-behaviors, see Chapter 5, "Diagnostic Messages".

## 4.1. Status Value on Exit

The header file internal.H defines values returned by mcpp to a parent process. mcpp returns 0 on success, and errno for errno != 0 and 1 for errno == 0 on error. Success means that no error has occurred.

## 4.2. Include Directory Search Path

This section explains the order in which mcpp searches directories for an include file when it encounters a #include directive.

1. If a #include directive argument takes A Form of neither "file-name" nor <file-name>, and is a macro, the macro is expanded. The resulting filename must take a form of either "file-name" or <file-name>. Otherwise, it causes an error.
2. If the resulting filename, either in form of "file-name" or <file-name>, is a full path name, mcpp tries to open it. If it fails, it causes an error.
3. If the resulting filename is not a full path but takes a form of "file-name", mcpp regards it as a filename relative from the current directory or source file directory, and begins searching from that directory. The former is a directory from which mcpp was invoked and the latter is a directory where the source file that includes the "file-name" resides. Depending on the specified options and compiler systems, mcpp begins searching directories as follows:
   1. If -I1 is specified, search begins from current directory.
   2. If -I2 is specified, source file directory.
   3. If -I3 is specified, current first and then source file directory.
   By default, the compiler-specific-builds for UNIX compiler systems, GCC or Visual C begin searching from the source file directory. The other compiler-specific-builds begin searching at the current directory. However, Borland C-specific-build searches current first and then source file directory. The compiler-independent-build of mcpp begins search from the source file directory.
   For GCC, the directories specified by -iqoute option are searched next. For Visual C, also the directories of each ancestor file of source file are searched one by one.
   If mcpp fails to find the desired file, it begins searching as shown in step 4.
   In case of a nested #include, if search begins at current directory, the base directory is always the same. If search begins at a source file directory, the base directory changes each time a header file resides in other directory.
4. If the resulting filename is not a full path name but takes a form of <file-name>, mcpp searches directories in the following order. If any of these directories are specified as a relative path, then mcpp regards it as a relative directory from the current directory at mcpp startup. If mcpp fails to find or open the desired file after searching all the directories in these order, it causes an error.
   1. Directory(s) specified with the -I <directory> option on mcpp invocation. If several directories are specified, they are searched in the order in which specified (with the left first).
   2. For GCC-specific-build, directories specified with the -isystem option. If several directories are specified, they are searched in the order specified (from the left).
   3. Directories specified with an environment variable. ENV_C_INCLUDE_DIR in noconfig.H (configed.H) defines environment variable names. In C++, ENV_CPLUS_INCLUDE_DIR, if defined, takes precedence over ENV_C_INCLUDE_DIR. GCC-specific-build uses C_INCLUDE_PATH (and also CPLUS_INCLUDE_PATH for C++) as default environment variable. Other mcpp uses `INCLUDE` (and also `CPLUS_INCLUDE` for C++) as default. If an environment variable specifies several directories with each separated with a delimiter, they are searched in the order in which specified. Windows and other OSs use ";" and ":" as delimiter, respectively.
   4. Implementation-specific directories for C++ defined by the CPLUS_INCLUDE_DIR? macros in noconfig.H (configed.H).
   5. Site-specific directories defined by setsysdirs() in system.c (For UNIX systems, `/usr/local/include`).
   6. Implementation-specific directories defined by the C_INCLUDE_DIR? macros in noconfig.H (configed.H).
   7. System-specific directories defined by setsysdirs() in system.c (For UNIX systems, `/usr/include`).

With the -I- option (-nostdinc option for GCC-specific-build and -X for Visual C-specific-build), the directories specified in 4.4 and later are not searched.

ANSI C Rationale says the ANSI committee intends to define a current directory as base directory. I think this is acceptable, in that the base directory is always constant and that the specification is clearer. However, some implementations, such as UNIX, seem to define a source file directory as base one at least for #include "header". The compiler-independent-build of mcpp also takes source file directory as base, according to the majority.

## 4.3. How to Construct Header Name

This section explains how to construct a header-name pp-token and extract a file name from it.

1. If source code contains a header file name in the string literal format, mcpp regards it as a header-name and removes the " at the both ends to construct a filename. This can be applied to a string literal resulting from macro expansion in source code.
2. If source code contains a header file name in the <filename> format, mcpp regards it as a header-name and removes the < and > at the both ends to construct a filename. This can be applied to a <filename> format sequence resulting from macro expansion. The spaces in the macro are retained squeezing multiple spaces into one space.
3. In any case, mcpp converts \ to /, although both of "\" and "/" can be used as path delimiters on Windows.

## 4.4. Evaluation of #if Expression

Evaluation of #if expression depends on the largest integer type of the host compiler (by which mcpp was compiled) and that of the target compiler (which uses mcpp). Since the compiler-independent-build has no target compiler, the type depends only on the host compiler.

mcpp in Standard mode evaluates #if expression in the common largest integer type of the host and target compiler. Nevertheless, mcpp in pre-Standard mode evaluates it in (signed) long.

In the compiler-systems having type "long long", if `__STDC_VERSION__` is set to 199901L or higher using the -V199901L option, mcpp evaluates a #if expression in "long long" or "unsigned long long", according to the C99 specification. Although C90 and C++98 stipulate that #if expression is evaluated in long / unsigned long, mcpp evaluate it in long long / unsigned long long even in C90 or C++98 mode, and issues a warning in case of the value overflows the range of long / unsigned long. *1

Visual C and Borland C 5.5 do not have a "long long" type, but have an __int64 type of the same length. So, a #if expression is evaluated as __int64 / unsigned __int64. (However, since LL and ULL suffixes cannot be used in Visual C++ 2002 or earlier and Borland C 5.5, these suffixes must not be used in coding other than #if lines.)

In addition, when you invoke with the -+ option for C++ preprocessing, mcpp evaluates pp-tokens 'true' and 'false' in a #if expression to 1LL (or 1L) and 0LL (or 0L), respectively.

mcpp in Standard mode evaluates #if expression as follows. For a compiler without long long, please read "long long" and "unsigned long long" hereinafter, until the end of 4.5, as "long" and "unsigned long", respectively. For pre-Standard mode read all of them as "long".

1. An integer constant token with a U suffix, including character constants, is evaluated in unsigned long long. (Note that pre-Standard mode does not recognize the U suffix).
2. Otherwise, a token within the range of non-negative long long is evaluated in long long.
3. Otherwise, a token within the range of unsigned long long is evaluated in unsigned long long.
4. Otherwise, it is diagnosed as an out of range error.
5. In a binary operation, if either operand is unsigned long long, both are converted to unsigned long long. Otherwise, an operation is performed in signed long long.

Anyway, an integer constant token always has a non-negative value.
In pre-Standard mode, an integer constant token is evaluated within the range of non-negative long. A token beyond that range is diagnosed as an out of range error. All the operations are performed within the range of long.

If both of host and target compilers have type unsigned long long and the range of unsigned long long of the host is narrower than that of the target, a beyond that host range is evaluated to an out of range error.

If an operation using constant tokens produces a result out of range of long long, an out of range error occurs. If it produces a result out of range of unsigned long long, a warning is issued. This can be applied to intermediate operation results.

Since a bitwise right shift of a negative value or a division operation using it does not provide portability, mcpp issues a warning. If an operation using a mixture of unsigned and signed operands converts a signed negative value to an unsigned positive value, a warning is also issued. How these values are evaluated depends on the specification of the compiler-proper of the host system.

C90 and C++98 makes it a rule that a preprocessor evaluates a #if expression in long/unsigned long (in C99, the maximum integer type is used). These specifications are rougher than those of compiler-propers. A (#)if expression is often evaluated differently between preprocessor and compiler-proper, especially when sign extension is involved.

In addition, since keywords are not used during Standard C preprocessing, sizeof or cast cannot be used in a #if expression. Of course, neither variables, enumeration constants, nor floating point numbers can be used there. Standard mode allows the "defined" operator in a #if expression as well as the #elif directive. Except for these differences, mcpp evaluates a #if expression in accordance with priority of and the associative law among operators, just as compiler-propers do. In a binary operation, an arithmetic conversion often takes place to equalize the types on both-hand sides; If one operand is unsigned long long and the other is long long, the both are converted to unsigned long long.

Note:

*1 mcpp up to V.2.5 evaluated #if expression in C90 and C++98 by long long / unsigned long long internally, and issued an error on overflow of long / unsigned long. From V.2.6 onward, mcpp degraded the error to warning for compatibility with GCC or Visual C.

## 4.5. Character Constant Evaluation in #if Expression

Constant tokens in a #if expression includes identifiers (macros and non-macros), integer tokens and character constants. How to evaluate character constants is implementation-defined and lacks of portability. Even (#)if 'const' is sometimes evaluated differently between preprocessor and compiler-proper. Note that Standards does not even guarantee that (#)if 'const' is evaluated to the same.

mcpp in POSTSTD mode does not evaluate a character constant in a #if expression, which is almost meaningless, and makes it an error.

Like other integer constant tokens, mcpp evaluates a character constant in a #if expression within the range of long long or unsigned long long. (In pre-Standard mode, long only.)

A multi-byte character or a wide character is generally evaluated with 2-bytes type, except for the UTF-8 encoding, which is evaluated with 4-bytes type. Since UTF-8 has a variable length, mcpp evaluates it with 4-byte type. mcpp does not support EUC's 3 byte encoding scheme. (A 3-byte character is recognized as 1 byte + 2 bytes. As a consequence, its value is evaluated correctly.) Although there are some implementations using the 2-byte encoding scheme that define wchar_t as 4-byte, mcpp has no relevance to wchar_t. The following paragraphs describe two-byte multi-byte character encodings.

Multi-byte character constants, such as 'X', are evaluated to ((First byte value << 8) + Second byte value). (8 is the value of `CHAR_BIT` in <limits.h>.) Note that 'X' is used here to designate a multi-byte character. Though 'X' itself is not a multi-byte character, it is used here to avoid character garbling.

Let me take an example of multi-character character constants, such as 'ab', '\x12\x3', and '\x123\x45'. 'a', 'b', '\x12', '\x3' and '\x123' are regarded as one byte. When a multi-character character constant is evaluated, each one byte, starting from the highest one, is evaluated within the range of [0, 0xFF] and combined by shifting it to left by 8. (0xFF is the value of `UCHAR_MAX` in <limits.h>.) If the value of one escape sequence exceeds 0xFF, an out of range error occurs. Therefore, in the implementation of the ASCII character set, the above three tokens are evaluated to 0x6162, 0x1203 and error, respectively.

L'X' is evaluated to the same value as 'X'. Let me take an example of multi-character wide character constants, such as L'ab', L'\x12\x3', and L'\x123\x45'. L'a', L'b', L'\x12', L'\x3', L'\x123', and L'\x45' are regarded as one wide character. When a multi-character wide character constant is evaluated, each wide character, starting from the highest one, is evaluated within the range of [0, 0xFFFF] and combined by shifting it to left by 16. If the value of one escape sequence exceeds the maximum value of an unsigned 2-byte integer, an out of range error occurs. Therefore, in the implementation of the ASCII character set, the above three tokens are evaluated to 0x00610062, 0x00120003, and 0x01230045, respectively.

If the values of a multi-character character constant and a multi-character wide character constant exceed the range of unsigned long long, an out of range error occurs.

With `__STDC_VERSION__` or `__cplusplus` set to 199901L or higher, mcpp evaluates a Universal Character Name (UCN) in the form of \uxxxx and \Uxxxxxxxx as a hex escape sequence. (I know this evaluation is nonsense but no other way.)

If the compiler-proper of the target compiler system uses a signed char or signed wchar_t, a character constant in a (#)if expression may be evaluated differently between mcpp and compiler-proper. The range that causes a range error may also differ between them. In addition, evaluation of multi-character character constants and multi-byte character constants varies even among preprocessors and among compilers. Standard C does not define whether, with `CHAR_BIT` set to 8, 'ab' is evaluated to 'a' * 256 +'b' or 'a' + 'b' * 256.

In general, character constants should not be used in an #if expression, as long as you have an alternative method. I think an alternative method always exists.

## 4.6. #if sizeof (type)

Standard C stipulates that preprocessing is a process independent of run-time environments or compiler-proper specifications, thus prohibiting it from using sizeof and cast in an #if expression. However, pre-Standard mode allows sizeof (type) in a #if expression. This was done as a part of my effort to add necessary modifications to DECUS cpp, such as adding long long and long double processing, while retaining its original functionality. As to cast, I neither implemented nor had a will to do so because it would require troublesome work.

A series of macros beginning with S_, such as S_CHAR, in eval.c define the size of each type. Under cross implementation, these macros must be modified to specify size of the types, in integer values, used in the target system.

I have to admit that mcpp does not provide the full functionality of #if sizeof. mcpp just ignores the letter of "signed" or "unsigned" preceding char, short, int, long, and long long when it appears in a #if sizeof. Also mcpp does not support sizeof (void *). I know this is a half-hearted implementation but I do not want to increase the number of flags in system.H in vain for this non-conforming function. I initially thought of removing the sizeof code from the original version because I did not intend to support cast at all, but on the second thought, I decided to make a small amount of modifications to make use of the existing code.

## 4.7. How to Handle White-Space Sequence

mcpp in principle compresses a white-space sequence, excluding <newline>, as a token separator into one space character during tokenization in the translation phase 3. If -k or -K option is specified in STD mode, however, it outputs horizontal white spaces as they are without compressing. It also deletes a white-space sequence at the end of a line.

A white-space sequence at the beginning of a line is deleted in POSTSTD mode, and putout as they are in other modes. The latter is special treatment for convenience of human reading. *1

This compression and deletion occurs during the intermediate phase. The next phase 4 involves macro expansion and preprocess-directive-line processing. Macro expansion may sometimes produce several space characters before and after the macro. Of course, the number of space characters does not affect compilation results.

Standard C says that whether implementation compresses a white-space sequence into one space character during the translation phase 3 is implementation-defined, but you usually do not have to worry about this. <Vertical-tab> or <form-feed> in a preprocessor directive line may adversely affect portability, since this is undefined in Standard C. mcpp converts it to one space character.

Note:

*1 Up to V.2.6.3 mcpp squeezed line top white spaces into one space. In V.2.6.4, it changed the behavior.

## 4.8. Default Specifications for mcpp Executables

This section describes the specifications of mcpp executables generated when DIFfile and makefile for each compiler system in the noconfig directory are used to compile mcpp with default settings. When a configure script is used to compile mcpp, the generated mcpp may differ, depending on configure's results, however, as long as OS and compiler system versions are same, generated mcpps would be same except for include directories.

The compiler-independent-build of mcpp has the constant specifications regardless of the compiler system with which mcpp was compiled, except a few features dependent on OS and CPU.

There are compiler-independent-build and compiler-specific-build for mcpp executables, and each executable has several behavioral modes. For those, refer to 2.1. This section describes the settings centering on STD mode.

DIFfiles and makefiles are for the following compiler systems:

> FreeBSD 6.3 | GCC V.3.4
> Vine Linux 4.2 / x86 | GCC V.2.95, V.3.2, V.3.3, V.3.4, V.4.1
> Debian GNU/Linux 4.0 / x86 | GCC V.4.1
> Ubuntu Linux 8.04 / x86_64 | GCC V.4.2
> Fedora Linux 9 / x86 | GCC V.4.3
> Mac OS X Leopard / x86 | GCC V.4.0
> CygWIN | 1.3.10 (GCC V.2.95), 1.5.18 (GCC 3.4)
> MinGW & MSYS | GCC 3.4
> WIN32 | LCC-Win32 2003-08, 2006-03
> WIN32 | Visual C++ 2003, 2005, 2008
> WIN32 | Borland C++ V.5.5

In addition, for the following compilers which I don't have, the difference files contributed from some users are contained here.

> WIN32 | Visual C++ V.6.0, 2002
> WIN32 | Borland C++ V.5.9 (C++Builder 2007)

Of all the macros defined in noconfig.H and system.H, the settings of those mentioned below are identical among every mcpp executable, regardless of their compiler systems.

Each mcpp is compiled with DIGRAPHS_INIT == FALSE, so enables digraph when the -2 (-digraphs) option is specified.
With TRIGRAPHS_INIT == FALSE, trigraph is enabled with the -3 (-trigraphs) option.
With OK_UCN set to TRUE, Universal Character Name (UCN) can be used in C99 and C++.
With OK_MBIDENT set to FALSE, multi-byte-characters cannot be used in identifiers.

With STDC set to 1, the initial value of `__STDC__` is 1.

The translation limits are set as follows.

> NMACPARS (Maximum number of macro arguments) | 255
> NEXP (Maximum number of nested levels of #if expressions) | 256
> BLK_NEST (Maximum number of nested levels of #if section) | 256
> RESCAN_LIMIT (Maximum number of nested levels of macro rescans) | 64
> IDMAX (Valid length of identifier) | 1024
> INCLUDE_NEST (Maximum number of #include nest level) | 256
> NBUFF (Maximum length of a source line) *1 | 65536
> NWORK (Maximum length of an output line) | 65536
> NMACWORK (Size of internal buffers used for macro expansion) | 262144

On GCC-specific-build and Visual C-specific-build, however, NMACWORK is used as the maximum length of an output line.

This macro differs on OS regardless of build types.

MBCHAR (Default encoding of multibyte character):

> Linux, FreeBSD, Mac OS X | EUC-JP
> WIN32, CygWIN, MinGW | SJIS

The settings of the macros below are different among compiler systems.

STDC_VERSION (Initial value of `__STDC_VERSION__`):

> Compiler-independent, GCC 2 | 199409L
> Others | 0L

HAVE_DIGRAPHS (Is digraphs output as it is?):

> Compiler-independent, GCC, Visual C | TRUE
> Others | FALSE

EXPAND_PRAGMA (Is a #pragma line macro-expanded in C99?):

> Visual C, Borland C | TRUE
> Others | FALSE

GCC 2.7-2.95 defines `__STDC_VERSION__` to 199409L. However, in GCC V.3.*,V.4.*, `__STDC_VERSION__` is no longer predefined by default and is now defined in accordance with an execution option. mcpp setting for GCC follows these variations.

If STDC_VERSION is set to 0L, mcpp predefines `__STDC_VERSION__` as 0L. So, specifying the -V199409L option sets `__STDC__` and `__STDC_VERSION__` to 1 and 199409L, respectively and allows only predefined macros that begin with '_', resulting in mcpp in the strictly C95 conforming mode. The -V199901L option specifies C99 mode.

In C99 mode, mcpp predefines `__STDC_HOSTED__` as 1.

mcpp itself predefines neither `__STDC_ISO_10646__`, `__STDC_IEC_559__` nor `__STDC_IEC_559_COMPLEX__`. These values are compiler-system-specific. In glibc 2 / x86, the system header defines `__STDC_IEC_559__` and `__STDC_IEC_559_COMPLEX__` as 1. Other compiler systems do not define them.

If HAVE_DIGRAPHS is set to FALSE, digraph is output after converting to usual token.

The argument of #pragma line beginning with STDC, MCPP or GCC is never macro-expanded even if EXPAND_PRAGMA == TRUE.

Include directories are set as follows:

System-specific or site-specific directories under UNIX-like OSs are as follows (common to compiler-independent-build and compiler-specific-build):

> FreeBSD, Linux, Mac OS X, CygWIN | /usr/include, /usr/local/include

Mac OS X has also the framework directories set to /System/Library/Frameworks and /Library/Frameworks by default.

On MinGW, /mingw/include is the default include directory.

CygWIN GCC-specific-build changes /usr/include to /usr/include/mingw by -mno-cygwin option.

For the implementation-specific directories that vary among compiler systems and their versions, see the DIFfiles. The compiler-independent-build does not set implementation-specific directories. mcpp for the compiler systems on Windows does not preset any directory but uses the environment variables: INCLUDE, CPLUS_INCLUDE. These environment variables are used by the compiler-independent-build too.

If these default settings do not suit you, change settings to recompile mcpp, or use environment variables or the -I option.

When the length of a preprocessed line exceeds NWORK-1, mcpp generally divides it into several lines so that each line length becomes equal to or less than NWORK-1. A string literal length must be equal to or less than NWORK-2. mcpp of GCC-specific-build and Visual C-specific-build, however, do not divide output line.

Again for confirmation, the macros mentioned above in italics are used only to compile mcpp, and are not built-in macros in a mcpp executable.

If you invoke mcpp without an input file and enter '#pragma MCPP put_defines', the built-in macros will be displayed.

With `__STDC__` set to 1 or higher, the macros that do not begin with '_' are deleted. The -N (-undef) option deletes all the macros other than `__MCPP`. After -N, you can use -D to defines macro symbols over again. When you use a different compiler system version from those specified here, -N and -D allow you to redefine your version macro without recompiling mcpp. The -D option allows you to redefine a particular macro without using -N or -U.

When you use the -+ (-lang-c++) option to specify C++ preprocessing, `__cplusplus` is predefined with its initial value of 1L. In addition, some other macros are also predefined:

Although there are some predefined macros in GCC, those predefined by GCC were few, until GCC V.3.2. Most of them are passed from gcc to cpp by the -D option. So, it is not necessary for mcpp to define them for compatibility. However, mcpp predefines these macros for being used in a stand alone manner, such as pre-preprocessing.

GCC V.3.3 and later predefines 60 or 70 macros (suddenly). GCC-specific-build of mcpp V.2.5 and later for GCC V.3.3 or later also includes these predefined macros other than the above ones. These GCC-specific predefined macros are written in `mcpp_g*.h` header files, which is generated by installation of mcpp.

Since FreeBSD, Linux, CygWIN, MinGW / GCC and LCC-Win32, Visual C 2008 have a type long long, an #if expression is evaluated in long long or unsigned long long. Visual C 6.0, 2002, 2003, 2005 and Borland C 5.5 do not have a "long long" type but __int64 and unsigned __int64 instead. These types are used.

In the above compiler systems with type long ranges:

    [-2147483647-1, 2147483647] ([-0x7fffffff-1, 0x7fffffff])

and unsigned long ranges:

    [0, 4294967295] ([0, 0xffffffff]).

In the compiler systems with type long long ranges:

    [-9223372036854775807-1, 9223372036854775807]
    ([-0x7fffffffffffffff-1, 0x7fffffffffffffff]),

and unsigned long long ranges:

    [0, 18446744073709551615] ([0, 0xffffffffffffffff]).

All the compiler-propers of the above compiler systems internally represent a signed integer as two's complement number. So do bit operations. This can be applied to mcpp's #if expression.

Right shift of a negative integer is an arithmetic shift. This can be applied to mcpp's #if expression. (Right shifting an integer by one bit halves the value with the sign retained)

In an integer division or modulus operation, if either or both operands are negative values, an algebraic operation like Standard C's ldiv() function is performed. This can be applied to mcpp's #if expression.

These OSs use the ASCII basic character set. So does mcpp.

There is a memory management routine, kmmalloc, that I developed. This routine has malloc(), free(), realloc() and other memory handling functions. If kmmalloc is installed in systems other than CygWIN or Visual C 2005 or 2008, kmmalloc is linked when the MALLOC=KMMALLOC (or -DKMMALLOC=1) option is specified in make. Also its heap memory debugging routine is linked. mcpp for Linux and LCC-Win32 uses EFREEP, EFREEBLK, EALLOCBLK, EFREEWRT and ETRAILWRT with an errno of 2120, 2121,2122, 2123 and 2124 assigned, and other mcpp uses 120, 121, 122, 123, and 124. (Refer to mcpp-porting.html#4.extra.) *2

On the systems other than GNU and Visual C, you should preset the environment variable TZ, for example JST-9 in Japan. Or, the `__DATE__` and `__TIME__` macros are not set correctly.

Note:

*1 This limit applies also to the line spliced by <backslash><newline> deletion. Moreover, it applies to the line after converting a comment into a space and possibly concatenated multiple logical lines by a comment spreading across the lines.

*2 CygWIN 1.3.10 and 1.5.18 provides malloc() that has an internal routine named _malloc_r() which is called by a few other library functions. So this malloc() cannot be replaced with other malloc(). Also in Visual C 2005 and 2008, the program terminating routine calls an internal routine of resident malloc(), hence other malloc() cannot be used.

# 5. Diagnostic Messages

## 5.1. Diagnostic Messages Format

This section covers diagnostic messages issued by mcpp, as well as their meaning. By default, these messages are output to stderr. With the -Q option, they are redirected to the mcpp.err file in the current directory. A diagnostic message is output in the following manner:

1. "filename: line: " is followed by "fatal error: ", "error: " or "warning: " and then by any of the diagnostic messages shown in sections 5.3 to 5.9. Although the specification that a diagnostic message has to fit in one line that begins with "filename: line:" seems to lack of flexibility, I followed because it is a traditional way of implementing messages in C on UNIX and because various tools have already assumed that. Some mcpp messages do not fit in a line of usual terminal.
2. If an error occurs during macro expansion, the macro invocation is displayed. For nested macro invocation, mcpp shows each macro names and its definitions, as well as the source filename and line number where the macro is defined.
3. The source file name, the line number and the line at which an error has occurred are displayed. If an error has occurred in an included file, the names, line numbers and the #include lines of all the including files are displayed. Usually, a logical line with comments replaced with a space character is displayed. The logical line is constructed from one or more physical lines with '\' at the line end. If a comment spreads over several lines, several logical lines are concatenated into one, which is displayed as the line. In this case, the line number of the last concatenated physical line is displayed. Note that if an error occurs during the translation phase before processing a comment, the line in the phase is displayed.

If the -j option is specified, mcpp outputs neither the above 2 nor 3.

Diagnostic messages are divided into three levels:

> fatal error | Indicates an error is so serious that it is no longer meaningful to continue preprocessing.
> error | Indicates there is a syntax or usage error.
> warning | Indicates code lacks of portability or may contain a bug.

Warnings are further divided into five classes:

> Class 1 | Source code may contain a bug or at least lack portability.
> Class 2 | Probably, source code will present no problem in practical use, but is problematic in terms of Standard conformance.
> Class 4 | Probably, source code will present no problem in practical use, but is problematic in terms of portability.
> Class 8 | Rather surplus warnings to #if groups skipped, sub-expression in #if expression whose evaluation is skipped, and etc.
> Class 16 | Warning to trigraphs and digraphs.

Warnings other than Class 1 or 2 are rather specific to mcpp.

mcpp has various types of diagnostic messages. For example, STD mode provides the following types of diagnostics for each level and class.

> fatal error | 17 types
> error | 76 types
> warning class 1 | 49 types
> warning class 2 | 15 types
> warning class 4 | 17 types
> warning class 8 | 30 types
> warning class 16 | 2 types

Principally, these messages point the coding in question. The diagnostic messages below have a sample value embedded in a token or a numeric value from source code. For the messages with a macro name embedded, a value the macro is expanded into is shown in real messages.

Depending on cases, a same message is issued as warning or error, in which case, this manual gives the first occurrence a detailed description. For the subsequent occurrences, the message is only listed.

## 5.2. Translation Limits

Of all the errors shown below, some errors, such as a buffer overflow, occur due to mcpp specification restrictions. Some macros in system.H define translation limits, such as a buffer size. Enlarge the buffer size and recompile mcpp if necessary, however, be careful not to increase it too much. A large buffer in a system with a small amount of memory may cause an "out of memory" error frequently.

## 5.3. Fatal Errors

A fatal error occurs and preprocessing is terminated when it is no longer possible to continue preprocessing due to an I/O error or a shortage of memory, or it is no longer meaningful to do so due to a buffer overflow. A status value of failure is returned to a parent process.

### 5.3.1. mcpp's Own Bugs

- `Bug:`
  This message has several types. Should it be issued, it would indicate mcpp's own bug. I think this message is rarely issued, but should it be issued, do not hesitate to let me know the situation.

### 5.3.2. Physical Errors

- `File read error`
  An error has occurred during reading a source file. Disk or file-system may have been damaged.
- `File write error`
  An error has occurred during writing to a file. Disk or file-system may have been damaged or full.
- `Out of memory (required size is 0x1234 bytes)`
  Runs short of memory. mcpp tried to obtain memory of 0x1234 bytes from the heap, but in vain. This error occurs when there are too many long macro definitions on a system with a small amount of memory. Divide your source file to decrease the number of macro definitions in one translation unit.

### 5.3.3. Translation Limits and Internal Buffer Errors

- `Too long header name "long-file-name"`
  The length of the full path name of a file to include (file name concatenated with the specified directory path) has exceeded PATHMAX.
- `Too long source line`
  The length of a physical line in source file has exceeded NBUFF-2. The source code may not be written in C.
- `Too long logical line`
  The length of a logical line, which is constructed from the several physical lines with \ at the line end, has exceeded NBUFF-2. This error may occur when a defined macro is too long. The code should be written not as a macro but as a function.
- `Too long line spliced by comments`
  The length of a preprocessed line with a comment replaced with a space character has exceeded NBUFF-2. This error occurs when several lines are concatenated into one if a comment spreads over several lines. Divide the comment into several parts and write each on a separate line.
- `Too long token`
  A preprocessed line has a token with a length more than NWORK-2. mcpp tries to divide the preprocessed line into a length NWORK that the compiler-proper can accept. However, if a line contains a extremely long token, it sometimes fails to do so.

The following four errors may also be caused by a buffer overflow at a token that is not so particularly long during macro expansion, in which case, you should divide the macro invocation.

- `Too long quotation "long-string"`
  A string literal, character constant or header-name is too long. In case of a string literal, divide it. Standard conforming compiler concatenate adjacent string literals for you.
- `Too long pp-number token "1234567890toolong"`
  A preprocessing-number token is too long. This error is issued in Standard mode.
- `Too long number token "12345678901234......"`
  A number token is too long. This error is issued in pre-Standard mode.
- `Buffer overflow scanning token "token"`
  A buffer overflow has occurred during token scan. This message is issued to tokens other than string literals, character constants, header-names and pp-numbers.
- `More than BLK_NEST nesting of #if (#ifdef) sections`
  The depth of nested #if, #ifdef, and #ifndef has exceeded BLK_NEST. (In real message, the macro name BLK_NEST is replaced with an actual numerical value. This is applied to all the messages below with a macro name embedded.) Divide the #if section.
- `More than INCLUDE_NEST nesting of #include`
  The depth of nested #included has exceeded INCLUDE_NEST. Probably the #includes are in infinite recursion.

### 5.3.4. #pragma MCPP preprocessed Related Errors

- `This is not the preprocessed source`
  Although the "#pragma MCPP preprocessed" directive is found, this is not a source preprocessed by mcpp.
- `This preprocessed file is corrupted`
  This seems to be a source preprocessed by mcpp, but cannot be used because it is destroyed.

## 5.4. Errors

mcpp issues an error message when it found a grammatical error. Standard C stipulates that a compiler system should issue a diagnostic message when they encounter a violation of syntax rules or constraints. Principally, Standard mode issues an error message to this type of violation, but sometimes issues a warning.

mcpp issues an error message or warning to most of undefined items in Standard C. However, mcpp issues neither an error nor a warning to the following undefined items:

1. ' or /* in a header name in the form of a string literal: mcpp regards them as characters, resulting in a file open error. (' or /* in a header name enclosed with < and > is regarded as the beginning of a character constant or a comment, resulting in some errors.) Although how to treat \ in a header name is undefined in Standard C, mcpp does not check it because it may eventually cause an error when mcpp actually tries to open the file. mcpp on Windows issues a class 2 warning to \ and converts it to /.
2. #undef defined: Although #undef-ing a name "defined" yields an undefined result, mcpp does not issue a message because, in the first place, mcpp does not allow definition of a macro named "defined", so the macro to be undefined never exists.
3. Illegal multi-byte character sequence in a comment: Although how to deal with such character sequence is undefined in Standard C, mcpp does not issue a message because it does no harm. (mcpp issues a warning to an illegal multi-byte character sequence in string literals, character constants and header names.)
4. Identifiers that begin with _ (Reserved for compiler systems): Although using these identifiers in a user program will cause an undefined result, mcpp does not check it because mcpp does not always have a means to decide whether these identifiers are used in a user program or the compiler-system.
5. `__STDC_ISO_10646__`, `__STDC_IEC_559__`, and `__STDC_IEC_559_COMPLEX__`: Although #defining or #undef-ing these optional C99 predefined macros yields an undefined result, mcpp does not check it because mcpp does not always have a means to determine whether these macros appear in a user program or the compiler-system. (These macros are most likely to be defined in a header file of a compiler system.)
6. UCN equivalent sequence: Although it is undefined in C99 how to deal with a UCN equivalent sequence generated by deleting <backslash><newline> during the translation phase 2 or by concatenating string literals, mcpp does not issue a message and regards it as a UCN.

For details on what is a violation of syntax rule or constraint, undefined, unspecified or implementation-defined in Standard C preprocessing, refer to cpp-test.html.

Even if an error occurs, mcpp continues preprocessing as long as they are not fatal one. mcpp shows the number of errors and returns the status of failure to the parent process when it exits.

### 5.4.1. Character and Token Related Errors

- `Illegal control character 0x1b, skipped the character`
  A control code other than a white space character is found in a string literal, character constant, header name or comment. mcpp skips it and continues preprocessing.

The following several messages are all token-related errors. For the first four, mcpp skips the line in question and continues preprocessing. The first three are string literal or other token-related errors, indicating that a closing quotation mark is not found by the end of the logical line. This type of error occurs when you write a text that does not take a form of a preprocessing-token sequence in neither a string literal nor comment, as shown below:

    #error I can't understand.

As processing-tokens are not so strictly defined as C tokens in the compiler-proper, most character sequences are regarded as pp-token sequences, as long as they belong to a source character set. Therefore, it is only this type of coding that causes a preprocessing-token error. Pp-token errors may occur in a skipped #if group.

- `Unterminated string literal "string`
  A string literal is unterminated. A string literal cannot spread over several logical lines. If necessary, write a string literal on each of several lines and have the compiler concatenate them. This error may occur during conversion into a string by a #operator, in which case the line in question is not skipped. mcpp in OLDPREP mode does not make an unterminated string literal an error. (Instead, it regards the line end as literal end.) Nor mcpp does when invoked with the -a (-lang-asm, -x assembler-with-cpp) option (it issues a warning); it regards an unterminated string literal as a literal spreading over several lines and concatenates a line with the next by inserting \n.
- `Unterminated character constant 't understand.`
  A character constant is not terminated. mcpp in OLDPREP mode and lang-asm mode does not make it an error. (Instead, it regards the line end as literal end.)
- `Unterminated header name <header.h`
  A header-name is not terminated. " or ' in a header-name enclosed with < and > causes the above two errors, not this one. If /* is found in a header-name enclosed with < and >, mcpp regards it and the following text as a comment.
- `Empty character constant ''`
  A character constant is empty. In lang-asm mode, mcpp only issues a warning, but an error in other modes.
- `Illegal UCN sequence`
  mcpp in STD mode invoked with `__STDC_VERSION__` set to 199901L or in C++ mode can recognizes UCN. This message is issued when the number of orders of a hex sequence that begins with \u and \U in an identifier is less than four and eight, respectively. (If this occurs in a character constant in a #if expression, an undefined escape sequence warning results. Other tokens are not checked by mcpp.)
- `UCN cannot specify the value "0000007f"`
  UCN cannot specify a hex value in the ranges of 0 to 9f, except for 0x24 ($), 0x40 (@) and 0x60 (`), and of d800 to dfff. The former range agrees with the range of the basic source character set. The latter range falls into the reserved area for special characters. Note C++ does not have the latter restriction. (Specifications slightly differ among Standards for an unknown reason.) However, when mcpp in STD mode is invoked as C++ with -V199901L to preset the `__cplusplus` macro to 199901L or higher, mcpp behaves in accordance with the C99 specifications in this respect.
- `Illegal multi-byte character sequence "XY"`
  mcpp in STD mode compiled with OK_MBIDENT == TRUE allows for a multi-byte character in an identifier in C99, however, it will cause an error when it finds a character sequence that cannot be regarded as a multi-byte character although the first byte of the sequence is that of a multi-byte character. (In other than identifier, this illegal sequence causes a warning.)

### 5.4.2. Unterminated Source File Related Errors

This section covers messages issued when a source file ends with an unterminated #if section or macro invocation. If the file (not included file) marks the end of input, the message "End of input", not "End of file", is issued.

These diagnostic messages are issued as an error or warning, depending on mcpp modes.

Standard mode issues these messages as error, in which case mcpp skips the macro invocation in question and restores relationship between paired directives in a #if section to that of when the file is initially included.

On the other hand, pre-Standard mode issues warnings. OLDPREP mode does not even issue warning except on unterminated macro call.

- `End of file within #if (#ifdef) section started at line 123`
  #if (#ifdef or #ifndef) on the line 123 does not have a corresponding #endif.
- `End of file within macro invocation started at line 123`
  A macro invocation that begins at the line 123 is not terminated by the end of the file. This error may occur when an argument has an ill-balanced parenthesis, or when a token error occurs between opening and closing parentheses, in which case, mcpp continues to read tokens for a corresponding parenthesis until it reaches to the file end. (Possibly, a buffer overflow may occur before reaching there.) In addition, since macro expansion specifications vary among modes, a macro that is successfully expanded in a mode may not in other modes.

### 5.4.3. Ill-Balanced Preprocessing Group Related Errors

This section covers errors caused by ill balanced directives of #if, #else and etc. Even if mcpp finds ill balance among these directives, it continues processing, assuming that the processing group so far still continues. mcpp checks to see whether directives are balanced even in a skipped #if group.

The #if (#ifdef) section is a block between #if (#ifdef or #ifndef) and #endif. The #if (#elif, #else) group is a smaller block, say, between #if (#ifdef or #ifndef) and #elif, between #elif and #else, or between #else and #endif within the #if (#ifdef) section.

- `Already seen #else at line 123`
  Another #else (#elif) is found after #else at the line 123. #endif may be missing.
- `Not in a #if (#ifdef) section`
  #else (#elif, #endif) is found without #if (#ifdef or #ifndef).
- `Not in a #if (#ifdef) section in a source file`
  An included file has #else (#elif or #endif) without #if (#ifdef or #ifndef). If the included file in question had been in the including source file, this error would never have occurred. In other words, each of these directives contained in a separate file is not balanced by itself. The only Standard mode issues this error. (pre-Standard mode issues a warning.)

The following two errors occur when #asm and #endasm are not balanced. These messages are issued only by compiler-specific-build for a particular compiler system and in pre-Standard mode.

- `In #asm block started at line 123`
  A #asm block that begins at the line 123 has another #asm. #asm cannot be nested. Maybe, the programmer forgot to write #endasm.
- `Without #asm`
  #endasm is found in a non #asm block.

### 5.4.4. Simple Syntax Errors on Directive Lines

This section covers simple syntax errors on directive lines that begin with #. The errors hereinafter discussed until 5.4.12 do not occur within a skipped #if group. (mcpp invoked with the -W8 option issues a warning to an unknown directive.)

When mcpp finds a directive line with a syntax error, it ignores the line and continues processing, in which case, it neither regards #if as the beginning of a section nor changes line numbers even with a #line. If a #include or #line line has a macro argument, Standard mode expands the macro and checks the syntax. Pre-Standard mode does not expand the macro.

Although the messages below do not show the directive name in question, the source line that follows the message show it. (A directive line with a comment converted to a space character always becomes one line, which is called "preprocessed line" here.)

- `Illegal #directive "123"`
  A token that immediately follows # is not a name. The token must be a directive name. (OLDPREP mode regards #123 as #line 123.)
- `Unknown #directive "pseudo-directive"`
  The directive "pseudo-directive" is not implemented. mcpp invoked with the -a (-lang-asm or -x assembler-with-cpp) option issues a warning, not an error.
- `No argument`
  #if, #elif, #ifdef, #ifndef, #assert or #line has no arguments.
- `No header name`
  A #include line does not have an argument, or expansion of a macro argument of a #include line results in no token.
- `Not a header name "UNDEFINED_MACRO"`
  The specified argument is not a header name. This message is issued when a macro that should define a header name is not defined. A header name must be enclosed with < and >, or ", ".
- `Not an identifier "123"`
  #ifdef, #ifndef, #define or #undef requires an identifier as an argument, but 123 is not an identifier.
- `No identifier`
  #define or #undef does not have an argument.
- `No line number`
  #line has a macro argument, but its expansion has resulted in no token.
- `Not a line number "name"`
  The first argument of a #line is not a numeric token (preprocessing number).
- `Line number "0x123" isn't a decimal digits sequence`
  The first argument of a #line must be a decimal integer. Standard mode issues this message. In pre-Standard mode, hex and octal integer tokens are allowed although a warning is issued.
- `Line number "2147483648" is out of range of [1,2147483647]`
  The first argument of a #line must be within the range of 1 to 2147483647. 0 is regarded as an error. This is applied to Standard mode.
- `Not a file name "name"`
  The second argument of a #line, if any, must be a string literal. An identifier or wide string literal is not allowed here.

The following error occurs only in Standard mode and this directive is ignored. OLDPREP mode issues neither an error nor a warning. KR mode issues a warning and continues preprocessing as if there had been no "junk" text.

- `Excessive token sequence "junk"`
  #else, #endif, #asm, or #endasm line has a junk text, or such text follows a valid argument of #ifdef, #ifndef, #include, #line or #undef line.

### 5.4.5. Syntax Errors in #if Expressions

This section covers syntax-related errors in #if, #elif and #assert directives. If a #if (#elif) line has these errors, mcpp evaluates it to false, skips the #if (#elif) group, and continues processing.

For a skipped #if (#ifdef, #ifndef, #elif or #else) group, mcpp checks validity of C preprocessing tokens and balance of these directives, but not other grammatical errors.

A #if line has a sub-expression whose evaluation is skipped. For example, in case of #if a || b, if "a" is evaluated to true, "b" is not evaluated at all. However, the following 14 types of syntax errors or translation limit errors are checked, even if they are located in a sub-expression whose evaluation is skipped.

- `More than NEXP*2-1 constants stacked at "12"`
  The number of constants in the stack has exceeded NEXP*2-1 when mcpp tried to evaluate "12" in a #if expression. The depth of nested #if expressions is too deep.
- `More than NEXP*3-1 operators and parens stacked at "+"`
  The total number of operators and parenthesis in the stack has exceeded NEXP*3-1 when mcpp tried to evaluate '+' in a #if expression. (A pair of parentheses is counted as two.) The depth of nested #if expressions is too deep.
- `Misplaced constant "12"`
  A #if expression has a constant '12' where no constant should be found. This error occurs when casting, such as (int)0x8000, is used in a #if expression, where casting is not allowed. In this case, (int)0x8000 is evaluated to (0)0x8000, causing this error. The int is regarded as an identifier that is not defined as macro and is evaluated to 0.
- `Operator ">" in incorrect context`
  A #if expression has a > operator where no > should be found. If a macro MACRO is defined as 0 token, #if MACRO > 0 will be expanded to #if > 0, causing this error, which is indicated by the preceding warning -- Macro "MACRO" is expanded to 0 token.
- `Unterminated expression`
  A #if expression is not terminated. This error is caused by, for example, #if a || MACRO with MACRO defined as 0 token.
- `Excessive ")"`
  A #if expression has a ")" that does not corresponds to "(".
- `Missing ")"`
  A #if expression does not have a ")" that corresponds to "(".
- `Misplaced ":", previous operator is "+"`
  : without a corresponding ?.
- `Bad defined syntax`
  A #if defined has a syntax error. This error is caused by an unbalanced parenthesis or missing identifier in an argument. When a macro expansion causes this error, mcpp displays this message followed by an expansion result.
- `Can't use a string literal "string"`
  A string literal is not allowed as a constant in a #if expression.
- `Can't use a character constant 'a'`
  In POSTSTD mode, a character constant, or a wide character constant is not allowed as a constant in a #if expression.
- `Can't use the operator "++"`
  A #if expression has an illegal operator, such as = or ++.
- `Not an integer "1.23"`
  Only integers, including character constants, are allowed as a constant in a #if expression.
- `Can't use the character 0x24`
  A #if expression contains an illegal character (code 0x24), which is not any of the preprocessing tokens: identifiers, operators, punctuators, string literals, character constants, and preprocessing numbers. (Control codes are excluded since they had been checked before.) Even compiler-specific-builds for compiler systems that allow $ in an identifier disallow it depending options. Of course, this is not checked in a skipped group.

The following error messages are relevant to #if sizeof. Only pre-Standard mode issues this error.

- `sizeof: Syntax error`
  A #if sizeof has a syntax error. This error is caused by an unbalanced parenthesis or missing arguments.
- `sizeof: No type specified`
  Like sizeof(*), the "type" of #if sizeof (type) is not specified. Note that sizeof ((*)()) is a valid syntax to determine the size of a pointer to a function.

### 5.4.6. #if Expression Evaluation Errors

The following errors do not occur in a sub-expression whose evaluation is skipped. (mcpp invoked with the -W8 option issues a warning.)

The Standards say that #if expression is evaluated by the largest integer type in C99 and long / unsigned long in C90 and in C++98. mcpp evaluate it by long long / unsigned long long even if in C90 or C++98, and issues a warning on the value outside of long / unsigned long in C90 and in C++98. In this subsection, please read the following long long / unsigned long long as long / unsigned long for the compiler without long long, and as long in pre-Standard mode. In POSTSTD mode, character constant in #if expression is not available and causes a different error.

- `Constant "123456789012345678901" is out of range`
  An integer constant has a value that exceeded the range of unsigned long long.
- `Integer character constant 'abcdefghi' is out of range`
  A character constant 'abcdefghi' has a value that exceeded the range of unsigned long long.
- `Wide character constant L'abcde' is out of range`
  A wide character constant L'abcde' has a value that exceeded the range of unsigned long long. This error occurs only in STD mode.
- `8 bits can't represent escape sequence 'x123'`
  An escape sequence in a character constant has exceeded the range of 8 bits ([0, 0xFF]).
- `16 bits can't represent escape sequence L'x12345'`
  An escape sequence in a wide character constant has exceeded the range of 16 bits (32 bits for UTF-8). This error occurs only in STD mode.
- `Division by zero`
  A #if expression contains a division by zero. A division can be expressed using / or %. This error may be caused by a #if dividend/divisor with the divisor not defined as a macro. To avoid this error, "#if defined divisor && (dividend/divisor ..)" is recommended.
- `Result of "op" is out of range`
  An operation result using the operator op is out of range of (unsigned) long long. Op is any of binary operators: *, /, %, +, and -. When two's complement representation is used, the unary operator '-' will cause an overflow with -`LLONG_MIN`. Unsigned long long will never cause an overflow, so it does not cause this error. If the result of an algebraic calculation is out of range, a warning is issued.

The following errors are relevant to sizeof. They are not issued in a sub-expression whose evaluation is skipped (The -W8 option issues a warning). Only in pre-Standard mode.

- `sizeof: Unknown type "type"`
  The "type" of #if sizeof (type) is unknown.
- `sizeof: Illegal type combination with "type"`
  A type combination, like #if sizeof (long float), is invalid.

### 5.4.7. #define Related Errors

This section covers #define related errors. A macro will not be defined if an error occurs at #define. The # and ## operator related errors occurs in Standard mode. `__VA_ARGS__` related errors also occur in Standard mode. Although variable argument macro is a C99 specification, mcpp allows these macros to be used in C90 and C++ modes for compatibility with GCC and Visual C++ 2005, 2008. (A warning is issued.)

- `"defined" shouldn't be defined`
  A macro named "defined" cannot be defined. Standard mode checks this.
- `"__STDC__" shouldn't be redefined`
  The `__STDC__` macro cannot be #defined. The same can be said with `__STDC_VERSION__`, `__FILE__`, `__LINE__`, `__DATE__` and `__TIME__` (`__STDC_HOSTED__` in C99 mode, and `__cplusplus` when mcpp is invoked with -+ option). Standard mode checks these macros.
- `"__VA_ARGS__" shouldn't be defined`
  C99 allows a variable argument macro with the `__VA_ARGS__` parameter in the replacement list, but this identifier cannot be defined as a macro.
- `More than NMACPARS parameters`
  The number of parameters of a macro definition has exceeded NMACPARS.
- `Empty parameter`
  A macro definition has an empty parameter.
- `Illegal parameter "123"`
  A token other than an identifier is used in a parameter of a macro definition. In Standard mode, even an identifier `__VA_ARGS__` cannot be used.
- `Duplicate parameter name "a"`
  A macro definition has a duplicate parameter name "a".
- `Missing "," or ")" in parameter list "(a,b"`
  A macro definition does not have a parenthesis ")" that closes a parameter list. Or, a parameter is followed by neither ',' nor ')'.
- `No token before ##`
  No token precedes the ## operator in the replacement list of a macro definition.
- `No token after ##`
  No token follows the ## operator in the replacement list of a macro definition.
- `## after ##`
  The replacement list of a macro definition has a token sequence of "## ##". Some may do not regard this as error, but since concatenation of ## with other token always generates an invalid token, when this happens in macro expansion, it always causes an error. mcpp makes it an error when it finds this in a macro definition.
- `Not a formal parameter "id"`
  A function-like macro definition has a # operator whose operand id is not a parameter name.
- `"..." isn't the last parameter`
  "`...`" must be the last parameter of a macro definition. In pre-Standard mode, "`...`" causes an illegal parameter error.
- `"__VA_ARGS__" without corresponding "..."`
  "`__VA_ARGS__`", an identifier in a replacement list, can be used only when it has a corresponding "`...`" parameter.

In STD mode of GCC-specific-build, if you write GCC2-spec variadic using `__VA_ARGS__`, you will get this error. `__VA_ARGS__` should be used only in GCC3-spec or C99-spec variadic.

- `__VA_ARGS__ cannot be used in GCC2-spec variadic macro`

### 5.4.8. #undef Related Errors

This section covers #undef related errors.

- `"__STDC__" shouldn't be undefined`
  The `__STDC__` macro cannot be #undefined. The same can be said with `__STDC_VERSION__`, `__FILE__`, `__LINE__`, `__DATE__` and `__TIME__` (`__STDC_HOSTED__` in C99 mode, and `__cplusplus` when invoked with -+ option). Standard mode checks these macros.

### 5.4.9. Macro Expansion Errors

This section covers macro expansion errors. mcpp displays a macro definition, as well as the source filename and line number where it is found. The errors related to # or ## operator can occur only in Standard mode.

- `Less than necessary N argument (s) in macro call "macro( a)"`
  A macro invocation has an insufficient number of arguments. This macro requires N number of arguments. mcpp assigns a zero token to missing arguments and continues to process. mcpp does not regard a macro that takes only one parameter with zero number of arguments specified as error because it cannot distinguish an empty argument from a missing argument. OLDPREP mode issues a warning instead of an error on this case.
- `More than necessary N argument (s) in macro call "macro( a, b, c)"`
  A macro invocation has too many arguments. The macro should take N number of arguments. mcpp ignores surplus arguments and continues processing. In OLDPREP mode, a warning is issued instead of an error.
- `Not a valid preprocessing token "+12"`
  The ## operator has concatenated two pp-tokens, resulting in an invalid token "+12". The token may be separated at a later time. Standard mode continues processing. STD mode invoked with the -lang-asm (-x assembler-with-cpp, -a) option also issues a warning instead of an error.
- `Not a valid string literal "\\"str\""`
  When a # operator tried to convert macro invocation's argument into a string, a token sequence of "\\"str"" has resulted, instead of a single valid string literal. \ that precedes or follows the literal cause the error. (When STD mode tries to convert such an argument into a string, it may or may not cause an unterminated string literal error.) STD mode tries to continue processing but maybe an error occurs again in the compilation phase. This error can not occur in POSTSTD mode. (An unterminated string literal error may occur).

When the following errors occur, the macro invocation will be skipped.

- `Buffer overflow expanding macro "macro" at "something"`
  A buffer overflow has occurred at "something" during macro expansion. Divide the macro.
- `Unterminated macro call "macro( a, (b, c)"`
  A macro invocation is not terminated. This error usually occurs when a macro invocation on the directive line is not terminated at that line. In Standard mode, a macro in an argument is expanded before argument substitution, in which case the macro invocation must be terminated in the argument. In POSTSTD mode, a macro invocation unterminated in a replacement list also causes this error.
- `Rescanning macro "macro" more than RESCAN_LIMIT times at "something"`
  The depth of nested macros is so deep that the number of rescans has exceeded RESCAN_LIMIT at "something" during expansion. This error occurs only in Standard mode but it is quite rare.
- `Recursive macro definition of "macro" to "macro"`
  A macro definition is recursive. This error occurs only in pre-Standard mode. When the number of rescans has exceeded PRESTD_RESCAN_LIMIT, mcpp regards it as a recursive macro definition.

The following errors can occur only with -K option in STD mode. These errors mean that the macro is extremely complex and buffer for macro notification ran short. Almost impossible to happen in real life.

- `Too many magics nested in macro argument`
- `Too many nested macros in tracing MACRO`

### 5.4.10. #error and #assert

- `#error`
  A #error directive has been executed. Following this message, the #error line is displayed. If an argument itself contains a token error, such as unterminated strings, #error is not executed. The only Standard mode has #error.
- `Preprocessing assertion failed:`
  A #assert directive has been executed. Following this message, #assert line arguments are displayed. If any of the arguments contains an error, mcpp regards assertion has failed. The only mcpp of other than GCC-specific-build in pre-Standard mode has #assert.

### 5.4.11. Failure of #include

- `Can't open include file "file-name"`
  This error occurs when a file to include does not exist. Probably, this is due to wrong spelling of the file name or an "include directory" should have been specified.

### 5.4.12. Other Errors

The following two are checked when mcpp is invoked with the -V199901L option. The same thing can be said when mcpp is invoked with the -V199901L option in C++ mode.

- `Operand of _Pragma() is not a string literal`
  The _Pragma() operator must take an argument of one string literal or wide string literal.
- `_Pragma operator found in directive line`
  _Pragma() operator is an alternative to #pragma directive. It cannot be used in a directive line.

## 5.5. Warnings (Class 1)

A warning is issued when source, although syntactically correct, possibly contains some coding mistakes or has a portability problem. Warnings are divided into five classes: 1, 2, 4, 8, and 16. These classes are enabled when the -W <n> option is specified on mcpp invocation. <n> specifies a ORed value of any of 1, 2, 4, 8, and 16. Class 4, for example, can be specified explicitly with -W4, and implicitly with -W<n>, where <n> is 1|4, 1|2|4, 2|4, 1|4|8, 4|8, 4|16, etc., because the AND-ed value of <n> and 4 is 4 (non-0).

Standard mode issues an error message to most of the source code that causes a Standard C undefined behavior, but a warning to some.

Likewise, Standard mode always issues a warning to the source code which uses Standard C unspecified specifications, except for the following:

1. Evaluation order of sub-expressions in a #if expression: Although the evaluation order of the operands of operators other than ||, &&, ? , and : is unspecified in Standard C, mcpp does not issue a warning because #if expression does not cause side-effects and therefore the evaluation order does not affect results. mcpp always evaluates integer constant tokens from left to right in the order they appear and performs an operation in accordance with an operator grouping rule when their values are needed.

Standard mode issues a warning to many implementation-defined behaviors, except for the following:

1. Directories the #include directive searches for a file to include and how to construct a header-name pp-token from #include's argument: mcpp does not issue a warning because there will be too many warnings if it actually does. Unless a header name is a macro, the source token sequence, including spaces, are used as it is. If it is a macro, the expanded result, including spaces, is used. (In POSTSTD mode, a space character is inserted between pp-tokens during macro expansion. A header-name is constructed by concatenating the resulting pp-tokens from < to > and then by removing space characters. Anyway, in POSTSTD, a header-name enclosed with < and > is obsolete.) When mcpp encounters '#pragma MCPP debug path' or '#debug path', it displays a search path, instead of issuing a warning.
2. Evaluation of a single byte character constant, such as 'a', and of a wide character constant that consists of only one multi-byte character, such as L'X', in a #if expression.: mcpp does not issue a warning because even with the same basic character set used, there are an unlimited number of factors that limits the portability, such as single byte Katakana, presence or absence of a sign, encoding scheme of Kanji, and etc. The same thing can be said with UCN.
3. Bit operations using negative numbers in a #if expression: Although bit operation results depend on internal representation of an integer on a machine, most of the machines use two's complement representation, thus causing no portability problem. However, mcpp issues a warning to a right bit shift operation of a negative value and a division operation involving either or both of negative operands because they lack of portability.
4. A sequence of several white space characters as a token separator: Standard C states that it is implementation-defined whether a sequence of white space characters is replaced by one space character in the translation phase 3, but you do not have to worry about this. Portability becomes an issue only when a preprocessing directive line has <vertical-tab> or <form-feed>. mcpp converts it into one space character and issues a warning. For a sequence of several space characters and tabs, mcpp compresses it into one space character without a warning.
5. Compiler system's own built-in macros will not cause warning.
6. #pragma sub-directive: Principally, mcpp does not issue a warning to #pragma sub-directive, however, for #pragma once, #pragma __setlocale, #pragma MCPP * which mcpp itself processes, it issues a warning if they have an invalid argument. In addition, mcpp issues a warning to GCC V.3's #pragmas, such as #pragma GCC poison (dependency), that resident preprocessor processes but mcpp does not.
7. Doubled \: Although it is implementation-defined in C99 whether a single \ is changed into double \ (\\) when the # operator converts a UCN sequence into a string, mcpp does not issue a warning to this. mcpp does not double \.

As you see, mcpp can perform almost all the portability checks necessary at a preprocessing level.

POSTSTD mode is identical with STD mode except for some specification differences described in section 2.1.

Regardless of the number of warnings, mcpp always returns a status of success. mcpp invoked with the -W0 option does not issue a warning.

### 5.5.1. Character, Token and Comment Related Warnings

- `Converted [CR+LF] to [LF]`
  Converted the newline code from [CR+LF] to [LF]. This warning is issued when the source file for Windows is compiled on UNIX-like systems. This warning is issued only once, on warning level of class 1 in compiler-independent-build and class 2 in compiler-specific-build.
- `Illegal control character 0x1b in quotation`
  A string literal, character constant or header name has a control code other than a white space character, which may cause an error in the compiler-proper. This way of coding is not desirable. A control code in string literals or character constants should be written using an escape sequence.
- `Illegal multi-byte character sequence "XY" in quotation`
  The first byte (X) of "XY" in a string literal, character constant or header name is the first byte of a multi-byte character (Kanji), while the second byte (Y) is not the second byte of a multi-byte character. "XY" may be displayed garbled. mcpp does not regard "XY" as a single multi-byte character. It treats the first byte as a single-byte character and the second byte as the next character.
  mcpp usually does not issue a warning to a character in an external character set, as long as it is within the proper range. Even within the proper range, there are some holes (no corresponding characters). mcpp does not check whether such a character is defined or not. The following table shows the range of each multi-byte character set:

  > Encoding | first byte | second byte
  > shift-JIS | 0x81-0x9f, 0xe0-0xfc | 0x40-0x7e, 0x80-0xfc
  > EUC-JP | 0x8e, 0xa1-0xfe | 0xa1-0xfe
  > KS C 5601 | 0xa1-0xfe | 0xa1-0xfe
  > GB 2312-80 | 0xa1-0xfe | 0xa1-0xfe
  > Big Five | 0xa1-0xfe | 0x40-0x7e, 0xa1-0xfe
  > ISO-2022-JP | 0x21-0x7e | 0x21-0x7e

  Beside character codes, ISO-2022-JP has a shift sequence. Apart from the shift sequence, all the multi-byte characters other than UTF-8 are two bytes length.
  In UTF-8, multi-byte characters are mostly 2 or 3 bytes, and possibly 4 bytes length. Most of kanji are encoded in 3 bytes. The first byte is within the range of 0xc2 to 0xef, second, third and fourth 0x80 to 0xbf. Details are omitted here. Anyway, all the bytes must fall within these ranges. In addition, there are some illegal sequences even in these ranges: mcpp warns at those sequences.
  Note that since mcpp is unable to recognize EUC-JP's three byte encoding (JIS X 0213), it regards 0x8f + 0xa1-0xfe + 0xa1-0xfe not as one character but as two characters of 0x8f and 0xa1-0xfe + 0xa1-0xfe. As a result, mcpp does not issue a warning to the three byte encoding and can evaluate it correctly, except for a wide character constant in a #if expression. In EUC-JP, a character with the first byte of 0x8e (a half-width Katakana) is encoded in two bytes, and treated as a multi-byte character.
  This warning is not issued in a skipped #if group.
- `"/*" in comment`
  A comment has a sequence of /*. Unless it is intended, the programmer may have forgot to enclose the comment. Comments cannot be nested.
- `Too long identifier, truncated to "very_long_identifier"`
  Since the length of an identifier has exceeded IDMAX, it is truncated to IDMAX.
- `Illegal digit in octal number "089"`
  An octal numeric token contains 8 or 9. The only pre-Standard mode issues this warning. Standard mode does not check whether a numerical token on lines other than #if directives is correct or not. If a #if expression has an octal numeric token of 8 or 9, it will cause a "Not an integer" error.
- `Unterminated string literal, catenated to the next line`
  Although an unterminated string literal in a logical line is normally regarded as an error, mcpp invoked with the -lang-asm (-x assembler-with-cpp, -a) option regards it as a multi-line string literal and concatenates the line with the next by inserting '\n'. This way of writing has no advantage. Using a functionality to concatenate adjacent string literals is preferable.
- `Unterminated character constant 't understand.`
  mcpp in lang-asm mode does not regard this an error.
- `Empty character constant ''`
  A character constant is empty. In lang-asm mode, mcpp only issues a warning.

### 5.5.2. Unterminated Source File Related Warnings

On unterminated line or comments, the following messages are issued. OLDPREP mode does not issue warning.

- `End of file with no newline, supplemented newline`
  A file must be terminated with a newline. mcpp supplements the line with <newline>.
- `End of file with \, deleted the \`
  A file must not be terminated with <backslash><newline>. mcpp deletes the <backslash>.
- `End of file with unterminated comment, terminated the comment`
  A comment is not terminated. mcpp terminates the comment.

The following warning messages are issued in pre-Standard mode. Pre-Standard mode ignores these warnings to continue processing until it reaches the end of input, causing many unexpected results. Standard mode issues an error. OLDPREP mode does not issue even warning, except on unterminated macro.

- `End of file within #if (#ifdef) section starting from line 123`
- `End of file within macro invocation starting from line 123`
- `End of file with unterminated #asm block starting from line 123`
  #asm on the line 123 does not have a corresponding #endasm.

### 5.5.3. Directive Line Related Warnings

- `The macro is redefined`
  mcpp displays this message followed by the source filename and line number where this macro definition is found.
  The macro has been redefined with a different content. Source must not be well organized. The following conditions must be met for macro definitions with the same name to exist. Or, the new definition is regarded as a redefinition, and a warning is issued.
  1. Have the same number of parameters.
  2. Have the same replacement list. (One or more white space character between tokens are regarded as one. In POSTSTD, the difference of the token separators does not matter because any number of space characters is changed into one, regardless of the presence or absence of the token separators.)
  3. In Standard mode, parameter names must be the same. In POSTSTD mode and in pre-Standard mode, they are not checked.
- `Unknown argument "name"`
  There is no such an argument of '#pragma MCPP debug' or '#debug' as "name".
- `No argument`
  A '#pragma MCPP debug' or '#debug' does not have an argument.
- `Not an identifier "123"`
  The argument of a '#pragma MCPP debug' or '#debug' is not an identifier.

The following message is issued only in Standard mode.

- `"and" is defined as macro`
  "and" is defined as a macro in C++.
  Whereas in C95 "and" or other 11 names are defined as macros by <iso646.h>, those are operator tokens in C++,

The following message is issued only in STD mode.

- `No space between macro name "MACRO" and repl-text`
  There is no space between macro name and replacement list of a #define line. Normally, this does not happen, but it does happens when an illegal character is used in a macro name as follows:

      #define THIS$AND$THAT(a, b)   ((a) + (b))

  mcpp interprets this as follows:

      #define THIS  $AND$THAT(a, b) ((a) + (b))

  and issues a warning. Of course, this is a quite rare case.

The following warnings are issued only in lang-asm mode.

- `Illegal #directive "+"`
- `Unknown #directive "pseudo-directive"`
  Though these are usually errors, lang-asm mode issues only warnings.

The following warnings on #pragma line are issued only in Standard mode. The lines are outputted in principle in spite of the warnings. However, the lines to be processed by preprocessor such as most of the lines starting with #pragma MCPP or #pragma GCC are not outputted. The pragmas for compiler or linker such as `#pragma GCC visibility *` are outputted without warning.

- `No sub-directive`
  A #pragma line does not have any argument. The line is ignored.
- `Unknown encoding "encoding"`
  The encoding name, "encoding", specified with #pragma __setlocale( "encoding") is not implemented. For the encoding name, refer to 2.8.
- `Too long encoding name "encoding"`
  The encoding name, "long-long-encoding", specified with #pragma __setlocale( "long-long-encoding") exceeds 19 bytes. mcpp ignores it.
- `Bad push_macro syntax`
- `Bad pop_macro syntax`
  There is a syntax error in #pragma MCPP push_macro, #pragma MCPP pop_macro, #pragma push_macro or #pragma pop_macro. To use these #pragma directives, first enclose a macro name in an argument with ", " and then further enclose with ( ). For example, ("MACRO"). (A redundant specification for compatibility with Visual C.)
- `"MACRO" has not been defined`
  MACRO in the argument,("MACRO"), for #pragma MCPP push_macro, #pragma MCPP pop_macro, #pragma push_macro, or #pragma pop_macro is not defined as a macro.
- `"MACRO" is already pushed`
  MACRO of #pragma MCPP push_macro ("MACRO") has been pushed and then further #undef-ed. Without redefining the MACRO, push would not be possible.
- `"MACRO" has not been pushed`
  MACRO in #pragma MCPP pop_macro( "MACRO") has not been pushed. It may have been already popped.

The GCC-specific-build issues the following warnings:

- `Ignored #ident`
- `Ignored #sccs`
  #ident or #sccs lines are ignored.

GCC-specific-build issues a Class 2 warning to a line with #pragma GCC followed by either poison or dependency and does not output the line. GCC V.3 resident preprocessor process the line but mcpp does not.

The following warnings are issued only in pre-Standard mode. Standard mode regards them as errors.

- `Not in a #if (#ifdef) section in a source file`
- `Line number "0x123" isn't a decimal digit sequence`

KR mode issues the following warning. Standard mode issues the same warning only to #pragma once, #pragma MCPP put_defines, #pragma MCPP push_macro, #pragma MCPP pop_macro, #pragma push_macro, #pragma pop_macro, #pragma MCPP debug, #pragma MCPP end_debug, and #endif for GCC-specific-build on STD mode; for other directives, Standard mode issues an error. OLDPREP mode issues neither an error nor a warning.

- `Excessive token sequence "junk"`

### 5.5.4. #if Expression Related Warnings

The following three warnings are relevant to an argument of #if, #elif, or #assert:

- `Macro "MACRO" is expanded to "defined"`
  The macro MACRO in a #if expression has been expanded to "defined". mcpp treats this strange macro not as identifier but as operator. How to treat it is undefined in Standard C.
- `Macro "MACRO" is expanded to "sizeof"`
  The macro MACRO in a #if expression has been expanded to sizeof. mcpp treats this strange macro not as identifier but as operator. Pre-Standard mode issues this warning.
- `Macro "MACRO" is expanded to 0 token`
  The macro MACRO has been expanded to zero token. If this happens in a #if expression, it almost always causes an error. The purpose of this warning is to indicate the cause of an error.

The followings warnings are also relevant to an argument of #if, #elif or #assert. They are not issued in a sub-expression whose evaluation is skipped. (mcpp invoked with the -W8 option issues them.)

- `Undefined escape sequence '\x'`
  There is no such escape sequence as \x. \x is evaluated to a two byte sequence. (Of course, an escape sequence of "\x" followed by a hex string is valid.) This warning is also issued to a UCN with an insufficient number of orders.

The followings warnings are relevant to operations and types in a constant expression on #if, #elif or #assert lines. No warnings are also issued in a skipped sub-expression. (mcpp invoked with -W8 issues them.)

mcpp evaluate #if expression by long long / unsigned long long even if in C90 or C++98, and issues a warning on the value outside of long / unsigned long in C90 and in C++98. Also on LL suffix in other than C99, mcpp issues a warning. These warnings are of class 1 in compiler-independent-build and class 2 in compiler-specific-build. In POSTSTD mode, character constants are not used in #if expression, hence no warning is issued. (Those make errors.)

- `Constant "123456789012" is out of range of (unsigned) long`
  An integer constant has a value that exceeded the range of unsigned long.
- `Integer character constant 'abcde' is out of range of unsigned long`
  A character constant 'abcde' has a value that exceeded the range of unsigned long.
- `Wide character constant L'abc' is out of range of unsigned long`
  A wide character constant L'abc' has a value that exceeded the range of unsigned long. This error occurs only in STD mode.
- `Result of "op" is out of range of (unsigned) long`
  An operation result using the operator op is out of range of (unsigned) long. Op is any of binary operators: *, /, %, +, and -. When two's complement representation is used, the unary operator '-' will cause an overflow with -`LONG_MIN`. Unsigned long will never cause an overflow, so it does not cause an error. If the result of an algebraic calculation is out of range, a warning is issued.
- `LL suffix is used in other than C99 mode "123LL"`
  LL suffix is used for an integer in other than C99 mode.
- `Shift count "40" is larger than bit count of long`
  The value of the right operand of a bit shift operator, << or >>, exceeds the bit count of long.
- `Negative value "-1" is converted to positive "18446744073709551615"`
  A mixture of signed and unsigned operations results in conversion of a signed negative value into an unsigned positive value. This is not an error, but indicates source code may contain a bug. For both operands of a binary operator, such as *, /, %, +, -, <, >, <=, >=, ==, !=, &, ^ and | , and the second and third operands of a ternary operator, ? and :, if one operand is unsigned and the other is signed, the signed one is always converted into unsigned.
- `Illegal shift count "-1"`
  The value of the right operand of a bit shift operator, << or >>, is a negative number or exceeds the bit count of long long. Probably, this is also a bug in source code.
- `"op" of negative number isn't portable`
  If an operation using a binary operator (op) results in either or both of negative operands, it lacks of portability. "Op" is any of /, %, and >>. The >> operator with a negative left operand provides portability across compiler systems on computers having an arithmetic shift command, where a one-bit shift means a division by 2. Otherwise, it does not provide portability.

### 5.5.5. Macro Expansion Related Warnings

In these warnings, mcpp displays a macro definition followed by the source filename and line number where the macro is defined.

- `Macro started at line 123 swallowed directive-like line`
  mcpp has read a line that begins with # as an argument of the macro that begins at the line 123. Maybe, the macro invocation has a bug. If it had not been for the macro, the line that begins with # would have been interpreted as a directive line. The same thing could be said if the macro had been located in a #if group whose evaluation is skipped, and the line is treated as a directive, because such macro is never expanded.
- `Replacement text "sub(" of macro "head" involved subsequent text`
  Rescanning of the replacement list "sub(" of the macro "head" has involved the text succeeding the macro invocation. K&R 1st to Standard C did not regard this as an error, but if you used this type of macro without having these standards in mind to receive this warning, your macro definition or macro invocation is probably not correct. If you are intended to use such macro, it is an unusual macro. The only STD mode issues this warning. COMPAT mode issues this warning only on class 8. In pre-Standard mode, the same situation may arise but no warning is issued. POSTSTD mode never issues this warning because rescanning does not involve the text succeeding the replacement list. (A macro may be expanded quite differently or causes an "unterminated macro call" error.)
- `Less than necessary N argument (s) in macro call "macro( a)"`
  An insufficient number of arguments of a macro invocation. Normally, this causes an error, but in case of missing only one argument of a macro that takes a variable number of arguments, mcpp issues a warning. This is to decrease migration problems of variable argument macros between GCC and C99.
- `Removed ',' preceding the absent variable argument`
  Since variable argument is absent and the replacement list has a sequence `", ## __VA_ARGS__"`, removed the comma immediately preceding `"## __VA_ARGS__"`. This warning is issued only in Standard mode of GCC-specific-build.
- `Old style predefined macro "linux" is used`
  The non-conforming predefined macro without leading '_' is used. This warning is only on Standard mode of GCC-specific-build.

The following two are issued only in OLDPREP mode. (In other mode it causes an error.)

- `Less than necessary N argument(s) in macro call "macro( a)"`
- `More than necessary N argument(s) in macro call "macro( a, b, c)"`

### 5.5.6. Line Number Related Warnings

This section covers line number related warnings.

- `Line number "32768" is out of range of [1,32767]`
  In C90 and C++, the first argument of a #line must be within the range of 1 to 32767. 0 is also out of range. With `__STDC_VERSION__` >= 199901L or `__cplusplus` >= 199901L, the valid range is 1 to 2147483647. Therefore, in C90 or C++ mode, mcpp issues a warning, not an error, to the range of 32768 to 2147483647. Standard mode issues this warning.

In C90, when you use #line to specify a value slightly below 32767, you won't receive an error, but sooner or later, the line number will exceed 32767, in which case, mcpp continues to increase the line number while issuing a warning. Some compiler-proper may not accept this large line number. It is not desirable to specify a large number with #line.

- `Line number 32768 got beyond range`
  The source line number has reached 32768, at which a warning is issued one time.
- `Line number 32769 is out of range`
  When the `__LINE__` macro is expanded, the lime number has exceeded 32767.

### 5.5.7. #pragma MCPP warning, #warning

- `#warning`
- `#pragma MCPP warning`
  A #pragma MCPP warning (#warning) directive has been executed. Following the above message, the line is displayed. (If an argument of #pragma MCPP warning has a token error, such as unterminated string, #pragma MCPP warning is not executed.) Although this directive appears in the Warning Level 1 section, this warning is issued at every warning level. Standard mode has #pragma MCPP warning, while pre-Standard mode has #warning.

## 5.6. Warnings (Class 2)

This section covers warnings to code that does not contains a bug but causes a portability problem.

- `Converted [CR+LF] to [LF]`
  Converted the newline code from [CR+LF] to [LF]. This warning is issued on warning level of class 1 in compiler-independent-build and class 2 in compiler-specific-build.

mcpp evaluate #if expression by long long / unsigned long long even if in C90 or C++98, and issues a warning on the value outside of long / unsigned long in C90 and in C++98. Also LL suffix in other than C99 mode gets a warning as well as i64 suffix of compiler-specific-builds for Visual C and Borland C. These warnings are of class 1 in compiler-independent-build and class 2 in compiler-specific-build.

- `Constant "123456789012" is out of range of (unsigned) long`
- `Integer character constant 'abcde' is out of range of unsigned long`
- `Wide character constant L'abc' is out of range of unsigned long`
- `Result of "op" is out of range of (unsigned) long`
- `LL suffix is used in other than C99 mode "123LL"`
- `I64 suffix is used in other than C99 mode "123i64"`
- `Shift count "40" is larger than bit count of long`

Only the Standard mode issues the following five warnings:

- `Parsed "//" as comment`
  A text from // to the end of the line is interpreted as a comment. This is a legal notation in C99 and C++. In C90 mode mcpp treats it as a comment after issuing a warning.
- `Variable argument macro is defined`
  Although it is the C99 Standard that stipulates variable argument macros, a variable argument macro has been defined in C90 or C++ mode.
- `Empty argument in macro call "MACRO( a, ,"`
  A macro invocation has an empty argument, in which case, mcpp regards the argument as zero number of pp-token sequences and treats it as such. The empty argument is legal in C99, while it is undefined in C90, thus causing a lack of portability. (mcpp regards an empty argument even without a ',' not as an empty argument, but as a missing argument, thus issuing an error. Since zero number of arguments and one empty argument is syntactically indistinguishable, mcpp does not make both an error.) Writing an empty argument in source code is not generally preferable. I recommend that you should code:

      #define EMPTY

  , if possible, and then write `EMPTY` where an empty argument is written.
- `Skipped the #pragma line`
  GCC V.3 provides several #pragma directives in the form of #pragma GCC <args>. Its preprocessor processes some of them, but mcpp does not support #pragma GCC poison and #pragma GCC dependency. This warning is issued to a #pragma directive compiler-specific preprocessors process but mcpp does not.
- `Not a valid preprocessing token "+12"`
  Concatenating two pp-tokens with the ## operator results in an invalid token "+12", which normally causes an error. However, mcpp invoked with the -lang-asm (-x assembler-with-cpp, -a) option does not regard it as an error.

The following warning is issued only in POSTSTD mode.

- `Header-name enclosed by <, > is an obsolescent feature <stdio.h>`
  The header name in the form of <stdio.h> is one of the specifications I want to abolish. I recommend to use "stdio.h".

The following two warnings are issued only in some compiler systems. Of course, the coding in question is valid in those particular systems, but it lacks of portability, so a warning is issued to remind users of it.

- `#include_next is not allowed by Standard`
- `#warning is not allowed by Standard`
  These directives are valid in GCC but not Standard C-conforming and lack of portability.
- `GCC2-spec variadic macro is defined`
  Though GCC2-spec variadic macro is valid in GCC-specific-build, this macro is not portable.
- `Converted to /`
  A #include directive contains \ in the header name. mcpp converts \ into /. "\" is a valid path delimiter in OSs, such as Windows, but undefined in Standard C. It is safe to use /. mcpp on Windows issues this warning only once. (mcpp does not regard " preceded by \ as a delimiter of a string literal, raising an "unterminated string literal" error.)
- `'$' in identifier "THIS$AND$THAT"`
  An identifier has a '$'. The only mcpp compiled with DOLLAR_IN_NAME set to TRUE issues this warning only once because '$' lacks of portability although it is valid in this mcpp. '$' being regarded as a pp-token, other mcpp parses THIS$AND$THAT into five components THIS, $, AND, $ and THAT, resulting in a compiler error.

## 5.7. Warnings (Class 4)

Standard C guarantees some minimum translation limits. It is desirable that a preprocessor imposes translation limits that exceed these values, but source programs that uses preprocessor' own translation limits will restrict portability. mcpp provides some macros in "system.H" that allows you to set translation limits to any values you like. mcpp in Standard mode issues a warning to source code that exceeds a Standard C guaranteed limit. However, these messages are excluded from Class 1 and 2 because they may be issued frequently, depending on standard headers of compiler systems or source programs.

- `Logical source line longer than 509 bytes`
  The length of a logical source line has exceeded 509 bytes.
- `Quotation longer than 509 bytes "very_very_long_string"`
  The length of a string literal, character constant or header name has exceeded 509 bytes.
- `More than 8 nesting of #include`
  The depth of nested #includes has exceeded 8. This warning is issued only when it reaches 9.
- `More than 8 nesting of #if (#ifdef) sections`
  The depth of nested #ifs, #ifdefs, or #ifndefs has exceeded 8. This warning is issued only when it reaches 9.
- `More than 1024 macros defined`
  The number of defined macros has reached 1024. This number includes both of pre-defined macros and those defined in header files.
- `String literal longer than 509 bytes "very_very_long_string"`
  Expansion of a macro using the # operator has generated a string literal longer than 509 bytes.

The following warnings are not issued in a skipped #if group.

- `More than 32 nesting of parens in #if expression`
  The depth of nested parentheses in a #if expression has exceeded 32. This warning is issued only when it reaches 33.
- `More than 31 parameters`
  The number of parameters of a macro definition has exceeded 31.
- `Identifier longer than 31 bytes "very_very_long_name"`
  The length of an identifier has exceeded 31 bytes.

With `__STDC_VERSION__` >= 199901L, the Standard specified translation limits are as follows:

> Length of logical source line | 4095 bytes
> Length of string literal, character constant, or header name | 4095 bytes
> Identifier length | 63 characters
> Depth of nested #includes | 15
> Depth of nested #ifs, #ifdefs, or #ifndefs | 63
> Depth of nested parentheses in #if expression | 63
> Number of macro parameters | 127
> Number of definable macros | 4095

Note that the length of a UCN or multi-byte-character in an identifier is counted as the number of characters, not bytes. (A queer stipulation)

When mcpp is invoked with the -+ option to specify C++ preprocessing, the Standard guideline of translation limits are as follows:

> Length of logical source line | 65536 bytes
> Length of string literal, character constant, or header name | 65536 bytes
> Identifier length | 1024 characters
> Depth of nested #includes | 256
> Depth of nested #ifs, #ifdefs, or #ifndefs | 256
> Depth of nested parentheses in #if expression | 256
> Number of macro parameters | 256
> Number of definable macros | 65536

Note that mcpp allows the maximum number of macro parameters of 255. So, when it reaches 256, mcpp issues an error.

The following warnings are excluded from class 1 and 2 because they are issued too frequently.

- `Converted 0x0c to a space`
  [FF], [VT], [CR] (other than in [CR][LF] sequence) in source code as token separators are converted into a space character. How to deal with these token separators located on a directive line is undefined in Standard C. If they are located in comments, string literals, or character constants, mcpp does not convert them. (Of course, mcpp can do so, but I do not want mcpp to impose a greater restriction on a character set used since it essentially depends on the compiler-proper.) On the other hand, [TAB] as a token separator is converted into a space character, but no warning is issued because it does not affect compilation at all. ([TAB] means nothing but a space to both of preprocessor and compiler-proper.) [FF] are found sometimes in actual source to indicate "end of page". This is not a recommendable style.
- `Undefined symbol`
  In #if line the identifier "name" is not defined as a macro. It is evaluated to zero. This is not an error at all, but may be a program bug. No warning is issued to an argument of a #if defined. This warning can be avoided by writing #if defined name && (name ..), instead of #if name .., or by invoking mcpp with the -D name=0 option. C++ gives "true" and "false" tokens special treatment and evaluates to 1 and 0, respectively, without a warning.
- `Multi-character wide character constant L'ab' isn't portable`
  A wide character constant value varies even among compiler systems using the same character set because the encoding scheme of wide character constants and how to evaluate multi-characters depend on compiler systems. Therefore, #if expressions using them do not provide portability. The only STD mode issues this warning. POSTSTD mode does not permit character literal in #if expression, so this causes an error. (The next item is also treated the same way.)
- `Multi-character or multi-byte character constant 'XY' isn't portable`
  Since how to evaluate the value of a multi-character or multi-byte character constant depends on compiler systems, #if expressions using them do not provide portability. The only STD mode issues this warning.

The following two warnings are issued only in Standard mode.

- `Macro with mixing of ## and # operators isn't portable`
  A function-like macro has a token sequence of "## #" in the replacement list. This sequence of two operators lack of portability because their priority is unspecified in Standard C. mcpp takes precedence # over ##. Note that if a function-like macro has a token sequence in the reverse order "# ##", mcpp regards it as an error because the operand of the # operator must be a parameter.
- `Macro with multiple ## operators isn't portable`
  A macro definition has only one token or parameter inserted between ## operators in the replacement list. This macro may lack of portability because the evaluation order of ## operators is unspecified in Standard C. mcpp applies the ## operator from left to right.

This warning is only with -K option in STD mode.

- `Too long comment, discarded up to here`
  The comment is longer than 256 lines, mcpp discards it up to here. It is not a good style to include long document in source.

## 5.8. Warnings (Class 8)

There is little chance that the indicated source code contains a bug, but these messages are issued to call attention to it. mcpp invoked with the -W8 option issues these warnings.

In a skipped #if group, whether preprocessing directives, such as #ifdef, #ifndef, #elif, #else, and #endif, are balanced or not is checked. However, mcpp invoked with the -W8 option also checks non-conforming or unknown directives. Standard mode issues a warning when the depth of nested #ifs exceeds 8.

- `Illegal #directive "+" (in skipped block)`
- `Unknown #directive "pseudo-directive" (in skipped block)`
- `More than 8 nesting of #if (#ifdef) sections (in skipped block)`
- `#include_next is not allowed by Standard (in skipped block)`
- `#warning is not allowed by Standard (in skipped block)`

The following warnings are related to #if expression. Given an expression of `#if a || b`, for example, if "a" is true, "b" is not evaluated. However, mcpp invoked with -W8 issues a warning to non-evaluated sub-expressions, in which case, the note saying "in non-evaluated sub-expression" is appended.

- `Constant "123456789012345678901" is out of range`
- `Constant "123456789012" is out of range of (unsigned) long`
- `LL suffix is used in other than C99 mode "123LL"`
- `I64 suffix is used in other than C99 mode "123i64"`
- `Shift count "40" is larger than bit count of long`
- `Integer character constant 'abcdefghi' is out of range`
- `Integer character constant 'abcde' is out of range of unsigned long`
- `Wide character constant L'abcdef' is out of range`
- `Wide character constant L'abc' is out of range of unsigned long`
- `8 bits can't represent escape sequence 'x123'`
- `16 bits can't represent escape sequence L'x12345'`
- `Division by zero`
- `Undefined symbol "name", evaluated to 0`
- `sizeof: Unknown type "type"`
- `sizeof: Illegal type combination with "type"`
- `Multi-character wide character constant L'ab' isn't portable`
- `Multi-character or multi-byte character constant 'XY' isn't portable`
- `Undefined escape sequence '\x'`
- `UCN cannot specify the value "0000007f"`
- `Negative value "-1" is converted to positive "18446744073709551615"`
- `Result of "op" is out of range`
- `Result of "op" is out of range of (unsigned) long`
- `Illegal shift count "-1"`
- `"op" of negative number isn't portable`
- `sizeof is disallowed in C Standard`
  The purpose of this warning is to remind users of the fact that Standard C does not allow for #if sizeof, although pre-Standard mode implements it.
- `"MACRO" wasn't defined`
  An undefined name is specified with #undef. Standard C does not regard it as an error.
- `Macro "macro" needs arguments`
  A token with the same name as a macro with arguments appears in a stand alone manner. mcpp does not expand it and leave it as it is. The only pre-Standard mode issues this warning. (Standard mode does not issue a warning since such a token does not cause any problem.)
- `Replacement text "sub(" of macro "head" involved subsequent text`
  Rescanning of the replacement list "sub(" of the macro "head" has involved the text succeeding the macro invocation. COMPAT mode issues this warning only on class 8, whereas STD mode issues on class 1.

## 5.9. Warnings (Class 16)

Trigraphs and digraphs are not used at all in an environment where they are not need to. If they are found in such an environment, attention needs to be paid. The purpose of the -W16 option is to find such trigraphs and digraphs. On the other hand, these warnings are very bothersome in an environment where trigraphs or digraphs are used on a regular basis because they are issued very frequently. For this reason, I set up a separate class for these warnings. Anyway, mcpp issues these messages only in the state where the trigraphs or digraphs are enabled. Digraph is for Standard mode only, and trigraph is for STD mode only.

- `2 trigraph(s) converted`
  Two trigraph sequences in this physical line have been converted. Does the programmer really intend to write trigraph?
- `2 digraph(s) converted`
  Two digraph sequences in this line have been converted. Does the programmer really intend to write digraphs? mcpp compiled with HAVE_DIGRAPHS == FALSE in STD mode converts a digraph into a regular token in the following manner after preprocessing:

      <% -> {      <: -> [      %:    -> #
      %> -> }      :> -> ]      %:%:  -> ##

  Therefore, the compiler-proper is not necessary to be able to handle digraphs. However, POSTSTD mode converts a digraph into a regular pp-token during the translation phase 1. The difference of this behavior between the modes appears when a # operator converts a digraph into a string; STD mode directly converts a digraph sequence into a string, while POSTSTD mode converts it into a regular pp-token, and then into a string. In addition, if a string literal contains a character sequence which is equivalent to a digraph sequence, STD mode does not convert it, while POSTSTD mode converts it into a character sequence of the corresponding pp-tokens.
  STD mode does not issue a warning to a digraph that appears on a preprocessing-directive line and disappears in a due course because this warning is issued only to converted digraphs.

## 5.10. Diagnostic Messages Index

Diagnostic Message | Fatal error | Error | Warning class
--- | --- | --- | ---
| 1 | 2 | 4 | 8 | 16
`"..." isn't the last parameter` |  | 5.4.7
`"/*" in comment` |  |  | 5.5.1
`"and" is defined as macro` |  |  | 5.5.3
`"defined" shouldn't be defined` |  | 5.4.7
`"MACRO" has not been defined` |  |  | 5.5.3
`"MACRO" has not been pushed` |  |  | 5.5.3
`"MACRO" is already pushed` |  |  | 5.5.3
`"MACRO" wasn't defined` |  |  |  |  |  | 5.8
`"op" of negative number isn't portable` |  |  | 5.5.4 |  |  | 5.8
`"__STDC__" shouldn't be redefined` |  | 5.4.7
`"__STDC__" shouldn't be undefined` |  | 5.4.8
`"__VA_ARGS__" without corresponding "..."` |  | 5.4.7
`"__VA_ARGS__" cannot be used in GCC2-spec variadic macro` |  | 5.4.7
`## after ##` |  | 5.4.7
`#error` |  | 5.4.10
`#include_next is not allowed by Standard` |  |  |  | 5.6 |  | 5.8
`#warning` |  |  | 5.5.7
`'$' in identifier "THIS$AND$THAT"` |  |  |  | 5.6
`16 bits can't represent escape sequence L'\x12345'` |  | 5.4.6 |  |  |  | 5.8
`2 digraph(s) converted` |  |  |  |  |  |  | 5.9
`2 trigraph(s) converted` |  |  |  |  |  |  | 5.9
`8 bits can't represent escape sequence '\x123'` |  | 5.4.6 |  |  |  | 5.8
`_Pragma operator found in directive line` |  | 5.4.12
`Already seen #else at line 123` |  | 5.4.3
`Bad defined syntax` |  | 5.4.5
`Bad pop_macro syntax` |  |  | 5.5.3
`Bad push_macro syntax` |  |  | 5.5.3
`Buffer overflow expanding macro "macro" at "something"` |  | 5.4.9
`Buffer overflow scanning token "token"` | 5.3.3
`Bug:` | 5.3.1
`Can't open include file "file-name"` |  | 5.4.11
`Can't use a character constant 'a'` |  | 5.4.5
`Can't use a string literal "string"` |  | 5.4.5
`Can't use the character 0x24` |  | 5.4.5
`Can't use the operator "++"` |  | 5.4.5
`Constant "123456789012" is out of range of (unsigned) long` |  |  | 5.5.4 | 5.6 |  | 5.8
`Constant "1234567890123456789012" is out of range` |  | 5.4.6 |  |  |  | 5.8
`Converted 0x0c to a space` |  |  |  |  | 5.7
`Converted [CR+LF] to [LF]` |  |  | 5.5.1 | 5.6
`Converted \ to /` |  |  |  | 5.6
`Division by zero` |  | 5.4.6 |  |  |  | 5.8
`Duplicate parameter names "a"` |  | 5.4.7
`Empty argument in macro call "MACRO( a, ,"` |  |  |  | 5.6
`Empty character constant ''` |  | 5.4.1 | 5.5.1
`Empty parameter` |  | 5.4.7
`End of file with no newline, supplemented the newline` |  |  | 5.5.2
`End of file with unterminated #asm block started at line 123` |  | 5.4.2 | 5.5.2
`End of file with unterminated comment, terminated the comment` |  |  | 5.5.2
`End of file with \, deleted the \` |  |  | 5.5.2
`End of file within #if (#ifdef) section started at line 123` |  | 5.4.2 | 5.5.2
`End of file within macro call started at line 123` |  | 5.4.2 | 5.5.2
`Excessive ")"` |  | 5.4.5
`Excessive token sequence "junk"` |  | 5.4.4 | 5.5.3
`File read error` | 5.3.2
`File write error` | 5.3.2
`GCC2-spec variadic macro is defined` |  |  |  | 5.6
`Header-name enclosed by <, > is an obsolescent feature` |  |  |  | 5.6
`I64 suffix is used in other than C99 mode "123i64"` |  |  |  | 5.6 |  | 5.8
`Identifier longer than 31 bytes "very_very_long_name"` |  |  |  |  | 5.7
`Ignored #ident` |  |  | 5.5.3 |  |  | 5.8
`Ignored #sccs` |  |  | 5.5.3 |  |  | 5.8
`Illegal #directive "123"` |  | 5.4.4 | 5.5.3 |  |  | 5.8
`Illegal control character 0x1b in quotation` |  |  | 5.5.1
`Illegal control character 0x1b, skipped the character` |  | 5.4.1
`Illegal digit in octal number "089"` |  |  | 5.5.1
`Illegal multi-byte character sequence "XY" in quotation` |  |  | 5.5.1
`Illegal multi-byte character sequence "XY"` |  | 5.4.1
`Illegal parameter "123"` |  | 5.4.7
`Illegal shift count "-1"` |  |  | 5.5.4 |  |  | 5.8
`Illegal UCN sequence` |  | 5.4.1
`In #asm block started at line 123` |  | 5.4.3
`Integer character constant 'abcde' is out of range of unsigned long` |  |  | 5.5.4 | 5.6 |  | 5.8
`Integer character constant 'abcdefghi' is out of range` |  | 5.4.6 |  |  |  | 5.8
`Less than necessary N argument(s) in macro call "macro( a)"` |  | 5.4.9 | 5.5.5
`Line number "0x123" isn't a decimal digits sequence` |  | 5.4.4 | 5.5.6
`Line number "2147483648" is out of range of 1,2147483647` |  | 5.4.4
`Line number "32768" got beyond range` |  |  | 5.5.6
`Line number "32768" is out of range of 1,32767` |  |  | 5.5.6
`Line number "32769" is out of range` |  |  | 5.5.6
`LL suffix is used in other than C99 mode "123LL"` |  |  | 5.5.4 | 5.6 |  | 5.8
`Logical source line longer than 509 bytes` |  |  |  |  | 5.7
`Macro "MACRO" is expanded to "defined"` |  |  | 5.5.4
`Macro "MACRO" is expanded to "sizeof"` |  |  | 5.5.4
`Macro "MACRO" is expanded to 0 token` |  |  | 5.5.4
`Macro "macro" needs arguments` |  |  |  |  |  | 5.8
`Macro started at line 123 swallowed directive-like line` |  |  | 5.5.5
`Macro with mixing of ## and # operators isn't portable` |  |  |  |  | 5.7
`Macro with multiple ## operators isn't portable` |  |  |  |  | 5.7
`Misplaced ":", previous operator is "+"` |  | 5.4.5
`Misplaced constant "12"` |  | 5.4.5
`Missing ")"` |  | 5.4.5
`Missing "," or ")" in parameter list "(a,b"` |  | 5.4.7
`More than 1024 macros defined` |  |  |  |  | 5.7
`More than 31 parameters` |  |  |  |  | 5.7
`More than 32 nesting of parens in #if expression` |  |  |  |  | 5.7
`More than 8 nesting of #if (#ifdef) sections` |  |  |  |  | 5.7 | 5.8
`More than 8 nesting of #include` |  |  |  |  | 5.7
`More than BLK_NEST nesting of #if (#ifdef) sections` | 5.3.3
`More than INCLUDE_NEST nesting of #include` | 5.3.3
`More than necessary N argument(s) in macro call "macro( a, b, c)` |  | 5.4.9
`More than NEXP*2-1 constants stacked at "12"` |  | 5.4.5
`More than NEXP*3-1 operators and parens stacked at "+"` |  | 5.4.5
`More than NMACPARS parameters` |  | 5.4.7
`Multi-character or multi-byte character constant 'XY' isn't portable` |  |  |  |  | 5.7 | 5.8
`Multi-character wide character constant L'ab' isn't portable` |  |  |  |  | 5.7 | 5.8
`Negative value "-1" is converted to positive "18446744073709551615"` |  |  | 5.5.4 |  |  | 5.8
`No argument` |  | 5.4.4 | 5.5.3
`No header name` |  | 5.4.4
`No identifier` |  | 5.4.4
`No line number` |  | 5.4.4
`No space between macro name "MACRO" and repl-text` |  |  | 5.5.3
`No sub-directive` |  |  | 5.5.3
`No token after ##` |  | 5.4.7
`No token before ##` |  | 5.4.7
`Not a file name "name"` |  | 5.4.4
`Not a formal parameter "id"` |  | 5.4.7
`Not a header name "UNDEFINED_MACRO"` |  | 5.4.4
`Not a line number "name"` |  | 5.4.4
`Not a valid preprocessing token "+12"` |  | 5.4.9 |  | 5.6
`Not a valid string literal` |  | 5.4.9
`Not an identifier "123"` |  | 5.4.4 | 5.5.3
`Not an integer "1.23"` |  | 5.4.5
`Not in a #if (#ifdef) section` |  | 5.4.3
`Not in a #if (#ifdef) section in a source file` |  | 5.4.3 | 5.5.3
`Operand of _Pragma() is not a string literal` |  | 5.4.12
`Operator ">" in incorrect context` |  | 5.4.5
`Old style predefined macro "linux" is used` |  |  | 5.5.5
`Out of memory (required size is 0x1234 bytes)` | 5.3.2
`Parsed "//" as comment` |  |  |  | 5.6
`Preprocessing assertion failed` |  | 5.4.10
`Quotation longer than 509 bytes "very_very_long_string"` |  |  |  |  | 5.7
`Recursive macro definition of "macro" to "macro"` |  | 5.4.9
`Removed ',' preceding the absent variable argument` |  |  | 5.5.5
`Replacement text "sub(" of macro "head" involved subsequent text` |  |  | 5.5.5 |  |  | 5.8
`Rescanning macro "macro" more than RESCAN_LIMIT times at "something"` |  | 5.4.9
`Result of "op" is out of range` |  | 5.4.6 |  |  |  | 5.8
`Result of "op" is out of range of (unsigned) long` |  |  | 5.5.4 | 5.6 |  | 5.8
`Shift count "40" is larger than bit count of long` |  |  | 5.5.4 | 5.6 |  | 5.8
`sizeof is disallowed in C Standard` |  |  |  |  |  | 5.8
`sizeof: Illegal type combination with "type"` |  | 5.4.6 |  |  |  | 5.8
`sizeof: No type specified` |  | 5.4.5
`sizeof: Syntax error` |  | 5.4.5
`sizeof: Unknown type "type"` |  | 5.4.6 |  |  |  | 5.8
`Skipped the #pragma line` |  |  |  | 5.6
`String literal longer than 509 bytes "very_very_long_string"` |  |  |  |  | 5.7
`The macro is redefined` |  |  | 5.5.4
`This is not a preprocessed source` | 5.3.4
`This preprocessed file is corrupted` | 5.3.4
`Too long comment, discarded up to here` |  |  |  |  | 5.7
`Too long header name "long-file-name"` | 5.3.3
`Too long identifier, truncated to "very_long_identifier"` |  |  | 5.5.1
`Too long line spliced by comments` | 5.3.3
`Too long logical line` | 5.3.3
`Too long number token "12345678901234"` | 5.3.3
`Too long pp-number token "1234toolong"` | 5.3.3
`Too long quotation "long-string"` | 5.3.3
`Too long source line` | 5.3.3
`Too long token` | 5.3.3
`Too many magics nested in macro argument` |  | 5.4.9
`Too many nested macros in tracing MACRO` |  | 5.4.9
`UCN cannot specify the value "0000007f"` |  | 5.4.1 |  |  |  | 5.8
`Undefined escape sequence '\x'` |  |  | 5.5.4 |  |  | 5.8
`Undefined symbol "name", evaluated to 0` |  |  |  |  | 5.7 | 5.8
`Unknown #directive "pseudo-directive"` |  | 5.4.4 | 5.5.4 |  |  | 5.8
`Unknown argument "name"` |  |  | 5.5.3
`Unterminated character constant 't understand.` |  | 5.4.1
`Unterminated expression` |  | 5.4.5
`Unterminated header name` |  | 5.4.1
`Unterminated macro call "macro( a, (b,c)"` |  | 5.4.9
`Unterminated string literal` |  | 5.4.1
`Unterminated string literal, catenated to the next line` |  |  | 5.5.1
`Variable argument macro is defined` |  |  |  | 5.6
`Wide character constant L'abc' is out of range of unsigned long` |  |  | 5.5.4 | 5.6 |  | 5.8
`Wide character constant L'abc' is out of range` |  | 5.4.6 |  |  |  | 5.8

# 6. Reporting on Bugs and Others

I have developed the Validation Suite to verify conformance of preprocessing to Standard C/C++, and released it along with mcpp source. The Validation Suite is intended to allow you to verify all the Standard C preprocessing specifications. Of course, I used the Validation Suite to check mcpp. And what is more, I have compiled mcpp in many compiler systems to verify its behavior. Therefore, I am confident that mcpp is now almost flawless, free of bugs and misinterpretation of specifications, however, I cannot deny the possibility that it still contains some bugs.

If you find a strange behavior, do not hesitate to let me know. If you receive a diagnostic message saying "Bug: ...", it is undoubtedly a bug of mcpp or a compiler system. (Probably, it's mcpp's.) How illegal a user program may be, should mcpp lose control, it is mcpp that is to be blamed for it.

When you report a bug, please be sure to provide the following information:

1. Compiler system mcpp is ported to.
2. A sample source (shorter is better) that allows reproduction of what looks like a bug.
3. Preprocessing results.

Other than bugs, I would appreciate if you give me feedback on mcpp usage, diagnostic messages or this manual.

For your feedback or information, please post to "Open Discussion Forum" at:

http://mcpp.sourceforge.net/

or send via e-mail.