# 字句解析の動作イメージ（Pythonで擬似実装）
 
# 入力ソースコード
source = 'let total = price * 1.08;'
 
# トークン化結果
tokens = [
    Token(type='KEYWORD',    value='let',     line=1, col=1),
    Token(type='IDENTIFIER', value='total',   line=1, col=5),
    Token(type='ASSIGN',     value='=',       line=1, col=11),
    Token(type='IDENTIFIER', value='price',   line=1, col=13),
    Token(type='MULTIPLY',   value='*',       line=1, col=19),
    Token(type='FLOAT',      value='1.08',    line=1, col=21),
    Token(type='SEMICOLON',  value=';',       line=1, col=25),
    Token(type='EOF',        value='',        line=1, col=26),
]

# トークンパターンの定義例
import re
from dataclasses import dataclass
from enum import Enum, auto
 
class TokenType(Enum):
    # リテラル
    INTEGER = auto()
    FLOAT = auto()
    STRING = auto()
 
    # 識別子とキーワード
    IDENTIFIER = auto()
    KEYWORD = auto()
 
    # 演算子
    PLUS = auto()
    MINUS = auto()
    MULTIPLY = auto()
    DIVIDE = auto()
    ASSIGN = auto()
    EQUAL = auto()        # ==
    NOT_EQUAL = auto()    # !=
    LESS_THAN = auto()
    GREATER_THAN = auto()
 
    # 区切り文字
    LPAREN = auto()
    RPAREN = auto()
    LBRACE = auto()
    RBRACE = auto()
    SEMICOLON = auto()
    COMMA = auto()
 
    # 特殊
    EOF = auto()
    NEWLINE = auto()
 
@dataclass
class Token:
    type: TokenType
    value: str
    line: int
    column: int
 
# トークンパターン（優先順位順）
TOKEN_PATTERNS = [
    (r'\s+',                         None),           # 空白（スキップ）
    (r'//[^\n]*',                    None),           # 行コメント（スキップ）
    (r'/\*[\s\S]*?\*/',              None),           # ブロックコメント
    (r'\d+\.\d+',                    TokenType.FLOAT),
    (r'\d+',                         TokenType.INTEGER),
    (r'"[^"]*"',                     TokenType.STRING),
    (r'==',                          TokenType.EQUAL),
    (r'!=',                          TokenType.NOT_EQUAL),
    (r'[a-zA-Z_][a-zA-Z0-9_]*',     None),           # 後で判定
    (r'\+',                          TokenType.PLUS),
    (r'-',                           TokenType.MINUS),
    (r'\*',                          TokenType.MULTIPLY),
    (r'/',                           TokenType.DIVIDE),
    (r'=',                           TokenType.ASSIGN),
    (r'\(',                          TokenType.LPAREN),
    (r'\)',                           TokenType.RPAREN),
    (r'\{',                          TokenType.LBRACE),
    (r'\}',                          TokenType.RBRACE),
    (r';',                           TokenType.SEMICOLON),
    (r',',                           TokenType.COMMA),
]
 
KEYWORDS = {'let', 'fn', 'if', 'else', 'while', 'for', 'return', 'true', 'false'}
 
class Lexer:
    def __init__(self, source: str):
        self.source = source
        self.pos = 0
        self.line = 1
        self.column = 1
 
    def tokenize(self) -> list[Token]:
        tokens = []
        while self.pos < len(self.source):
            matched = False
            for pattern, token_type in TOKEN_PATTERNS:
                match = re.match(pattern, self.source[self.pos:])
                if match:
                    value = match.group(0)
                    if token_type is not None:
                        tokens.append(Token(token_type, value, self.line, self.column))
                    elif token_type is None and re.match(r'[a-zA-Z_]', value):
                        # 識別子 or キーワード
                        t = TokenType.KEYWORD if value in KEYWORDS else TokenType.IDENTIFIER
                        tokens.append(Token(t, value, self.line, self.column))
 
                    # 位置を進める
                    for ch in value:
                        if ch == '\n':
                            self.line += 1
                            self.column = 1
                        else:
                            self.column += 1
                    self.pos += len(value)
                    matched = True
                    break
 
            if not matched:
                raise SyntaxError(
                    f"Unexpected character '{self.source[self.pos]}' "
                    f"at line {self.line}, column {self.column}"
                )
 
        tokens.append(Token(TokenType.EOF, '', self.line, self.column))
        return tokens

# Prattパーサの実装例（演算子優先順位パーサ）
# 算術式 "1 + 2 * 3 - 4 / 2" を正しくパースする
 
from dataclasses import dataclass
from typing import Union
 
@dataclass
class NumberNode:
    value: float
 
@dataclass
class BinaryOpNode:
    op: str
    left: 'ASTNode'
    right: 'ASTNode'
 
@dataclass
class UnaryOpNode:
    op: str
    operand: 'ASTNode'
 
ASTNode = Union[NumberNode, BinaryOpNode, UnaryOpNode]
 
class PrattParser:
    """Prattパーサ: 演算子の優先順位と結合性を簡潔に扱える"""
 
    # 演算子の優先順位（Binding Power）
    PRECEDENCE = {
        '+': (1, 2),    # (left_bp, right_bp)
        '-': (1, 2),
        '*': (3, 4),
        '/': (3, 4),
        '^': (6, 5),    # 右結合（right_bp < left_bp）
    }
 
    def __init__(self, tokens: list[Token]):
        self.tokens = tokens
        self.pos = 0
 
    def parse(self) -> ASTNode:
        return self.parse_expression(0)
 
    def parse_expression(self, min_bp: int) -> ASTNode:
        # Null Denotation（NUD）: 前置の解析
        token = self.tokens[self.pos]
        self.pos += 1
 
        if token.type == TokenType.INTEGER or token.type == TokenType.FLOAT:
            left = NumberNode(float(token.value))
        elif token.type == TokenType.MINUS:
            # 前置マイナス（単項演算子）
            operand = self.parse_expression(5)  # 高い優先順位
            left = UnaryOpNode('-', operand)
        elif token.type == TokenType.LPAREN:
            left = self.parse_expression(0)
            self.pos += 1  # skip ')'
        else:
            raise SyntaxError(f"Unexpected token: {token}")
 
        # Left Denotation（LED）: 中置の解析
        while self.pos < len(self.tokens):
            op_token = self.tokens[self.pos]
            if op_token.value not in self.PRECEDENCE:
                break
 
            left_bp, right_bp = self.PRECEDENCE[op_token.value]
            if left_bp < min_bp:
                break
 
            self.pos += 1
            right = self.parse_expression(right_bp)
            left = BinaryOpNode(op_token.value, left, right)
 
        return left
 
# 使用例
# "1 + 2 * 3" をパースすると:
# BinaryOpNode('+', NumberNode(1), BinaryOpNode('*', NumberNode(2), NumberNode(3)))
# つまり 1 + (2 * 3) = 7 と正しく解析される

# シンボルテーブルの実装例
class SymbolTable:
    """変数・関数のスコープとの紐づけを管理"""
 
    def __init__(self, parent=None):
        self.symbols: dict[str, dict] = {}
        self.parent: SymbolTable | None = parent
 
    def define(self, name: str, type_info: str, mutable: bool = True):
        if name in self.symbols:
            raise SemanticError(f"Variable '{name}' is already defined in this scope")
        self.symbols[name] = {
            'type': type_info,
            'mutable': mutable,
            'used': False,
        }
 
    def lookup(self, name: str) -> dict | None:
        """現在のスコープから親スコープへ向かって検索"""
        if name in self.symbols:
            self.symbols[name]['used'] = True
            return self.symbols[name]
        if self.parent:
            return self.parent.lookup(name)
        return None
 
    def check_unused(self) -> list[str]:
        """未使用の変数を検出（警告用）"""
        return [name for name, info in self.symbols.items() if not info['used']]
 
# 意味解析器
class SemanticAnalyzer:
    def __init__(self):
        self.scope = SymbolTable()  # グローバルスコープ
        self.errors: list[str] = []
        self.warnings: list[str] = []
 
    def enter_scope(self):
        self.scope = SymbolTable(parent=self.scope)
 
    def exit_scope(self):
        unused = self.scope.check_unused()
        for name in unused:
            self.warnings.append(f"Variable '{name}' is defined but never used")
        self.scope = self.scope.parent
 
    def analyze_assignment(self, name: str, value_type: str, declared_type: str = None):
        # 型チェック
        if declared_type and declared_type != value_type:
            self.errors.append(
                f"Type mismatch: cannot assign {value_type} to {declared_type}"
            )
            return
 
        # 変数の存在チェック
        existing = self.scope.lookup(name)
        if existing and not existing['mutable']:
            self.errors.append(f"Cannot reassign immutable variable '{name}'")

; LLVM IR の例: 2つの数値を加算する関数
 
; 関数定義: i32 add(i32 a, i32 b) { return a + b; }
define i32 @add(i32 %a, i32 %b) {
entry:
    %result = add i32 %a, %b
    ret i32 %result
}
 
; フィボナッチ関数（再帰版）
define i64 @fib(i64 %n) {
entry:
    %cmp = icmp sle i64 %n, 1
    br i1 %cmp, label %base, label %recursive
 
base:
    ret i64 %n
 
recursive:
    %n_minus_1 = sub i64 %n, 1
    %fib1 = call i64 @fib(i64 %n_minus_1)
    %n_minus_2 = sub i64 %n, 2
    %fib2 = call i64 @fib(i64 %n_minus_2)
    %result = add i64 %fib1, %fib2
    ret i64 %result
}
 
; LLVM IRの特徴:
; - SSA形式（Static Single Assignment）: 各変数は一度だけ代入される
; - 型付き: 全ての値が明示的な型を持つ
; - ターゲット非依存: x86, ARM, RISC-V 等に変換可能
; - 最適化パスが適用しやすい設計

// 最適化の実例: GCCの最適化レベルによるコード変化
 
// 元のCコード
int sum_array(const int* arr, int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        total += arr[i];
    }
    return total;
}
 
// -O0（最適化なし）: 素直にメモリアクセス
// 全ての変数がメモリ上に配置される
//   mov    DWORD PTR [rbp-4], 0      ; total = 0
//   mov    DWORD PTR [rbp-8], 0      ; i = 0
//   jmp    .L2
// .L3:
//   mov    eax, DWORD PTR [rbp-8]    ; i をロード
//   cdqe
//   lea    rdx, [0+rax*4]
//   mov    rax, DWORD PTR [rbp-24]   ; arr をロード
//   add    rax, rdx
//   mov    eax, DWORD PTR [rax]      ; arr[i] をロード
//   add    DWORD PTR [rbp-4], eax    ; total += arr[i]
//   add    DWORD PTR [rbp-8], 1      ; i++
// .L2:
//   cmp    ... ; i < n
 
// -O2（推奨最適化）: レジスタ活用、ベクトル化
// 変数はレジスタに配置、ループアンローリング適用
//   xor    eax, eax                  ; total = 0（レジスタ）
//   test   esi, esi                  ; n == 0?
//   jle    .done
// .loop:
//   add    eax, DWORD PTR [rdi]      ; total += *arr
//   add    rdi, 4                    ; arr++
//   dec    esi                       ; n--
//   jnz    .loop
// .done:
//   ret
 
// -O3（積極的最適化）: SIMD自動ベクトル化
// SSE/AVXを使って4個/8個を同時加算
//   vpxor  xmm0, xmm0, xmm0         ; 累積レジスタ = 0
// .loop:
//   vpaddd xmm0, xmm0, [rdi]        ; 4個同時加算
//   add    rdi, 16
//   dec    ecx
//   jnz    .loop
//   ; 水平加算で最終結果を得る

# 実際のコンパイルプロセスを段階的に確認する
 
# ステップ1: プリプロセス（マクロ展開、インクルード）
gcc -E main.c -o main.i
 
# ステップ2: コンパイル（C → アセンブリ）
gcc -S main.c -o main.s
 
# ステップ3: アセンブル（アセンブリ → オブジェクトファイル）
gcc -c main.c -o main.o
 
# ステップ4: リンク（オブジェクト → 実行可能バイナリ）
gcc main.o -o main
 
# 全て一括で実行
gcc main.c -o main
 
# LLVM/Clangの場合（IRを確認）
clang -S -emit-llvm main.c -o main.ll  # LLVM IR出力
clang -c -emit-llvm main.c -o main.bc  # LLVM ビットコード出力
llvm-dis main.bc                        # ビットコード → テキストIR
opt -O2 main.ll -o main_opt.ll         # IRレベルの最適化
llc main_opt.ll -o main.s               # IR → アセンブリ

# C/C++: Make / CMake
# Makefile の例
CC = gcc
CFLAGS = -Wall -O2
TARGET = myapp
SRCS = main.c util.c parser.c
OBJS = $(SRCS:.c=.o)
 
$(TARGET): $(OBJS)
	$(CC) $(CFLAGS) -o $@ $^
 
%.o: %.c
	$(CC) $(CFLAGS) -c -o $@ $<
 
clean:
	rm -f $(OBJS) $(TARGET)

# Rust: Cargo.toml
[package]
name = "myapp"
version = "0.1.0"
edition = "2021"
 
[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
 
[profile.release]
opt-level = 3      # 最大最適化
lto = true          # リンク時最適化
codegen-units = 1   # 単一コード生成ユニット（最適化に有利）
strip = true        # シンボル除去（バイナリサイズ削減）

// Go: go.mod
module example.com/myapp
 
go 1.22
 
require (
    github.com/gin-gonic/gin v1.9.1
    gorm.io/gorm v1.25.5
)

# Rustのコンパイル速度改善の実例
 
# sccache の導入
cargo install sccache
export RUSTC_WRAPPER=sccache
 
# cranelift バックエンド（デバッグビルドを高速化）
# .cargo/config.toml
# [unstable]
# codegen-backend = true
# [profile.dev]
# codegen-backend = "cranelift"
 
# 依存クレートの事前ビルド
cargo build  # 初回は全依存をビルド（遅い）
cargo build  # 2回目は差分のみ（速い）
 
# mold リンカーの使用（リンク時間を大幅短縮）
# .cargo/config.toml
# [target.x86_64-unknown-linux-gnu]
# linker = "clang"
# rustflags = ["-C", "link-arg=-fuse-ld=mold"]

# Python のコードは内部的にバイトコードにコンパイルされる
import dis
 
def add(a, b):
    return a + b
 
dis.dis(add)
# 出力:
#   LOAD_FAST   0 (a)
#   LOAD_FAST   1 (b)
#   BINARY_ADD
#   RETURN_VALUE
 
# .pyc ファイル = コンパイル済みバイトコード
# __pycache__/ に自動キャッシュされる

# より複雑な関数のバイトコードを確認
import dis
 
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)
 
dis.dis(fibonacci)
# 出力例:
#   0 LOAD_FAST                0 (n)
#   2 LOAD_CONST               1 (1)
#   4 COMPARE_OP               1 (<=)
#   6 POP_JUMP_IF_FALSE       12
#   8 LOAD_FAST                0 (n)
#  10 RETURN_VALUE
#  12 LOAD_GLOBAL              0 (fibonacci)
#  14 LOAD_FAST                0 (n)
#  16 LOAD_CONST               1 (1)
#  18 BINARY_SUBTRACT
#  20 CALL_FUNCTION            1
#  22 LOAD_GLOBAL              0 (fibonacci)
#  24 LOAD_FAST                0 (n)
#  26 LOAD_CONST               2 (2)
#  28 BINARY_SUBTRACT
#  30 CALL_FUNCTION            1
#  32 BINARY_ADD
#  34 RETURN_VALUE
 
# バイトコードを直接操作する（上級テクニック）
import types
 
code = fibonacci.__code__
print(f"定数: {code.co_consts}")
print(f"変数名: {code.co_varnames}")
print(f"スタック深度: {code.co_stacksize}")
print(f"バイトコード: {code.co_code.hex()}")

# CPythonのGILとは:
# - CPythonインタプリタ全体を保護するロック
# - 一度に1つのスレッドしかPythonバイトコードを実行できない
# - CPU バウンドな処理ではマルチスレッドの恩恵が受けられない
 
import threading
import time
 
# CPUバウンドタスク: GILによりマルチスレッドが効かない
def cpu_bound_task(n):
    total = 0
    for i in range(n):
        total += i * i
    return total
 
# シングルスレッド
start = time.time()
cpu_bound_task(10_000_000)
cpu_bound_task(10_000_000)
single_time = time.time() - start
 
# マルチスレッド（GILのせいで速くならない）
start = time.time()
t1 = threading.Thread(target=cpu_bound_task, args=(10_000_000,))
t2 = threading.Thread(target=cpu_bound_task, args=(10_000_000,))
t1.start(); t2.start()
t1.join(); t2.join()
multi_time = time.time() - start
 
print(f"シングルスレッド: {single_time:.2f}s")
print(f"マルチスレッド:   {multi_time:.2f}s")  # ほぼ同じか遅い
 
# 解決策1: multiprocessing（プロセス分離）
from multiprocessing import Pool
 
start = time.time()
with Pool(2) as p:
    results = p.map(cpu_bound_task, [10_000_000, 10_000_000])
process_time = time.time() - start
print(f"マルチプロセス:   {process_time:.2f}s")  # 約2倍速
 
# 解決策2: I/Oバウンドタスクなら asyncio
import asyncio
import aiohttp
 
async def fetch_urls(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [session.get(url) for url in urls]
        responses = await asyncio.gather(*tasks)
        return responses
 
# 解決策3: Python 3.13+ の free-threaded mode (PEP 703)
# GILを無効化してマルチスレッドを活用可能にする実験的機能
# python3.13t script.py  # GILなしモード

# Ruby のバイトコードを確認する
code = RubyVM::InstructionSequence.compile("puts 1 + 2")
puts code.disasm
# 出力例:
# == disasm: #<ISeq:<compiled>@<compiled>:1 (1,0)-(1,12)>==========
# 0000 putself                                                          (   1)[Li]
# 0001 putobject_INT2FIX_1_
# 0002 putobject                    2
# 0004 opt_plus                     <calldata!mid:+, argc:1, ARGS_SIMPLE>[CcCr]
# 0006 opt_send_without_block       <calldata!mid:puts, argc:1, FCALL|ARGS_SIMPLE>
# 0008 leave
 
# Ruby 3.x の YJIT（Yet Another JIT）
# JIT コンパイラが組み込まれている
# ruby --yjit script.rb  # YJIT有効化
# Ruby 3.3以降はデフォルトで有効

-- Lua: 非常に軽量なバイトコードインタプリタ
-- レジスタベースVM（スタックベースより高効率）
 
-- LuaJIT: トレーシングJITによる最高レベルの性能
-- 動的言語としては異例の実行速度を達成
 
-- Luaが組み込み用途で人気の理由:
-- 1. インタプリタが非常に小さい（〜200KB）
-- 2. C APIが優秀（ホスト言語との統合が容易）
-- 3. メモリ消費が少ない
-- 4. LuaJITの性能がCに迫る
 
-- ゲームエンジン、Webサーバー（OpenResty）、
-- ネットワーク機器、RedisのスクリプトなどでLuaは広く使われる

# Pythonの対話型環境は探索的プログラミングに最適
 
# 標準REPL
$ python3
>>> import json
>>> data = {"name": "Alice", "age": 30}
>>> json.dumps(data, indent=2)
'{\n  "name": "Alice",\n  "age": 30\n}'
 
# IPython: 強化版REPL
$ ipython
In [1]: import pandas as pd
In [2]: df = pd.read_csv("sales.csv")
In [3]: df.describe()  # データの統計情報を即座に確認
In [4]: %timeit df.sort_values("amount")  # ベンチマーク
In [5]: %debug  # 直前の例外をデバッグ
 
# Jupyter Notebook: ブラウザベースの対話環境
# データ分析・可視化・ドキュメンテーションを統合

// Node.jsのREPL
$ node
> const arr = [1, 2, 3, 4, 5]
> arr.filter(x => x % 2 === 0).map(x => x * x)
[ 4, 16 ]
> .help  // ヘルプ表示
> .exit  // 終了

// V8（JavaScript）のJIT最適化の例
 
// 型が安定している関数 → 最適化されやすい
function add(a, b) {
    return a + b;
}
 
// 常にnumber型で呼ばれる → 高速な機械語に変換
for (let i = 0; i < 1000000; i++) {
    add(i, i + 1);  // → 整数加算の機械語に最適化
}
 
// 途中で型が変わると脱最適化（deoptimization）が発生
add("hello", " world");  // → string型！前提が崩れる
// JITコンパイラは最適化されたコードを破棄し、再インタプリタに戻る
 
// === V8が最適化しやすいコードの書き方 ===
 
// Good: 型が安定している
function calculateTotal(items) {
    let total = 0;                    // 常にnumber
    for (let i = 0; i < items.length; i++) {
        total += items[i].price;      // 常にnumber
    }
    return total;
}
 
// Bad: 型が不安定（Hidden Class が変化する）
function createUser(name, age) {
    const user = {};
    user.name = name;   // Hidden Class 変化
    user.age = age;     // Hidden Class 変化
    if (age > 18) {
        user.adult = true;  // 条件付きプロパティ → Hidden Class 分岐
    }
    return user;
}
 
// Good: プロパティを最初から全て定義
function createUser(name, age) {
    return {
        name: name,
        age: age,
        adult: age > 18,   // 常に存在 → Hidden Class が安定
    };
}

// JVMのJIT最適化を確認するフラグ
 
// JITコンパイルのログを表示
// java -XX:+PrintCompilation MyApp
 
// 出力例:
//   42   1       java.lang.String::hashCode (55 bytes)
//   43   2       java.util.HashMap::hash (20 bytes)
//   44   3 %     MyApp::hotLoop @ 5 (30 bytes)
//
// %: OSR（On-Stack Replacement）コンパイル
// 数字: コンパイルレベル
 
// インライン展開の閾値を変更
// java -XX:InlineSmallCode=2000 MyApp
 
// エスケープ解析の有効化（デフォルトで有効）
// java -XX:+DoEscapeAnalysis MyApp
 
// GraalVM の Native Image（AOTコンパイル）
// native-image -jar myapp.jar
// → 起動時間: JVM 数百ms → Native Image 数十ms
// → メモリ: JVM 数百MB → Native Image 数十MB

# PyPy は CPython より 10-100 倍高速な場合がある
 
# CPython で遅いコードが PyPy で高速化される例
def matrix_multiply(a, b, n):
    """n×n 行列の乗算（純粋Python実装）"""
    result = [[0] * n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            for k in range(n):
                result[i][j] += a[i][k] * b[k][j]
    return result
 
# CPython: 約10秒（n=500）
# PyPy:    約0.3秒（n=500）
# NumPy:   約0.01秒（n=500）← C拡張なのでどちらでも高速
 
# PyPyが高速な理由:
# 1. トレーシングJIT: ホットループを検出して機械語に変換
# 2. 型特殊化: ループ内の変数型を固定してチェックを省略
# 3. ボクシング除去: int/float をヒープ確保せずレジスタで扱う
# 4. ループ最適化: ガードの巻き上げ、ベクトル化
 
# PyPyの制限:
# - C拡張との互換性問題（CPython API に依存するライブラリ）
# - 起動時間が CPython より遅い（JITのウォームアップ）
# - メモリ消費が CPython より多い場合がある

// .NET の実行パイプライン
// C# ソースコード → Roslyn コンパイラ → CIL (Common Intermediate Language)
// → RyuJIT (JIT コンパイラ) → ネイティブ機械語
 
// CILの例（IL DASM で確認可能）
// .method public static int32 Add(int32 a, int32 b) cil managed
// {
//     .maxstack 2
//     ldarg.0      // a をスタックにプッシュ
//     ldarg.1      // b をスタックにプッシュ
//     add          // 加算
//     ret          // 結果を返す
// }
 
// .NET 8 の AOT コンパイル
// dotnet publish -r linux-x64 -c Release /p:PublishAot=true
// → ネイティブバイナリを生成（JVMのGraalVM native-imageに相当）
 
// .NET の階層的コンパイル
// Tier 0: 最小限の最適化（高速起動）
// Tier 1: フルJIT最適化（ホットメソッド）
// R2R (Ready to Run): AOT + JIT のハイブリッド

// Rust → Wasm のコンパイル例
 
// lib.rs
#[no_mangle]
pub extern "C" fn fibonacci(n: i32) -> i32 {
    if n <= 1 {
        return n;
    }
    fibonacci(n - 1) + fibonacci(n - 2)
}
 
// ビルドコマンド
// cargo build --target wasm32-unknown-unknown --release
 
// wasm-bindgen を使った JavaScript との連携
// use wasm_bindgen::prelude::*;
//
// #[wasm_bindgen]
// pub fn greet(name: &str) -> String {
//     format!("Hello, {}!", name)
// }

// JavaScript から Wasm を呼び出す
 
// 方法1: fetch + instantiate
async function loadWasm() {
    const response = await fetch('fibonacci.wasm');
    const bytes = await response.arrayBuffer();
    const { instance } = await WebAssembly.instantiate(bytes);
 
    const result = instance.exports.fibonacci(40);
    console.log(`fib(40) = ${result}`);
}
 
// 方法2: ストリーミングコンパイル（推奨）
async function loadWasmStreaming() {
    const { instance } = await WebAssembly.instantiateStreaming(
        fetch('fibonacci.wasm')
    );
    return instance.exports;
}
 
// Wasm の線形メモリを使ったデータ共有
async function processArray() {
    const { instance } = await WebAssembly.instantiateStreaming(
        fetch('processor.wasm')
    );
 
    const memory = instance.exports.memory;
    const buffer = new Float64Array(memory.buffer, 0, 1000);
 
    // JavaScript側でデータを書き込み
    for (let i = 0; i < 1000; i++) {
        buffer[i] = Math.random();
    }
 
    // Wasm側で高速に処理
    const result = instance.exports.process_array(1000);
    console.log(`Result: ${result}`);
}

# WASIを使ったコマンドラインツールの例
 
# Rustで書いたプログラムをWASI向けにコンパイル
cargo build --target wasm32-wasi --release
 
# Wasmtime で実行
wasmtime target/wasm32-wasi/release/myapp.wasm
 
# ファイルアクセスの許可（サンドボックス）
wasmtime --dir=/tmp target/wasm32-wasi/release/myapp.wasm
 
# ネットワークアクセスの許可
wasmtime --tcplisten=127.0.0.1:8080 target/wasm32-wasi/release/server.wasm

// TypeScript → JavaScript のトランスパイル例
 
// TypeScript ソースコード
interface User {
    name: string;
    age: number;
    email?: string;
}
 
function greetUser(user: User): string {
    const greeting = `Hello, ${user.name}!`;
    if (user.age >= 18) {
        return `${greeting} Welcome, adult user.`;
    }
    return `${greeting} Welcome, young user.`;
}
 
const users: User[] = [
    { name: "Alice", age: 30, email: "alice@example.com" },
    { name: "Bob", age: 16 },
];
 
const messages = users.map(greetUser);
 
// トランスパイル後の JavaScript（ES2020ターゲット）
"use strict";
function greetUser(user) {
    const greeting = `Hello, ${user.name}!`;
    if (user.age >= 18) {
        return `${greeting} Welcome, adult user.`;
    }
    return `${greeting} Welcome, young user.`;
}
const users = [
    { name: "Alice", age: 30, email: "alice@example.com" },
    { name: "Bob", age: 16 },
];
const messages = users.map(greetUser);
 
// 注目点:
// - interfaceは完全に消える（型情報は実行時には不要）
// - 関数の型注釈も消える
// - ロジックはそのまま保持される
// - TypeScriptの価値は「コンパイル時の型チェック」にある

# 演習: 以下の関数のバイトコードを dis.dis() で確認せよ
import dis
 
# 関数1: 単純な条件分岐
def max_value(a, b):
    if a > b:
        return a
    return b
 
# 関数2: リスト内包表記
def square_evens(numbers):
    return [n * n for n in numbers if n % 2 == 0]
 
# 関数3: ジェネレータ
def fibonacci_gen():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
 
# それぞれの関数のバイトコードを確認
print("=== max_value ===")
dis.dis(max_value)
print("\n=== square_evens ===")
dis.dis(square_evens)
print("\n=== fibonacci_gen ===")
dis.dis(fibonacci_gen)
 
# 考察ポイント:
# - COMPARE_OP, POP_JUMP_IF_FALSE の動作
# - リスト内包表記の内部実装（別関数として生成される）
# - yield のバイトコード表現

# benchmark.py: CPythonとPyPyで実行して比較せよ
import time
 
def benchmark_loop(n):
    """純粋なCPU計算（JITの恩恵を最も受けやすい）"""
    total = 0
    for i in range(n):
        if i % 2 == 0:
            total += i * i
        else:
            total -= i
    return total
 
def benchmark_string(n):
    """文字列操作（メモリ確保が頻繁）"""
    result = ""
    for i in range(n):
        result += str(i)
    return len(result)
 
def benchmark_dict(n):
    """辞書操作（ハッシュテーブル）"""
    d = {}
    for i in range(n):
        d[i] = i * i
    total = sum(d.values())
    return total
 
benchmarks = [
    ("Loop computation", benchmark_loop, 10_000_000),
    ("String concatenation", benchmark_string, 100_000),
    ("Dictionary operations", benchmark_dict, 1_000_000),
]
 
for name, func, n in benchmarks:
    start = time.time()
    result = func(n)
    elapsed = time.time() - start
    print(f"{name}: {elapsed:.3f}s (result={result})")
 
# 実行方法:
# python3 benchmark.py     # CPython
# pypy3 benchmark.py       # PyPy

# 演習: 以下のインタプリタを拡張せよ
# 1. 変数の代入と参照を追加（let x = 10; x + 5）
# 2. 比較演算子を追加（==, !=, <, >）
# 3. if-else 文を追加
# 4. 関数定義と呼び出しを追加
 
from dataclasses import dataclass
from typing import Union
 
# === AST ノード ===
@dataclass
class Number:
    value: float
 
@dataclass
class BinaryOp:
    op: str
    left: 'Expr'
    right: 'Expr'
 
@dataclass
class UnaryOp:
    op: str
    operand: 'Expr'
 
Expr = Union[Number, BinaryOp, UnaryOp]
 
# === 字句解析器 ===
def tokenize(source: str) -> list[str]:
    tokens = []
    i = 0
    while i < len(source):
        if source[i].isspace():
            i += 1
        elif source[i].isdigit() or source[i] == '.':
            j = i
            while j < len(source) and (source[j].isdigit() or source[j] == '.'):
                j += 1
            tokens.append(source[i:j])
            i = j
        elif source[i] in '+-*/()':
            tokens.append(source[i])
            i += 1
        else:
            raise SyntaxError(f"Unexpected character: {source[i]}")
    return tokens
 
# === 構文解析器（再帰下降） ===
class Parser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.pos = 0
 
    def peek(self):
        if self.pos < len(self.tokens):
            return self.tokens[self.pos]
        return None
 
    def consume(self):
        token = self.tokens[self.pos]
        self.pos += 1
        return token
 
    def parse(self):
        result = self.expression()
        if self.pos < len(self.tokens):
            raise SyntaxError(f"Unexpected token: {self.peek()}")
        return result
 
    def expression(self):
        left = self.term()
        while self.peek() in ('+', '-'):
            op = self.consume()
            right = self.term()
            left = BinaryOp(op, left, right)
        return left
 
    def term(self):
        left = self.unary()
        while self.peek() in ('*', '/'):
            op = self.consume()
            right = self.unary()
            left = BinaryOp(op, left, right)
        return left
 
    def unary(self):
        if self.peek() == '-':
            self.consume()
            operand = self.factor()
            return UnaryOp('-', operand)
        return self.factor()
 
    def factor(self):
        token = self.peek()
        if token == '(':
            self.consume()
            expr = self.expression()
            if self.consume() != ')':
                raise SyntaxError("Expected ')'")
            return expr
        else:
            self.consume()
            return Number(float(token))
 
# === 評価器 ===
def evaluate(node: Expr) -> float:
    match node:
        case Number(value):
            return value
        case BinaryOp('+', left, right):
            return evaluate(left) + evaluate(right)
        case BinaryOp('-', left, right):
            return evaluate(left) - evaluate(right)
        case BinaryOp('*', left, right):
            return evaluate(left) * evaluate(right)
        case BinaryOp('/', left, right):
            divisor = evaluate(right)
            if divisor == 0:
                raise ZeroDivisionError("Division by zero")
            return evaluate(left) / divisor
        case UnaryOp('-', operand):
            return -evaluate(operand)
 
# === REPL ===
def repl():
    print("Simple Calculator (type 'quit' to exit)")
    while True:
        try:
            line = input(">>> ")
            if line.strip().lower() == 'quit':
                break
            tokens = tokenize(line)
            ast = Parser(tokens).parse()
            result = evaluate(ast)
            print(f"= {result}")
        except Exception as e:
            print(f"Error: {e}")
 
if __name__ == "__main__":
    repl()

# 演習: RustのコードをWasmにコンパイルしてブラウザで実行する
 
# 1. ツールのインストール
# rustup target add wasm32-unknown-unknown
# cargo install wasm-pack
 
# 2. プロジェクト作成
# cargo new --lib wasm-demo
# cd wasm-demo
 
# 3. Cargo.toml に追加
# [lib]
# crate-type = ["cdylib"]
# [dependencies]
# wasm-bindgen = "0.2"
 
# 4. src/lib.rs を編集
# use wasm_bindgen::prelude::*;
#
# #[wasm_bindgen]
# pub fn fibonacci(n: u32) -> u64 {
#     match n {
#         0 => 0,
#         1 => 1,
#         _ => {
#             let mut a: u64 = 0;
#             let mut b: u64 = 1;
#             for _ in 2..=n {
#                 let temp = a + b;
#                 a = b;
#                 b = temp;
#             }
#             b
#         }
#     }
# }
 
# 5. ビルド
# wasm-pack build --target web
 
# 6. HTMLから呼び出す（index.html）
# <script type="module">
#     import init, { fibonacci } from './pkg/wasm_demo.js';
#     await init();
#     console.log(fibonacci(50));
# </script>