EPITA SPE C Workshop - D0

Transcription

1 EPITA SPE C Workshop - D0 marwan.burelle@lse.epita.fr

2 Overview 1 B, PDP And Unics From Bell s Lab To ISO normalization 2 Imperative And Structured Syntax 3 Compilers Using make Other 4 Simple Mathematical Functions Vectors 5

3 B, PDP And Unics From Bell s Lab To ISO normalization

4 Birth Of A Legend Back in the 1960 s: programming languages and operating systems was in an early state. One of the biggest project was Multics a join project between MIT, General Electric and Bell Labs. One major innovation of Multics was that is was almost completely written in an higher-level language (PL/I) Despite a lot of money and brains, Multics finally fails to meet its ambitious goals. Experience gathered when working on Multics leads Ken Thompson and Denis Ritchie from Bell s Lab to build a new operating system. You can have a first hand and detailed version of this story in [2]. B, PDP And Unics From Bell s Lab To ISO normalization

5 Overview B, PDP And Unics From Bell s Lab To ISO normalization 1 B, PDP And Unics From Bell s Lab To ISO normalization

6 From games to operating systems After implementing a game on a PDP-7, Ken Thompson realized that abstracting low-level operations in an operating system can greatly simplify applications development. Due to the lack of a proper environment on the PDP-7, the first kernel and almost all basic elements of the system was coded by Thompson using assembly. But he didn t want to be stuck with PDP assembly language. Unfortunately, most compilers was to big for the 8K bytes of memory in the PDP-7. B, PDP And Unics From Bell s Lab To ISO normalization

7 B and UNICS Thompson simplified BCPL (an imperative language from the MIT) and create a new language: B B was merely an evoluated assembly language with only one kind of values (machine words), functions and structured control flows. From 1969 to 1972, Thompson used B to implements UNICS. Evolution of the hardware and works from Denis Ritchie give birth to a new language: C. B, PDP And Unics From Bell s Lab To ISO normalization

8 After B... Denis Ritchie introduced several changes in the B programming language, among others the most important were: notion of types (char, int... ) structures (or records) a preprocessor The language evolved a lot during the 1970 s The success of Unix and related softwares (BSD distribution, Internet Protocol Stack... ) make the C programming language the most used and known programming language. Among other aspect, the choice to provide I/O operations and other interractions in external librairies rather than directly as language features were one of the reason of its popularity. B, PDP And Unics From Bell s Lab To ISO normalization

9 Overview B, PDP And Unics From Bell s Lab To ISO normalization 1 B, PDP And Unics From Bell s Lab To ISO normalization

10 Before ANSI As any research project, the first C evolved a lot, following necessity and adding features as needs arise. In 1978, Denis Ritchie and Brian Kernighan publish the first edition of the reference book [1] While this book tries to completely describe the language, several evolutions appear even before the publication of the book. Effort to make the language portable and to have a portable implementation (the pcc compiler widely used at that time) make the language evolved very fast. It seems that C needs to be unified and normalized at some points. B, PDP And Unics From Bell s Lab To ISO normalization

11 ANSI C By 1989 the ANSI published the first official C standard This stantard was accepted by ISO the following year under the reference ISO/IEC While trying to preserve compatibility with previous versions of C, it introduces a stronger notion of types (enforcing types parameters verification for external functions) and define a complete describtion of the C library. This version of C is probably the most widely used and syntactic changes introduced at that time are now considered as the standard syntax. This version is often called: ANSI C, C89 or C90 B, PDP And Unics From Bell s Lab To ISO normalization

12 Standard Library The standard defines a set of routines used for I/O, string manipulations or memory allocation. Standard Library defines (in the ANSI version) the following headers: Standard Library <assert.h> <ctype.h> <errno.h> <float.h> <iso646.h> <limits.h> <locale.h> <math.h> <setjmp.h> <signal.h> <stdarg.h> <stddef.h> <stdio.h> <stdlib.h> <string.h> <time.h> <wchar.h> <wctype.h> B, PDP And Unics From Bell s Lab To ISO normalization The standard library is also defined by POSIX, it is the same set of headers extended with Unix centric functions and system calls.

13 C99 and C11 In 1999, ISO published a newer version of the standard: C99 99 mainly extends the standard library but brought also minor language changes: Boolean type Original BCPL comments style: // The possibility to declare variables at any place in the code and not only at the begining of blocks. Variable declaration inside the for statements static inline functions Compound statement (block of statements used as expression) B, PDP And Unics From Bell s Lab To ISO normalization In 2011 a new version of the standard appears, C11, appart from various library evolution, the main and most important evolution is a new semantics adpated to parallel programming.

14 Other Extensions And Implementations The language and the standard library is extended by various organizations to fit specific needs. On Unix like systems, most people use POSIX and BSD extension to the standard library: system calls, threads management... Compiler also offers syntax extensions: attributes, intrinsic statements, inline assembly... Over the time popular extensions may be integrated in the ISO standard. Anyway, many obscure aspects of the standard are not supported by all compilers. In fact, C11 is too young to be available in actual compilers and even C99 isn t yet fully supported by any compiler (but actual support is probably largely sufficient.) B, PDP And Unics From Bell s Lab To ISO normalization

15 Imperative And Structured Syntax

16 A First Example First Example /* A simple example */ #include <stdio.h> /* Computing n! */ unsigned fact(unsigned n) { return n?n*fact(n-1):1; } Imperative And Structured Syntax int main() { printf("fact(5) = %d\n", fact(5)); return 0; }

17 Overview 2 Imperative And Structured Syntax Imperative And Structured Syntax

18 Global Overview C belongs to the family of imperative and structured languages. The outer structure of a program is a series of global variables and functions definitions (with a special function serving as entry point.) As other imperative languages expressions and statement are distinct elements. Since it s a structured language, the syntax provides various control flow operations (if, switch and various kind of loops.) The language provides also various kind of data: usual basic types (integers of different size and floating point numbers), records (called structures), union, enumeration type and a kind of array. Imperative And Structured Syntax

19 Memory Model, Pointers and Arrays (1) C has special memory model (inherited from BCPL and B) where the memory is seen as big array of bytes (in BCPL and B it was an array of machine words.) In this model an integer (unsigned) can be interpreted as an index in the memory array: it becomes a pointer. So one can access the pointed memory cell using the dereference operation. If p is a pointer, then *p returns the value in the corresponding memory cell. Since pointers are simply integer rather than abstraction over machine memory addresses (address mechanisms are sometimes a little bit more complex than just simple integer), arithmetic operations such as addition can be used over them. In this model, if p points to some memory cell, p+1 points to the next cell. Imperative And Structured Syntax

20 Memory Model, Pointers and Arrays (2) In B and BCPL, since the only type available was machine words, the pointers mechanism can serves as an array mechanism. To silently recover the B semantics, arithmetic over pointers has a type oriented semantics. In C, if p is pointer to some type t and value of this type need a storing size of size bytes, then the expression p+x (where x is any integer, signed or not) is interpreted as : p + size*x A simplified syntax for array accesses is provided, based on this semantics: p[i] is equivalent to *(p+i) Imperative And Structured Syntax

21 Separate Compilation C compilation schema allow for separate compilation units. To provide the finally binary, the linker assigns addresses to each symbol in different unit and then replaces symbol names with thoses addresses. The language itself doesn t provide any modules mechanism: as long as each used symbols is described somewhere in the source code, the first steps of compilation will work (it only requires to verify the existence of symbols, their sizes and eventually their structures.) This simple mechanism as some drawback, but offers a powerfull and yet simple way of dealing with separate unit. Imperative And Structured Syntax

22 Overview 2 Imperative And Structured Syntax Imperative And Structured Syntax

23 Global Code Structures All our code will be placed in functions. A functions body is a sequence of statements. There s no procedure, function return type can be void: the empty type. The return statement in function always escape the current context, even for void functions. The special function main is used as an entry point to the program. Functions can be recursive or mutuality recursive, the only constraint is that type of functions should be declared before their calls. Imperative And Structured Syntax

24 Expression Expression can be: A scalar value (integer, float... ): 42 Two expressions and a binary operator, or one expression with an unary operator: e1 + e2 or e++ A function call: f(e1,e2) A ternary operation: e1? e2 : e3 Field access: e.name or with pointer e->name An assignement (can be combine with an operation): x = e or x += e A type cast: (int)e A sequence of expressions: e1, e2 Every expression return a value even assignement and can have side-effect. Imperative And Structured Syntax

25 Statements Statements can be: An empty statement: ; An expression: e; A control flow structure: if/else, while, do/while or for loop A control flow special statement: return, break, continue and goto. A block (a sequence of statements) Variables declarations. While statements should not return any value in a pure imperative model, in C each statement leaves a value on the stack that sometimes can be used as return value. Imperative And Structured Syntax

26 Variables Declarations All variables declarations (global or local) follow the same structure. The syntax obey to the paradigm: declared as used. Some example: Declaring Variables // A simple int int x; // An array of 256 int int t[256]; // A pointer to char char *s; // A pointer to some struct struct my_struct *p; // A pointer to a function from int to float float(*fp)(int); Imperative And Structured Syntax

27 More Declarations More... // Several variables on the same line int x, y, z; // mixed with initialization int x, y = 0, z; //... pointers... int x, *y, z; Beware, for the last example, the star (*) is always attached to the variable, not the type, and thus, x is an integer, y a pointer to an integer and z an integer.... and even more... // string literal for init char *s = "a string literal"; Imperative And Structured Syntax

28 Assignements In C an assignement is an expression returning the assigned value. There s other possible assignements: operator-assignement (like +=) providing a short-hand for fetch and modify operations. The language also offers increment and decrement in two flavor: pre-increment: returns the value before the modification post-increment: returns the value after the modification As usual, all assignement operations can only be used on left-value operands (variables, array cells or dereferenced pointers... ) Imperative And Structured Syntax

29 Assignements Some Assignements int x, y, z; // Assign 42 to y, and then to x x = y = 42; // test an assigned value if ( (z = x+y) > 42 ) x = 41; // Now x==41, and we want to make it wright x += 1; // now x == 42! x -= 2; // and now 40 x /= 2, x *= 2; // more... y = ++x; // x = 41 and y = 41 z = x++; // x = 42 and z = 41 Imperative And Structured Syntax

30 Control Flow Structures: loops C provides two kind of loops: while and do/while loops. for loops are a variation of the while loop and not real bounded iterations loop (like in Pascal.) Syntax: while while ( cond ) statement Syntax: do/while do statement while ( cond ); Syntax: for for (expr; cond; expr) statement Imperative And Structured Syntax

31 Control Flow Structures: if C provides the usual if construction with optional else. The construction obey traditional rules. The so-called then statement and else statement are just statement (and then can be block) and one can use a terminating semi-colon unlike in Pascal. if ( cond ) statement Syntax: if Imperative And Structured Syntax if ( cond ) statement else statement Syntax: if-else

32 Control Flow Special return: the return statement exit the actual function and return the given value. break: exit the inner most loop (directly jump after the control flow statement.) continue: skip to the next loop iteration (directly jump at the begining of the control flow statement.) goto: jump to a specific label (a label is a marker you can simply add to any statement in the code.) Can traverse context, use with caution. Imperative And Structured Syntax

33 Compilers Using make Other

34 Overview 3 Compilers Using make Other Compilers Using make Other

35 Available Compilers There exists several compilers for various environment. The most known (and used) are: GNU Compiler Collection (gcc) Intel C Compiler clang (LLVM) BSD evolution of the original pcc SUN/Solaris C Compiler Microsoft C Compiler Borland/Inprise C Compiler Each compiler have various advantages and drawbacks. They also support more or less the standard (C89 for all of them, C99 at various state and C11 experimentaly.) Compilers Using make Other

36 Open Source Unix Compilers GNU Compiler Collection gcc: Probably the one that support the biggest number of architectures Originally based on pcc, it is now able to compile a wide variety of languages (C, C++, Java, Objective-C, Pascal, Fortran... ) A pretty good optimizing compiler. Error messages tend to be a little raw. Support C99, C++98 and a growing part of C++11 gcc is considered as one of the bloatest software. clang (LLVM): Have less (for now) architectures support. Better error messages Based on a generic back-end (LLVM) Better internal conception Support C99, C++98 and a growing part of C++11 Support also GNU-C extension (from gcc) Compilers Using make Other

37 Commercial Compilers Intel Compilers: Probably the best optimizing compiler for ia32, emt64 and ia64 Support for incomming standard is on the way. Implementation reference for all OpenMP (parallel extension to C) Microsoft Compilers: Compiler from the Visual Studio suite but also available as command line tools Have its own syntax extension Almost full support of C++11 for next release (expected) And for the other... Compilers Using make Other

38 Usage And Options We will focus on gcc and clang (preferred), they globally have the same option and syntax. Suppose you want to compile a single file program, the source code is in prg.c and we want to produce prg. Here are the the commands with the two compilers: > clang -o prg prg.c > gcc -o prg prg.c And now, the same with the usual options: > clang -Wall -Wextra -std=c99 -O2 -o prg prg.c > gcc -Wall -Wextra -std=c99 -O2 -o prg prg.c Compilers Using make Other

39 Usual Options -Wall: activate standard warnings -Wextra: add extra warnings -std=c99: use the ISO C99 standard, can be replaced with various variant like c89, gnu89 (c89 + GNU extensions), gnu99 (c99 + GNU extensions)... -O2: use optimization level 2 (triggers even more warnings.) Optimization levels range from -O0 (no optimization at all) to -O3 (a lot of optimizations are activated.) -g: produce information for the debugger (should not be used in conjunction with -ON with N>0) -o name: produce file name -c: do not link produced code, only output object file (file.o) Compilers Using make Other

40 Multiple Files Project When splitting your code in multiple files, you need some header files providing symbol signatures for other files. Suppose we have the following source code files: data.c, algo.c and main.c We should provide the following headers: data.h and algo.h. To compile the project we should first produce object files: data.o and algo.o We can then produce the executable (prg for example) by providing object files when compiling main.c. Compilers Using make Other clang -Wall -Wextra -std=c99 -O2 -c data.c clang -Wall -Wextra -std=c99 -O2 -c algo.c clang -Wall -Wextra -std=c99 -O2 -o prg data.o algo.o main.c

41 Overview 3 Compilers Using make Other Compilers Using make Other

42 Predefined Rules make already knows how to produce object files out of C files, it knows also how to produce an executable out of a single source files. Let us try! hello.c #include <stdio.h> int main() { printf("hello, World!\n"); return 0; } Compilers Using make Other > make hello cc hello.c -o hello > make hello.o cc -c -o hello.o hello.c

43 Controlling Predefined Rules make uses several environment variables to control which compiler to use and which options should it be given. > rm -f hello hello.o > setenv CC clang > setenv CFLAGS "-Wall -Wextra -std=c99 -O2" > make hello clang -Wall -Wextra -std=c99 -O2 hello.c -o hello > make hello.o clang -Wall -Wextra -std=c99 -O2 -c -o hello.o hello.c Compilers Using make Other

44 An Example Of A Makefile Makefile # A Simple Makefile Example CC=clang CFLAGS= -Wall -Wextra -std=c99 -O2 LDFLAGS= SRC= data.c algo.c OBJ= ${SRC:.c=.o} Compilers Using make Other main: ${OBJ} clean:: rm -f *~ *.o main # END

45 Overview 3 Compilers Using make Other Compilers Using make Other

46 More? Unix traditionally provides a lot of developers tools. You ll probably use the gdb debugger. You can reformat your code using indent. You can analyse it in order to find performance bottlenecks using gprof You can verify your memory usage with valgrind. Compilers Using make Other

47 Simple Mathematical Functions Vectors

48 Overview 4 Simple Mathematical Functions Vectors Simple Mathematical Functions Vectors

49 Factorial Recursive Factorial // size_t: unsigned integer word sized size_t fact(size_t n) { return n > 1? n * fact(n-1) : 1; } Iterative Factorial size_t fact_iter(size_t n) { size_t res=1; for (; n; --n) res *= n; return res; } Simple Mathematical Functions Vectors

50 Fibonacci Recursive Fibonacci size_t fibo(size_t n) { return n > 1? fibo(n-1) + fibo(n-2) : n; } Iterative Fibonacci size_t fibo_iter(size_t n) { size_t curr=1, prev=0, tmp; for (size_t i=1; i < n; ++i) { tmp = curr; curr += prev; prev = tmp; } return n > 1? curr : n; } Simple Mathematical Functions Vectors

51 Quick Power Recursive Quick Power size_t qpower(size_t a, size_t b) { if (!b ) return 1; return (b % 2? a : 1) * qpower(a*a, b >> 1); } Iterative Quick Power size_t qpower_iter(size_t a, size_t b) { if (!b ) return 1; size_t accu; for (accu = 1; b > 1; b >>= 1) { accu *= b % 2? a : 1; a *= a; } return accu * a; } Simple Mathematical Functions Vectors

52 Overview 4 Simple Mathematical Functions Vectors Simple Mathematical Functions Vectors

53 Vectors: Headers The following example is a toy example demonstrating the splitting of a program in several files. data.h /* A simple vector structure: header */ #ifndef EXAMPLE_DATA_H_ #define EXAMPLE_DATA_H_ typedef struct s_vect *vector; struct s_vect { size_t size; int tab[256]; }; void vector_init(vector v); void vector_add(vector v, int x); #endif Simple Mathematical Functions Vectors

54 Vectors: Basic Operations data.c /* A simple vector structure */ #include <stdlib.h> #include "data.h" void vector_init(vector v) { v->size = 0; } Simple Mathematical Functions Vectors void vector_add(vector v, int x) { if (v->size < 256) v->tab[v->size++] = x; }

55 Vectors: An Algo algo.h #ifndef EXAMPLE_ALGO_H_ #define EXAMPLE_ALGO_H_ int find(vector v, int x); #endif /* A simple algo */ #include <stdlib.h> #include "data.h" #include "algo.h" algo.c Simple Mathematical Functions Vectors int find(vector v, int x) { size_t i=0; for (; i < v->size && v->tab[i]!= x; ++i); return (i < v->size && v->tab[i] == x); }

56 And The Main Program main.c #define _XOPEN_SOURCE 500 #include <stdlib.h> #include <stdio.h> #include "data.h" #include "algo.h" int main(int argc, char *argv[]) { int seed=42, target; size_t size=64; struct s_vect inner_vect; vector v = &inner_vect; if (argc > 1) seed = atoi(argv[1]); if (argc > 2) size = atoi(argv[2]); srandom(seed); Simple Mathematical Functions Vectors

57 And The Main Program main.c if (argc > 3) target = atoi(argv[3]); else target = random() % size; vector_init(v); for (size_t i=0; i<size; ++i) vector_add(v, random() % size); printf("looking for %d in v: %s\n", target, find(v,target)?"yes":"no"); Simple Mathematical Functions Vectors return 0; }

58

59 Kernighan and Ritchie.. Prentice Hall, Englewood Cliffs, D. Ritchie. The development of the C language. In Second History of s Conference, April 1993.