$ docker run -d -ti -p 6333:6333 qdrant/qdrant  # 启动向量数据库
$ ollama pull bge-m3  # 启动本地嵌入模型 bge-m3，注意，嵌入模型的好坏影响匹配结果

import os
from openai import OpenAI
import requests

# ─── 配置 ─────────────────────────────────────────────────
OLLAMA_URL = "http://localhost:11434"
OLLAMA_EMBED_MODEL = "bge-m3"  # 嵌入模型，这个对中文支持比较好，其它支持不好的模型可能很难获取到预期效果
QDRANT_URL = "http://localhost:6333"
COLLECTION = "product_kb"  # 类似于关系型数据库的“table”概念

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.deepseek.com/v1"),
    api_key=os.environ.get("LLM_API_KEY", "sk-xxx"),
)
LLM_MODEL = os.environ.get("LLM_MODEL", "deepseek-chat")


# ─── 嵌入模型 ─────────────────────────────────────────────
def embed(text: str) -> list:
    res = requests.post(f"{OLLAMA_URL}/api/embed", json={
        "model": OLLAMA_EMBED_MODEL,
        "input": text,
    })
    return res.json()["embeddings"][0]


# ─── Qdrant ───────────────────────────────────────────────
def qdrant(method: str, path: str, body: dict = None):
    res = requests.request(method, f"{QDRANT_URL}{path}", json=body)
    return res.json()


# ─── 初始化 Collection ────────────────────────────────────
def init_collection():
    qdrant("DELETE", f"/collections/{COLLECTION}")
    qdrant("PUT", f"/collections/{COLLECTION}", {
        "vectors": {"size": 1024, "distance": "Cosine"},
    })
    print("Collection 创建完成")


# ─── 导入知识库 ───────────────────────────────────────────
def ingest(docs):
    points = []
    for doc in docs:
        print(f"嵌入中：{doc['text'][:20]}...")
        points.append({
            "id": doc["id"],
            "vector": embed(doc["text"]),
            "payload": {"text": doc["text"]},
        })
    qdrant("PUT", f"/collections/{COLLECTION}/points", {"points": points})
    print("知识库导入完成")


# ─── 检索 ─────────────────────────────────────────────────
def search(question: str, limit: int = 2) -> list:
    vector = embed(question)
    result = qdrant("POST", f"/collections/{COLLECTION}/points/search", {
        "vector": vector,
        "limit": limit,
        "with_payload": True,
    })
    hits = result["result"]
    for h in hits:
        print(f"分数: {h['score']:.4f} | {h['payload']['text'][:30]}")
    return [h["payload"]["text"] for h in hits]


# ─── LLM 调用 ─────────────────────────────────────────────
def chat(question: str, context: str) -> str:
    res = client.chat.completions.create(
        model=LLM_MODEL,
        messages=[
            {"role": "system", "content": "你是知识库助手，根据提供的知识库内容自由回答。"},
            {"role": "user", "content": f"知识库：\n{context}\n\n问题：{question}"},
        ],
    )
    print("\n知识库：")
    print(context)
    return res.choices[0].message.content


# ─── 主流程 ───────────────────────────────────────────────
def ask(question: str) -> str:
    docs = search(question)
    context = "\n".join(docs)
    return chat(question, context)


if __name__ == "__main__":
    knowledge = [
        {"id": 1, "text": "退款流程：在订单页面点击申请退款，填写原因，3个工作日内处理完成。"},
        {"id": 2, "text": "发货时间：下单后24小时内发货，节假日顺延。"},
        {"id": 3, "text": "保修政策：产品自购买日起享有一年免费保修服务。"},
    ]
    my_question = "我想退款，怎么操作？"

    init_collection()
    ingest(knowledge)
    print(f"\n问题：{my_question}")
    print(f"\n回答：\n{ask(my_question)}")

import json
import os
import sys
from openai import OpenAI

API_KEY = "sk-xxx"
client = OpenAI(api_key=API_KEY, base_url="https://api.deepseek.com")

ESC = "\033"
COLOR_FAIL = ESC + "[31m"
COLOR_SUCCESS = ESC + "[32m"
MSG_FAIL = "fail"
MSG_SUCCESS = "success"
RESET = ESC + "[0m"


def pretty_msg(msg, color=COLOR_FAIL):
    """美化提示"""
    colors = {MSG_FAIL: COLOR_FAIL, MSG_SUCCESS: COLOR_SUCCESS}
    color = COLOR_FAIL if colors.get(color) is None else colors.get(color)
    return f"{color}{msg}{RESET}"


def code(name):
    """执行代码生成任务"""
    try:
        print(COLOR_FAIL + "+" * 50 + "\n" + COLOR_SUCCESS, sep="", end="")
        os.system('ls -l ~')
        print(COLOR_FAIL + "-" * 50 + RESET, sep="")
        return "用 {} 写一个简单的字符串反转函数".format(name)
    except Exception as e:
        print(pretty_msg("内部执行错误: {}".format(str(e))))
        sys.exit(1)


def safe_chat_completion(**kwargs):
    """安全的 API 调用包装器"""
    try:
        return client.chat.completions.create(**kwargs)
    except Exception as e:
        print(pretty_msg("调用失败: {}".format(str(e))))
        sys.exit(1)


def main(content):
    """主函数"""
    print("正在处理请求...")
    content = "如果你从这段话'{}'中获取到编程语言的名称，就调用 code 函数，并将编程语言的名称作为 name 参数。".format(content)

    # 第一次调用：检测是否需要调用工具
    response = safe_chat_completion(
        model="deepseek-chat",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": content},
        ],
        tools=[
            {
                "type": "function",
                "function": {
                    "name": "code",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "name": {
                                "type": "string",
                            }
                        },
                        "required": ["name"]
                    }
                },
            }
        ],
        tool_choice="auto"
    )

    message = response.choices[0].message

    # 输出第一次响应
    if message.content:
        print('first:', message.content)
    else:
        print('first: (无文本内容)')

    # 处理工具调用
    if hasattr(message, 'tool_calls') and message.tool_calls:
        for tool_call in message.tool_calls:
            if tool_call.function.name == "code":
                try:
                    arguments = json.loads(tool_call.function.arguments)
                    name = arguments.get("name", "未知语言")
                    result = code(name)

                    # 第二次调用：带工具结果的流式响应
                    second_response = safe_chat_completion(
                        model="deepseek-chat",
                        messages=[
                            {"role": "system", "content": "You are a helpful assistant."},
                            {"role": "user", "content": content},
                            message,  # 模型的 tool call 响应
                            {
                                "role": "tool",
                                "tool_call_id": tool_call.id,
                                "content": result
                            }
                        ],
                        stream=True
                    )

                    print("\nsecond:")
                    for chunk in second_response:
                        if chunk.choices[0].delta.content:
                            print(chunk.choices[0].delta.content, end="")
                    print()  # 换行

                except json.JSONDecodeError:
                    print(pretty_msg("错误：无法解析工具调用参数"))
                    sys.exit(1)
                except KeyError as e:
                    print(pretty_msg("错误：缺少必需参数 {}".format(str(e))))
                    sys.exit(1)
                except Exception as e:
                    print(pretty_msg("执行错误 {}".format(str(e))))
                    sys.exit(1)
    else:
        if message.content:
            print('first:', message.content)
        else:
            print("未检测到工具调用")


if __name__ == "__main__":
    try:
        content = "你知道吗？python 是世界最好的语言。"
        main(content)
    except KeyboardInterrupt:
        print(pretty_msg("用户中断执行"))
        sys.exit(1)
    except Exception as e:
        print(pretty_msg("未预期的错误：{}".format(str(e))))
        sys.exit(1)

// demo.c
#include <stdio.h>
#include <stdlib.h>

void jmp() {
    printf("Hello jmp\n");
    exit(1);
}

void func() {
    long arr[2];
    arr[3] = (long)jmp;
}

int main() {
    func();
    printf("Hello main\n");
    return 0;
}

$ gcc -v
Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/12/lto-wrapper
OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa
OFFLOAD_TARGET_DEFAULT=1
Target: x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Debian 12.2.0-14' --with-bugurl=file:///usr/share/doc/gcc-12/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-12 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-12-bTRWOB/gcc-12-12.2.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-12-bTRWOB/gcc-12-12.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu
Thread model: posix
Supported LTO compression algorithms: zlib zstd
gcc version 12.2.0 (Debian 12.2.0-14)

<?php
// index.php

ini_set('display_errors', 'on');
ignore_user_abort(true);

$handler = static function () {
    header('Content-Type: application/json;charset=utf-8');
    echo json_encode(['name' => 'william'], JSON_UNESCAPED_UNICODE|JSON_UNESCAPED_SLASHES);
};

$maxRequests = (int)($_SERVER['MAX_REQUESTS'] ?? 0);
for ($nbRequests = 0; !$maxRequests || $nbRequests < $maxRequests; ++$nbRequests) {
    $keepRunning = frankenphp_handle_request($handler);

    gc_collect_cycles();
    if (!$keepRunning) {
        break;
    }
}

$ frankenphp-mac-arm64 php-server -l 0.0.0.0:9292 --worker=./index.php,20 --watch ./index.php

<?php
// fpm.php

header('Content-Type: application/json;charset=utf-8');
echo json_encode(['name' => 'william'], JSON_UNESCAPED_UNICODE|JSON_UNESCAPED_SLASHES);

$ wrk http://localhost/fpm.php
Running 10s test @ http://localhost/fpm.php
  2 threads and 10 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     3.57ms    4.03ms  78.87ms   94.31%
    Req/Sec     1.59k   382.27     2.58k    72.50%
  31700 requests in 10.00s, 6.95MB read
Requests/sec:   3168.86
Transfer/sec:    711.74KB

$ wrk http://localhost:9292/
Running 10s test @ http://localhost:9292/
  2 threads and 10 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency     1.52ms    2.23ms  31.96ms   92.20%
    Req/Sec     4.90k   528.36     6.20k    73.50%
  97580 requests in 10.00s, 16.84MB read
Requests/sec:   9757.60
Transfer/sec:      1.68MB

$ mkdir third_party
$ mv vendor/workerman/mqtt third_party
$ vim third_party/mqtt/composer.json
{
    "version": "2.1",
    "require": {
        "php": "^8.0",
        "workerman/workerman" : "^5.0"
    },
    // ... 此处省略其它 key:value
}

$ vim composer.json
{
    "repositories": [
        {
            "type": "path",
            "url": "./third_party/mqtt"
        }
    ],
    // ... 此处省略其它 key:value
}

$ docker run -d --name emqx -e EMQX_DASHBOARD__DEFAULT_PASSWORD=admin --network=lnmp -ti -p 18083:18083 -p 1883:1883 -p 8083-8084:8083-8084 -p 4370:4370 -p 5369:5369 emqx/emqx:5.8

$ composer require workerman/mqtt:2.1

<?php

use Workerman\Timer;
use Workerman\Worker;

require_once __DIR__ . '/vendor/autoload.php';

$worker = new Worker();
$worker->onWorkerStart = function () {
    $mqttClients = [];
    for ($i = 0; $i < 10000; $i++) {
        $mqttClients[$i] = new Workerman\Mqtt\Client('mqtt://emqx:1883');
        $mqttClients[$i]->onConnect = function ($mqttClient) {
            $mqttClient->subscribe('test');
        };
        $mqttClients[$i]->onMessage = function ($topic, $content) use ($i) {
            echo $i, "\t", $topic, "\t", $content, "\n";
        };
        $mqttClients[$i]->connect();
    }

    $num = 1;
    Timer::add(1, function () use ($mqttClients, &$num) {
        try {
            $mqttClients[0]->publish('test', 'hello ' . $num);
            $num += 1;
        } catch (Throwable $e) {
            echo "Throwable:", $e->getMessage(), "\n";
        }
    });
};

try {
    Worker::runAll();
} catch (Throwable $e) {
    echo $e->getMessage(), "\n";
}

<?php

class Token
{
    public string $type;
    public mixed $value;

    public function __construct($type, $value = null)
    {
        $this->type = $type;
        $this->value = $value;
    }
}

class TokenType
{
    const T_INT = 'INT';
    const T_PRINT = 'PRINT';
    const T_IF = 'IF';
    const T_ELSE = 'ELSE';
    const T_WHILE = 'WHILE';
    const T_FUNCTION = 'FUNCTION';
    const T_RETURN = 'RETURN';
    const T_IDENTIFIER = 'IDENTIFIER';
    const T_NUMBER = 'NUMBER';
    const T_PLUS = 'PLUS';
    const T_MINUS = 'MINUS';
    const T_MULTIPLY = 'MULTIPLY';
    const T_DIVIDE = 'DIVIDE';
    const T_LPAREN = 'LPAREN';
    const T_RPAREN = 'RPAREN';
    const T_LBRACE = 'LBRACE';
    const T_RBRACE = 'RBRACE';
    const T_SEMICOLON = 'SEMICOLON';
    const T_COMMA = 'COMMA';
    const T_ASSIGN = 'ASSIGN';
    const T_LT = 'LT';
    const T_GT = 'GT';
    const T_EQ = 'EQ';
    const T_NEQ = 'NEQ';
    const T_LE = 'LE';
    const T_GE = 'GE';
    const T_AND = 'AND';
    const T_OR = 'OR';
    const T_NOT = 'NOT';
    const T_EOF = 'EOF';
}

class Lexer
{
    private string $source;
    private int $pos;
    private ?string $currentChar;

    public function __construct($source)
    {
        $this->source = $source;
        $this->pos = 0;
        $this->currentChar = $source[0] ?? null;
    }

    private function advance(): void
    {
        $this->pos++;
        if ($this->pos < strlen($this->source)) {
            $this->currentChar = $this->source[$this->pos];
        } else {
            $this->currentChar = null;
        }
    }

    private function skipWhitespace(): void
    {
        while (ctype_space($this->currentChar)) {
            $this->advance();
        }
    }

    private function number(): Token
    {
        $result = '';
        while (ctype_digit($this->currentChar)) {
            $result .= $this->currentChar;
            $this->advance();
        }
        return new Token(TokenType::T_NUMBER, intval($result));
    }

    private function identifier(): Token
    {
        $result = '';
        while ((ctype_alpha($this->currentChar) || ctype_digit($this->currentChar) || $this->currentChar == '_')) {
            $result .= $this->currentChar;
            $this->advance();
        }

        $keywords = [
            'print' => TokenType::T_PRINT,
            'if' => TokenType::T_IF,
            'else' => TokenType::T_ELSE,
            'while' => TokenType::T_WHILE,
            'function' => TokenType::T_FUNCTION,
            'return' => TokenType::T_RETURN,
        ];
        if (isset($keywords[$result])) {
            return new Token($keywords[$result]);
        }
        return new Token(TokenType::T_IDENTIFIER, $result);
    }

    public function getNextToken(): Token
    {
        while ($this->currentChar !== null) {
            if (ctype_space($this->currentChar)) {
                $this->skipWhitespace();
                continue;
            }

            if (ctype_alpha($this->currentChar) || $this->currentChar == '_') {
                return $this->identifier();
            }

            if (ctype_digit($this->currentChar)) {
                return $this->number();
            }

            if ($this->currentChar == '+') {
                $this->advance();
                return new Token(TokenType::T_PLUS);
            }
            if ($this->currentChar == '-') {
                $this->advance();
                return new Token(TokenType::T_MINUS);
            }
            if ($this->currentChar == '*') {
                $this->advance();
                return new Token(TokenType::T_MULTIPLY);
            }
            if ($this->currentChar == '/') {
                $this->advance();
                return new Token(TokenType::T_DIVIDE);
            }
            if ($this->currentChar == '(') {
                $this->advance();
                return new Token(TokenType::T_LPAREN);
            }
            if ($this->currentChar == ')') {
                $this->advance();
                return new Token(TokenType::T_RPAREN);
            }
            if ($this->currentChar == '{') {
                $this->advance();
                return new Token(TokenType::T_LBRACE);
            }
            if ($this->currentChar == '}') {
                $this->advance();
                return new Token(TokenType::T_RBRACE);
            }
            if ($this->currentChar == ';') {
                $this->advance();
                return new Token(TokenType::T_SEMICOLON);
            }
            if ($this->currentChar == ',') {
                $this->advance();
                return new Token(TokenType::T_COMMA);
            }
            if ($this->currentChar == '!') {
                $this->advance();
                if ($this->currentChar == '=') {
                    $this->advance();
                    return new Token(TokenType::T_NEQ);
                }
                return new Token(TokenType::T_NOT);
            }
            if ($this->currentChar == '=') {
                $this->advance();
                if ($this->currentChar == '=') {
                    $this->advance();
                    return new Token(TokenType::T_EQ);
                }
                return new Token(TokenType::T_ASSIGN);
            }
            if ($this->currentChar == '<') {
                $this->advance();
                if ($this->currentChar == '=') {
                    $this->advance();
                    return new Token(TokenType::T_LE);
                }
                return new Token(TokenType::T_LT);
            }
            if ($this->currentChar == '>') {
                $this->advance();
                if ($this->currentChar == '=') {
                    $this->advance();
                    return new Token(TokenType::T_GE);
                }
                return new Token(TokenType::T_GT);
            }
            if ($this->currentChar == '&') {
                $this->advance();
                if ($this->currentChar == '&') {
                    $this->advance();
                    return new Token(TokenType::T_AND);
                }
            }
            if ($this->currentChar == '|') {
                $this->advance();
                if ($this->currentChar == '|') {
                    $this->advance();
                    return new Token(TokenType::T_OR);
                }
            }

            throw new Exception("无法识别的字符: " . $this->currentChar);
        }

        return new Token(TokenType::T_EOF);
    }
}

abstract class ASTNode
{
}

class Program extends ASTNode
{
    public array $statements;

    public function __construct($statements)
    {
        $this->statements = $statements;
    }
}

class Block extends ASTNode implements Statement
{
    public array $statements;

    public function __construct($statements)
    {
        $this->statements = $statements;
    }
}

interface Statement
{
}

class PrintStatement extends ASTNode implements Statement
{
    public Expression $expression;

    public function __construct($expression)
    {
        $this->expression = $expression;
    }
}

class IfStatement extends ASTNode implements Statement
{
    public Expression $condition;
    public Statement $thenBranch;
    public Statement $elseBranch;

    public function __construct($condition, $thenBranch, $elseBranch = null)
    {
        $this->condition = $condition;
        $this->thenBranch = $thenBranch;
        $this->elseBranch = $elseBranch;
    }
}

class WhileStatement extends ASTNode implements Statement
{
    public Expression $condition;
    public Statement $body;

    public function __construct($condition, $body)
    {
        $this->condition = $condition;
        $this->body = $body;
    }
}

class FunctionDeclaration extends ASTNode implements Statement
{
    public string $name;
    public array $params;
    public Statement $body;

    public function __construct($name, $params, $body)
    {
        $this->name = $name;
        $this->params = $params;
        $this->body = $body;
    }
}

class ReturnStatement extends ASTNode implements Statement
{
    public Expression $expression;

    public function __construct($expression)
    {
        $this->expression = $expression;
    }
}

class ExpressionStatement extends ASTNode implements Statement
{
    public Expression $expression;

    public function __construct($expression)
    {
        $this->expression = $expression;
    }
}

interface Expression
{
}

class Assignment extends ASTNode implements Expression
{
    public Variable $variable;
    public Expression $expression;

    public function __construct($variable, $expression)
    {
        $this->variable = $variable;
        $this->expression = $expression;
    }
}

class BinaryExpression extends ASTNode implements Expression
{
    public Expression $left;
    public string $operator;
    public Expression $right;

    public function __construct($left, $operator, $right)
    {
        $this->left = $left;
        $this->operator = $operator;
        $this->right = $right;
    }
}

class UnaryExpression extends ASTNode implements Expression
{
    public string $operator;
    public Expression $expression;

    public function __construct($operator, $expression)
    {
        $this->operator = $operator;
        $this->expression = $expression;
    }
}

class Literal extends ASTNode implements Expression
{
    public mixed $value;

    public function __construct($value)
    {
        $this->value = $value;
    }
}

class Variable extends ASTNode implements Expression
{
    public string $name;

    public function __construct($name)
    {
        $this->name = $name;
    }
}

class FunctionCall extends ASTNode implements Expression
{
    public string $name;
    public array $arguments;

    public function __construct($name, $arguments)
    {
        $this->name = $name;
        $this->arguments = $arguments;
    }
}

class Parser
{
    private Lexer $lexer;
    private Token $currentToken;

    public function __construct($lexer)
    {
        $this->lexer = $lexer;
        $this->currentToken = $this->lexer->getNextToken();
    }

    private function eat(string $tokenType): void
    {
        if ($this->currentToken->type == $tokenType) {
            $this->currentToken = $this->lexer->getNextToken();
        } else {
            throw new Exception("期望 " . $tokenType . "，但获得 " . $this->currentToken->type);
        }
    }

    public function parse(): Program
    {
        $statements = [];
        while ($this->currentToken->type != TokenType::T_EOF) {
            $statements[] = $this->statement();
        }
        return new Program($statements);
    }

    private function statement(): Statement
    {
        return match ($this->currentToken->type) {
            TokenType::T_PRINT => $this->printStatement(),
            TokenType::T_IF => $this->ifStatement(),
            TokenType::T_WHILE => $this->whileStatement(),
            TokenType::T_FUNCTION => $this->functionDeclaration(),
            TokenType::T_RETURN => $this->returnStatement(),
            TokenType::T_LBRACE => $this->block(),
            default => $this->expressionStatement(),
        };
    }

    private function block(): Block
    {
        $this->eat(TokenType::T_LBRACE);
        $statements = [];
        while ($this->currentToken->type != TokenType::T_RBRACE) {
            $statements[] = $this->statement();
        }
        $this->eat(TokenType::T_RBRACE);
        return new Block($statements);
    }

    private function printStatement(): PrintStatement
    {
        $this->eat(TokenType::T_PRINT);
        $this->eat(TokenType::T_LPAREN);
        $expr = $this->expression();
        $this->eat(TokenType::T_RPAREN);
        $this->eat(TokenType::T_SEMICOLON);
        return new PrintStatement($expr);
    }

    private function ifStatement(): IfStatement
    {
        $this->eat(TokenType::T_IF);
        $this->eat(TokenType::T_LPAREN);
        $condition = $this->expression();
        $this->eat(TokenType::T_RPAREN);
        $thenBranch = $this->statement();
        $elseBranch = null;
        if ($this->currentToken->type == TokenType::T_ELSE) {
            $this->eat(TokenType::T_ELSE);
            $elseBranch = $this->statement();
        }
        return new IfStatement($condition, $thenBranch, $elseBranch);
    }

    private function whileStatement(): WhileStatement
    {
        $this->eat(TokenType::T_WHILE);
        $this->eat(TokenType::T_LPAREN);
        $condition = $this->expression();
        $this->eat(TokenType::T_RPAREN);
        $body = $this->statement();
        return new WhileStatement($condition, $body);
    }

    private function functionDeclaration(): FunctionDeclaration
    {
        $this->eat(TokenType::T_FUNCTION);
        $name = $this->currentToken->value;
        $this->eat(TokenType::T_IDENTIFIER);
        $this->eat(TokenType::T_LPAREN);
        $params = [];
        if ($this->currentToken->type != TokenType::T_RPAREN) {
            $params[] = $this->currentToken->value;
            $this->eat(TokenType::T_IDENTIFIER);
            while ($this->currentToken->type == TokenType::T_COMMA) {
                $this->eat(TokenType::T_COMMA);
                $params[] = $this->currentToken->value;
                $this->eat(TokenType::T_IDENTIFIER);
            }
        }
        $this->eat(TokenType::T_RPAREN);
        $body = $this->block();
        return new FunctionDeclaration($name, $params, $body);
    }

    private function returnStatement(): ReturnStatement
    {
        $this->eat(TokenType::T_RETURN);
        $expr = null;
        if ($this->currentToken->type != TokenType::T_SEMICOLON) {
            $expr = $this->expression();
        }
        $this->eat(TokenType::T_SEMICOLON);
        return new ReturnStatement($expr);
    }

    private function expressionStatement(): ExpressionStatement
    {
        $expr = $this->expression();
        $this->eat(TokenType::T_SEMICOLON);
        return new ExpressionStatement($expr);
    }

    private function expression(): Expression
    {
        return $this->assignment();
    }

    private function assignment(): Expression
    {
        $expr = $this->logicalOr();
        if ($this->currentToken->type == TokenType::T_ASSIGN) {
            if (!($expr instanceof Variable)) {
                throw new Exception("赋值目标无效");
            }
            $this->eat(TokenType::T_ASSIGN);
            $value = $this->assignment();
            return new Assignment($expr, $value);
        }
        return $expr;
    }

    private function logicalOr(): Expression
    {
        $expr = $this->logicalAnd();
        while ($this->currentToken->type == TokenType::T_OR) {
            $operator = $this->currentToken->type;
            $this->eat(TokenType::T_OR);
            $right = $this->logicalAnd();
            $expr = new BinaryExpression($expr, $operator, $right);
        }
        return $expr;
    }

    private function logicalAnd(): Expression
    {
        $expr = $this->equality();
        while ($this->currentToken->type == TokenType::T_AND) {
            $operator = $this->currentToken->type;
            $this->eat(TokenType::T_AND);
            $right = $this->equality();
            $expr = new BinaryExpression($expr, $operator, $right);
        }
        return $expr;
    }

    private function equality(): Expression
    {
        $expr = $this->comparison();
        while ($this->currentToken->type == TokenType::T_EQ || $this->currentToken->type == TokenType::T_NEQ) {
            $operator = $this->currentToken->type;
            if ($operator == TokenType::T_EQ) {
                $this->eat(TokenType::T_EQ);
            } else {
                $this->eat(TokenType::T_NEQ);
            }
            $right = $this->comparison();
            $expr = new BinaryExpression($expr, $operator, $right);
        }
        return $expr;
    }

    private function comparison(): Expression
    {
        $expr = $this->addition();
        while (in_array($this->currentToken->type, [TokenType::T_LT, TokenType::T_GT, TokenType::T_LE, TokenType::T_GE])) {
            $operator = $this->currentToken->type;
            $this->eat($operator);
            $right = $this->addition();
            $expr = new BinaryExpression($expr, $operator, $right);
        }
        return $expr;
    }

    private function addition(): Expression
    {
        $expr = $this->multiplication();
        while ($this->currentToken->type == TokenType::T_PLUS || $this->currentToken->type == TokenType::T_MINUS) {
            $operator = $this->currentToken->type;
            if ($operator == TokenType::T_PLUS) {
                $this->eat(TokenType::T_PLUS);
            } else {
                $this->eat(TokenType::T_MINUS);
            }
            $right = $this->multiplication();
            $expr = new BinaryExpression($expr, $operator, $right);
        }
        return $expr;
    }

    private function multiplication(): Expression
    {
        $expr = $this->unary();
        while ($this->currentToken->type == TokenType::T_MULTIPLY || $this->currentToken->type == TokenType::T_DIVIDE) {
            $operator = $this->currentToken->type;
            if ($operator == TokenType::T_MULTIPLY) {
                $this->eat(TokenType::T_MULTIPLY);
            } else {
                $this->eat(TokenType::T_DIVIDE);
            }
            $right = $this->unary();
            $expr = new BinaryExpression($expr, $operator, $right);
        }
        return $expr;
    }

    private function unary(): Expression
    {
        if ($this->currentToken->type == TokenType::T_NOT || $this->currentToken->type == TokenType::T_MINUS) {
            $operator = $this->currentToken->type;
            $this->eat($operator);
            $expr = $this->unary();
            return new UnaryExpression($operator, $expr);
        }
        return $this->primary();
    }

    private function primary(): Expression
    {
        $token = $this->currentToken;
        if ($token->type == TokenType::T_NUMBER) {
            $this->eat(TokenType::T_NUMBER);
            return new Literal($token->value);
        }
        if ($token->type == TokenType::T_IDENTIFIER) {
            $this->eat(TokenType::T_IDENTIFIER);

            if ($this->currentToken->type == TokenType::T_LPAREN) {
                $this->eat(TokenType::T_LPAREN);
                $args = [];
                if ($this->currentToken->type != TokenType::T_RPAREN) {
                    $args[] = $this->expression();
                    while ($this->currentToken->type == TokenType::T_COMMA) {
                        $this->eat(TokenType::T_COMMA);
                        $args[] = $this->expression();
                    }
                }
                $this->eat(TokenType::T_RPAREN);
                return new FunctionCall($token->value, $args);
            }
            return new Variable($token->value);
        }
        if ($token->type == TokenType::T_LPAREN) {
            $this->eat(TokenType::T_LPAREN);
            $expr = $this->expression();
            $this->eat(TokenType::T_RPAREN);
            return $expr;
        }
        throw new Exception("无法识别的 token: " . $token->type);
    }
}

class OpCode
{
    const ICONST = 'ICONST';
    const LOAD = 'LOAD';
    const STORE = 'STORE';
    const PRINT = 'PRINT';
    const ADD = 'ADD';
    const SUB = 'SUB';
    const MUL = 'MUL';
    const DIV = 'DIV';
    const LT = 'LT';
    const GT = 'GT';
    const EQ = 'EQ';
    const NE = 'NE';
    const LE = 'LE';
    const GE = 'GE';
    const AND = 'AND';
    const OR = 'OR';
    const NOT = 'NOT';
    const JMP = 'JMP';
    const JMPF = 'JMPF';
    const CALL = 'CALL';
    const RET = 'RET';
    const POP = 'POP';
}

class CodeGenerator
{
    private array $instructions = [];
    private array $functions = [];

    public function generate($node): array
    {
        if ($node instanceof Program) {
            $funcDecls = [];
            $mainStmts = [];
            foreach ($node->statements as $stmt) {
                if ($stmt instanceof FunctionDeclaration) {
                    $funcDecls[] = $stmt;
                } else {
                    $mainStmts[] = $stmt;
                }
            }

            foreach ($mainStmts as $stmt) {
                $this->genStatement($stmt);
            }

            $jumpPos = $this->emit(OpCode::JMP, 0);
            $funcStart = count($this->instructions);

            foreach ($funcDecls as $func) {
                $funcName = $func->name;
                $entryPoint = count($this->instructions);
                $this->functions[$funcName] = ['params' => $func->params, 'entry' => $entryPoint];
                $this->genStatement($func->body);
                $this->emit(OpCode::RET);
            }

            $this->patch($jumpPos, count($this->instructions));
            return $this->instructions;
        } else {
            throw new Exception("无效的 AST 节点");
        }
    }

    private function genStatement($node): void
    {
        if ($node instanceof PrintStatement) {
            $this->genExpression($node->expression);
            $this->emit(OpCode::PRINT);
        } elseif ($node instanceof ExpressionStatement) {
            $this->genExpression($node->expression);
            $this->emit(OpCode::POP);
        } elseif ($node instanceof Assignment) {
            $this->genExpression($node->expression);
            $this->emit(OpCode::STORE, $node->variable->name);
        } elseif ($node instanceof IfStatement) {
            $this->genExpression($node->condition);
            $jmpFalsePos = $this->emit(OpCode::JMPF, 0);
            $this->genStatement($node->thenBranch);
            if ($node->elseBranch !== null) {
                $jmpEndPos = $this->emit(OpCode::JMP, 0);
                $this->patch($jmpFalsePos, count($this->instructions));
                $this->genStatement($node->elseBranch);
                $this->patch($jmpEndPos, count($this->instructions));
            } else {
                $this->patch($jmpFalsePos, count($this->instructions));
            }
        } elseif ($node instanceof WhileStatement) {
            $startPos = count($this->instructions);
            $this->genExpression($node->condition);
            $jmpFalsePos = $this->emit(OpCode::JMPF, 0);
            $this->genStatement($node->body);
            $this->emit(OpCode::JMP, $startPos);
            $this->patch($jmpFalsePos, count($this->instructions));
        } elseif ($node instanceof Block) {
            foreach ($node->statements as $stmt) {
                $this->genStatement($stmt);
            }
        } elseif ($node instanceof ReturnStatement) {
            if ($node->expression !== null) {
                $this->genExpression($node->expression);
            } else {
                $this->emit(OpCode::ICONST, 0);
            }
            $this->emit(OpCode::RET);
        } else {
            throw new Exception("未知的语句类型");
        }
    }

    private function genExpression($node): void
    {
        if ($node instanceof Literal) {
            $this->emit(OpCode::ICONST, $node->value);
        } elseif ($node instanceof Variable) {
            $this->emit(OpCode::LOAD, $node->name);
        } elseif ($node instanceof Assignment) {
            $this->genExpression($node->expression);
            $this->emit(OpCode::STORE, $node->variable->name);
        } elseif ($node instanceof BinaryExpression) {
            $this->genExpression($node->left);
            $this->genExpression($node->right);
            switch ($node->operator) {
                case TokenType::T_PLUS:
                    $this->emit(OpCode::ADD);
                    break;
                case TokenType::T_MINUS:
                    $this->emit(OpCode::SUB);
                    break;
                case TokenType::T_MULTIPLY:
                    $this->emit(OpCode::MUL);
                    break;
                case TokenType::T_DIVIDE:
                    $this->emit(OpCode::DIV);
                    break;
                case TokenType::T_LT:
                    $this->emit(OpCode::LT);
                    break;
                case TokenType::T_GT:
                    $this->emit(OpCode::GT);
                    break;
                case TokenType::T_EQ:
                    $this->emit(OpCode::EQ);
                    break;
                case TokenType::T_NEQ:
                    $this->emit(OpCode::NE);
                    break;
                case TokenType::T_LE:
                    $this->emit(OpCode::LE);
                    break;
                case TokenType::T_GE:
                    $this->emit(OpCode::GE);
                    break;
                case TokenType::T_AND:
                    $this->emit(OpCode::AND);
                    break;
                case TokenType::T_OR:
                    $this->emit(OpCode::OR);
                    break;
                default:
                    throw new Exception("未知的二元运算符: " . $node->operator);
            }
        } elseif ($node instanceof UnaryExpression) {
            if ($node->operator == TokenType::T_MINUS) {
                $this->emit(OpCode::ICONST, 0);
                $this->genExpression($node->expression);
                $this->emit(OpCode::SUB);
            } elseif ($node->operator == TokenType::T_NOT) {
                $this->genExpression($node->expression);
                $this->emit(OpCode::NOT);
            } else {
                throw new Exception("未知的一元运算符: " . $node->operator);
            }
        } elseif ($node instanceof FunctionCall) {
            foreach ($node->arguments as $arg) {
                $this->genExpression($arg);
            }

            $this->emit(OpCode::CALL, ['name' => $node->name, 'argc' => count($node->arguments)]);
        } else {
            throw new Exception("未知的表达式类型");
        }
    }

    private function emit($opcode, $operand = null): int
    {
        $instr = ['op' => $opcode];
        if ($operand !== null) {
            $instr['operand'] = $operand;
        }
        $this->instructions[] = $instr;
        return count($this->instructions) - 1;
    }

    private function patch($pos, $target): void
    {
        $this->instructions[$pos]['operand'] = $target;
    }

    public function getFunctions(): array
    {
        return $this->functions;
    }
}

class VirtualMachine
{
    private array $instructions;
    private array $functions;
    private int $ip;
    private array $stack;
    private array $globals;
    private array $callStack;

    public function __construct($instructions, $functions)
    {
        $this->instructions = $instructions;
        $this->functions = $functions;
        $this->ip = 0;
        $this->stack = [];
        $this->globals = [];
        $this->callStack = [];
    }

    public function run()
    {
        while ($this->ip < count($this->instructions)) {
            $instr = $this->instructions[$this->ip];
            switch ($instr['op']) {
                case OpCode::ICONST:
                    $this->stack[] = $instr['operand'];
                    $this->ip++;
                    break;
                case OpCode::LOAD:
                    $var = $instr['operand'];
                    $this->stack[] = $this->globals[$var] ?? 0;
                    $this->ip++;
                    break;
                case OpCode::STORE:
                    $var = $instr['operand'];
                    $value = array_pop($this->stack);
                    $this->globals[$var] = $value;
                    $this->ip++;
                    break;
                case OpCode::PRINT:
                    $value = array_pop($this->stack);
                    echo $value . "\n";
                    $this->ip++;
                    break;
                case OpCode::ADD:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = $a + $b;
                    $this->ip++;
                    break;
                case OpCode::SUB:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = $a - $b;
                    $this->ip++;
                    break;
                case OpCode::MUL:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = $a * $b;
                    $this->ip++;
                    break;
                case OpCode::DIV:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = intval($a / $b);
                    $this->ip++;
                    break;
                case OpCode::LT:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = ($a < $b) ? 1 : 0;
                    $this->ip++;
                    break;
                case OpCode::GT:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = ($a > $b) ? 1 : 0;
                    $this->ip++;
                    break;
                case OpCode::EQ:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = ($a == $b) ? 1 : 0;
                    $this->ip++;
                    break;
                case OpCode::NE:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = ($a != $b) ? 1 : 0;
                    $this->ip++;
                    break;
                case OpCode::LE:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = ($a <= $b) ? 1 : 0;
                    $this->ip++;
                    break;
                case OpCode::GE:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = ($a >= $b) ? 1 : 0;
                    $this->ip++;
                    break;
                case OpCode::AND:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = ($a && $b) ? 1 : 0;
                    $this->ip++;
                    break;
                case OpCode::OR:
                    $b = array_pop($this->stack);
                    $a = array_pop($this->stack);
                    $this->stack[] = ($a || $b) ? 1 : 0;
                    $this->ip++;
                    break;
                case OpCode::NOT:
                    $a = array_pop($this->stack);
                    $this->stack[] = (!$a) ? 1 : 0;
                    $this->ip++;
                    break;
                case OpCode::JMP:
                    $this->ip = $instr['operand'];
                    break;
                case OpCode::JMPF:
                    $cond = array_pop($this->stack);
                    if (!$cond) {
                        $this->ip = $instr['operand'];
                    } else {
                        $this->ip++;
                    }
                    break;
                case OpCode::CALL:
                    $funcInfo = $instr['operand'];
                    $funcName = $funcInfo['name'];
                    $argc = $funcInfo['argc'];
                    if (!isset($this->functions[$funcName])) {
                        throw new Exception("未定义函数: " . $funcName);
                    }
                    $fn = $this->functions[$funcName];

                    $this->callStack[] = [$this->ip + 1, $this->globals];

                    $args = [];
                    for ($i = 0; $i < $argc; $i++) {
                        array_unshift($args, array_pop($this->stack));
                    }

                    $this->globals = [];
                    $params = $fn['params'];
                    for ($i = 0; $i < count($params); $i++) {
                        $this->globals[$params[$i]] = $args[$i] ?? 0;
                    }
                    $this->ip = $fn['entry'];
                    break;
                case OpCode::RET:
                    $retValue = array_pop($this->stack);
                    if (empty($this->callStack)) {
                        return $retValue;
                    }

                    list($this->ip, $prevGlobals) = array_pop($this->callStack);
                    $this->globals = $prevGlobals;
                    $this->stack[] = $retValue;
                    break;
                case OpCode::POP:
                    array_pop($this->stack);
                    $this->ip++;
                    break;
                default:
                    throw new Exception("未知的操作码: " . $instr['op']);
            }
        }
    }
}


// 主程序部分

$source = <<<'EOT'
print(1 + 2 * 3);
print(1 + 2 * (3 + 4));

a = 10;

print(2 * (a + 10));

while(a > 0) {
    print(a);
    if (a == 1) {
        a = a - 11; 
    } else {
        a = a - 1;
    }
}
print(a);

function factorial(n) {
    if(n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

print(factorial(5));

function sum(a, b) {
    print(666666);
    return a + b;
}

b = 10;
print(sum(10, b));
EOT;

try {
    $lexer = new Lexer($source);
    $parser = new Parser($lexer);
    $ast = $parser->parse();
    $codegen = new CodeGenerator();
    $instructions = $codegen->generate($ast);
    $functions = $codegen->getFunctions();

    echo json_encode($instructions), "\n\n";
    echo json_encode($functions), "\n\n";

    $vm = new VirtualMachine($instructions, $functions);
    $vm->run();
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

func chromeHeadlessRunning() (bool, error) {
    cmd := exec.Command("ps", "ajx")
    output, err := cmd.Output()
    if err != nil {
        return false, err
    }

    scanner := bufio.NewScanner(strings.NewReader(string(output)))
    for scanner.Scan() {
        line := scanner.Text()
        if strings.Contains(line, "Chrome") &&
            strings.Contains(line, "headless") &&
            !strings.Contains(line, "grep") {
            return true, nil
        }
    }

    return false, nil
}

func waitForCDP(port string, timeout time.Duration) bool {
    deadline := time.Now().Add(timeout)
    for time.Now().Before(deadline) {
        conn, err := net.DialTimeout("tcp", port, time.Second)
        if err == nil {
            conn.Close()
            return true
        }
        time.Sleep(200 * time.Millisecond)
    }
    return false
}

func getDebuggerInfo() interface{} {
    httpClient := http.Client{}
    req, err := http.NewRequest(http.MethodPut, debuggerBaseUrl+"/json/new", nil)
    isFatal(err)

    res, err := httpClient.Do(req)
    isFatal(err)
    defer res.Body.Close()

    bodyBytes, err := io.ReadAll(res.Body)
    isFatal(err)

    var i interface{}
    err = json.Unmarshal(bodyBytes, &i)
    isFatal(err)

    return i
}

{
    "method": "Page.navigate",
    "params": {
        "url": "https://example.com"
    }
}

<?php

class SimulateSelenium
{
    public static string $webdriverURL = 'http://localhost:9515';

    public static string $findDriver = "ps ajx | grep chromedriver | grep -v grep";

    public static function get($url = '')
    {
        $pid = pcntl_fork();
        if ($pid < 0) {
            exit("fork error");
        } else if ($pid == 0) {
            echo "starting chromedriver...\n";
            if (!shell_exec(self::$findDriver)) {
                pcntl_exec("/usr/bin/env", ["chromedriver", "--port=9515", "&"], ["PATH" => "/Users/wu/Bin"]);
            }
        } else {
            $timeout = 10;
            while ($timeout > 0) {
                if (shell_exec(self::$findDriver)) {
                    break;
                }

                echo "waiting for chromedriver...\n";
                sleep(1);
                $timeout--;
            }

            $session = self::request('POST', self::$webdriverURL . "/session", [
                'capabilities' => [
                    'alwaysMatch' => [
                        'browserName' => 'chrome',
                    ],
                ]
            ]);

            if (!isset($session['value']['sessionId'])) {
                echo "无法创建浏览器 session\n";
                exit(1);
            }

            $sessionId = $session['value']['sessionId'];

            self::request('POST', self::$webdriverURL . "/session/$sessionId/url", [
                'url' => $url,
            ]);

            $title = self::request('GET', self::$webdriverURL . "/session/$sessionId/title");

            echo "页面标题: " . $title['value'] . "\n";

            self::request('DELETE', self::$webdriverURL . "/session/$sessionId");
        }
    }

    private static function request($method, $url, $data = null)
    {
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
        if ($data !== null) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
            curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
        }
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        $res = curl_exec($ch);
        curl_close($ch);
        return json_decode($res, true);
    }
}

SimulateSelenium::get('https://baidu.com');

bindPort=8080
vhostHTTPPort=8080

serverAddr="example.com"
serverPort=8080

[[proxies]]
name="web"
type="http"
localIP="127.0.0.1"
localPort=80
customDomains=["example.com"]

bindPort=8080
vhostHTTPSPort=443

serverAddr="example.com"
serverPort=8080

[[proxies]]
name="web"
type="https"
customDomains=["example.com"]

[proxies.plugin]
type="https2http"
localAddr="127.0.0.1:80"

crtPath="./example.com_public.crt"
keyPath="./example.com.key"
hostHeaderRewrite="127.0.0.1"

class Lexer
{
    private $input;
    private $pos = 0;
    private $currentChar;

    public function __construct($input)
    {
        $this->input = $input;
        $this->currentChar = $input[0] ?? null;
    }

    private function advance()
    {
        $this->pos++;
        $this->currentChar = $this->input[$this->pos] ?? null;
    }

    private function skipWhitespace()
    {
        while ($this->currentChar !== null && ctype_space($this->currentChar)) {
            $this->advance();
        }
    }

    private function integer()
    {
        $result = '';
        while ($this->currentChar !== null && ctype_digit($this->currentChar)) {
            $result .= $this->currentChar;
            $this->advance();
        }
        return (int)$result;
    }

    private function identifier()
    {
        $result = '';
        while ($this->currentChar !== null && (ctype_alnum($this->currentChar) || $this->currentChar === '_')) {
            $result .= $this->currentChar;
            $this->advance();
        }
        return $result;
    }

    public function getNextToken()
    {
        while ($this->currentChar !== null) {
            // 忽略空白符
            if (ctype_space($this->currentChar)) {
                $this->skipWhitespace();
                continue;
            }

            // 当前字符为整型时，扫描后续部分的整型字符
            if (ctype_digit($this->currentChar)) {
                return ['type' => 'INTEGER', 'value' => $this->integer()];
            }

            // 当前字符为字母时，扫描后续部分的字母或数字字符
            if (ctype_alpha($this->currentChar)) {
                $id = $this->identifier();
                // 如果扫描到的 token 为 print，则将其标记为关键词 print
                if (strtoupper($id) === 'PRINT') {
                    return ['type' => 'PRINT', 'value' => $id];
                }
                return ['type' => 'ID', 'value' => $id];
            }

            // 普通的符号
            switch ($this->currentChar) {
                case '=':
                    $this->advance();
                    return ['type' => 'ASSIGN', 'value' => '='];
                case '+':
                    $this->advance();
                    return ['type' => 'PLUS', 'value' => '+'];
                case '-':
                    $this->advance();
                    return ['type' => 'MINUS', 'value' => '-'];
                case '*':
                    $this->advance();
                    return ['type' => 'MUL', 'value' => '*'];
                case '/':
                    $this->advance();
                    return ['type' => 'DIV', 'value' => '/'];
                case ';':
                    $this->advance();
                    return ['type' => 'SEMI', 'value' => ';'];
                case '(':
                    $this->advance();
                    return ['type' => 'LPAREN', 'value' => '('];
                case ')':
                    $this->advance();
                    return ['type' => 'RPAREN', 'value' => ')'];
                default:
                    throw new Exception("Invalid character: " . $this->currentChar);
            }
        }

        return ['type' => 'EOF', 'value' => null];
    }
}