Lecture 05 by adeel109

VIEWS: 3 PAGES: 8

									                                                Chapter 5



Preprocessor .....................................................................................................2
  Preprocessor directives: #ifdef and #ifndef ....................................................2
  Prevent multiple definitions in header files.....................................................2
  Turning debugging code off and on ...............................................................2
Some Preprocessor directives...........................................................................3
        #define....................................................................................................3
  Example: macro #defines ..............................................................................3
        #error ......................................................................................................3
        #include ..................................................................................................3
Conditional Compilation - #if, #else, #elif, and #endif........................................4
        #ifdef and #ifndef ....................................................................................4
        #undef.....................................................................................................4
        #line ........................................................................................................4
        #pragma .................................................................................................4
The # and ## Preprocessor Operators ..............................................................5
Macros ..............................................................................................................5
  Standard Predefined Macros .........................................................................5
        __FILE__ ................................................................................................6
        __LINE__................................................................................................6
        __DATE__ ..............................................................................................6
        __TIME__ ...............................................................................................6
        __STDC__..............................................................................................6
        __STDC_VERSION__............................................................................7
        __STDC_HOSTED__ .............................................................................7
        __cplusplus.............................................................................................7
Summary...........................................................................................................7
Tips ...................................................................................................................7
                                 Preprocessor Directives                                 2




Preprocessor
The preprocessor is a program that runs prior to compilation and potentially modifies a
source code file. It may add code in response to the #include directive, conditionally
include code in response to #if, #ifdef, #ifndef directives or define constants using the
#define directive.
As defined by the ANSI standard, the C preprocessor contains the following directives:

#if #ifdef #ifndef #else #elif #include #define #undef #line #error #pragma

Preprocessor directives: #ifdef and #ifndef
The #ifdef (if defined) and #ifndef (if not defined) preprocessor commands are used to
test if a preprocessor variable has been "defined".

Prevent multiple definitions in header files
When there are definitions in a header file that can not be made twice, the code below
should be used. A header file may be included twice because more than one other
“include file” includes it, or an included file includes it and the source file includes it
again.

To prevent bad effects from a double include, it is common to surround the body in the
include file with the following:

#ifndef MYHEADERFILE_H
#define MYHEADERFILE_H
...   // This will be seen by the compiler only once
#endif /* MYHEADERFILE_H */


Turning debugging code off and on
Debugging code is necessary in programs; however, it is not usually appropriate to leave
it in the delivered code. The preprocessor #ifdef command can surround the debugging
code. If DEBUG is defined as below (probably in an include file) all debugging statement
surrounded by the #ifdef DEBUG statement will be active. However, if it isn't defined,
none of the statements will make it through the preprocessor.

#define DEBUG
...
#ifdef DEBUG
 . . . // debugging output
#endif
                                 Preprocessor Directives                                  3


Some Preprocessor directives
• #define
#define defines an identifier (the macro name) and a string (the macro substitution) which
will be substituted for the identifier each time the identifier is encountered in the source
file. Once a macro name has been defined, it may be used as part of the definition of
other macro names.

If the string is longer than one line, it may be continued by placing a backslash on the end
of the first line. By convention, C programmers use uppercase for defined identifiers.


Example: macro #defines
  #define TRUE 1
  #define FALSE 0

The macro name may have arguments, in which case every time the macro name is
encountered; the arguments associated with it are replaced by the actual arguments found
in the program, as in:

   #define ABS(a) (a)<0 ? -(a) : (a)
   ...
   printf("abs of -1 and 1: %d %d", ABS(-1), ABS(1));

Such macro substitutions in place of real functions increase the speed of the code at the
price of increased program size.

• #error
#error forces the compiler to stop compilation. It is used primarily for debugging. The
general form is:

   #error error_message

When the directive is encountered, the error message is displayed, possibly along with
other information (depending on the compiler).

• #include
#include instructs the compiler to read another source file, which must be included
between double quotes or angle brackets. Examples are:

   #include "stdio.h"
   #include <stdio.h>

Both of these directives instruct the compiler to read and compile the named header file.
If a file name is enclosed in angle brackets, the file is searched for as specified by the
creator of the compiler. If the name is enclosed in double quotes, the file is searched for
                                  Preprocessor Directives                                  4

in an implementation-defined manner, which generally means searching the current
directory. (If the file is not found, the search is repeated as if the name had been enclosed
in angle brackets.)

Conditional Compilation - #if, #else, #elif, and
#endif
Several directives control the selective compilation of portions of the program code, viz,
#if, #else, #elif, and #endif.

The general form of #if is:
   #if constant_expression
  statement sequence
   #endif

#else works much like the C keyword else. #elif means "else if" and establishes an if-
else-if compilation chain.

Amongst other things, #if provides an alternative method of "commenting out" code. For
example, in
   #if 0
   printf("#d",total);
   #endif

the compiler will ignore printf("#d",total);.

• #ifdef and #ifndef
#ifdef means "if defined", and is terminated by an #endif. #ifndef means "if not defined".

• #undef
#undef removes a previously defined definition.

• #line
line changes the contents of __LINE__ (which contains the line number of the currently
compiled code) and __FILE__ (which is a string which contains the name of the source
file being compiled), both of which are predefined identifiers in the compiler.

• #pragma
The #pragma directive is an implementation-defined directive which allows various
instructions to be given to the compiler i.e. it allows a directive to be defined.
The #pragma directive is the method specified by the C standard for providing additional
information to the compiler, beyond what is conveyed in the language itself. Three forms
of this directive (commonly known as pragmas) are specified by the 1999 C standard. A
C compiler is free to attach any meaning it likes to other pragmas.
                                   Preprocessor Directives                             5


The # and ## Preprocessor Operators
The # and ## preprocessor operators are used when using a macro #define. The #
operator turns the argument it precedes into a quoted string. For example, given:

#define mkstr(s) # s

the preprocessor turns the line
    printf(mkstr(I like C);
into
    printf("I like C");
The ## operator concatenates two tokens. For example, given:
    #define concat(a, b) a ## b

    int xy=10;
    printf("%d",concat(x, y);
the preprocessor turns the last line into:
    printf("%d", xy);

Macros
A macro is a fragment of code which has been given a name. Whenever the name is used,
it is replaced by the contents of the macro. There are two kinds of macros. They differ
mostly in what they look like when they are used. Object-like macros resemble data
objects when used, function-like macros resemble function calls.

You may define any valid identifier as a macro, even if it is a C keyword. The
preprocessor does not know anything about keywords. This can be useful if you wish to
hide a keyword such as const from an older compiler that does not understand it.
However, the preprocessor operator defined can never be defined as a macro, and C++'s
named operators cannot be macros when you are compiling C++.

To define a macro that takes arguments, you use the #define command with a list of
parameters in parentheses after the name of the macro. The parameters may be any valid
C identifiers separated by commas at the top level (that is, commas that aren't within
parentheses) and, optionally, by white-space characters. The left parenthesis must follow
the macro name immediately, with no space in between.

For example, here's a macro that computes the maximum of two numeric values:
       #define min(X, Y) ((X)>(Y) ? (X):(Y))


Standard Predefined Macros
The standard predefined macros are specified by the C and/or C++ language standards, so
they are available with all compilers that implement those standards. Older compilers
may not provide all of them. Their names all start with double underscores.
                                  Preprocessor Directives                                   6


• __FILE__
This macro expands to the name of the current input file, in the form of a C string
constant. This is the path by which the preprocessor opened the file, not the short names
specified in #include or as the input file name argument. For example,
"/usr/local/include/myheader.h" is a possible expansion of this macro.

• __LINE__
This macro expands to the current input line number, in the form of a decimal integer
constant. While we call it a predefined macro, it's a pretty strange macro, since its
"definition" changes with each new line of source code.

__FILE__ and __LINE__ are useful in generating an error message to report an inconsistency
detected by the program; the message can state the source line at which the inconsistency
was detected. For example,

fprintf (stderr, "Internal error: "
            "negative string length "
            "%d at %s, line %d.",
      length, __FILE__, __LINE__);

An #include directive changes the expansions of __FILE__ and __LINE__ to correspond to
the included file. At the end of that file, when processing resumes on the input file that
contained the #include directive, the expansions of __FILE__ and __LINE__ revert to the values
they had before the #include (but __LINE__ is then incremented by one as processing moves
to the line after the #include).

•   __DATE__

This macro expands to a string constant that describes the date on which the preprocessor
is being run. The string constant contains eleven characters and looks like "Feb 12 1996".
If the day of the month is less than 10, it is padded with a space on the left.

•   __TIME__

This macro expands to a string constant that describes the time at which the preprocessor
is being run. The string constant contains eight characters and looks like "23:59:01".

•   __STDC__

In normal operation, this macro expands to the constant 1, to signify that this compiler
conforms to ISO Standard C.
                                Preprocessor Directives                               7


•   __STDC_VERSION__

This macro expands to the C Standard's version number, a long integer constant of the
form yyyymmL where yyyy and mm are the year and month of the Standard version.
This signifies which version of the C Standard the compiler conforms to.

This macro is not defined if the -traditional option is used, nor when compiling C++ or
Objective-C.

•   __STDC_HOSTED__

This macro is defined, with value 1, if the compiler's target is a hosted environment. A
hosted environment has the complete facilities of the standard C library available.

•   __cplusplus

This macro is defined when the C++ compiler is in use. You can use __cplusplus to test
whether a header is compiled by a C compiler or a C++ compiler. This macro is similar
to __STDC_VERSION__, in that it expands to a version number.




Tips
    •   Do use the preprocessor directives as much as possible in your programme as it
        makes the programme more robust.
                                Preprocessor Directives                                8


   •   Using the #defined, #ifndef directives helps in Prevent multiple definitions in
       header files.

   •    Conditional compilation with the use of preprocessor directives provides a very
       easy way for turning the debug code on and off.

   •   A macro is a fragment of code which has been given a name. Whenever the name
       is used, it is replaced by the contents of the macro.

   •   Macros can be used for writing clear and easily comprehensible code.

   •   Do remember that whenever the macro name is used, it is replaced by the contents
       of the macro.




Summary
The preprocessor is a program that runs prior to compilation and potentially modifies a
source code file. It may add code in response to the #include directive, conditionally
include code in response to #if, #ifdef, #ifndef directives or define constants using the
#define directive.

A simple macro is a kind of abbreviation. It is a name which stands for a fragment of
code. Some standard pre-defined Macros include __FILE__, __LINE__, __DATE__,
__TIME__ etc.

								
To top