Each phase, through verification and transformation, establishes stronger invariants with respect to the things that it conveys to the next so that it is easier to record each subsequent phase than if they had to take into account all the previous ones. The middle part of the compiler in this context is only an intermediate code generator, but this often includes various optimizations and transformations of the intermediate code. The first three phases are collectively called the front end of the compiler, and the last three phases are collectively called the back end. Assembly and linking, assembly language code are translated into a binary representation, and addresses of variables, functions, etc. Machine code generation, the intermediate language is translated into assembly language (textual representation of machine code) for a specific machine architecture. Register placement, symbolic variable names used in intermediate code are converted to numbers, each of which corresponds to a register in the target machine code. Intermediate code generation, the program is translated into a simple machine-independent intermediate language. Type checking, this step parses the syntax tree to determine if the program violates certain consistency requirements, for example, if a variable is used but not declared, or if it is used in a context that does not make sense given the type of the variable, such as trying to use a boolean value as a function pointer. This stage is often referred to as parsing. Parsing, at this stage, the list of tokens obtained as a result of lexical analysis is ordered in a tree structure (called a syntax tree) that reflects the structure of the program. Lexical analysis is the initial part of reading and analyzing the text of a program: the text is read and divided into tokens, each of which corresponds to a character in the programming language, for example, a variable name, keyword, class, or number. On some compilers, the order of the steps may be slightly different, some steps may be combined or split into multiple steps, or some additional steps may be inserted between those mentioned below. The general division into phases is described below.

Often, some modules can be used by multiple compilers. Some of these modules are written by hand, while others can be created based on specifications. Usually, each stage is handled by a separate module. Conceptually, these phases operate in series (although in practice they often alternate), each phase (except the first) takes the output of the previous phase as input. The standard way to do this is to split the compilation into multiple steps with well-defined expectations. Since writing a compiler is difficult, we need to structure the work.

Flex and bison for codebox