CS222

1. Week 4 - Wednesday CS222

2. Last time • What did we talk about last time? • Control flow • Loops • Lab 3

3. Questions?

4. Project 2

5. Quotes Unix was not designed to stop its users from doing stupid things, as that would also stop them from doing clever things. Doug Gwyn

6. Bad Things

7. break • The break command is a necessary part of the functioning of a switch statement • But, it can also be used to jump out of a loop • Whenever possible (i.e. always), it should not be used to jump out of a loop • Everyone once in a while, it can make things a little clearer, but usually not • Loops should have one entry point and one exit for(value = 3; value < 1000; value += 2){ … if( !isPrime(value) ) break; } for(value = 3; value < 1000 && isPrime(value); value += 2) { … }

8. continue • The continue command is similar to the break command • It will cause execution to jump to the bottom of the loop • If it is a for loop, it will execute the increment • For all loops, it will return to the top if the condition is true • It makes things easier for the programmer up front, but the code becomes harder to follow • The effect can be simulated with careful use of if statements

9. goto(a four letter word) • A goto command jumps immediately to the named label • Unlike break and continue, it is not a legal command in Java • Except in cases of extreme (EXTREME) performance tuning, it should never be used • Spaghetti code results for(value = 3; value < 1000; value += 2){ if( !isPrime(value) ) goto stop; } printf("Loop exited normally.\n"); stop: printf("Program is done.\n");

10. Systems Programming

11. Kernel • When people say OS, they might mean: • The whole thing, including GUI managers, utilities, command line tools, editors and so on • Only the central software that manages and allocates resources like the CPU, RAM, and devices • For clarity, people use the term kernel for the second meaning • Modern CPUs often operate in kernel mode and user mode • Certain kinds of hardware access or other instructions can only be executed in kernel mode

12. What does the kernel do? • Manages processes • Creating • Killing • Scheduling • Manages memory • Usually including extensive virtual memory systems • File system activities (creation, deletion, reading, writing, etc.) • Access to hardware devices • Networking • Provides a set of system calls that allow processes to use these facilities

13. Shells • A shell is a program written to take commands and execute them • Sometimes called a command interpreter • This is the program that manages input and output redirection • By default, one of the shells is your login shell, the one that automatically pops up when you log in (or open a terminal) • It's a program like any other and people have written different ones with features they like: • sh The original Bourne shell • csh C shell • kshKorn shell • bash Bourne again shell, the standard shell on Linux

14. Users and groups • On Linux, every user has a unique login name (user name) and a corresponding numerical ID (UID) • A file (/etc/passwd) contains the following for all users: • Group ID: first group of which the user is a member • Home directory: starting directory when the user logs in • Login shell • Groups of users exist for administrative purposes and are defined in the /etc/group file

15. Superusers • The superuser account has complete control over everything • This account is allowed to do anything, access any file • On Unix systems, the superuser account is usually called root • If you are a system administrator, it is recommended that you do not stay logged in as root • If you ever get a virus, it can destroy everything • Instead, administrators should log in to a normal account and periodically issue commands with elevated permission (often by using sudo)

17. Single file system • In Windows, each drive has its own directory hierarchy • C: etc. • In Linux, the top of the file system is the root directory/ • Everything (including drives, usually mounted in /mnt) is under the top directory • /bin is for programs • /etc is for configuration • /usr is for user programs • /boot is for boot information • /dev is for devices • /home is for user home directories

18. Files • There are regular files in Linux which you can further break down into data files and executables (although Linux treats them the same) • A directory is a special kind of file that lists other files • Links in Linux are kind of like shortcuts in Windows • There are hard links and soft links (or symbolic links) • File names can be up to 255 characters long • Can contain any ASCII characters except / and the null character \0 • For readability and compatibility, they should only use letters, digits, the hyphen, underscore, and dot • Pathnames describe a location of a file • They can start with / making them absolute paths • Or they are relative paths with respect to the current working directory

19. File permissions • Every file has a UID and GID specifying the user who owns the file and the group the file belongs to • For each file, permissions are set that specify: • Whether the owner can read, write, or execute it • Whether other members of the group can read, write, or execute it • Whether anyone else on the system can read, write, or execute it • The chmod command changes these settings (u is for owner, g is for group, and o is everyone else)

20. File I/O • All I/O operations in Linux are treated like file I/O • Printing to the screen is writing to a special file called stdout • Reading from the keyboard is reading from a special file called stdin • When we get the basic functions needed to open, read, and write files, we'll be able to do almost any kind of I/O

21. Processes • A process is a program that is currently executing • In memory, processes have the following segments: • Text The executable code • Data Static variables • Heap Dynamically allocated variables • Stack Area that grows and shrinks with function calls • A segmentation fault is when your code tries to access a segment it's not supposed to • A process generally executes with the same privileges as the user who started it

22. System calls • A system call is a way to ask the kernel to do something • Since a lot of interesting things can only be done by the kernel, system calls must be provided to programmers via an API • When making a system call, the processor changes from user mode to kernel mode • There is a fixed number of system calls defined for a given system

23. glibc • The most common implementation of the Standard C Library is the GNU C Library or glibc • Some of the functions in the glibc perform systems calls and some do not • There are slight differences between the versions of the glibc • Microsoft also has an implementation of the Standard C Library that doesn't always behave the same

24. Handling system errors • There are no exceptions in C • Instead, when a system call fails, it usually returns -1 • To find out why the system call failed • First, make sure you #include <errno.h> • Then check the value of the integer errno in your program after the system call fails • Use the man pages to determine what a given value of errno means • The perror() function is often used to print errors instead of printf() • It sends the output to stderr instead of stdout

25. Error handling example #include<stdio.h> #include<fcntl.h> #include<errno.h> int main() { intfd= open("eggplant.txt", O_WRONLY | O_CREAT | O_EXCL); if(fd == -1) { perror("Failure to create file: "); if( errno == EACCES ) perror("Insufficient privileges\n"); else if( errno == EEXIST ) perror("File already exists\n"); else perror("Unknown error\n"); exit(EXIT_FAILURE); } return 0; }

26. System types • C has a feature called typedef which allows a user to give a new name to a type • System types are often created so that code is portable across different systems • The most common example is size_t, which is the type that specifies length • It's usually the same as unsigned int • There are named types for process IDs (pid_t), group IDs (gid_t), user IDs (uid_t), time (time_t), and many others

27. Functions

28. Anatomy of a function definition type name( arguments ) { statements }

29. Differences from Java methods • You don't have to specify a return type • But you should • intwill be assumed if you don't • If you start calling a function before it has been defined, it will assume it has return type int and won't bother checking its parameters

30. Prototypes • Because the C language is older, its compiler processes source code in a simpler way • It does no reasonable typechecking if a function is called before it is defined • To have appropriate typechecking for functions, create a prototype for it • Prototypes are like declarations for functions • They usually come in a block at the top of your source file

31. Prototype example #include<stdio.h> introot(intvalue); //integer square root int main() { int output = root(19); printf("Value: %d\n", output); return 0; } introot(intvalue) { inti = 0; while( i*i <= value ) i++; returni – 1; } • Parameter names in the prototype are optional (and don't have to match) • Both of the following work: int root(int); int root(int blah); • You can also declare a prototype locally (inside a function), but there isn't a good reason to do so

32. Insanity • If your method takes nothing, you should put void in the argument list of the prototype • Otherwise, type checking is turned off for the arguments double stuff(); int main() { double output = stuff(6.4, "bang"); //legal return 0; } double stuff(void); int main() { double output = stuff(6.4, "bang"); //error return 0; }

33. Return values • C does not force you to return a value in all cases • The compiler may warn you, but it isn't an error • Your function can "fall off the end" • Sometimes it works, other times you get garbage int sum(int a, intb) { intresult = a + b; return result; } int sum(int a, intb) { intresult = a + b; }

34. Examples of functions doing bad things • Functions without return types • Functions with return types but no return statements • Functions that return different things than they say they will

35. Scope

36. Scope • The scope of a name is the part of the program where that name is visible • In Java, scope could get complex • Local variables, class variables, member variables, • Inner classes • Static vs. non-static • Visibility issues with public, private, protected, and default • C is simpler • Local variables • Global variables

37. Local scope • Local variables and function arguments are in scope for the life of the function call • They are also called automatic variables • They come into existence on the stack on a function call • Then disappear when the function returns • Local variables can hide global variables

38. Global scope • Variables declared outside of any function are global variables • They exist for the life of the program • You can keep data inside global variables between function calls • They are similar to static members in Java intvalue; void change() { value = 7; } intmain() { value = 5; change(); printf("Value: %d\n", value); return 0; }

39. Use of global variables • Global variables should rarely be used • Multiple functions can write to them, allowing inconsistent values • Local variables can hide global variables, leading programmers to think they are changing a variable other than the one they are • Code is much easier to understand if it is based on input values going into a function and output values getting returned

40. Hiding • If there are multiple variables with the same name, the one declared in the current block will be used • If there is no such variable declared in the current block, the compiler will look outward one block at a time until it finds it • Multiple variables can have the same name if they are declared at different scope levels • When an inner variable is used instead of an outer variable with the same name, it hides or shadows the outer variable • Global variables are used only when nothing else matches • Minimize variable hiding to avoid confusion

41. extern declarations • What if you want to use a global variable declared in another file? • No problem, just put extern before the variable declaration in your file • There should only be one true declaration, but there can be many extern declarations referencing it • Function prototypes are implicitly extern file2.c file1.c file3.c program.c

42. static declarations • The static keyword causes confusion in Java because it means a couple of different (but related) things • In C, the static keyword is used differently, but also for two confusing things • Global static declarations • Local static declarations

43. Global static variables • When the static modifier is applied to a global variable, that variable cannot be accessed in other files • A global static variable cannot be referred to as an extern in some other file • If multiple files use the same global variable, each variable must be static or an extern referring to a single real variable • Otherwise, the linker will complain that it's got variables with the same name

44. Local static variables • You can also declare a static variable local to a function • These variables exist for the lifetime of the program, but are only visible inside the method • Some people use these for bizarre tricks in recursive functions • Try not to use them! • Like all global variables, they make code harder to reason about • They are not thread safe

45. Local staticexample #include <stdio.h> void unexpected() { static intcount = 0; count++; printf("Count: %d", count); } intmain() { unexpected(); //Count: 1 unexpected(); //Count: 2 unexpected(); //Count: 3 return 0; }

46. Compiling multiple files • All real programs are written in multiple files • To compile such files, do the following • Create a header file (with a .h extension) for every file that contains prototypes for functions you're going to use in other files • #include those header files in every file that uses them • When you run gcc, put all the .c files needed on the line at the same time

47. Multiple compilation example • Your main() function and core program is in a file called program.c • You have files called networking.c and graphics.c that have networking and graphics functions that your program uses • You should have headers called networking.h and graphics.h (names don't have to match, but it is better if they do) • At the top of program.c should be: • To run gcc you type: #include "networking.h" #include"graphics.h" gccprogram.cnetworking.cgraphics.c -o program

48. Or you can use compile but not link • You can compile a file into object code without linking it into an executable • Produces a .o file • That way, you can compile all the pieces separately and then link them later • This can be more efficient if you are updating some of the code but not all of it • To compile but not link, use gcc -c • We could compile the previous example as follows gcc –c program.c gcc –c networking.c gcc –c graphics.c gccprogram.onetworking.ographics.o-o program

49. Makefiles to the rescue • Now that we're talking about compiling multiple files, a makefile really makes (ha, ha) sense all: program program: program.onetworking.ographics.o gccprogram.onetworking.ographics.o -o program program.o: program.cnetworking.hgraphics.h gcc –c program.c networking.o: networking.c gcc –c networking.c graphics.o: graphics.c gcc –c graphics.c clean: rm -f *.o program

50. Upcoming