Software 1 - Preprocessor & misc. (11)

administrivia

Web Page - http://www.cs.tau.ac.il/~efif/courses/Software1_Spring_04

The C Preprocessor

• A translation applied before the compiler
  • Preprocessor, compiler, linker
• Textual substitution
  • File inclusion - inserting the contents of another file into your source file, as if you had typed it all in there
  • Macro substitution - replacing instances of one piece of text with another.
  • Conditional compilation - depending on various circumstances, certain parts of your source code are seen or not seen by the compiler

The C Preprocessor syntax

• Line based - must begin at the beginning of a line, and each ends at the end of the line
  • You can break long lines with the '\' character at the end of the line
    • Useful especially for text substitution directives
• Begin with the # character
• Knows nothing about C statements or expressions
  • Playing tricky and outrageous games with the preprocessor is considered sporting in some circles

File inclusion

• A line of the form

  #include <filename.h>

  or

  #include "filename.h"

• The contents of the file filename.h is read, parsed, and compiled at that point.
• After filename.h is processed, compilation continues on the line following the #include line
• example
  Place the prototypes of several related function in a header file myio.h

  extern int getline(char [], int);

  
  at the top of each source file add the line

  #include "myio.h"

• stdio.h - a collection of declarations (including external function prototype declarations)

The difference between the <> and ""

• Where the preprocessor searches for filename.h?
  • Files enclosed in <> - in central, standard directories
  • Files enclosed in "" - in the current directory or the directory containing the including source file
• What do they contain?
  • "" - usually used for header files you've written,
  • <> - usually used for headers which are provided for you

What should you put in header files?

• External declarations of global variables and functions commonly used
• A global variable
  • Must have exactly one defining instance,
  • Can have external declarations in many places
• Common declarations and definitions
  • If they ever change, they only have to be changed in one place
  • It is an error to declare a variable of one type externaly in one place and define its instance with another type
    • If the two places are two source files, separately compiled, only the linker will catch the discrepancy
  • Ensures consistent declarations.
    • Include the header in the source file where the defining instance appears, too
      • The compiler can check that the declaration and definition match

What should you put in header files?

• Common declarations and definitions
  • Preprocessor macro definitions
  • Structure definitions (which we haven't seen yet)
  • typedef declarations (which we have hardly seen).
• However, there are a few things not to put in header files:
  • Defining instances of global variables.
  • Function bodies (which are also defining instances)
    • it'S much better to learn how to use your compiler or linker to combine together separately-compiled object files

Using a third-party library

• Two-step process
  • You must #include the header in the files where you call the library functions,
  • You must tell the linker to read in the functions from the library itself

Macro definition and substitution

• K&R Sec. 4.11.2
• A preprocessor line of the form

  #define name text

  • name - the given macro name
  • text - the given replacement text.
• name is replaced with text
  • After that for the rest of the current source file, or
  • Until name is undefined

    #undef name

Macro name and replacement text

• Follows the same rules as ordinary identifiers
  • Can contain only letters, digits, and underscores
  • May not begin with a digit
• Since macros behave quite differently from normal variables (or functions), it is customary to give them names which are all capital letters
• the replacement text can be absolutely anything

Macro use

• Propagate constants around
• Make them more self-documenting.
• Example

  char line[100]; ... getline(line, 100);

  If we ever decide that 100 is too smal, we'll have to remember to change the number in two (or more) places.

  #define MAXLINE 100 char line[MAXLINE]; ... getline(line, MAXLINE);

Macro definition and substitution syntax

• There does not have to be (and in fact there usually is not) a semicolon at the end of a #define line
• If you accidentally type

  #define MAXLINE 100; /* WRONG */

  then when you later declare

  char line[MAXLINE];

  the preprocessor will expand it to

  char line[100;]; /* WRONG */

Macro evaluation

• Evaluation not performed when the macro is defined
• Suppose that you write something meaningless like

  #define A 2 #define B 3 #define C A + B int x = C * 2;

  You'd expect x to end up with the value 10, but
  • The preprocessor substitutes text for macros exactly as you have written it,
  • First, C is substituted

    int x = A + B * 2;

  • Then, the macros A and B are substituted

    int x = 2 + 3 * 2;

  • using the normal precedence of multiplication over addition x is intialized with the value 8
• It is always a good idea to include explicit parentheses

  #define C (A + B)

Macros which look like little functions

• Macros like MAXLINE act like constant expressions
• Macros can look like little functions
  • They expand to replacement text which is a function of the actual arguments they are invoked with
  • This is as far as we go here

Conditional compilation

• K&R Sec. 4.11.3
• controls which parts of your program get compiled

  #ifdef name program text #else more program text #endif

• If name is defined, "program text" is compiled and "more program text" is ignored. Otherwise, the opposite
• Different then if statement
  • Controls which statements are executed at run time
• The #else is optional

Other directives

• #ifndef name - compiles code if the macro is not defined
• #if expresion - compiles code if expression is true

  #if 0 program text #endif

• #if defined(name) - like #ifdef name, but can be augmented
  • #if defined(name1) && defined(name2)

Conditional compilation is useful

• You are writing a portable program that depends on
  • Compiler
  • Operating system
  • computer
• Different versions of code, one for each situation, between suitable #ifdef directives
• Compilers have ways of letting you define macros from
  • The invocation command line

    cl.exe -Dname

  • In a configuration file
  • Many predefine certain macro names related to the operating system, processor, or compiler in use.

Example

• In ANSI C, the function to delete a file is remove
• On older Unix systems, the function was called unlink

  #ifdef unix unlink(filename); #else remove(filename); #endif

• You could place the line

  #define unix

  at the top of the file when compiling under an old Unix system
  • No need to give it any replacement text
  • Any definition for a macro, even if the replacement text is empty, causes an #ifdef to succeed
• C compilers on old Unix systems tend to predefine it for you
  • No need to define the macro unix at all

Conditional compilation is useful

• Building different versions from the same source code
• Compiling different versions with different features present in the different versions
• Turn debugging statements on or off

  #ifdef DEBUG printf("x is %d\n", x); #endif

• Define the macro DEBUG from the compiler invocatin line
  • Use a compiler flag such as -DDEBUG

A program that prints out it's own code?

• wio2.c

  char s[] = {0x23, 0x69, 0x6e, 0x63, 0x6c, 0x75, 0x64, 0x65, 0x20, 0x3c, 0x73, 0x74, 0x64, 0x69, 0x6f, 0x2e, 0x68, 0x3e, 0xa, 0x69, 0x6e, 0x74, 0x20, 0x6d, 0x61, 0x69, 0x6e, 0x28, 0x29, 0xa, 0x7b, 0xa, 0x20, 0x20, 0x69, 0x6e, 0x74, 0x20, 0x69, 0x3b, 0xa, 0xa, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x66, 0x28, 0x22, 0x63, 0x68, 0x61, 0x72, 0x20, 0x73, 0x5b, 0x5d, 0x20, 0x3d, 0x20, 0x7b, 0x22, 0x29, 0x3b, 0xa, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x28, 0x69, 0x3d, 0x30, 0x3b, 0x69, 0x3c, 0x31, 0x36, 0x37, 0x3b, 0x69, 0x2b, 0x2b, 0x29, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x66, 0x28, 0x22, 0x30, 0x78, 0x25, 0x78, 0x2c, 0x20, 0x22, 0x2c, 0x20, 0x73, 0x5b, 0x69, 0x5d, 0x29, 0x3b, 0xa, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x66, 0x28, 0x22, 0x30, 0x78, 0x30, 0x7d, 0x3b, 0x5c, 0x6e, 0x22, 0x29, 0x3b, 0xa, 0x20, 0x20, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x66, 0x28, 0x22, 0x25, 0x73, 0x22, 0x2c, 0x20, 0x73, 0x29, 0x3b, 0xa, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x30, 0x3b, 0xa, 0x7d, 0xa, 0x0}; #include <stdio.h> int main() { int i; printf("char s[] = {"); for(i=0;i<167;i++) printf("0x%x, ", s[i]); printf("0x0};\n"); printf("%s", s); return 0; }

• wio1.c

  int printf(const char *, ...);char p[]="int printf(const char *, ...);char p[]=%c%s%c;int main(){printf(p,34,p,34,10);return 0;}%c";int main(){printf(p,34,p,34,10);return 0;}

• ASCII - American Standard Code for Information Interchange