The Complete Course of Compiler Design

Learn how a compiler translates high-level source code into machine code, exploring source-to-source and source-to-machine types and the full language processing pipeline from preprocessor to loader.

Understand six compiler phases, starting with lexical analysis that tokenizes input and removes whitespace, then syntax analysis, semantic analysis, intermediate code generation, code optimization, and target code generation.

Construct a lexical analyzer from first principles, using regular expressions to identify lexemes and produce tokens, while interfacing with the symbol table and parser, and stripping comments and whitespace.

Develop regular expressions to match examples like the sentence 'I like dancing' and a mathematical expression, as part of the compiler design course.

Explore regular expression construction by uniting character sets with whitespace, forming a subset of a to z, and combining a keyword, an identifier, digits, and the equal sign.

Divide the equation into small parts and perform the NFA. Apply concatenation of three a and five f, then union, iteration, and epsilon moves to form the NFA diagram.

Identify states a to e and inputs a and b, derive transitions, and build transition table with start at a and finish at e (a→b on a, a→c on b).

Identify and remove left factoring to resolve ambiguity in given grammars, apply a formula to split into two productions with a new a prime, and present corrected grammar forms.

Explore top down and bottom up parsing, focusing on recursive descent and predictive parsers. Learn how leftmost derivation builds a parse tree in preorder, with backtracking and lookahead strategies.

Explore first and follow sets and their role in constructing predictive parsing tables for grammars, enabling lk parsers and clear handling of terminals, non-terminals, and epsilon.

Explore how to compute the first and follow sets for a given grammar, as addressed in question 8.

Construct an L1 parsing table from the given grammar and determine whether the input string is acceptable.

Examine how the runtime environment manages memory layout, activation records, and variable scope, coordinating stack and heap to support function calls, dynamic allocation, and cross-platform execution.

Explore activation records, or stack frames, as the data structure that manages function calls on the runtime call stack through creation, execution, and destruction, storing locals, parameters, and return addresses.

Explore constant folding, an optimization that evaluates constant expressions at compile time and replaces them with computed values, and declare constants to enable further optimization in modern C++ compilers.

Identify and perform dead code elimination during optimization to remove unreachable blocks. Reduce code size, improve execution, and simplify maintenance.

Apply previously learned optimization methods to optimize the given C++ code provided in the question.

Explore constant folding, dead code elimination, and common subexpression elimination to optimize C plus plus code. See how merging constants, removing unused results, and sharing repeated subexpressions yields streamlined code.

Explore target program code in compiler design. Understand absolute and relocatable machine code, assembly output, and Java bytecodes interpreted by the Java Virtual Machine.

Master memory management in code generation by balancing resource optimization, memory safety, and correctness, focusing on stack and heap allocation, memory organization, data alignment, and global and static data.

Derive a strategy score from the expression using non-terminals, then generate and optimize assembly code by eliminating redundant moves and sequence operations on registers and memory.

Evaluate and optimize the provided code by analyzing the expression and assembly code to derive an optimized version.

Learn how to evaluate and optimize an expression by reshuffling strategy and assembly code, comparing evaluation orders to minimize instructions and generate threaded code using registers like t1 and r0.

Explore the differences between static and dynamic compilation, including how static compilation creates a self-contained executable and slower startup, while dynamic (jit) compilation adapts at runtime using profiling.

Explore domain-specific languages (DSLs) that tailor code to a domain, including external and internal DSLs, their abstractions, syntax and semantics, benefits, and design steps.

The lecture demonstrates a dsl for building expressions by creating variables and constants and composing binary operations like plus, minus, times, and divide via operator overloads with unique_ptr ownership.

Demonstrates building a simple internal DSL in C++ to express and evaluate binary operations with constants and variables, printing results to the console for the complete course of compiler design.

Build a simple domain specific language from the given problem by identifying nouns and verbs, then implement an internal DSL in C++ to manage products, quantity, and inventory.