To port a compiler to a new machine.

To improve an existing compiler.

Process:

Start with a small subset of the language, for which a simple compiler can be written, perhaps in assembly language or an existing high-level language.
Use this basic compiler to compile a more complete version of the compiler, written in the subset language.
Iteratively use the more complete compiler to compile even more sophisticated versions of itself, until a full-featured compiler for the language is achieved, written entirely in that language.

T-Diagrams: A common way to represent bootstrapping is using T-diagrams. A compiler written in language $L_i$ that translates source language $L_s$ to target language $L_t$ is represented as:

   L_s
  -----
   L_i
  -----
   L_t

Bootstrapping involves using an existing compiler to compile a new compiler for the same language. For example, to build a C compiler (C to Machine M) written in C, on machine M:

   C      C
  -----   -----
   ASM     C
  -----   -----
   M       M

The C compiler written in ASM on M compiles the C compiler written in C, producing a C compiler in M.

Cross-Compiler:

Definition: A cross-compiler is a compiler that runs on one computer architecture (the host system) but generates executable code for a different computer architecture (the target system).
Why it's used:
- Embedded Systems: Often, embedded systems have limited resources (memory, processing power) and cannot host a full-fledged compiler. Code is developed on a powerful workstation and cross-compiled for the embedded target.
- New Architectures: When a new CPU architecture is being developed, a cross-compiler is needed to generate code for it before native compilers are available.
- Resource Constraints: To compile programs for systems with different operating systems or environments.
Example: A C compiler running on an x86-64 Linux machine that produces executable binaries for an ARM-based microcontroller. The host is x86-64 Linux, the target is ARM.
T-Diagram Example: A C to ARM compiler running on an x86 machine:
```
   C
  -----
  x86
  -----
  ARM
```
Here, the compiler itself runs on x86, but its output is for ARM.

5. Explain Input Buffering in detail.

Introduction: Input buffering is a technique used in the lexical analysis phase of a compiler to efficiently read and process the source program, minimizing disk I/O operations and speeding up character-by-character scanning.

Explanation:

When a lexical analyzer reads characters from the source file, it typically doesn't read one character at a time directly from disk. Disk access is slow. Instead, it reads a large block of characters into a buffer in main memory. This significantly reduces the number of slow I/O operations.

Types of Input Buffering Schemes:

Single Buffer Scheme:
- The entire input is loaded into one large buffer.
- Two pointers, `lexemeBegin` and `forward`, are used. `lexemeBegin` points to the start of the current lexeme, and `forward` scans ahead to find its end.
- When `forward` reaches the end of the buffer, the entire buffer needs to be refilled from the input file.
- Disadvantage: If a lexeme spans across the buffer boundary (i.e., `forward` is at the end, but the lexeme isn't complete), handling this requires special log