---

C pre-processor

---

• C pre-processor
  • Before invoking the C compiler, the C programming language system will always invoke a

    C pre-processor

    to process the program source code.

    ---

  • Tasks performed by the C pre-processor:

    Read in included file #include <stdio.h> or #include "header.h" Removes comments from the source code /* .......... */ or: // ........ Process macro (symbolic) definitions #define ... ....

  ---

  ---

  ---

• Comments in C

  • It used to be that C only have multi-line comments enclosed between the pairs of "brackets" /* ... */:

    /* ..... ..... ..... */

    ---

  • Examples:

    /* This is a comment in a C program */ /* * This is an another comment * in a C program */

    ---

  • A later revision C99 in 1999 of the C programming language has added the C++ style comment:

    // This is now allowed as comment

    ---

  • The C pre-processor will remove all comments.

    Demo:

    Compile this program comment.c: /* --------------------------------------- This is a comment --------------------------------------- */ This is a NOT comment (will generate syntax error !) int main( int argc, char* argv[] ) { printf( "Hello World !\n" ); } using this command: gcc -E comment.c

    ---

  • Result:

    # 1 "comment.c" # 1 "" # 1 "" # 1 "comment.c" This is a NOT comment (will generate syntax error !) int main( int argc, char* argv[] ) { printf( "Hello World !\n" ); }

    ---

  • Example Program: (Demo above code)                                                
    • Prog file: click here

    How to run the program:

    Right click on link and save in a scratch directory To compile:   gcc -E comment.c Look at the output on the terminal....

  ---

  ---

  ---

  ---

  ---

  ---

• Macro definitions
  • Macro:

    Macro = a rule or pattern that specifies how a certain input sequence (= a sequence of characters) should be mapped to a replacement sequence

    ---

  • Syntax to define a macro:

    #define <identifier> <replacement token list> #define <identifier>(<parameter list>) <replacement token list>

    Meaning:

    Every occurence of the <identifier> string in the source code will be replaced by the <replacement token list>.

    ---

  • Use of macros in C:

    Defining constant Defining simple functions

  ---

  ---

• Defining symbolic constants in C
  • C uses the C pre-processor's #define macro construct to define symbolic constants

    ---

    Example:

    #define PI 3.141592653589793238462643383279502884197 #define MAX 99999 int main( int argc, char* argv[] ) { int x; double y; x = MAX; y = PI; }

    After processing with gcc -E constant.c:

    int main( int argc, char* argv[] ) { int x; double y; x = 99999; y = 3.141592653589793238462643383279502884197; }

    ---

  • Example Program: (Demo above code)                                                
    • Prog file: click here

    How to run the program:

    Right click on link and save in a scratch directory To compile:   gcc -E constant.c Look at the output on the terminal....

  ---

  ---

• Defining simple functions in C
  • You can use the #define macro construct to define simple (one line) functions

    ---

    Example:

    #define square(x) (x*x) int main( int argc, char* argv[] ) { double a, b; b = square(a); }

    After processing with gcc -E macro1.c:

    int main( int argc, char* argv[] ) { double a, b; b = (a*a); ( square(a) ---> (a*a) ) }

    ---

  • Example Program: (Demo above code)                                                
    • Prog file: click here

    How to run the program:

    Right click on link and save in a scratch directory To compile:   gcc -E macro1.c Look at the output on the terminal....

    ---

    ---

  • Caveat:

    Make very sure that you use brackets to prevent errors caused by operator precedence

    Example:

    #define sum(x,y) x+y /* Sum: x+y */ int main( int argc, char* argv[] ) { double a, b, c; c = sum(a, b); /* Compute a+b */ c = 2*sum(a, b); /* Compute 2*(a+b) ??? */ }

    After processing with gcc -E macro2.c:

    int main( int argc, char* argv[] ) { double a, b, c; c = a+b; c = 2*a+b; /* Wrong !!! Not equal to: 2*(a+b) !!! */ }

    ---

  • Example Program: (Demo above code)                                                
    • Prog file: click here

    How to run the program:

    Right click on link and save in a scratch directory To compile:   gcc -E macro2.c Look at the output on the terminal....

  ---

  ---

• Undefining a macro
  • Undefine a macro:

    #undef macro-name

    Example:

    #undef PI #undef MAX #undef square

  ---

  ---

  ---

  ---

  ---

  ---

• Including files
  • The #include directive:

    #include <filename> - include file "filename" from the C's standard include directory (which is: /usr/include) #include "filename" - include file "filename" from a user specified diretory

    The default user specified include directory is:

    The current directory

    ---

  • Specifying user specified include directories:

    gcc -Idir1 -Idir2 .... C-program

    The C compiler will look for include files included with #include "..." in directories dir1, dir2, etc.

    ---

  • Common practice:

    Included file in C programs usually ends with the .h extention .h = header file extension. The include files are called header files because the #include command almost always is located at the top (head) of a C program file !!!

    ---

  • Example:

    file1.h	include1.c
    #define square(x) (x*x)	#include "file1.h" int main( int argc, char* argv[] ) { double a, b; b = square(a); }

    Output of gcc -E include1.c:

    int main( int argc, char* argv[] ) { double a, b; b = (a*a); }

    ---

  • Notes:

    The #include command is often at the start (head) of a C program Hence, the included files are called header files in C After reading in the included ("header") file, the C preprocessor will process the included file The #include command can be nested: An included file can itself contain an #include command.