Overview of Language Processing System Introduction to Compiler Design - Compiler

Overview of Language Processing System

The language processing system for high-level programming languages consists of several tools and program modules that together translate source programs into executable machine code, support program development, and manage program execution. Typical components are preprocessors, translators (compilers and interpreters), assemblers, and loader/link-editors. Each component performs specific tasks such as transforming source text, detecting errors, producing object code, resolving references and placing programs into memory for execution.

Preprocessor

A preprocessor produces input for a compiler by transforming or augmenting the source text before compilation begins. Preprocessors are commonly used to provide conveniences and language features that are not part of the core source language.

Common preprocessor functions

• Macro processing: Allows the definition of macros that act as shorthand for longer constructs. A macro expansion replaces macro invocations with the corresponding expanded code.
• File inclusion: Includes the contents of header or other source fragments into the program text to enable modularity and reuse.
• Conditional compilation: Enables compilation of selected portions of code depending on compile-time conditions (useful for platform-specific code or debug builds).
• Rational preprocessor: Augments older or simpler languages with more modern control-flow and data-structuring facilities by transforming added constructs into the base language constructs.
• Language extensions: Adds small language features or notational conveniences by translating them into standard language constructs (for example, adding syntactic sugar or domain-specific constructs).

Compiler

A compiler is a translator program that reads a program written in a high-level language (the source program) and translates it into an equivalent program in a lower-level language, typically machine code or an intermediate code (the object program). Compilers also perform error detection and report diagnostic messages to the programmer.

To execute a program written in a high-level language, two broad steps occur:

• The source program is translated (compiled) into an object program (machine code or intermediate code).
• The resulting object program is loaded into memory and executed.

Typical phases of a compiler

• Lexical analysis: Converts a stream of characters into a stream of tokens (identifiers, keywords, literals, operators).
• Syntax analysis (parsing): Analyses the token stream according to the grammar to build a parse tree or abstract syntax tree (AST).
• Semantic analysis: Checks semantic rules (type checking, scope, declarations) and annotates the AST; builds or consults the symbol table.
• Intermediate code generation: Produces a language-independent intermediate code (three-address code, syntax-directed translation) representing program behaviour.
• Optimisation: Improves the intermediate code or target code to make execution faster or use less space while preserving semantics.
• Code generation: Translates intermediate code into target machine code or assembly.
• Code emission and assembly: Emits the final object code; may produce relocation information and symbol tables for linking.
• Error handling and diagnostics: Reports lexical, syntactic and semantic errors and provides useful diagnostics to the programmer.

Assembler

Programmers found machine language hard to read and write, so symbolic mnemonics were introduced for machine instructions. A program called an assembler automates translation from an assembly language (the mnemonic form) to machine language (the object program).

• The input to an assembler is called the source program; the output is the machine-language translation (the object program).
• The assembler typically also generates relocation and symbol information used later by the loader/link-editor.
• Assemblers may support assembler directives (pseudo-ops) for data allocation, constants, and conditional assembly.

Interpreter

An interpreter is a program that directly executes statements of a source program without producing a separate object program that is later loaded for execution. The interpreter analyses and executes the program representation on the fly, giving the impression that the source program is executed as if it were machine language.

Phases of interpretation

1. Lexical analysis
2. Syntax analysis
3. Semantic analysis
4. Direct execution (interpretation) of the parsed and analysed constructs

Advantages

• Modifications to the user program can be quickly tested because changes take effect immediately without a separate compile step.
• Dynamic typing and dynamic changes of object types are easier to support.
• Interactive debugging is simplified because the interpreter can execute a program statement by statement.
• An interpreter can make a language more platform independent by providing a machine-dependent runtime engine while keeping the source code portable.

Disadvantages

• Execution is usually slower than compiled code because interpretation incurs runtime overhead.
• Memory consumption can be greater since the interpreter and its runtime structures remain resident during execution.

Loader and Link-Editor

After translation by an assembler or compiler, the resulting object programs must be placed into memory and prepared for execution. A loader is a program that places object code into memory and prepares it for execution. A link-editor (linker) combines multiple object modules and resolves external references to produce a complete executable.

Why a separate loader/link-editor?

If the assembler or compiler directly placed object code into memory and transferred control to it, the translator would remain in memory and be wasted during execution; retranslation would also be required each run. Separating translation and loading improves efficiency.

Relocation

Relocation is the task of adjusting program addresses so that object code modules can be placed at arbitrary memory locations. A relocation loader or link-editor updates addresses and references so modules can be loaded anywhere in memory.

Typical functions performed by relocation loaders / link-editors

• Combine object modules from different source files into a single executable or load module.
• Resolve external references and symbols between object modules (symbol resolution).
• Adjust addresses and relocate code and data so they reference correct memory locations (relocation).
• Load the relocated code and data into main memory and transfer control to the program's entry point.

Translator

A translator is any program that takes a program written in one language and produces an equivalent program in another language. Translators also perform error detection and report violations of language rules to the programmer.

• Translators detect and report lexical, syntactic and semantic errors when the source program violates the high-level language's specification.
• Important roles of a translator include translating the high-level language (HLL) input into an equivalent machine-level (ML) output and providing diagnostic messages for programmer errors.

Types of Translators

• Interpreter
• Compiler
• Preprocessor
• Assembler

List of Compilers (examples)

• Ada compilers
• ALGOL compilers
• BASIC compilers
• C# compilers
• C compilers
• C++ compilers
• COBOL compilers
• Java compilers