Slide Set 5. for ENCM 339 Fall Steve Norman, PhD, PEng. Electrical & Computer Engineering Schulich School of Engineering University of Calgary

Transcription

1 Slide Set 5 for ENCM 339 Fall 2016 Steve Norman, PhD, PEng Electrical & Computer Engineering Schulich School of Engineering University of Calgary October 2016

2 ENCM 339 Fall 2016 Slide Set 5 slide 2/32 Contents Character code functions and <ctype.h> The Toolchain The C preprocessor Macros with parameters File inclusion with #include Conditional compilation

3 ENCM 339 Fall 2016 Slide Set 5 slide 3/32 Outline of Slide Set 5 Character code functions and <ctype.h> The Toolchain The C preprocessor Macros with parameters File inclusion with #include Conditional compilation

4 ENCM 339 Fall 2016 Slide Set 5 slide 4/32 Character code functions and <ctype.h> Use of #include <ctype.h> makes available a number of functions related to classifying character codes and converting character codes. An example is the isdigit function, described on Slide 29 of Slide Set 2. Another example is the toupper function, used in an example on the next slide. Let s write down a specification for the toupper function.

5 ENCM 339 Fall 2016 Slide Set 5 slide 5/32 What will be the output of this program? #include <stdio.h> #include <ctype.h> int main(void) { char *p = "Hello, ENCM 339 students!\n"; while (*p!= \0 ) { printf("%c", toupper(*p)); p++; } return 0; }

6 ENCM 339 Fall 2016 Slide Set 5 slide 6/32 Outline of Slide Set 5 Character code functions and <ctype.h> The Toolchain The C preprocessor Macros with parameters File inclusion with #include Conditional compilation

7 ENCM 339 Fall 2016 Slide Set 5 slide 7/32 The Toolchain Informally, the word compiler is often used to refer to a system that makes executable files from source code files. So, based on your experience doing Labs 1 3, you might read the command gcc foo.c as run the compiler to try to make executable file a.out from the source file foo.c. Using that informal meaning for compiler, describe what this command does: gcc bar.c -o bar

8 ENCM 339 Fall 2016 Slide Set 5 slide 8/32 Really, though, the command gcc runs several different programs these programs are called tools, and together the tools form a system called a toolchain. For development using the C programming language there are four essential tools. This a rough and incomplete summary: preprocessor (we ll cover this very soon); compiler translate C code into another language called assembly language; assembler translate assembly language into a format called machine code; linker combine pieces of machine code and pieces of other information together to make an executable file.

9 ENCM 339 Fall 2016 Slide Set 5 slide 9/32 So, what is a more precise way to describe this command from slide 7...? gcc foo.c Concepts such as assembly language, the assembler, machine code, and the linker are not ENCM 339 topics we ll look at them in detail in ENCM 369 (Computer Organization). The preprocessor, though, is an ENCM 339 topic it s what we re going to study next.

10 ENCM 339 Fall 2016 Slide Set 5 slide 10/32 Outline of Slide Set 5 Character code functions and <ctype.h> The Toolchain The C preprocessor Macros with parameters File inclusion with #include Conditional compilation

11 ENCM 339 Fall 2016 Slide Set 5 slide 11/32 The C preprocessor As the pre- part of its name suggests, the preprocessor processes C code in advance of giving C code to the compiler. C code goes in to the preprocessor, and modified C code comes out. In ENCM 339, we ll look at three main kinds of preprocessing: handling macros set up with the #define directive; file inclusion, using the #include directive; conditional compilation, using directives such as #if, #ifdef, #ifndef, #endif, and a few others. There are a few other kinds of preprocessing that we won t cover see Chapter 15 of C in a Nutshell (2nd edition) for details.

12 ENCM 339 Fall 2016 Slide Set 5 slide 12/32 Macros and the #define directive In discussion of computer programming, the word macro means, roughly, a rule for substituting a small piece of source code with another small piece of source code. The C preprocessor offers two main kinds of macros: #define macros without parameters, which are relatively simple; #define macros with parameters, which are more complicated. Probably the most common use of macros without parameters is setting up named constants, as shown on the next slide.

13 ENCM 339 Fall 2016 Slide Set 5 slide 13/32 Normally a #define directive for a macro without parameters is placed on a single line by itself, with this syntax: #define macro name replacement text Here is an example of a macro that is set up incorrectly: #define SECONDS_PER_DAY = double days2sec(double days) { return SECONDS_PER_DAY * days; } What went wrong here? How should it be fixed?

14 ENCM 339 Fall 2016 Slide Set 5 slide 14/32 Names for macros The rules are the same as the rules for names of things like variables, functions, function arguments, and so on... Start with a letter, and follow that with letters, digits, and/or underscores. By convention, most C programmers use ALL CAPS for names of macros, so that they stand out from other names, but the preprocessor will accept macro names with lowercase letters. (Warning: Do not create a name that starts with an underscore this kind of name is said to be reserved for the implementation. Roughly speaking, if you create such a name you risk getting the preprocessor or compiler very confused.)

15 ENCM 339 Fall 2016 Slide Set 5 slide 15/32 Named constants in C and C++ Where a C programmer would write something like this... #define RAD_PER_DEG ( / 180.0)... a C++ programmer would probably write... const double RAD_PER_DEG = / 180.0; What explanations are there for the difference in styles of setting up named constants? Also, why type in so many digits of π?

16 ENCM 339 Fall 2016 Slide Set 5 slide 16/32 Outline of Slide Set 5 Character code functions and <ctype.h> The Toolchain The C preprocessor Macros with parameters File inclusion with #include Conditional compilation

17 ENCM 339 Fall 2016 Slide Set 5 slide 17/32 Macros with parameters These are most easily explained by example. In the code below, x and y are macro parameters. (The example macros have one parameter each, but you re also allowed to #define a macro with two or more parameters.) #define BAD_SQUARE(x) x * x #define GOOD_SQUARE(y) ((y) * (y)) int main(void) { int a = 3, b = 4, c, d; c = BAD_SQUARE(a + b); d = GOOD_SQUARE(a + b); return 0; } What values will the variables c and d get, and why?

18 ENCM 339 Fall 2016 Slide Set 5 slide 18/32 Repeated macro expansion #define SQUARE(a) #define RECIP_SQR(b) int main(void) { double x = 2.0, y; y = RECIP_SQR(x); return 0; } ((a) * (a)) (1.0 / SQUARE(b)) What will the preprocessor do with the assignment statement? What are the general rules for cases like this?

19 ENCM 339 Fall 2016 Slide Set 5 slide 19/32 About writing macros with parameters Avoid doing it! Macros with parameters are notorious causes of hard-to-diagnose syntax errors and other mysterious program defects. Decades ago, it often made sense to write a macro that could be used like a function, but would be more efficient than a function. C compilers are much better these days, and can optimize a call to a simple function so that the function is just as efficient as a macro. There are some valid but highly specialized reasons for writing macros with parameters. Leave that work to experts (or become an expert yourself)!

20 ENCM 339 Fall 2016 Slide Set 5 slide 20/32 Macro names used in string constants #include <stdio.h> // In case we want to rename our application... #define PROGNAME "FooSonic" int main(void) { printf("welcome to the PROGNAME program!\n"); //... more code goes here... return 0; } What output will be produced by the call to printf? What are two different ways to solve the problem?

21 ENCM 339 Fall 2016 Slide Set 5 slide 21/32 Outline of Slide Set 5 Character code functions and <ctype.h> The Toolchain The C preprocessor Macros with parameters File inclusion with #include Conditional compilation

22 ENCM 339 Fall 2016 Slide Set 5 slide 22/32 File inclusion with #include A #include directive calls for inclusion of C code from another source file. There are two main forms: one uses angle brackets, and the other uses double quotes. Here is a familiar example of #include with angle brackets: #include <stdio.h> And here is an example with double quotes: #include "quux.h"

23 ENCM 339 Fall 2016 Slide Set 5 slide 23/32 #include with angle brackets This tells the preprocessor to include a library header file a file full of function prototypes, type declarations, macro definitions, and other things, all related to some portion of the library that is available to all C programs on a given platform. There is an example program on the next slide. The program shows a couple of uses of #include with angle brackets, and also demonstrates the strcat function. What is the effect of #include <stdio.h>? What is the effect of #include <string.h>? What is the program output? The array s is larger than it needs to be. What is the minimum size of the array needed for safe operation of the program?

24 ENCM 339 Fall 2016 Slide Set 5 slide 24/32 #include <stdio.h> #include <string.h> int main(void) { char s[20]; strcpy(s, "Foo"); strcat(s, "tball"); printf("%s!\n", s); return 0; }

25 ENCM 339 Fall 2016 Slide Set 5 slide 25/32 #include with double quotes Every program in Labs 1 to 3 of ENCM 339 in Fall 2016 has had a single.c file for its source code. But typical C projects involve multiple.c files and.h files, all sitting in a single directory in a file system. (Directory is another word for folder.) (Really big C projects have multiple.c files and.h files in multiple directories, but we won t look at that in ENCM 339.) #include with double quotes is used to include a file that is part of a specific project, not part of the C library. The next slide shows an example of a very tiny multi-file C project.

26 ENCM 339 Fall 2016 Slide Set 5 slide 26/32 file main.c #include "quux.h" int main(void) { quux(42); return 0; } file quux.h void quux(double x); file quux.c #include <stdio.h> #include "quux.h" void quux(double x) { printf("%f\n", x); } There are a bunch of questions about this project on the next slide...

27 ENCM 339 Fall 2016 Slide Set 5 slide 27/32 What is an easy way to use the gcc command to build an executable file called foo from the given source files? Why does main.c include quux.h? Why does quux.c include quux.h? What does the term translation unit mean, and what are the translation units produced from main.c and quux.c? What is the program output?

28 ENCM 339 Fall 2016 Slide Set 5 slide 28/32 Outline of Slide Set 5 Character code functions and <ctype.h> The Toolchain The C preprocessor Macros with parameters File inclusion with #include Conditional compilation

29 ENCM 339 Fall 2016 Slide Set 5 slide 29/32 Conditional compilation This refers to the idea that some lines of C code will make it through the preprocessor to the compiler, and other lines will not, depending on certain preprocessor directives. As a term, conditional compilation is somewhat of a misnomer, because it is really something that happens in the preprocessor, not in the compiler. (Misnomer: A word or term that suggests a meaning that is known to be wrong. [... ] A misnomer may also be simply a word that is used incorrectly or misleadingly. Source: Wikipedia.) In the next few slides, we ll look at some examples of conditional compilation, but we won t try to be comprehensive about all the different kinds of conditional compilation made available by the C preprocessor.

30 ENCM 339 Fall 2016 Slide Set 5 slide 30/32 Use of #if to comment out code void foo(int i, const char *s) { #if 1 // printf calls here to help find bugs... printf("args received by foo are...\n"); printf(" i = %d, s points to \"%s\"\n", i, s); #endif } //... foo does actual work here... By changing a single character in the above code, how could we avoid having foo print debugging information about its arguments?

31 ENCM 339 Fall 2016 Slide Set 5 slide 31/32 #ifndef: if not defined... The C standard does not specify that M_PI must be a named constant set up with #define in <math.h>, but in many C libraries, such a #define is present in <math.h>. It s an error to try to redefine a macro in a translation unit. Why exactly does the code below solve a problem? #include <stdio.h> #include <math.h> #ifndef M_PI #define M_PI #endif //... C function definitions here use M_PI...

32 ENCM 339 Fall 2016 Slide Set 5 slide 32/32 More conditional compilation Sometimes conditional compilation is used so that different pieces of C code get compiled depending on what platform the code is being compiled for. For example, one chunk of code might be right for 64-bit Linux, another chunk might be right for 32-bit Windows 7, another for 64-bit Windows 7 or 8, and so on... Yet another practical use for conditional compilation is creation of things called include guards we ll come back to that after we look at C struct types.