CSc 352 An Introduction to the C Preprocessor Saumya Debray Dept. of Computer Science The University of Arizona, Tucson debray@cs.arizona.edu

The C preprocessor and its role text: Ch. 14 C compiler (e.g., gcc) cpp (C preprocessor) cc1 (C compiler) compiled code source program expand some kinds of characters discard whitespace and comments each comment is replaced with a single space process directives: file inclusion (#include) macro expansion (#define) conditional compilation (#if, #ifdef, …) expanded code

#include Specifies that the preprocessor should read in the contents of the specified file usually used to read in type definitions, prototypes, etc. proceeds recursively #includes in the included file are read in as well Two forms: #include <filename> searches for filename from a predefined list of directories the list can be extended via “gcc –I dir” #include “filename” looks for filename specified as a relative or absolute path

#include : Example where does it come from? man 3 printf : a predefined include file that: comes with the system gives type declarations, prototypes for library routines (printf)

#include: cont’d We can also define our own header files: a header file has file-extension ‘.h’ these header files typically contain “public” information type declarations macros and other definitions function prototypes often, the public information associated with a code file foo.c will be placed in a header file foo.h these header files are included by files that need that public information #include “myheaderfile.h”

Macros A macro is a symbol that is recognized by the preprocessor and replaced by the macro body Structure of simple macros: #define identifier replacement_list Examples: #define BUFFERSZ 1024 #define WORDLEN 64

Using simple macros We just use the macro name in place of the value, e.g.: #define BUFLEN 1024 #define Pi 3.1416 … char buffer[BUFLEN]; area = Pi * r * r; NOT: #define BUFLEN = 1024 #define Pi 3.1416; 

Example 1

we can “macroize” symbols selectively Example 2 we can “macroize” symbols selectively

(else preprocessor will assume we’re defining a simple macro Parameterized macros Macros can have parameters these resemble functions in some ways: macro definition ~ formal parameters macro use ~ actual arguments Form: #define macroName(arg1, …, argn) replacement_list Example: #define deref(ptr) *ptr #define MAX(x,y) x > y ? x : y no space here! (else preprocessor will assume we’re defining a simple macro

Example

Macros vs. functions Macros may be (slightly) faster don’t incur the overhead of function call/return however, the resulting code size is usually larger this can lead to loss of speed Macros are “generic” parameters don’t have any associated type arguments are not type-checked Macros may evaluate their arguments more than once a function argument is only evaluated once per call

Macros vs. Functions: Argument Evaluation Macros and functions may behave differently if an argument is referenced multiple times: a function argument is evaluated once, before the call a macro argument is evaluated each time it is encountered in the macro body. Example: Dbl(u++) expands to: u++ + u++ int dbl(x) { return x + x;} … u = 10; v = dbl(u++); printf(“u = %d, v = %d”, u, v); prints: u = 11, v = 20 #define Dbl(x) x + x u = 10; v = Dbl(u++); prints: u = 12, v = 21

Properties of macros Macros may be nested in definitions, e.g.: #define Pi 3.1416 #define Twice_Pi 2*Pi in uses, e.g.: #define double(x) x+x #define Pi 3.1416 … if ( x > double(Pi) ) … Nested macros are expanded recursively

Pitfalls of nested macros Oops!

What happened? textual replacement!

Avoiding the problem

What happened

Header Files Have a file extension “.h” Contain shared definitions typedefs macros function prototypes referenced via “#include” directives

Header files: example

typedefs Allow us to define aliases for types Syntax: Example: typedef old_type_name new_type_name; new_type_name becomes an alias for old_type_name Example: typedef int BasePay; typedef struct node { int value; struct node *next; } node;

Example defines “wcnode” as an alias for “struct wc” we can use “wcnode” in place of“struct wc” but not here, since “wcnode” has not yet been defined

What if a file is #included multiple times? foo.h bar1.h bar2.h bar.c

Example of multiple inclusions

Problems with multiple inclusions

Solution to multiple inclusion problem Use conditional compilation to ensure that a header file is “really included” at most once header file’s responsibility to protect itself from multiple-inclusion problems uses a conditional-compilation directive #ifndef in effect sets a flag when a file is included so we don’t include it again relies on convention we need to understand it so we don’t break it

Conditional Compilation: #ifdef #ifdef identifier line1 … linen #endif macros can be defined by the compiler: gcc –D macroName gcc –D macroName=definition macros can be defined without giving them a specific value, e.g.: #define macroName line1 … linen will be included if identifier has been defined as a macro; otherwise nothing will happen.

Conditional Compilation: #ifndef #ifndef identifier line1 … linen #endif line1 … linen will be included if identifier is NOT defined as a macro; otherwise nothing will happen.

Solution to multiple inclusion problem The header file is written as follows: #ifndef file_specific_flag #define file_specific_flag …contents of file… #endif file_specific_flag usually constructed from the name of the header file: E.g.: file = foo.h  flag = _FOO_H_ try to avoid macro names starting with ‘_’ indicates whether or not this file has been included already

straightforward, but needs discipline to use consistently Another use of #ifdefs They can be useful for controlling debugging output Example 1: guard debugging code with #ifdefs: #ifdef DEBUG …debug message… #endif Example 2: use the debug macro to control what debugging code appears in the program: #define DMSG(msg) printf(msg) // debugging output #else #define DMSG(msg) {} // empty statement straightforward, but needs discipline to use consistently

Example 1(a)

to address the “too many arguments to macro” problem Example 1(b) to address the “too many arguments to macro” problem “too many arguments” issue resolved, but the macro expansion isn’t working quite the way we want

Example 1(c)

Generalizing #ifdef #if constant-expression line1 … linen #endif  line1 … linen included if constant-expression evaluates to a non-zero value Common uses: #if 1 or #if 0