When the program terminates, a "termination" status is returned to the command line interpreter. By convention, a termination status of 0 indicates the program terminated normally, and non-zero termination status indicates the program terminated abnormally. For example, mkdir returns 0 if it makes the specified directory but returns non-zero if it could not make the directory. A compiler returns 0 of the source code compiled without error, but it returns non-zero if it detects one or more errors in the code.

Both DOS and Linux can make use of the termination status. After calling the compiler to compile source code, the following line runs the program only if the compile was successful.

	[ $? = 0 ] && prog	# linux
	if errorlevel 0 prog	# DOS

In the case of Java and C (and C++), program execution begins with a call the the function main. The "words" on the command line are passed to the program via the main function argument list. In Java and C, the main declaration would be as follows.

	public static void main (string args[])	// Java
	int main (int argc, char *(args[]))	// C (and C++)

Standard Input/Output

File names

Text files

Linking

With C, all the object files that make up a program must be linked into a single file called an executable file. The executable file may have any name but again programmers should choose meaningful names.

A simple C program

	//---------------------------
	// A totally useless program.
	//---------------------------
	int main (int argc, char *(args[]))
        	{
		int	status;		// Program exit status
		int	ii;		// An index into the array
		char	str[10];	// An array of chars (string)
		
		//-----------------------------------
		// Assign the string "ab" into `str'.
		//-----------------------------------
		ii = 0;
		str[ii++] = 'a';
		str[ii++] = 'b';
		str[ii++] = '\0';
		if (ii == 10)
			status = 1;
		else
			status = 0;
        	return status;		// Style: only at end! Why?
        	}

Some familiar stuff

1. Types
   1. int
   2. short
   3. long
   4. long long
   5. unsigned int
   6. char
   7. unsigned char
   8. float
   9. double
   • What is missing from this list?
   • Can you assign an int into a char?
   • Can you assign an int into a int?
2. Constants
   1. 22
   2. 022
   3. 'c'
   4. '\t' /* TAB */
   5. '\0 /* NEWLINE */
   6. "abc"
   7. 5.2
   8. .2
   9. 5.
   10. 5e4
   11. 5e+4
   12. 5e-4
   13. 5.2e9
   14. .2e9
   15. 5.e9
3. Statements

           var = exp;
           if (exp)
                   {
                   // stmt list
                   }
           else    {
                   // stmt list
                   }
           while (exp)
                   {
                   // stmt list
                   }
   	switch (expr)
   		{
   	case CONST1:
                   // stmt list
   		break;
   	case CONST2:
                   // stmt list
   		break;
   	default:
                   // stmt list
   		break;
   		}
           break;
           continue;
   	return;
   	return 12;
   

4. operators
   1. - a       /* unary minus */
   2. ! a       /* logical not */
   3. a * b       /* mult */
   4. a / b       /* div */
   5. a % b       /* remainder or mod */
   6. a + b       /* add */
   7. a - b       /* sub */
   8. a < b       /* less than */
   9. a > b       /* greater than */
   10. a <= b       /* less than equal */
   11. a >= b       /* greater than equal */
   12. a != b       /* inequality */
   13. a == b       /* equality */
   14. a && b       /* logical and */
   15. a || b       /* logical or */
   16. a.b       /* member b of a */
   17. a[b]       /* element b of array a */
   1. & a       /* address of, `a' must be a variable or a function */
   2. * a       /* indirection */
   3. ~ a       /* bit not */
   4. ++ a       /* pre-increment */
   5. a ++       /* post-increment */
   6. -- a       /* pre-decrement */
   7. a --       /* post-decrement */
   8. sizeof a       /* size in bytes of `a' */
   9. a << b       /* left shift */
   10. a >> b       /* right shift */
   11. a & b       /* bitwise and */
   12. a ^ b       /* bitwise xor */
   13. a | b       /* bitwise or */
   14. a = b       /* assignment */
   15. a += b       /* a = a + b */
   16. a->b       /* (*a).b */

Compiling and linking C

	gcc -Wall -c t1.c		# t1.c => t1.o
	gcc -Wall -c t1.c t2.c		# t1.c => t1.o. t2.c => t2.o
	gcc -Wall t1.o -o tt		# t1.o => tt
	gcc -Wall t1.o t2.o -o tt	# t1.o,t2.o => tt
	gcc -Wall t1.o			# t1.o => a.out
	gcc -Wall t1.c -o tt		# t1.c => tt

Major pieces of a source file

#include 
#include "local.h"

#define	CON	5

extern	int	a1;  		// Permanent, global (import)   
	int	a2;          	// Permanent, global (import or export)
	int	a3 = 2;         // Permanent, global (export)
static	char	b;          	// Permanent, private to file
const	int	c = 3;		// Permanent, global (export), constant

extern	double	func1(int);	// Function, global (declaration/import)
	void	func2(char, int); // Function, global (declaration/import)
static	int	func3(void);	// Function, private (declaration/import)
static	int	func3b();	// BAD!!! (unknown parameters)

static	int	func4(char p1, int p2)	// Function, private (definition/export)
	{
	int	a;			// Temporary, private
	char	b;			// Temporary, private
static	long	c;			// Permanent, private
extern	double	func5(int);		// Permanent, global (import)

	a = 1;
	return 5;
	}

Basic I/O

	#include 

	#define MAX_LINE_SZ	80
	int	chr;	// Note: not a char
	char	line[MAX_LINE_SZ+4];
	int	len;

	chr = getchar();
	if (char != EOF) putchar(chr);

	status = fgets(line, MAX_LINE_SZ+2, stdin);
	if (status == NULL) exit(1); 
	len = strlen(line);
	if ( len > MAX_LINE_SZ) ...
	
	printf(format, a1, a2, ...);
	fprintf(stderr, format, a1, a2, ...);