1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Simple LLVM IR example for understanding
# This represents: int add(int a, int b) { return a + b; }

llvm_ir_example = """
define i32 @add(i32 %a, i32 %b) {
entry:
  %result = add i32 %a, %b
  ret i32 %result
}
"""

# LLVM provides several key advantages:
# 1. Reusable optimization infrastructure
# 2. Support for multiple source languages
# 3. Multiple target architectures
# 4. JIT compilation capabilities
# 5. Static analysis tools

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223

# Simple calculator language implementation

import re
from enum import Enum
from dataclasses import dataclass
from typing import List, Union, Optional

class TokenType(Enum):
    NUMBER = "NUMBER"
    PLUS = "PLUS"
    MINUS = "MINUS"
    MULTIPLY = "MULTIPLY"
    DIVIDE = "DIVIDE"
    LPAREN = "LPAREN"
    RPAREN = "RPAREN"
    EOF = "EOF"

@dataclass
class Token:
    type: TokenType
    value: str
    position: int

class Lexer:
    def __init__(self, text: str):
        self.text = text
        self.position = 0
        self.current_char = self.text[0] if text else None

    def advance(self):
        """Move to next character"""
        self.position += 1
        if self.position >= len(self.text):
            self.current_char = None
        else:
            self.current_char = self.text[self.position]

    def skip_whitespace(self):
        """Skip whitespace characters"""
        while self.current_char and self.current_char.isspace():
            self.advance()

    def read_number(self):
        """Read a number from input"""
        number = ""
        while self.current_char and (self.current_char.isdigit() or self.current_char == '.'):
            number += self.current_char
            self.advance()
        return number

    def get_next_token(self) -> Token:
        """Lexical analyzer (tokenizer)"""
        while self.current_char:
            if self.current_char.isspace():
                self.skip_whitespace()
                continue

            if self.current_char.isdigit():
                return Token(TokenType.NUMBER, self.read_number(), self.position)

            if self.current_char == '+':
                self.advance()
                return Token(TokenType.PLUS, '+', self.position)

            if self.current_char == '-':
                self.advance()
                return Token(TokenType.MINUS, '-', self.position)

            if self.current_char == '*':
                self.advance()
                return Token(TokenType.MULTIPLY, '*', self.position)

            if self.current_char == '/':
                self.advance()
                return Token(TokenType.DIVIDE, '/', self.position)

            if self.current_char == '(':
                self.advance()
                return Token(TokenType.LPAREN, '(', self.position)

            if self.current_char == ')':
                self.advance()
                return Token(TokenType.RPAREN, ')', self.position)

            raise ValueError(f"Invalid character '{self.current_char}' at position {self.position}")

        return Token(TokenType.EOF, None, self.position)

# Abstract Syntax Tree nodes
class ASTNode:
    pass

@dataclass
class NumberNode(ASTNode):
    value: float

@dataclass
class BinaryOpNode(ASTNode):
    left: ASTNode
    operator: Token
    right: ASTNode

@dataclass
class UnaryOpNode(ASTNode):
    operator: Token
    operand: ASTNode

class Parser:
    def __init__(self, lexer: Lexer):
        self.lexer = lexer
        self.current_token = self.lexer.get_next_token()

    def eat(self, token_type: TokenType):
        """Consume token of expected type"""
        if self.current_token.type == token_type:
            self.current_token = self.lexer.get_next_token()
        else:
            raise ValueError(f"Expected {token_type}, got {self.current_token.type}")

    def factor(self) -> ASTNode:
        """Parse factor: NUMBER | LPAREN expr RPAREN | (PLUS|MINUS) factor"""
        token = self.current_token

        if token.type == TokenType.PLUS:
            self.eat(TokenType.PLUS)
            return UnaryOpNode(token, self.factor())

        elif token.type == TokenType.MINUS:
            self.eat(TokenType.MINUS)
            return UnaryOpNode(token, self.factor())

        elif token.type == TokenType.NUMBER:
            self.eat(TokenType.NUMBER)
            return NumberNode(float(token.value))

        elif token.type == TokenType.LPAREN:
            self.eat(TokenType.LPAREN)
            node = self.expr()
            self.eat(TokenType.RPAREN)
            return node

        raise ValueError(f"Unexpected token {token.type}")

    def term(self) -> ASTNode:
        """Parse term: factor ((MULTIPLY | DIVIDE) factor)*"""
        node = self.factor()

        while self.current_token.type in (TokenType.MULTIPLY, TokenType.DIVIDE):
            token = self.current_token
            if token.type == TokenType.MULTIPLY:
                self.eat(TokenType.MULTIPLY)
            elif token.type == TokenType.DIVIDE:
                self.eat(TokenType.DIVIDE)

            node = BinaryOpNode(left=node, operator=token, right=self.factor())

        return node

    def expr(self) -> ASTNode:
        """Parse expression: term ((PLUS | MINUS) term)*"""
        node = self.term()

        while self.current_token.type in (TokenType.PLUS, TokenType.MINUS):
            token = self.current_token
            if token.type == TokenType.PLUS:
                self.eat(TokenType.PLUS)
            elif token.type == TokenType.MINUS:
                self.eat(TokenType.MINUS)

            node = BinaryOpNode(left=node, operator=token, right=self.term())

        return node

class Interpreter:
    def visit(self, node: ASTNode) -> float:
        """Evaluate AST node"""
        if isinstance(node, NumberNode):
            return node.value

        elif isinstance(node, UnaryOpNode):
            operand = self.visit(node.operand)
            if node.operator.type == TokenType.PLUS:
                return +operand
            elif node.operator.type == TokenType.MINUS:
                return -operand

        elif isinstance(node, BinaryOpNode):
            left = self.visit(node.left)
            right = self.visit(node.right)

            if node.operator.type == TokenType.PLUS:
                return left + right
            elif node.operator.type == TokenType.MINUS:
                return left - right
            elif node.operator.type == TokenType.MULTIPLY:
                return left * right
            elif node.operator.type == TokenType.DIVIDE:
                if right == 0:
                    raise ValueError("Division by zero")
                return left / right

        raise ValueError(f"Unknown node type: {type(node)}")

# Usage example
def calculate(expression: str) -> float:
    lexer = Lexer(expression)
    parser = Parser(lexer)
    ast = parser.expr()
    interpreter = Interpreter()
    return interpreter.visit(ast)

# Test the calculator
test_expressions = [
    "2 + 3 * 4",
    "(2 + 3) * 4",
    "10 / 2 - 3",
    "-5 + 10",
    "3.14 * 2"
]

for expr in test_expressions:
    result = calculate(expr)
    print(f"{expr} = {result}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

import mmap
import struct
from typing import List, Dict

class X86JITCompiler:
    """Simple JIT compiler for basic arithmetic operations"""

    def __init__(self):
        # Allocate executable memory
        self.code_size = 4096
        self.memory = mmap.mmap(-1, self.code_size,
                               mmap.MAP_PRIVATE | mmap.MAP_ANONYMOUS,
                               mmap.PROT_READ | mmap.PROT_WRITE | mmap.PROT_EXEC)
        self.code_offset = 0

    def emit_byte(self, byte: int):
        """Emit a single byte to code memory"""
        self.memory[self.code_offset] = byte
        self.code_offset += 1

    def emit_bytes(self, bytes_list: List[int]):
        """Emit multiple bytes"""
        for byte in bytes_list:
            self.emit_byte(byte)

    def emit_int32(self, value: int):
        """Emit 32-bit integer in little-endian"""
        bytes_data = struct.pack('<I', value & 0xFFFFFFFF)
        for byte in bytes_data:
            self.emit_byte(byte)

    def compile_add_function(self, a: int, b: int) -> int:
        """Compile function that adds two numbers"""
        # Function prologue
        self.emit_bytes([0x55])          # push rbp
        self.emit_bytes([0x48, 0x89, 0xE5])  # mov rbp, rsp

        # Load immediate values
        self.emit_bytes([0xB8])          # mov eax, immediate
        self.emit_int32(a)

        self.emit_bytes([0x05])          # add eax, immediate
        self.emit_int32(b)

        # Function epilogue
        self.emit_bytes([0x5D])          # pop rbp
        self.emit_byte(0xC3)             # ret

        # Get function pointer
        import ctypes
        func_type = ctypes.CFUNCTYPE(ctypes.c_int)
        func_ptr = ctypes.cast(ctypes.addressof(ctypes.c_char.from_buffer(self.memory)),
                              func_type)

        return func_ptr()

    def cleanup(self):
        """Free allocated memory"""
        self.memory.close()

# Example usage (simplified - real implementation needs more error handling)
# jit = X86JITCompiler()
# result = jit.compile_add_function(10, 20)  # Returns 30
# jit.cleanup()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# Python's functools.singledispatch - method overloading example
from functools import singledispatch
import json
from typing import Any

@singledispatch
def serialize(obj: Any) -> str:
    """Generic serialization function"""
    return str(obj)

@serialize.register
def _(obj: dict) -> str:
    """Serialize dictionary to JSON"""
    return json.dumps(obj)

@serialize.register
def _(obj: list) -> str:
    """Serialize list to JSON"""
    return json.dumps(obj)

@serialize.register
def _(obj: int) -> str:
    """Serialize integer"""
    return str(obj)

@serialize.register
def _(obj: float) -> str:
    """Serialize float with precision"""
    return f"{obj:.6f}"

# Usage demonstrates Python's dynamic dispatch
test_objects = [
    42,
    3.14159,
    {"name": "John", "age": 30},
    [1, 2, 3, 4, 5],
    "regular string"
]

for obj in test_objects:
    print(f"{type(obj).__name__}: {serialize(obj)}")

# Note: Python's and/or operators cannot be overridden
# This is why pandas/numpy arrays raise "ambiguous truth value" errors
import numpy as np

try:
    arr = np.array([True, False, True])
    if arr:  # This raises ValueError
        print("This won't print")
except ValueError as e:
    print(f"Cannot override and/or: {e}")
    print("Use arr.any() or arr.all() instead")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Small-C example - minimal C subset
#include "stdio.h"

main() {
    int i, factorial;

    printf("Enter number: ");
    i = getnum();

    factorial = 1;
    while (i > 1) {
        factorial = factorial * i;
        i = i - 1;
    }

    printf("Factorial is: ");
    putnum(factorial);
    printf("\n");
}

// Small-C features:
// - Minimal subset of C
// - Single pass compiler
// - Stack-based code generation
// - Educational focus
// - Self-hosting capability

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# Python implementation of basic FORTH concepts
class ForthStack:
    def __init__(self):
        self.stack = []
        self.dictionary = {}
        self.setup_builtins()

    def setup_builtins(self):
        """Setup basic FORTH words"""
        self.dictionary.update({
            '+': lambda: self.stack.append(self.stack.pop() + self.stack.pop()),
            '-': lambda: self.stack.append(-self.stack.pop() + self.stack.pop()),
            '*': lambda: self.stack.append(self.stack.pop() * self.stack.pop()),
            '/': lambda: self.stack.append(int(self.stack.pop(-2) / self.stack.pop())),
            'dup': lambda: self.stack.append(self.stack[-1]),
            'drop': lambda: self.stack.pop(),
            'swap': lambda: self.stack.extend([self.stack.pop(), self.stack.pop()]),
            '.': lambda: print(self.stack.pop()),
            '.s': lambda: print(f"Stack: {self.stack}"),
        })

    def execute(self, word: str):
        """Execute a FORTH word"""
        if word.isdigit() or (word.startswith('-') and word[1:].isdigit()):
            self.stack.append(int(word))
        elif word in self.dictionary:
            self.dictionary[word]()
        else:
            raise ValueError(f"Unknown word: {word}")

    def interpret(self, source: str):
        """Interpret FORTH source code"""
        words = source.split()
        for word in words:
            self.execute(word)

# FORTH example
forth = ForthStack()
forth.interpret("5 3 + .")  # Prints: 8
forth.interpret("10 2 / 3 * .")  # Prints: 15
forth.interpret("1 2 3 .s")  # Prints: Stack: [1, 2, 3]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# Example type system implementation concepts
from typing import Union, Generic, TypeVar, Protocol
from abc import ABC, abstractmethod

T = TypeVar('T')
U = TypeVar('U')

class Type(ABC):
    """Base class for type representations"""
    pass

class PrimitiveType(Type):
    def __init__(self, name: str):
        self.name = name

    def __str__(self):
        return self.name

class FunctionType(Type):
    def __init__(self, param_types: list[Type], return_type: Type):
        self.param_types = param_types
        self.return_type = return_type

    def __str__(self):
        params = ", ".join(str(t) for t in self.param_types)
        return f"({params}) -> {self.return_type}"

class GenericType(Type):
    def __init__(self, name: str, type_params: list[Type]):
        self.name = name
        self.type_params = type_params

    def __str__(self):
        params = ", ".join(str(t) for t in self.type_params)
        return f"{self.name}<{params}>"

# Type checker interface
class TypeChecker(Protocol):
    def check_expression(self, expr: 'Expression') -> Type:
        ...

    def unify_types(self, type1: Type, type2: Type) -> bool:
        ...

# Example usage
int_type = PrimitiveType("int")
string_type = PrimitiveType("string")
add_func_type = FunctionType([int_type, int_type], int_type)
list_int_type = GenericType("List", [int_type])

print(f"Integer type: {int_type}")
print(f"Add function: {add_func_type}")
print(f"List of integers: {list_int_type}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

# Compiler error handling framework
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum

class Severity(Enum):
    INFO = "info"
    WARNING = "warning"
    ERROR = "error"
    FATAL = "fatal"

@dataclass
class SourceLocation:
    filename: str
    line: int
    column: int

    def __str__(self):
        return f"{self.filename}:{self.line}:{self.column}"

@dataclass
class Diagnostic:
    severity: Severity
    message: str
    location: SourceLocation
    suggestions: List[str] = None

    def __str__(self):
        result = f"{self.severity.value}: {self.message} at {self.location}"
        if self.suggestions:
            result += "\n  Suggestions: " + ", ".join(self.suggestions)
        return result

class DiagnosticCollector:
    def __init__(self):
        self.diagnostics: List[Diagnostic] = []
        self.error_count = 0
        self.warning_count = 0

    def add_error(self, message: str, location: SourceLocation, suggestions: List[str] = None):
        self.diagnostics.append(Diagnostic(Severity.ERROR, message, location, suggestions))
        self.error_count += 1

    def add_warning(self, message: str, location: SourceLocation, suggestions: List[str] = None):
        self.diagnostics.append(Diagnostic(Severity.WARNING, message, location, suggestions))
        self.warning_count += 1

    def has_errors(self) -> bool:
        return self.error_count > 0

    def print_diagnostics(self):
        for diagnostic in self.diagnostics:
            print(diagnostic)

        if self.error_count > 0 or self.warning_count > 0:
            print(f"\n{self.error_count} error(s), {self.warning_count} warning(s)")

# Usage example
collector = DiagnosticCollector()
loc = SourceLocation("example.py", 42, 15)

collector.add_error(
    "Undefined variable 'x'",
    loc,
    ["Did you mean 'y'?", "Check variable declaration"]
)

collector.add_warning(
    "Unused variable 'temp'",
    SourceLocation("example.py", 38, 8),
    ["Remove variable or use it"]
)

collector.print_diagnostics()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

# Performance monitoring for compiler phases
import time
import psutil
from contextlib import contextmanager
from typing import Dict, Any

@contextmanager
def phase_timer(phase_name: str, stats: Dict[str, Any]):
    """Time and memory profile compiler phases"""
    process = psutil.Process()
    start_time = time.perf_counter()
    start_memory = process.memory_info().rss

    try:
        yield
    finally:
        end_time = time.perf_counter()
        end_memory = process.memory_info().rss

        stats[phase_name] = {
            'time_seconds': end_time - start_time,
            'memory_delta_mb': (end_memory - start_memory) / 1024 / 1024,
            'peak_memory_mb': end_memory / 1024 / 1024
        }

class CompilerProfiler:
    def __init__(self):
        self.phase_stats: Dict[str, Any] = {}

    def time_phase(self, phase_name: str):
        return phase_timer(phase_name, self.phase_stats)

    def print_report(self):
        print("Compiler Performance Report:")
        print("-" * 50)

        total_time = sum(stats['time_seconds'] for stats in self.phase_stats.values())

        for phase, stats in self.phase_stats.items():
            time_pct = (stats['time_seconds'] / total_time) * 100
            print(f"{phase:20} {stats['time_seconds']:8.3f}s ({time_pct:5.1f}%) "
                  f"{stats['memory_delta_mb']:+7.1f}MB")

        print("-" * 50)
        print(f"{'Total':<20} {total_time:8.3f}s")

# Usage in compiler implementation
profiler = CompilerProfiler()

def compile_program(source_code: str):
    with profiler.time_phase("Lexical Analysis"):
        tokens = tokenize(source_code)

    with profiler.time_phase("Parsing"):
        ast = parse(tokens)

    with profiler.time_phase("Semantic Analysis"):
        typed_ast = type_check(ast)

    with profiler.time_phase("Code Generation"):
        code = generate_code(typed_ast)

    profiler.print_report()
    return code