= Beginner


= Average


= Advanced

Syntaxic and lexical conventions

Commands :	command
Facultative elements :	[element]
lvalue :	variable that can figure at the left of an '=' sign, to which one can affect a value
rvalue :	variable that figures only at the right of an '=' sign, thas has a value but to which one can NOT affect a value
module :	result of the compilation of a segment of code encased between brackets { }

Table of contents

Syntaxic and lexical conventions.
Table of contents.
Keywords.
Operators.
Preprocessor commands
Program syntax.

Comments
Variable declaration.
Type definition: sizeof, typedef, enum, union, struct.
Type casting
Function declaration.

Program structure

Instructions
Blocs of instructions
Control sequences: if, else, while, break, continue, do, for, switch, case, default

Preprocessor use

Preprocessor instructions syntax

Keywords

auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while

Operators

=

+

-

*

/

%

<< , >>

&

|

^

< , > , <= , >= , == , !=

&&

||

+= , -= , *= , /= , &= , |=

unary -

~

!

unary &

unary *

variable ++

++ variable

variable --

-- variable

test?val_true:val_false

Preprocessor commands

#include

#define

#undef

#ifdef

#ifndef

#ifeq

#else

#endif

Program syntax

Comments


Comments are either a portion of text beginning by // (double slash) and ending at the end of the line, or a portion of text between /* and */ (slash star and star slash), newlines included.


Variable declaration


Before being given a value, then used, a variable must be declared. A variable declaration takes the form :

[modifier(s)] [sign/size] type [*] name [= value] ;


You must group all declarations either at the top of your code, before defining any function, or at the beginning of a function or a block (see function and block structures below). A modifier affects the memory status of the variable, and can be one of:


auto	automatic memory mode, also the default mode
const	constant declaration, this variable will become a rvalue once initialised, with a variable = value ; command
extern	keyword to make a variable declared in an external module known to our segment of code
register	this variable will be held in one of the processor registers, thus accelerating the access to it's value
static	this variable will NOT be discarded when we come out of this module
volatile	this variable can also be changed from outside this module, an opposite of const



'Sign/size' is one, or more, of the following:


long
short
signed
unsigned

Note that there is no boolean type, any integer type (int or char) can be used for the purpose: a null integer will stand for 'false' and a non-null integer will stand for 'true'.

'Type' is a user defined type, or one of the following basic types:


void	the 'empty' type, used to signify that a pointer doesn't points toward an effective value, or a function has no argument
char	one-byte character or integer -there is no long or short char-
int	a bigger sort of integer, usually 2-bytes long -short int: a 2-bytes integer, long int: a 4-bytes integer-
float	normal precision floating point real number
double	double precision floating point real number



'Name' is a string of characters, beginning with an alphabetic character, and without blank.

'Value' is a rvalue, evaluating to data of a type compatible with 'Type'.

The '*' (star) means the variable is merely a pointer toward a memory segment that contains a variable of the type 'Type', that is an integer representing the hardware adress of this segment.



Type definition


First of all, we spoke of data sizes while explaining the role of size modifiers such as short or long. The sizeof command returns the bytes used in memory by a given type of data:
int var_size = sizeof(type_name) ;
or
type_name var ;
int var_size = sizeof(var) ;

var_size now holds the size in bytes of the type type_name.

One can define new types with the instruction typedef:

typedef old_type_name new_type_name ;


Moreover, the programmer may define composite new types by using the enum, union and struct keywords.

The enum keyword:

enum e_name { name_1, name_2, ..., name_n } ;
defines a new type enum e_name that allows variables of this type to take one of the name_1, ... name_n values, identified to a index of position in the enum declaration, For instance, we could state enum e_name var = name_2 ;. The variable would then have the value name_2, identifying to the integer value 1 (name_1 would be 0, name_k would be k-1).
One can set explicitely the value of one of these keywords by using a definition like:

enum e_name { name_1, name_2 = 3, ..., name_n } ;
name_1 would then take the value 0, name_2 the value 3, and name_3 the value 4, and so on, incrementing the value of 1 for each new keyword. Note that an enum e_name variable can also take values different from these of any keyword, by a cast from an arbitrary integer value (see casting below).

The union keyword:

union u_name {

type_1 member_1 ;
:
:
type_n member_n ;

} ;

defines a new type union u_name. It uses a segment of memory whose length is the maximum length of type_1, ..., type_n. An instruction var.member_k = value ;, if var is of type union u_name and value of type type_k, writes in the memory the bytes of value, from the beginning of the memory segment allocated for var, and to the extent of sizeof(type_k) bytes. The memory image is then:


|-----------------	member_1 value on sizeof(type_1) bytes
|-----------	member_2 value on sizeof(type_2) bytes
| :	:
|-----------	member_n value on sizeof(type_n) bytes


The struct keyword:

struct s_name {

type_1 member_1 ;
:
:
type_n member_n ;

} ;

defines a new type struct s_name. It uses a segment of memory whose length is the sum of the lengthes of type_1, ..., type_n. The members member_1, ..., member_n lay contiguously in the memory. After initialising all the structure's members, the memory image looks like:

|--------------------	|---------------------------	|-----------	|--------------------
member_1 value on sizeof(type_1) bytes	member_2 value on sizeof(type_2) bytes	...	member_n value on sizeof(type_n) bytes

A structure can also include bit fields, to enable the access of individual bits of the memory used by the structure. The syntax is:

struct s_name {

type_1 member_1 ;
:
unsigned field_1 : length_1 ;
signed field_2 : length_2 ;
:
unsigned field_p : length_p ;
:
type_n member_n ;

} ;

Bit fields can be signed or unsigned, and their length is expressed in bits. However, their total size must comply with the alignment caracteristics of the computer. As a rule of the thumb, one must always try to use adjacent bit fields so that their total lenght is a power of two octets.

The programmer can also make composite type definitions, such as:

typedef enum e_boolean { false, true } boolean ;

thus creating a type boolean, that can have the values false identified to the integer 0, and true identified to 1.
An other complex definition could be:

typedef struct s_node {
int car ;
struct s_node * cdr ;
} node ;
typedef node * list ;

It defines a structure of node (basic structure for linked lists) and the corresponding list type.



Type casting


You can change the type attached to the return value of an expression by an operation named 'casting'. If we have, say, an expression evaluating to a value of type type_1, which we want to affect to a variable of type type_2, we could write:


lvalue = (type_2) expression ; //expression evaluates to type_1, lvalue is of type type_2

Of course, to do that it is necessary for type_1 and type_2 to be compatible, for instance two integer types, two floating types, an integer and a pointer, or two function types


Function declaration


Like a variable, a function must be declared before being instanciated (given a value) and used. A typical declaration looks as follows:

return_type function_name ( type_1 argument_1, ..., type_n argument_n ) ;


A function instantiation takes the form :

type_return function_name ( type_1 argument_1, ..., type_n argument_n ) {
// code...
return ret_value ; // of type return_type
}


Note that there is no semicolon at the end of a function definition, and that the auto, const, extern, static and volatile keywords can also be used.
The handling of functions is very similar to that of variables. To understand why, let us look at a typical result of the compilation of a C program. It has, to simplify, three parts:

_ A link table, list of addresses telling the system where to look for beginnings of functions to execute and data tu use.
_ The code section, where is stored the executable code of these functions (binary instructions understood by the processor).
_ The memory section, where will be stored the data and variables used by these functions.

For the compiler, a variable is then merely an entry in the table, containing an adress pointing into the memory section, while a function is an entry in the table with an adress pointing into the code section. You can refer to a function in a variable, for instance you can state, if function_1 was previously defined as above as a ret_type function_1(types) ; in the declaration part, you can affect the value of function_1 to function_2 with: ret_type function_2(types) = function_1 ;

Program structure

Instructions


A typical instruction has the form:

lvalue = function(rvalue_1, ..., rvalue_n) ;
or
lvalue = rvalue_1 operator_1 ( ( rvalue_2 operator_2 rvalue_3 ) ... rvalue_n ) ;


Valid operators are:







Binary operators: variable1 operator variable2
=	copies the value of the expression on the right into the memory segment designed by the variable on the left
+	plus
-	minus
*	multiply
/	divide
%	remainder
<< , >>	binary shift to the right or to the left, the left argument is the number of bits
&	bitwise and
|	bitwise or
^	exclusive or
< , > , <= , >= , == , !=	comparison operators: less than, more than, less or equal, more or equal, equal, different
&&	boolean and
||	boolean or
Binary operators: decrementation and incrementation, lvalue operator rvalue
+= , -= , *= , /= , &= , |=	takes the value of the left-hand variable, performs the operation denoted by the first character of the symbol on this value and the right-hand variable, then stores the result in the lvalue
Unary operators: operator variable
unary -	opposite
~	bitwise two-complement
!	boolean not: returns 0 for any non-null argument, and 1 otherwise
unary &	return the adress of the variable, as a pointer
unary *	return the contents of the memory segment pointed by the variable (variable of type Type *, return of type Type)
Unary operators: decrement and increment operators
variable ++	returns the value of the variable, then increments the contents of the variable
++ variable	increments the contents of the variable, then returns the incremented value
variable --	returns the value of the variable, then decrements the contents of the variable
-- variable	decrements the contents of the variable, then returns the decremented value
Ternary operator
test?val_true:val_false	returns val_true if test is non-null, or val_false otherwise




Blocs of instructions


Instructions can be grouped by brackets { ... } to form a block:

{

instruction_1 ;
:
:
instruction_n ;

}

In the C language, a block is treated as one instruction. In what follows, we will denote as "instruction ;" either a normal expression, of the form seen above, or a block of instruction. Note that in the first case, an instruction must always be followed by a semicolon. In a block, every instruction is itself folowed by a semicolon, but there is none after the brackets.



Control sequences


A typical control sequence looks as folows:

control(test) instruction ;


The if() { ... } [else { ... }] control sequence:

if(test) instruction_true ;
[ else instruction_false ; ]


executes the instruction instruction_true if the test expression returns a non-null value, and executes the instruction instruction_false if the test expression returns a null value. Note that you can chain if ... else clauses, following this pattern:

if(test_1) instruction_1 ;
else if(test_2) instruction_2 ;
else instruction_default ;


It works very much like the switch ... case ... default structure described below.

The while() { ... } control sequence:

while(test) instruction ;


loops, executing the instruction, while the test expression returns a non-null value. If it is null at the beginning, the instruction is never executed. In any loop structure, built with while, do, or for, you can stop the loop immediately by using the break keyword:

while(test) {
instruction_1 ;
:
instruction_k ;
if(test_break) break ;
instruction_k+1 ;
:
instruction_n ;

}


You can also use the continue keyword, that goes to the next iteration without finishing the current one.

The do { ... } while() control sequence:

do instruction ;
while(test) ;


executes the instruction, then loops if the test expression returns a non-null value. If it is null at the beginning, the instruction is executed once.

The for(;;) { ... } control sequence:

for(initialisation ; test ; incrementation) instruction ;


It is strictly equivalent to:

initialisation ;
while(test) {

instruction ;
incrementation ;

}


The switch() { case : ... [default : ...] } control sequence:

switch(expression) {


case value_1 :

instruction_1.1 ;
:
instruction_1.n1 ;


:
:

case value_n :

instruction_n.1 ;
:
instruction_n.n1 ;


[ default :

instruction_1 ;
:
instruction_d ; ]

}


This control structures goes to the first case value_k : satement where value_k equals expression (which must return an integer value), then executes all the instructions k.1, k.2, ... k.nk, then all the instructions of clauses k+1, k+2, ... n and default. If no value matches the expression return values, the default statement, if present, is executed. To stop the switch structure from executing these instructions, put a break where you want it to jump out of the structure, and resume normal execution.

Preprocessor use

Preprocessor instructions syntax


The preprocessor instructions begin by a #, followed by a keyword and arguments. There is no semicolon at the end. The most usefull is the #include instruction, that tells the preprocessor to add the contents of a given file to the current file:

#include <system_header_file.h>
or
#include "local_header_file.h"


The sytem header files will be searched in pre-defined directories, where are grouped all the general purpose header files. The local header files will be searched in the current directory. Their purpose is to declare functions whose source code is not included in the current file, but for which an executable code will be provided before the linking.

You can define variables,with the #define statement:

#define VAR_NAME value


The value field is optional, you can define a variable with no value. This functionality is used to create flags, set if the corresponding variable is defined, not set otherwise. You can also define functions, with the syntax:

#define MACRO_NAME(arg_1,arg_2,...,arg_n) definition


You can unset a variable, using the #undef statement:
#undef VAR_NAME


You can also use control statements with the preprocessor, such as the #if ... [#else ...] #endif structure. It's syntax is:

#ifXXX ARGUMENTS
(text_1)
[#else
(text_2)]
#endif


If the test performed by the #ifXXX statement succeeds, text_1 is processed and text_2 discarded, and the other way round if the test fails (or nothing is done if text_2 is not present). #ifXXX can be one of:


ifdef	tests if the variable name given as an argument is set
ifndef	tests if the variable name given as an argument is not set
ifeq	tests if the variable or constant values given in argument


When you use a macro defined with the #define preprocessor instruction, the preprocessor only replaces each of the symbolic arguments by the character string found in the same position as in the definition. It doesn't bother with operators priority, so you can obtain unexpected results when using macros defined without special care. To solve this problem, you can embed variables in parentesis in the definition, such as in the following example:

#define max(x1,x2) ((x2)>(x1))?(x2):(x1)

THE END