+\pagebreak
+%% -> Language %%
+\section{Language}
+\subsection{Notation}
+The syntax notation used in this document is that of a BNF specification. A set of
+derivation rules, often written as:
+\begin{lstlisting}[language=bnf]
+ symbol ::= expression
+\end{lstlisting}
+Where symbol is a nonterminal, and the expression consists of one or more sequences of
+symbols; more sequences are separated by a vertical bar \textbar, indicating a choice,
+the whole being a possible substitution for the symbol on the left. Symbols that never
+appear on the left side are terminals.
+\linebreak
+
+This document defines language syntax throughout it's way at defining language
+constructs If you're interested in a summary of the language syntax, one is given in
+annex A.
+
+%% -> Concepts %%
+\subsection{Concepts}
+%% ->-> Scopes of identifiers %%
+\subsubsection{Scopes of identifiers}
+An identifier can denote an object; a function, or enumeration; a label name; a macro
+name; or a macro parameter. The same identifier can denote difference items at different
+point in the program. A member of an enumeration is called an enumeration constant.
+Macro names and macro parameters are not considered further here, because prior to the
+semantic phase of program translation any occurrences of macro names in the source file
+are replaced by the preprocessing token sequences that constitute their macro definitions.
+\linebreak
+
+For each different item that an identifier designates, the identifier is visible (i.e,
+can be used) only within a region of program text called its scope. Different items
+designated by the same identifier either have different scopes, or are in different name
+spaces. There are four kinds of scopes: function, file, block and function prototype.
+(A function prototype is a declaration of a function that declares the types of its
+parameters.)
+\linebreak
+
+A label name is the only kind of identifier that has function scope. It can be used (in
+a goto statement) anywhere in the function in which it appears, and is declared
+implicitly by its syntactic appearance (prefixed by a : and a statement).
+\linebreak
+
+Every other identifier has scope determined by the placement of its declaration (in a
+declarator or type specifier). If the declarator or types specifier that declares the
+identifier appears outside any block or list of parameters, the identifier has file
+scope, which terminates at the end of the file. If the declartor or type specifier that
+declares the identifier appears inside a block or within the list of parameter
+declarations in a function definition, the identifier has block scope, which terminates
+at the end of the associated block. If the declarator or type specifier that declares
+the identifier appears within the list of parameter declarations in a function prototype
+(not part of a function definition), the identifier has function prototype scope, which
+terminates at the end of the function declarator. If an identifier designates two
+different items in the same name space, the scopes might overlap. If so, the scope of
+one item (the inner scope) will be a strict subset of the scope of the other item (the
+outer scope). Within the inner scope, the identifier designates the item declared in the
+inner scope; the item declared in the outer scope is hidden (and not visible) within
+the inner scope.
+\linebreak
+
+Unless explicitly stated otherwise, where this document uses the term "identifier" to
+refer to some item (as opposed to the syntactic construct), it refers to the item in the
+relevant name space whose declaration is visible at the point the identifier occurs.
+\linebreak
+
+Two identifiers have the same scope it and only if their scopes terminate at the same
+point.
+\linebreak
+
+Each enumeration constant has scope that begins just after the appearance of its defining
+enumerator in an enumerator list. Any other identifier has scope that begins just after
+the completion of its declarator.
+
+%% ->-> Name spaces of identifiers %%
+\subsubsection{Name spaces of identifiers}
+If more than one declaration of a particular identifier is visible at any point in a
+source file, the syntactic context disambiguates uses that refer to different items.
+Thus, there are separate name spaces for various categories of identifiers, as follows:
+\linebreak
+\begin{itemize}
+ \item Label names (disambiguated by the syntax of the label declaration and use);
+ \item Enumerations (disambiguated by following the keyword enum);
+ \item All other identifiers, called ordinary identifiers (declared in ordinary
+ declarators or as enumeration constants).
+\end{itemize}
+
+%% ->-> Types %%
+\subsubsection{Types}
+The meaning of a value stored in an object returned by a function is determined by the
+type of the expression used to access it. (An identifier declared to be an object is the simplest
+such expression; the type is specified in the declaration of the identifier.) Types are
+partitioned into object types (types that fully describe objects), function types(types
+that describe functions), and incomplete types(types that describe objects but lack
+information).
+\linebreak
+
+An object declared type bool is large enough to store the values 0 and 1.
+\linebreak
+
+An object declared type float is a real type; An object declared type vector is a
+comprised set of three floats that respectively represent the \underline{x,y,z}
+components of a three-dimensional vector.
+\linebreak
+
+An enumeration comprises a set of named integer constant values. Each distinct
+enumeration constitutes a different enumerated type.
+\linebreak
+
+Enumeration types and float are collectively called arithmetic types. Each arithmetic
+type belongs to one type domain.
+\linebreak
+
+The void type comprises an empty set of values; it is an incomplete type that cannot be
+completed.
+\linebreak
+
+A number of derived types can be constructed from the object, function and incomplete
+types, as follows:
+\linebreak
+
+\begin{itemize}
+ \item An array type describes a contiguously allocated nonempty set of objects with a
+ particular object types, called the element type. Array types are characterized
+ by their element type and by the number of elements in the array. An array type
+ is said to be derived from its element type, and if its element is type T, the
+ array type is sometimes called "array of T". The construction of an array type
+ from an element type is called "array type derivation".
+ \item A function type described a function with a specified return type. A function
+ type is characterized by its return type and the number and types of its
+ parameters. A function type is said to be derived from its return type, and if
+ its return type is T, the function type is sometimes called "function returning
+ T". The construction of a function type from a return type is called "function
+ type derivation".
+\end{itemize}
+
+Arithmetic types are collectively called scalar types. Arrays and vectors are
+collectively called aggregate types.
+\linebreak
+
+An array of unknown size is an incomplete type. It is completed, for an identifier of
+that byte, by specifying the size in a later declaration. Arrays are required to have
+known constant size.
+\linebreak
+
+A type is characterized by its type category, which is either the outermost derivation
+of a derived type (as noted above in the construction of derived types), or the type
+itself if the type consists of no derived types.
+\linebreak
+
+Any type so far mentioned is an unqualified type. Each unqualified type has several
+qualified version of its type, corresponding to the combinations of one, two, or all
+two of const and volatile qualifiers. The qualified or unqualified versions of a type
+are distinct types that belong to the same type category and have the same representation.
+A derived type is not qualified by the qualifiers (if any) of the type from which it
+is derived.
+\linebreak
+
+%% ->-> Compatible types and composite type %%
+\subsubsection{Compatible types and composite type}
+Two types have compatible type if their types are the same.
+\linebreak
+
+All declarations that refer to the same object or function shall have compatible type;
+otherwise the behavior is undefined.
+\linebreak
+
+A composite type can be constructed from two types that are compatible; it is a type that
+is compatible with both of the two types and satisfies the following conditions:
+\begin{itemize}
+ \item If one type is an array, the composite type is an array of that size.
+ \item If only one type is a function type with a parameter type list(a function
+ prototype), the composite type is a function prototype with the parameter type
+ list.
+ \item If both types are function types with parameter type lists, the type of each
+ parameter in the composite parameter type list is the composite type of the
+ corresponding parameters.
+\end{itemize}
+These rules apply recursively to types from which the twp types are derived.
+\linebreak
+
+%% ->Conversions %%
+\subsection{Conversions}
+Several operators convert operand values from one type to another automatically. This
+sub-clause specified the result required from such an implicit conversion.
+\linebreak
+
+Conversion from an operand value to a compatible type causes no change to the value or
+the representation.
+\linebreak
+
+%% ->->Aritmetic operands %%
+\subsubsection{Arithmetic operands}
+\paragraph*{Boolean type}
+When any scalar value is converted to bool, the result is 0 if the value compares equal
+to 0; otherwise the result is 1.
+
+%% ->->Other operands %%
+\subsubsection{Other operands}
+\paragraph{Lvalues, arrays and function designators}
+An lvalue is an expression with an object type or an incomplete type other than void;
+if an lvalue does not designate an object when it is evaluated, the behavior is undefined.
+When an object is said to have a particular type, the type is specified by the lvalue
+used to designate the object. A modifiable lvalue is an lvalue that does not have an
+array type, does not have an incomplete type, does not have a const-qualified type.
+\linebreak
+
+Except when it is the operand of the unary \& operator, the ++ operator, the -- operator,
+or the left operand of the . operator or an assignment operator, an lvalue that does not
+have array type is converted to the value stored in the designated object (and is no
+longer an lvalue). If the lvalue has qualified type, the value has the unqualified
+version of the type of the lvalue; otherwise, the value has the type of the lvalue. If
+the lvalue has an incomplete type and does not have array type, the behavior is undefined.
+\linebreak
+
+A function designator is an expression that has function type.
+\linebreak
+
+\paragraph*{void}
+The (nonexistent) value of a void expression (an expression that has type void) shall not
+be used in any way, and implicit conversions (except to void) shall not be applied to
+such an expression. If an expression of any other type is evaluated as a void expression
+, its value or designator is discarded. (A void expression is only evaluated for its
+side effects.)