Week 01 (Wednesday)

C Program Structure 1/18

Each C program consists of

a collection of modules (separate .c files)
which are combined to form an executable (a.out)

Makefiles 2/18

A Makefile helps to organise the compilation of modules of a C program

Example:

seqq: seqq.c
	gcc -Wall -Werror -o seqq seqq.c

The UNIX command make

looks for a file named Makefile in the current directory

and executes the gcc command

prompt$ make
gcc -Wall -Werror -o seqq seqq.c

or does nothing if the dependencies haven't changed since the last make
```
prompt$ make
make: `seqq' is up to date.
```

... Makefiles 3/18

Can have multiple targets:

example: a.o b.o c.o
	gcc -o a.out a.o b.o c.o

a.o: a.c
	gcc -Wall -c a.c

b.o: c.c
	gcc -Wall -c b.c

c.o: c.c
	gcc -Wall -c c.c

you can then run make example or make a.o or make b.o or make c.o
- this will make the named target and all the targets it depends on
simply typing make will do the first target (this is the default)

Module Interfaces 4/18

Names are shared via module interfaces

defined in .h files (e.g. a.c has interface in a.h)
containing a set of function definitions for external use
possibly with a set of typedefs (type definitions, see later)
rarely by making module global variables available

... Module Interfaces 5/18

Example module interface stdio.h

typedef FILE ...;

FILE *stdin, *stdout, *stderr;

FILE *fopen(char *fileName, char *mode);
int  fgetc(FILE *inf);
int  fputc(int ch, FILE *outf);
char *fgets(char *strbuf, int max, FILE *inf);
int  fputs(char *str, FILE *outf);
...

Many more examples available in .h files under /usr/include

Exercise: MyInt module 6/18

Design an interface to a module that provides:

a function to test if a number is even
e.g. int x; ... if (isEven(x)) { ...
a function to test if a number is odd
e.g. int x; ... while (isOdd(x)) { ...

Provide an implementation, testdriver and Makefile for the module.

... Exercise: MyInt module 7/18

Can generalise the Makefile by defining and using variables

Can also add a target to clean up directory

Example:


CC=gcc
CFLAGS=-Wall -Werror

tester: tester.o MyInt.o
	$(CC) $(CFLAGS) -o tester tester.o MyInt.o

tester.o: tester.c MyInt.h
	$(CC) $(CFLAGS) -c tester.c

MyInt.o: MyInt.c MyInt.h
	$(CC) $(CFLAGS) MyInt.c

clean:
	rm -f tester tester.o MyInt.o core

... Exercise: MyInt module 8/18

# General structure of a Makefile
definitions

target: dependencies
	commands

definitions define variables (optional)
target is the name of the object (usually an executable or .o file) you wish to make
- can have multiple targets
dependencies are the files that the object depends on
- usually a list of .c, .h, .o files
commands is a list of instructions that will make the target
- usually a compilation
- each command should be preceded by a tab

C Execution: External View 9/18

... C Execution: External View 10/18

Command-line arguments:

argc ... count of arguments, including command name
argv ... array of arguments, as text strings

File streams:

stdin ... standard input, by default: keyboard
stdout ... standard output, by default: screen
stderr ... standard error, by default: screen

Environment variables:

char *environ[] contains the env vars
the last element in environ[] contains NULL

... C Execution: External View 11/18

Example argc and argv:

C execution: Startup 12/18

All C programs must have a main() function.

Executing a C program causes main() to be invoked

with command-line arguments (via argc, argv)
with stdin, stdout, stderr already open for use

Program execution stops when the main() function returns.

return value 0 (EXIT_SUCCESS) indicates "successful completion"
return value 1 (EXIT_FAILURE) indicates "problems in execution"

(In fact, any non-zero value indicates execution errors; can use different values for different errors; check return status via $? in Unix shell)

C execution: Redirect 13/18

The streams stdin, stdout, stderr can be redirected

redirecting stdin
```
prompt$ myprog < input.data
```
redirecting stdout
```
prompt$ myprog > output.data
```
redirecting stderr
```
prompt$ myprog 2> error.data
```

C execution: Memory 14/18

An executing C program partitions memory into:

code ... fixed-size, read-only region
- contains the machine code instructions for the program
global data .. fixed-size, read-write region
- contain global variables and constant strings
heap ... very large, read-write region
- contains dynamic data structures created by malloc() (see later)
stack ... dynamically-allocated data (function local vars)
- consists of frames, one for each currently active function
- each frame contains local variables and house-keeping info

... C execution: Memory 15/18

Lifetime 16/18

Lifetime: duration that a variable is available in memory.

Variables in the global data ...

exist for the entire duration of program execution

Objects in the heap ...

are explicitly created via malloc(), removed by free() (see later)

Objects in the stack ...

are created automatically when the function is invoked
are removed automatically when the function returns

Exercise: Buggy Function 17/18

Explain what is wrong with this function:

// returns a string of 'x' characters
// e.g. xs(5) -> "xxxxx", xs(0) = ""
char *xs(int n) {
	int i;
	char buffer[100];
	// truncate if try to add too many 'x's
	if (n > 100) {
		n = 100;
	} else if (n < 0) {
		n = 0;
	}
	for (i = 0; i < n; i++) {
		buffer[i] = 'x';
	}
	buffer[i] = '\0';   // terminate string
	return buffer;
}

How could we fix the problem?

Tips for Next Week's Lab 18/18

Command line arguments; Makefiles

Meaning and use of argc and argv[0], argv[1], ...
Read command line argument(s) and convert to integer/floating point number
Test if conversion was successful and produce error message in case of wrong user input
```
prompt$ ./add3 1 2 a
./add3: found non-numerical argument
```
Write a Makefile to build executables for two of the programs

Produced: 11 Aug 2016