Preprocessor

#include

• #include "filename" searches current directory and system-dependent directories (on Unix, the system-dependent directory is /usr/include)
• #include <filename> searches only system-dependent directories (not the current directory)
• filename can be a relative path (like #include <subdir/file.h>)
• filename can also be an absolute path (like #include </home/chicken/egg.h>, but this is non-portable and therefore not recommended
  • the same result can be achieved using the -Idirectory argument to cc
• search order for directories is:
  1. current directory (if using #include "filename" form)
  2. any directories specified using the -Idirectory argument
  3. system-dependent directories (i.e /usr/include)
• #included files can include other files (which can include other files...)
  • without taking special precautions, can accidentally include a file in itself, causing an infinite loop...

#define

• #define name defines an empty macro in the preprocessor
  • #define DEBUG
  • #define SILLY
• #define name token(s) defines a macro which, when used later in the code, is replaced the symbol(s) in the token list
  • after #define PI 3.141593, a statement like PI + PI would be replaced by the preprocessor with 3.141593 + 3.141593
  • only replaces exact matches, so something like PIE - PI would be replaced with PIE - 3.141593
• #define name(args) token(s)
  • #define SQUARE(x) ((x) * (x)) defines a macro which replaces SQUARE(value) with ((value) * (value))
    • note that the parentheses are necessary to prevent unintended expansion
    • if SQUARE was defined as #define SQUARE(x) x * x, something like 4 / SQUARE(2) would get expanded to 4 / 2 * 2 which would be evaluated from left to right as "4 / 2 * 2" -> "2 * 2" -> "4" instead of the intended "4 / (2 * 2)" -> "4 / 4" -> "1"
• previously defined macros can be included in later macros:

  	#define PI	3.141593
  	#define PI2	PI * 2
  	#define SQR(z)	((z) * (z))
  	#define PI2SQ	SQR(PI2)
  

• a statement like 12 * PI2SQ is expanded as follows:
  • the preprocessor sees the PI2SQ and expands the statement to 12 * SQR(PI2)
  • after it has processed the entire line, it starts again at the front and replace the SQR, leaving 12 * ((PI2) * (PI2))
  • it scans this new line and replaces the two references to PI2, leaving 12 * ((PI * 2) * (PI * 2))
  • the penultimate scan replaces the two PI references, leaving 12 * ((3.141593 * 2) * (3.141593 * 2))
  • one last scan is done and the preprocessor discovers there's nothing left to do so it moves onto the next line

\ (continuation character)

• expressions can span multiple lines using \ as the last character on a line

  	#define SPLIT_EXPR	((12.3456789 * 9.87654) + \
  				 (54321 - 12345))
  
  	#define NOT_LESS_THAN(a, b)	\
  					if ((a) > (b)) \
  						(a) = (b)
  

#undef name

• tells the preprocessor to forget about name
• useful for localizing macros

  	#define TEMPORARY(a, b)		(((a) * (b)) / 12345.678)
  	val = TEMPORARY(exp, sect);
  	#undef TEMPORARY
  

Predefined symbols

• In ANSI C, the preprocessor automatically predefines the following macros:
  • __DATE__ - string containing current date (like "Jan 1 2000")
  • __TIME__ - string containing current time (like "12:34:56)
  • __FILE__ - string containing source file name (like "file.c")
  • __LINE__ - current line number in source file, expressed as an integer (like 7)
  • __STDC__ - non-zero integer in an ANSI C preprocessor, implementation-defined elsewhere (could be set to 0, could be undefined)

Conditional directives

• #ifdef name - if name has been defined as a preprocessor macro, process the following code
• #ifndef name - if name has not been defined, process the following code
• #endif - turn off the previous conditional directive
• #else - reverse the meaning of the previous conditional directive
• For example, with:

  	#ifdef __STDC_
  	#define CC_TYPE		"standard C"
  	#else
  	#define CC_TYPE		"nonstandard C"
  	#endif
  

  • when built with an ANSI C compiler, will define the CC_TYPE macro as "standard C"
  • when built with an older compiler, will define the CC_TYPE macro as "nonstandard C"
• defined(name) - evaluates to 1 if name has been defined
• #if defined(DEBUG) is the same as #ifdef DEBUG
• #if expression - if expression evaluates to a non-zero value, process the following code
  • expression may be as simple as:

    	#if 0
    	code which should not be compiled
    	#endif
    

    or as complicated as:

    	#if defined(UNIX) || \
    		(defined(MYSYS) && \
    		 (defined(SYS_VERSION) && (
    		  (SYS_VERSION > 17.2)))
    	special code
    	#endif
    

• #elif expression - ANSI C addition which allows:

  	#ifdef expression-1
  	blah blah blah
  	#else
  	# if expression-2
  	blech blech blech
  	# endif
  	#endif
  

  to be written as:

  	#ifdef expression-1
  	blah blah blah
  	#elif expression-2
  	blech blech blech
  	#endif
  

##

#

#pragma

• non-portable implementation-defined directive
• created by ANSI C committee
• when #pragma was first proposed in ANSI, the GNU C compiler implementer (who didn't like #pragma took "implementation-defined" to heart. If a #pragma was encountered by GCC, the compiler would
  • attempt to run /usr/games/hack (a Unix game)
  • attempt to run /usr/games/rogue (another Unix game)
  • attempt to run a "Tower of Hanoi" program using Emacs
  • die with a message saying "You are in a maze of twisty compiler features, all different

#error string

#line