Compilers are typically organized into distinct, yet interconnected, phases. This modular design helps manage complexity, allows for specialized algorithms in each phase, and facilitates easier maintenance and upgrades.

○ Analogy: This is like a spell checker or a basic word segmenter. It doesn't understand the meaning of the words, only that they are valid words in the language.
○ Function: The lexical analyzer (or "scanner") reads the raw source code as a stream of characters from left to right. Its primary job is to group these characters into meaningful units called tokens. Tokens are the smallest atomic units of a program that have a collective meaning (e.g., keywords, identifiers, operators, numbers, punctuation). It also strips out whitespace (spaces, tabs, newlines) and comments, as these are generally irrelevant to the program's execution logic.
○ Process: This phase typically uses a finite automaton (a mathematical model for sequential logic) derived from regular expressions (patterns defining token structures) to recognize token patterns.
○ Input: Source code (a raw text file).
○ Output: A stream of tokens, where each token is a pair: (token_type, value).
For example, (KEYWORD, "if"), (IDENTIFIER, "myVariable"), (OPERATOR, "="), (NUMBER, "123"), (PUNCTUATOR, ";").
○ Error Detection: Reports "lexical errors" or "scanning errors" if it encounters characters or sequences of characters that do not form a valid token according to the language's rules (e.g., $ in C++ unless it's part of a string).

○ Analogy: This is the grammar checker. It takes the "words" (tokens) and ensures they are arranged in a grammatically correct structure according to the language's rules. It builds sentences and paragraphs.
○ Function: The syntax analyzer (or "parser") receives the stream of tokens from the lexical analyzer. It then verifies if the sequence of tokens conforms to the grammar (syntax rules) of the programming language. If it does, it constructs a hierarchical representation of the program, most commonly a Parse Tree (which shows the full grammatical structure) or an Abstract Syntax Tree (AST). An AST is a more compact and abstract representation that captures the essential structural elements of the code, omitting many details from the parse tree that are irrelevant for subsequent phases.
○ Process: Parsers are based on formal grammars, specifically context-free grammars (CFGs). They use various parsing techniques, broadly categorized into:
■ Top-down parsing: Starts from the grammar's start symbol and tries to derive the input string by applying production rules (e.g., Recursive Descent, LL(k) parsers).
■ Bottom-up parsing: Starts from the input tokens and tries to reduce them to the grammar's start symbol (e.g., Shift-Reduce parsers, LR parsers like SLR, LALR, Canonical LR).
○ Input: Stream of tokens.
○ Output: A parse tree or, more commonly, an Abstract Syntax Tree (AST).
○ Error Detection: Reports "syntax errors" if the token sequence violates the language's grammatical rules (e.g., if (x) { ... without a closing }, or int ; where a variable name is expected). These are often the most common errors seen by programmers.

○ Analogy: This is the meaning checker. It goes beyond grammar to ensure that the "sentences" (parsed code) actually make logical sense and follow the deeper rules of the language. It checks if you're trying to add apples and oranges.
○ Function: This phase takes the syntax tree (AST) and checks for semantic correctness, meaning the code's logical consistency and adherence to the language's definition beyond just syntax. It adds information to the AST. Key tasks include:
■ Type Checking: Ensuring that operations are performed on compatible data types (e.g., you can't add an integer to a string directly in strongly typed languages).
■ Variable Declaration and Scope Checking: Verifying that all variables are declared before use and that they are accessed within their proper scope (where they are visible).
■ Function/Method Call Checking: Ensuring that the correct number and types of arguments are passed to functions, and that functions are called correctly.
■ Access Control: Checking if a program attempts to access private members of a class from outside.
■ Symbol Table Management: A crucial component of this phase is the Symbol Table. This data structure stores information about all identifiers (variables, functions, classes, etc.) in the program, including their type, scope, memory location (once known), and other attributes. The semantic analyzer constantly consults and updates the symbol table.
○ Input: Parse tree or Abstract Syntax Tree (AST).
○ Output: An annotated AST (where nodes are decorated with type information, symbol table entries, etc.) or an initial intermediate representation.
○ Error Detection: Reports "semantic errors" (e.g., undeclared variable 'x', type mismatch in assignment, function 'foo' expects 2 arguments but 3 were given).

○ Analogy: This is like translating a refined human language into a standardized, simple, and generic instruction set, similar to a universal instruction manual before it's tailored for a specific machine.
○ Function: The intermediate code generator translates the semantically checked AST into an intermediate representation (IR). This IR is a low-level, machine-independent code that is easier to generate from the AST and easier to translate into target machine code. It acts as a bridge, decoupling the front-end (language-specific) from the back-end (machine-specific) of the compiler. This allows a compiler to support multiple source languages by generating a common IR, and multiple target machines by having separate back-ends for each.
○ Common Intermediate Representations:
■ Three-Address Code (TAC): Instructions have at most three operands (e.g., result = operand1 op operand2). Each instruction performs one elementary operation. This makes optimization easier.
■ Example: A = B + C * D might become:
t1 = C * D
t2 = B + t1
A = t2
■ Quadruples: A representation of TAC where each instruction has four fields: (operator, operand1, operand2, result).
■ Triples: Similar to quadruples but implicit results, referring to previous instruction numbers.
■ Static Single Assignment (SSA) Form: A specialized IR where each variable is assigned a value only once. This simplifies dataflow analysis for optimization.
○ Input: Annotated AST.
○ Output: Intermediate Code in a chosen representation.

○ Analogy: This is the efficiency expert. It takes the standard instruction manual and refines it to be faster, use fewer steps, or require fewer resources, without changing the outcome.
○ Function: The optimizer's role is to transform the intermediate code into a more efficient equivalent without altering the program's observable behavior. The goal is to make the final executable faster, smaller, or consume less power. Optimization is often divided into machine-independent and machine-dependent phases.
○ Types of Optimizations:
■ Machine-Independent Optimizations: Applied to the IR without considering the specific target machine.
■ Common Subexpression Elimination: If an expression is computed multiple times with the same operands, compute it once and reuse the result.
■ Dead Code Elimination: Remove code that will never be executed or whose results are never used.
■ Constant Folding: Evaluate constant expressions at compile time (e.g., x = 5 + 3 becomes x = 8).
■ Loop Optimizations: Such as code motion (moving loop-invariant computations out of loops) and strength reduction (replacing expensive operations with cheaper ones, e.g., multiplication by bit shifts).
■ Inlining: Replacing a function call with the body of the function directly.
■ Data-Flow Analysis: A core technique used by optimizers to gather information about how data flows through the program, essential for many optimizations.
○ Input: Intermediate Code.
○ Output: Optimized Intermediate Code.
○ Impact: A well-designed optimization phase can significantly improve the performance of the generated code, making compilers a crucial component in high-performance computing.

○ Analogy: This is the final blueprint designer. It takes the optimized generic instructions and translates them into the specific, highly detailed instructions that the robot (CPU) understands, deciding which tools (registers) to use and where to store parts (memory).
○ Function: This is the final phase where the optimized intermediate code is translated into the actual target machine code (assembly language or directly into binary machine code) for the specific hardware architecture. This phase is highly machine-dependent.
○ Key Tasks:
■ Instruction Selection: Choosing the appropriate machine instructions for each IR operation, considering the target CPU's instruction set.
■ Register Allocation and Assignment: Deciding which program variables will reside in CPU registers (fastest access) and which will be stored in memory. This is critical for performance.
■ Memory Management: Determining the exact memory locations for variables, arrays, and other data structures.
■ Instruction Ordering/Scheduling: Rearranging instructions to minimize pipeline stalls or maximize instruction-level parallelism, leveraging the target CPU's micro-architecture.
■ Peephole Optimization: A small, localized optimization technique where a "peephole" (a small window of instructions) is examined to find and replace inefficient instruction sequences with better ones.
○ Input: Optimized Intermediate Code.
○ Output: Target Machine Code (e.g., assembly language, or directly executable binary).

The first three phases (Lexical Analysis, Syntax Analysis, Semantic Analysis) are often collectively called the Front-End of the compiler. They are primarily concerned with understanding the source language and are largely machine-independent.
The last two phases (Code Optimization, Code Generation) are typically called the Back-End. They are concerned with generating efficient code for the target machine and are highly machine-dependent.
Intermediate Code Generation acts as a bridge between the front-end and back-end. This separation allows for compiler portability: a new front-end can be built for a new language, or a new back-end for a new machine, while reusing existing parts.