# Tree-sitter TSF 语法解析器

这个项目为你的 TSF 语言创建了一个 Tree-sitter 语法解析器，支持完整的 TSF 语法特性。

## ✨ 完整语法特性

### 1. 🗨️ 注释（3 种方式）

```tsf
// 行注释
{ 块注释1 }
(* 块注释2 *)
```

### 2. 🔢 数字格式

```tsf
// 基础数字
100
1.2232442

// 科学记数法
1E2
-3.4e34
2.4e-23

// 不同进制
0x1A        // 十六进制
0b100       // 二进制
0o64        // 八进制

// 带符号数字
+123
-456.789
```

### 3. 📝 字符串和字面量

```tsf
// 字符串
'string0'
"string1"
"escaped \"quotes\" and \\backslashes"

// 特殊字面量
nil         // 空值
-INF        // 负无穷大
+INF        // 正无穷大
NAN         // 非数
false       // 布尔false
true        // 布尔true
```

### 4. 📊 数组构造（支持多层嵌套）

TSF 的数组语法使用 `array()` 构造函数，支持任意层级的嵌套：

#### 基础数组类型

```tsf
// 简单元素数组
array(1, 2, 3)
array("a", "b", "c")
array(1, "abc", true, nil)

// 键值对数组
array("key1": "value1", "key2": "value2")
array("name": "Alice", "age": 25, "active": true)

// 元组数组
array((1, "first"), (2, "second"), (3, "third"))
array(("id": 1, "name": "Alice"), ("id": 2, "name": "Bob"))

// 空数组
array()
```

#### 复杂嵌套示例

```tsf
// 多维数组
matrix := array(
    array(1, 2, 3),
    array(4, 5, 6),
    array(7, 8, 9)
);

// 键值对嵌套
config := array(
    "database": array(
        "host": "localhost",
        "port": 5432,
        "tables": array("users", "products", "orders")
    ),
    "cache": array(
        "redis": array("host": "redis.local", "port": 6379),
        "enabled": true
    )
);

// 混合结构：键值对 + 元组 + 嵌套数组
complex_data := array(
    "users": array(
        ("id": 1, "name": "Alice", "scores": array(85, 92, 78)),
        ("id": 2, "name": "Bob", "scores": array(91, 87, 95))
    ),
    "metadata": array(
        "total": 2,
        "stats": array(
            ("mean": 88.5, "data": array(1, 2, 3)),
            ("max": 95, "data": (true, false, nil))
        )
    )
);
```

#### 数组访问和操作

```tsf
// 索引访问
item := arr[0];
value := matrix[1][2];
nested := config["database"]["tables"][0];

// 切片访问
slice := arr[1:5];         // 从索引1到4
head := arr[:3];           // 前3个元素
tail := arr[2:];           // 从索引2到末尾

// 数组赋值
arr[index] := new_value;
matrix[i][j] := data;
config["setting"] := "value";
```

### 5. ➕ 运算符

#### 算术运算符

```tsf
+ - * / %           // 基本运算
+= -= /= *=         // 复合赋值
++ --               // 自增自减（前缀和后缀）
mod                 // 取余（同%）
div                 // 除取整，如7 div 3 = 2
^                   // 求幂，如2^3 = 8
~                   // 求对数，8~2=3
!                   // 求导数，!A=1/A
```

**自增自减运算符说明：**

- **前缀自增自减**：`++a`, `--a` - 作为独立的自增自减语句
- **后缀自增自减**：`a++`, `a--` - 作为表达式语句使用

```tsf
function example();
begin
    // 前缀自增自减语句
    ++counter;
    --index;

    // 后缀自增自减表达式语句
    counter++;
    index--;

    // 在表达式中使用
    result := ++a * 2;      // 前缀：先自增，再使用
    value := b++ * 2;       // 后缀：先使用，再自增（作为表达式）

    // 对象成员的自增自减
    ++obj.count;            // 前缀语句
    obj.count++;            // 后缀表达式语句
end;
```

#### 字符串连接运算符

```tsf
$                   // 万能连接符，可以连接任何类型
```

**$ 连接符示例：**

```tsf
// 基础连接
message := "Hello" $ " " $ "World";              // 结果: "Hello World"
info := "Count: " $ 42 $ " items";               // 结果: "Count: 42 items"

// 连接不同类型
status := "User " $ user_id $ " is " $ (is_active ? "active" : "inactive");

// 在表达式中使用
calculation := "Result: " $ (a + b) $ " = " $ result;

// 函数调用连接
log_entry := getTimestamp() $ ": " $ getMessage() $ " [" $ getLevel() $ "]";

// 对象属性连接
full_name := person.firstName $ " " $ person.lastName;

// raise语句中使用
raise "Error " $ error_code $ ": " $ error_message;

// echo语句中使用
echo "Processing " $ current_index $ " of " $ total_count $ " items";
```

#### 矩阵运算符

```tsf
`                   // 矩阵转置（前缀）
|                   // 矩阵列连接
Union               // 矩阵行连接
:|                  // 非完全矩阵列连接
!                   // 矩阵求逆与广义逆（前缀）
:*                  // 矩阵乘法
:\\                 // 矩阵左除
:^                  // 矩阵乘方
```

**矩阵运算符示例：**

```tsf
// 矩阵转置（前缀）
A := array((1,2,3),(4,5,6));    // 2x3矩阵
B := `A;                        // 转置为3x2矩阵: ((1,4),(2,5),(3,6))

// 矩阵列连接
matrix1 := array((1,2),(3,4));  // 2x2矩阵
matrix2 := array((5,6),(7,8));  // 2x2矩阵
combined := matrix1 | matrix2;   // 2x4矩阵: ((1,2,5,6),(3,4,7,8))

// 矩阵行连接
row_combined := matrix1 Union matrix2; // 4x2矩阵

// 矩阵求逆（前缀）
identity := !A;                 // A的逆矩阵

// 矩阵乘法
result := matrix1 :* matrix2;   // 矩阵乘法

// 矩阵左除
solution := A :\\ b;            // 求解线性方程组 Ax = b

// 矩阵乘方
power_matrix := A :^ 3;         // A的3次幂

// 复杂矩阵运算组合（前缀转置）
complex_result := `(A :* B) | (C Union D);

// 嵌套转置运算
double_transpose := ``A;        // 转置的转置，等于原矩阵
mixed_ops := `(!A) :* B;        // 先求逆，再转置，然后矩阵乘法
```

#### 集合运算符

```tsf
union               // 集合并集
union2              // 集合并集2
minus               // 集合差集
intersect           // 集合交集
```

**集合运算符示例：**

```tsf
// 集合定义
setA := array(1, 2, 3, 4, 5);
setB := array(4, 5, 6, 7, 8);
setC := array(2, 4, 6, 8, 10);

// 集合并集
union_result := setA union setB;        // 结果: array(1,2,3,4,5,6,7,8)

// 集合并集2（可能有不同的语义）
union2_result := setA union2 setB;

// 集合差集
diff_result := setA minus setB;         // 结果: array(1,2,3)

// 集合交集
intersect_result := setA intersect setB; // 结果: array(4,5)

// 复杂集合运算
complex_set := (setA union setB) intersect setC; // ((A∪B)∩C)

// 集合复合赋值
setA union= setB;           // setA = setA union setB
setA minus= setC;           // setA = setA minus setC
setA intersect= setB;       // setA = setA intersect setB

// 对象成员的集合运算
obj.values union= new_values;
data.items intersect= valid_items;
```

#### 复合赋值运算符（扩展）

```tsf
+=  -=  *=  /=      // 基础算术复合赋值
union=              // 集合并集复合赋值
union2=             // 集合并集2复合赋值
minus=              // 集合差集复合赋值
intersect=          // 集合交集复合赋值
```

#### 逻辑运算符

```tsf
.&& and             // 与
.|| or              // 或
.!! not             // 非
```

#### 位运算符

```tsf
.&                  // 位与
.|                  // 位或
.!                  // 位非
.^                  // 位异或
shl                 // 位左移
rol                 // 左循环移位
shr                 // 位右移
ror                 // 右循环移位
```

#### 比较运算符

```tsf
=                   // 等于
<>                  // 不等于
< > <= >=           // 大小比较
```

#### 三元条件运算符

```tsf
// 基本三元表达式
result := condition ? value_if_true : value_if_false;

// 实际示例
max := a > b ? a : b;
status := age >= 18 ? "adult" : "minor";
price := isMember ? originalPrice * 0.8 : originalPrice;

// 嵌套三元表达式
grade := score >= 90 ? "A" :
         score >= 80 ? "B" :
         score >= 70 ? "C" : "F";

// 在数组中使用
data := array(
    condition1 ? "option1" : "default1",
    condition2 ? array(1, 2, 3) : array(),
    x > 0 ? (positive_val, "positive") : (negative_val, "negative")
);
```

### 6. 📦 变量声明

```tsf
a := nil;                           // 普通赋值
const ca = 123;                    // 常量声明
global ga := array(1, 2, 3);       // 全局变量声明+初始化
global ga1;                        // 只声明全局变量
```

### 7. 📤 解包（Destructuring）赋值

```tsf
// 基础数组解包
[a, b, c] := array(1, 2, 3);                    // a=1, b=2, c=3

// 函数返回值解包
[x, y] := getCoordinates();                      // 解包函数返回的数组
[name, age, email] := getUserInfo(user_id);     // 解包用户信息

// 嵌套数组解包
[first, second, third] := matrix[0];            // 解包矩阵第一行
[user_data] := config["users"][0];              // 解包配置中的用户数据

// 复杂表达式解包
[min_val, max_val] := calculateRange(data);     // 解包计算结果
[status, message, data] := processRequest();     // 解包处理结果

// 在函数中使用解包
function processUserData();
begin
    [id, name, age, scores] := getUserById(123);

    // 处理解包后的数据
    if age >= 18 then
        echo "Adult user: " $ name $ " (ID: " $ id $ ")";

    // 解包嵌套数据
    [math, english, science] := scores;
    average := (math + english + science) / 3;

    return array("name": name, "average": average);
end;
```

### 8. 🔀 条件语句

```tsf
// if语句
if aaa then
begin
    // 代码块
end
else if bbb then
begin
    // 代码块
end
else begin
    // 代码块
end

// 单行if语句
if condition then statement;
if x > 0 then result := x;

// case语句
case age of
    10: println("10");
    11,12: begin
        println("11,12");
    end
    else
        println("case default");
end;
```

### 9. 🔄 循环语句

```tsf
// for...in 循环
for k,v in data do
begin
    if v = "c" then continue;
    process(k, v);
end;

// for...to 循环（递增）
for i:=0 to length(data) do
begin
    if i = 10 then break;
    process(data[i]);
end

// for...downto 循环（递减）
for i:=100 downto 0 do
    println(i);

// while 循环
while condition do
begin
    // 代码块
end;

// repeat...until 循环
a := 1;
repeat
    a++;
until a > 10;
return a;
```

### 10. 🎛️ 控制流

```tsf
break;              // 跳出循环
continue;           // 继续下一次循环
return value;       // 返回值
return;             // 无返回值返回
```

### 11. 🔑 关键字语句

TSF 提供了一些专用的关键字语句，用于特定的操作。

#### Echo 语句 - 输出打印

```tsf
// 输出多个值（用逗号分隔）
echo "Hello", " ", "World";                  // 输出：Hello World
echo "Value: ", x, " Type: ", type;          // 输出多个值
echo "Count:", count + 1, func();            // 表达式和函数调用

// 输出单个值
echo variable;                               // 输出单个变量
echo "Simple message";                       // 输出字符串
echo array(1, 2, 3);                        // 输出数组

// 配合$连接符使用
echo "Processing " $ current_index $ " of " $ total_count $ " items";
echo "User " $ user_name $ " logged in at " $ timestamp;
```

#### Raise 语句 - 异常抛出

```tsf
// 基本异常抛出
raise "Error message";                       // 抛出字符串消息
raise error_variable;                        // 抛出变量值
raise getErrorMessage();                     // 抛出函数返回值

// 使用表达式
raise "Error: " + error_code;                // 字符串拼接
raise "Error code " $ error_code $ " occurred";  // 使用$连接符

// 复杂异常消息构建
raise "User " $ user_id $ " permission denied at " $ getTimestamp();
raise "Invalid input: expected " $ expected_type $ ", got " $ actual_type;

// 条件性异常抛出
if invalid_input then
    raise "Invalid input provided";

if data = nil then
    raise "Data cannot be nil";
```

### 12. 🔍 判断语法

TSF 提供了专门的判断语法，用于类型检查和成员检查。

#### is class() - 类型判断

```tsf
// 基础类型判断
obj is class(MyClass)                        // 判断obj是否是MyClass的实例
instance is class(Person)                    // 判断instance是否是Person类型
data is class(Array)                         // 判断data是否是Array类型

// 使用qualified identifier
obj is class(namespace.ClassName)            // 带命名空间的类名
instance is class(mymodule.Person)          // 模块中的类

// 在条件语句中使用
if obj is class(Person) then
    echo "This is a Person object";
else
    echo "Not a Person object";

// 在三元表达式中使用
type_name := obj is class(Person) ? "Person" : "Other";
message := data is class(Array) ? "Array data" : "Non-array data";
```

#### in - 成员检查

```tsf
// 基础成员检查
1 in array(1, 2, 3)                          // 检查数字是否在数组中
"apple" in array("apple", "banana")          // 检查字符串是否在数组中
item in my_array                             // 检查元素是否在变量数组中

// 复杂表达式检查
(x + y) in valid_values                      // 表达式结果检查
user.id in authorized_ids                    // 对象属性检查
getValue() in allowed_values                 // 函数返回值检查

// 嵌套数组检查
target in data["items"]["list"]              // 检查嵌套数组成员
item in config["allowed"]["types"]           // 配置数组检查

// 在条件语句中使用
if value in valid_values then
    echo "Value is valid";
else
    raise "Invalid value: " $ value;
```

### 13. 📝 表达式语句

TSF 支持将表达式作为独立的语句使用，这在函数调用和计算中非常有用：

```tsf
function example();
begin
    // 表达式语句 - 函数调用
    func();
    obj.method();

    // 表达式语句 - 自增自减（后缀）
    counter++;
    index--;
    obj.value++;

    // 表达式语句 - 数学运算（可能有副作用）
    x + y;
    a * b + c;

    // 表达式语句 - 矩阵运算
    `matrix;                    // 转置操作（前缀）
    matrix1 :* matrix2;         // 矩阵乘法

    // 表达式语句 - 集合运算
    setA union setB;

    // 表达式语句 - 三元条件
    condition ? action1() : action2();

    // 表达式语句 - 复杂嵌套
    obj.method().getValue() + process(data);
end;
```

### 14. 🔧 函数定义

```tsf
// 参数不指定类型（用逗号分隔）
function syntax_func(a, b);
begin
    // 函数体
end

// 参数指定类型（用分号分隔）
function syntax_func(a: real; b: array of string);
begin
    // 函数体
end;

// 参数带默认值（用分号分隔）
function syntax_func(a: real = 1.0; c: string = "123")
begin
    var1 := 123;
end;

// 参数带默认值但无类型
function syntax_func(a = 1; b = 2)
begin
    // 函数体
end

// 返回类型
function calculate(x: real; y: real): real;
begin
    return x + y;
end;
```

### 15. 📞 函数调用

```tsf
// 无参数调用
test();

// 带参数调用
func(arg1, arg2);
println("{} == {}", k, ret);

// 链式调用
obj.method1().method2().method3();

// 嵌套调用
result := outer_func(inner_func(param));
```

#### 函数指针调用

TSF 支持函数指针的调用，使用 `##` 语法来调用通过指针引用的函数。

```tsf
// 函数指针调用语法
##pointer_func(param1, param2);

// 实际使用示例
function add(a: integer; b: integer): integer;
begin
    return a + b;
end;

function multiply(a: integer; b: integer): integer;
begin
    return a * b;
end;

function processWithCallback(x: integer; y: integer; callback_ptr);
begin
    // 使用函数指针调用
    result := ##callback_ptr(x, y);
    echo "Callback result: " $ result;
    return result;
end;

function demonstrateFunctionPointers();
begin
    // 获取函数指针
    add_ptr := @add;              // 获取add函数的指针
    mul_ptr := @multiply;         // 获取multiply函数的指针

    // 直接调用函数指针
    sum := ##add_ptr(5, 3);       // 等价于 add(5, 3)
    product := ##mul_ptr(4, 6);   // 等价于 multiply(4, 6)

    echo "Sum: " $ sum;           // 输出: Sum: 8
    echo "Product: " $ product;   // 输出: Product: 24

    // 将函数指针作为参数传递
    result1 := processWithCallback(10, 20, add_ptr);
    result2 := processWithCallback(10, 20, mul_ptr);

    return array("sum": result1, "product": result2);
end;

// 函数指针数组的使用
function useFunctionPointerArray();
begin
    // 创建函数指针数组
    operations := array(@add, @multiply);

    // 通过数组索引调用函数指针
    for i := 0 to length(operations) - 1 do
    begin
        operation := operations[i];
        result := ##operation(7, 3);
        echo "Operation " $ i $ " result: " $ result;
    end;

    return operations;
end;
```

**函数指针调用特性：**

- **调用语法**：`##pointer_name(arguments)`
- **指针获取**：使用 `@function_name` 获取函数指针
- **参数传递**：支持任意数量和类型的参数
- **返回值**：函数指针调用可以有返回值
- **动态调用**：可以在运行时决定调用哪个函数
- **方法指针**：支持对象方法的指针调用
- **数组存储**：函数指针可以存储在数组中进行批量操作

### 16. 🏗️ 类系统

#### 基础类声明

```tsf
// 声明一个简单的类
type Base = class
end; // 分号可有可无

// 继承一个类
type Child = class(Base)
end
```

#### 成员变量声明

```tsf
type MyClass = class
public
    member1;                    // 直接声明
private
    member2: string;            // 有类型的声明
protected
    [weakref]member3;           // 有[tag]的声明，weakref表示弱引用
    [weakref]member4: obj;      // 带类型和标签的声明
end;
```

#### 方法声明

```tsf
type MyClass = class
public
    // 构造和析构方法
    function Create();          // 默认构造方法
    function Destroy();         // 默认析构方法

    // 类内实现的方法
    function GetValue();
    begin
        return member1;
    end

    // 只声明的方法（类外实现）
    function Process(data: string);

    // 带修饰符的方法
    function VirtualFunc();virtual;     // 虚方法
    function OverloadFunc();overload;   // 重载方法
    function OverloadFunc(a: integer);overload; // 重载方法
private
    member1: integer;
end;
```

#### 操作符重载

TSF 支持类的操作符重载，允许自定义类如何响应特定的操作符。

```tsf
type MyClass = class
public
    // 构造函数
    function Create();

    // 操作符重载声明
    function operator[](index: integer);           // 数组访问操作符重载
    function operator+(other: MyClass);            // 加法操作符重载
    function operator=(other: MyClass);            // 赋值操作符重载
    function operator<>(other: MyClass);           // 不等于操作符重载
    function operator*(other: MyClass);            // 乘法操作符重载

    // 类内实现的操作符重载
    function operator++();                         // 前缀自增操作符重载
    begin
        value := value + 1;
        return self;
    end

private
    value: integer;
    data: array of string;
end;
```

**类外操作符重载实现：**

```tsf
// 类外实现操作符重载
function operator MyClass.[](index: integer);
begin
    if index >= 0 and index < length(data) then
        return data[index]
    else
        raise "Index out of bounds: " $ index;
end;

function operator MyClass.+(other: MyClass);
begin
    result := new MyClass();
    result.value := self.value + other.value;
    return result;
end;

function operator MyClass.=(other: MyClass);
begin
    return self.value = other.value;
end;

function operator MyClass.*(other: MyClass);
begin
    result := new MyClass();
    result.value := self.value * other.value;
    return result;
end;
```

**操作符重载使用示例：**

```tsf
function testOperatorOverloading();
begin
    // 创建对象
    obj1 := new MyClass();
    obj2 := new MyClass();

    // 使用重载的操作符
    item := obj1[0];                    // 调用 operator[]
    sum := obj1 + obj2;                 // 调用 operator+
    product := obj1 * obj2;             // 调用 operator*

    // 比较操作符
    if obj1 = obj2 then                 // 调用 operator=
        echo "Objects are equal";

    if obj1 <> obj2 then                // 调用 operator<>
        echo "Objects are not equal";

    // 自增操作符
    ++obj1;                             // 调用 operator++

    return sum;
end;
```

**支持的操作符重载：**

- **数组访问**：`[]`
- **算术运算**：`+` `-` `*` `/` `%` `^`
- **比较运算**：`=` `<>` `<` `>` `<=` `>=`
- **自增自减**：`++` `--`
- **赋值运算**：`:=`
- **其他运算**：根据需要可以重载更多操作符

#### 类外方法实现

```tsf
// 类外实现方法
function MyClass.Create();
begin
    member1 := 123;
end;

function MyClass.Process(data: string);
begin
    result := data + " processed";
end;

// 带修饰符的类外实现
function MyClass.VirtualFunc();virtual;
begin
    // 虚方法实现
end;
```

### 17. 🆕 对象创建和成员访问

#### 对象创建

```tsf
// 创建无参数对象
obj := new MyClass();

// 创建带参数对象
obj := new MyClass(param1, param2);

// 使用限定名称创建对象
obj := new package.MyClass();

// 创建对象并立即使用
result := new Calculator().add(1, 2);
```

#### 成员访问和操作

```tsf
// 成员访问
value := obj.property;
nested_value := obj.nested.property;

// 成员赋值
obj.property := 123;
obj.nested.value := "test";

// 方法调用
obj.method();
result := obj.calculate(10, 20);

// 链式调用
result := obj.method1().method2().getValue();

// 成员自增自减
obj.count++;
++obj.value;

// 成员复合赋值
obj.value += 10;
obj.score *= 1.1;

// 成员数组访问
item := obj.data[index];
obj.array[i] := new_value;
```

### 18. 📦 Unit（模块）系统

#### Unit 声明语法

```tsf
unit UnitName;                       // unit 声明，分号必须

interface                            // 对外接口部分
    // 公开的变量、常量和函数声明

implementation                       // 实现部分
    // 私有变量、常量和函数实现

initialization                       // 初始化部分（可选）
    // 单元加载时执行的代码

finalization                        // 析构部分（可选）
    // 单元卸载时执行的代码

end.                                // 结束标记，点号必须
```

#### 使用 Unit

```tsf
uses UnitName;                       // 引入单个单元
uses Unit1, Unit2, Unit3;           // 引入多个单元
```

#### 完整 Unit 示例

```tsf
unit DeMo_Unit_Test01;

interface
    var Ua, Ub;
    const CS = 888;
    function addv();
    function NumbJO(v);
    function print();

implementation
    const CN = array("奇数", "偶数");
    var Uc;

    function print();
    begin
        echo "当前值-Ua:", Ua, " Ub:", Ub, " Uc:", Uc, " CS:", CS;
    end

    function addv();
    begin
        Ua += 10;
        Uc += 1;
    end;

    function NumbJO(v);
    begin
        if (v mod 2) = 0 then
            echo v, "是一个", CN[1];
        else
            echo v, "是一个", CN[0];
    end;

initialization
    Ua := 100;
    Ub := "Tinysoft Unit";
    Uc := 1;

finalization
    echo "DeMo_Unit_Test01 End.";

end.
```

### 19. 🔍 数组索引和切片访问

```tsf
// 基础索引访问
item := arr[0];
value := matrix[i][j];

// 嵌套数组访问
user := data["users"][0];
score := user["scores"][1];

// 切片访问
slice := arr[1:5];         // 从索引1到4
head := arr[:3];           // 前3个元素
tail := arr[2:];           // 从索引2到末尾

// 复杂嵌套访问
nested_value := config["database"]["settings"]["cache"]["ttl"];

// 函数返回值的数组访问
first_item := getData()[0];
user_name := getUsers()[index]["name"];

// 对象方法链式访问
value := obj.getArray().slice(0, 5)[2];
```

### 20 TSL SELECT 语法

TSL 语言支持类似 SQL 的查询语法，但有其独特的特性和扩展。主要特点包括：

与标准 SQL 的主要区别

- 语句以 `end` 结束，而非分号
- 字段访问必须使用 `[字段名]` 格式
- 不支持 `TOP N`，但支持更灵活的 `DRANGE`
- 聚集函数名称添加 `of` 后缀（如 `countof`, `avgof`）
- 支持矩阵和数组操作
- 大小写敏感的字段名

#### 基本语法

- 通用语法结构

```sql
SELECT/UPDATE/DELETE/INSERT ... END;
```

- 字段访问方式
  - 单表访问：`["字段名"]`
  - 多表访问：`[表序号].["字段名"]`（表序号从 1 开始）
  - 整数下标访问：`[0]`（访问第 0 列）

#### SELECT 语句

##### select 基本语法

```sql
SELECT [选项] [DISTINCT] [DRANGE(范围)]
    <选择列表>
    FROM <数据源>
    [WHERE <条件>]
    [GROUP BY <分组表达式>]
    [HAVING <分组条件>]
    [ORDER BY <排序表达式>]
END;
```

#### SELECT 的变体

1. **SELECT** - 返回二维数组（默认）
2. **SSELECT** - 返回一维数组
3. **VSELECT** - 返回单个值
4. **MSELECT** - 返回 Matrix 类型（内存优化）

##### SELECTOPT 选项

| 选项名                 | 值  | 含义                 |
| ---------------------- | --- | -------------------- |
| SELECT_OPT_SINGLEV     | 1   | 返回单个值           |
| SELECT_OPT_SINGLEARRAY | 2   | 返回一维数组         |
| SELECT_OPT_MATRIX      | 4   | 返回 Matrix 类型     |
| SELECT_OPT_PACKED      | 8   | 行列下标为递增数字   |
| SELECT_OPT_AGGSAMENAME | 32  | 聚集函数保持原字段名 |

##### 选择列表语法

- `*` - 返回所有列
- `["字段名"]` - 返回指定列
- `表达式 AS "别名"` - 带别名的表达式
- `StartIndex TO EndIndex` - 返回指定范围的列

#### DRANGE 用法

1. **范围选择**：`DRANGE(0 TO 9)` - 返回第 0 到第 9 条记录
2. **负数索引**：`DRANGE(-10 TO -1)` - 返回最后 10 条记录
3. **等分选择**：`DRANGE(1 OF 10)` - 返回 10 等分中的第 1 份

#### WHERE 子句

```sql
WHERE ["字段名"] > 85
WHERE ["英语成绩"] > 85 AND ["数学成绩"] > 90
```

#### ORDER BY 子句

```sql
ORDER BY ["成绩"] DESC
ORDER BY ["语文成绩"] ASC, ["英语成绩"]/["语文成绩"] DESC
```

#### GROUP BY 子句

```sql
GROUP BY ["性别"]
GROUP BY ["性别"], groupfunc(["英语成绩"])
```

#### HAVING 子句

```sql
HAVING CountOf(*) > 1
HAVING AvgOf(["成绩"]) > 80
```

#### UPDATE 语句

##### update 基本语法

```sql
UPDATE <表名>
SET ["字段1"] = 值1, ["字段2"] = 值2
[WHERE <条件>]
END;
```

```sql
-- 更新单个字段
UPDATE B SET ["英语成绩"] = 79 WHERE ["学号"] = "03" END;

-- 更新多个字段
UPDATE B SET ["英语成绩"] = 79, ["语文成绩"] = 80 WHERE ["学号"] = "03" END;

-- 基于计算的更新
UPDATE B SET ["英语成绩"] = sqrt(["英语成绩"]) * 10 END;

-- 使用ThisRow更新整行
UPDATE R SET ThisRow = DATA WHERE ["学号"] = DATA["学号"] END;
```

#### DELETE 语句

##### delete 基本语法

```sql
DELETE FROM <表名>
[WHERE <条件>]
END;
```

```sql
-- 删除指定记录
DELETE FROM A WHERE ["学号"] = "01" END;

-- 删除所有记录
DELETE FROM A END;

-- 使用ThisRow条件
DELETE FROM R WHERE Sum(ThisRow * ThisRow) = 0 END;
```

#### INSERT 语句

##### insert 基本语法

```sql
-- 插入单行（按列顺序）
INSERT INTO <表名> VALUES (值1, 值2, ...);

-- 插入单行（指定字段）
INSERT INTO <表名> INSERTFIELDS(["字段1"], ["字段2"]) VALUES (值1, 值2);

-- 批量插入
INSERT INTO <表名> <数据数组>;
```

```sql
-- 按顺序插入
INSERT INTO A VALUES("06", "路人甲") END;

-- 指定字段插入
INSERT INTO A INSERTFIELDS(["学号"], ["姓名"], ["英语成绩"]) VALUES("06", "路人甲", 80) END;

-- 批量插入
A1 := array(("学号":"07", "姓名":"路人乙"), ("学号":"08", "姓名":"路人丙"));
INSERT INTO A A1 END;
```

#### 高级功能

##### JOIN 操作

1. **JOIN** - 内连接
2. **LEFT JOIN** - 左连接
3. **RIGHT JOIN** - 右连接
4. **FULL JOIN** - 全连接
5. **CROSS JOIN** - 笛卡尔积

##### JOIN 语法

```sql
-- 使用ON条件
SELECT * FROM A JOIN B ON [1].["学号"] = [2].["学号"] END;

-- 使用WITH ON优化（推荐）
SELECT * FROM A JOIN B WITH ([1].["学号"] ON [2].["学号"]) END;

-- 多字段JOIN
SELECT * FROM A JOIN B WITH ([1].["学号"], [1].["班级"] ON [2].["学号"], [2].["班级"]) END;

-- 多表JOIN
SELECT [1].*, [2].["英语成绩"], [3].["语文成绩"]
FROM A
JOIN B ON [1].["学号"] = [2].["学号"]
JOIN C ON [1].["学号"] = [3].["学号"]
END;
```

##### 聚集函数

| 函数      | 说明   |
| --------- | ------ |
| AvgOf()   | 平均值 |
| SumOf()   | 求和   |
| CountOf() | 计数   |
| MaxOf()   | 最大值 |
| MinOf()   | 最小值 |

##### 嵌套查询

```sql
SELECT *,
    (SELECT ["成绩"] FROM B WHERE ["学号"] = RefsOf(["学号"], 1) END) AS "成绩"
FROM A END;
```

#### 特殊关键字

##### ThisRow

- 访问当前行的完整数据
- 对一维数组查询特别有用
- 多表时使用 `ThisRow(表序号)`

##### ThisRowIndex

- 返回当前行的索引
- 即使在 ORDER BY 后仍返回原始位置
- 多表时使用 `ThisRowIndex(表序号)`

##### ThisGroup

- 在 GROUP BY 中使用
- 代表当前分组的子结果集
- 只能在 SELECT 的 FROM 子句中使用

##### ThisOrder

- 获取排序后的位置
- 相同值有相同排序号
- 排序号从 1 开始

##### RefsOf

- 访问上级结果集
- 语法：`RefsOf(表达式, 上级层数)`
- 用于嵌套查询中引用外层数据

#### 示例集合

##### 基础查询

```sql
-- 简单查询
SELECT * FROM ScoreList END;

-- 条件查询
SELECT * FROM ScoreList WHERE ["英语成绩"] > 85 END;

-- 排序查询
SELECT * FROM ScoreList ORDER BY ["英语成绩"] DESC END;

-- 限制结果
SELECT DRANGE(0 TO 9) * FROM ScoreList ORDER BY ["英语成绩"] DESC END;
```

##### 计算和转换

```sql
-- 添加计算列
SELECT *,
    RoundTo((["英语成绩"] + ["语文成绩"] + ["历史成绩"] + ["地理成绩"]) / 4, 2) AS "文科成绩"
FROM ScoreList END;

-- 使用聚集函数
SELECT AvgOf(["英语成绩"]) FROM ScoreList END;

-- 条件聚集
SELECT AvgOf(["英语成绩"]) FROM ScoreList WHERE ["英语成绩"] > 85 END;
```

##### 分组统计

```sql
-- 简单分组
SELECT ["性别"], AvgOf(["成绩"]), CountOf(*)
FROM ScoreList
GROUP BY ["性别"] END;

-- 多字段分组
SELECT ["性别"], ["年级"], AvgOf(["成绩"])
FROM ScoreList
GROUP BY ["性别"], ["年级"] END;

-- 分组筛选
SELECT groupfunc(["英语成绩"]), AvgOf(["英语成绩"]), CountOf(*)
FROM ScoreList
GROUP BY groupfunc(["英语成绩"])
HAVING CountOf(*) > 1 END;
```

##### 一维数组操作

```sql
-- 查询一维数组
R := array(1, 2, 3, 4, 5, 6);
R1 := SELECT ThisRow FROM R WHERE ThisRow > 5 END;

-- 返回一维结果
R2 := SSELECT ThisRow FROM R WHERE ThisRow > 5 END;

-- 更新一维数组
UPDATE R SET ThisRow = ThisRow * 10 END;
```

##### 复杂查询

```sql
-- 多表连接与计算
SELECT
    [1].["学号"],
    [1].["姓名"],
    [2].["英语成绩"],
    [3].["数学成绩"],
    ([2].["英语成绩"] + [3].["数学成绩"]) / 2 AS "平均分"
FROM 学生表
LEFT JOIN 英语成绩表 ON [1].["学号"] = [2].["学号"]
LEFT JOIN 数学成绩表 ON [1].["学号"] = [3].["学号"]
WHERE [1].["班级"] = "一班"
ORDER BY "平均分" DESC
END;
```

## 注意事项

1. **字段名大小写敏感**
2. **表序号从 1 开始计数**
3. **使用 WITH ON 代替 ON 以提高 JOIN 性能**
4. **聚集函数使用时注意添加 of 后缀**
5. **空值（NIL）的处理需要特别注意**
6. **UPDATE 可以自动创建新列（针对内存结果集）**

## 性能优化建议

1. 使用 WITH ON 进行 JOIN 操作
2. 合理使用 DRANGE 限制结果集大小
3. 在大数据集上使用 MSELECT 返回 Matrix 类型
4. 避免在 WHERE 子句中使用复杂计算
5. 适当使用索引和预计算优化查询

## 📝 语法规则和优先级

### 运算符优先级（从高到低）

1. **成员访问和数组访问**：`.` `[]`
2. **后缀运算符**：`++` `--`（后缀）
3. **前缀运算符**：`++` `--`（前缀）、`+` `-`（正负号）、`.!!` `not`、`.!`、`!`（求逆）、`` ` ``（矩阵转置）
4. **乘方运算符**：`^` `~` `:^`（矩阵乘方）
5. **乘除运算符**：`*` `/` `%` `mod` `div` `:*`（矩阵乘法）`:\\`（矩阵左除）
6. **加减运算符**：`+` `-` `|`（矩阵列连接）`Union`（矩阵行连接）`:|`（非完全矩阵列连接）
7. **连接运算符**：`$`
8. **位移运算符**：`shl` `rol` `shr` `ror`
9. **比较运算符**：`=` `<>` `<` `>` `<=` `>=`
10. **集合运算符**：`union` `union2` `minus` `intersect`
11. **判断运算符**：`is class()` `in`
12. **位与运算符**：`.&`
13. **位异或运算符**：`.^`
14. **位或运算符**：`.|`
15. **逻辑与运算符**：`.&&` `and`
16. **逻辑或运算符**：`.||` `or`
17. **三元条件运算符**：`? :`
18. **赋值运算符**：`:=` `+=` `-=` `*=` `/=` `union=` `union2=` `minus=` `intersect=`

### 语法规则说明

**自增自减语句规则：**

- **前缀自增自减**：`++variable;` `--variable;` - 作为独立的 `increment_statement`
- **后缀自增自减**：`variable++;` `variable--;` - 作为 `postfix_expression`，然后作为 `expression_statement` 使用
- **优先级和语义**：
  - 前缀：先修改变量值，再返回新值
  - 后缀：先返回原值，再修改变量值
  - 在表达式中使用时，两者的语义不同

**语句块规则：**

- 单行语句：可以省略 `begin end`
- 多行语句：必须用 `begin end` 包围
- `end` 后的分号可有可无

**类语法规则：**

- **类声明**：`type ClassName = class [inheritance] [members] end [;]`
- **继承语法**：`class(BaseClass)`
- **访问修饰符**：影响后续所有成员，直到遇到新的修饰符
- **成员标签**：`[tag]` 必须紧接在成员名称前
- **方法实现**：可以在类内或类外实现
- **操作符重载**：使用 `function operator[symbol]` 语法，类外实现使用 `function operator ClassName.[symbol]`

**Unit 语法规则：**

1. **Unit 声明必须在文件开头**
2. **Unit 名称后的分号不能省略**
3. **结束标记必须是 `end.`（点号不能省略）**
4. **一个文件只能包含一个 Unit**
5. **使用 `uses` 引入单元时，单元名不需要引号**

## 🚀 实际应用示例

### 使用所有新特性的综合示例

```tsf
// 使用所有新特性的综合示例
function comprehensive_matrix_processor(input_data);
begin
    // 使用解包获取输入
    [matrices, sets, config, filters] := input_data;

    // 验证配置
    if not (config["mode"] in array("matrix", "set", "mixed")) then
        raise "Invalid mode: " $ config["mode"] $ " (expected: matrix/set/mixed)";

    processed_results := array();

    for i := 0 to length(matrices) - 1 do
    begin
        matrix := matrices[i];

        // 使用is class判断对象类型
        if matrix is class(Matrix) then
        begin
            echo "Processing matrix: " $ matrix.name $ " (size: " $ matrix.rows $ "x" $ matrix.cols $ ")";

            // 矩阵运算
            transposed := `matrix.data;                    // 矩阵转置（前缀）
            inverted := !matrix.data;                      // 矩阵求逆
            squared := matrix.data :^ 2;                   // 矩阵平方

            // 矩阵连接运算
            if i < length(matrices) - 1 then
            begin
                next_matrix := matrices[i + 1];
                if next_matrix is class(Matrix) then
                begin
                    // 尝试不同的连接方式
                    col_concat := matrix.data | next_matrix.data;    // 列连接
                    row_concat := matrix.data Union next_matrix.data; // 行连接

                    // 矩阵乘法
                    if matrix.cols = next_matrix.rows then
                        multiplied := matrix.data :* next_matrix.data;
                end;
            end;

            processed_results[length(processed_results)] := array(
                "type": "matrix",
                "original": matrix.data,
                "transposed": transposed,
                "operations": array("transpose", "invert", "power")
            );
        end
        else begin
            echo "Skipping non-matrix object at index " $ i;
        end;
    end;

    // 集合运算处理
    combined_sets := array();
    for j := 0 to length(sets) - 1 do
    begin
        current_set := sets[j];

        // 集合运算
        if j = 0 then
            combined_sets := current_set
        else begin
            // 根据配置选择不同的集合运算
            operation := config["set_operation"];
            if operation = "union" then
                combined_sets union= current_set
            else if operation = "intersect" then
                combined_sets intersect= current_set
            else if operation = "minus" then
                combined_sets minus= current_set
            else
                combined_sets union2= current_set;
        end;
    end;

    // 使用函数指针进行回调处理
    if "callback" in config then
    begin
        callback_ptr := config["callback"];
        for result in processed_results do
        begin
            ##callback_ptr(result);              // 函数指针调用
        end;
    end;

    // 矩阵转置表达式语句
    `matrix;                            // 矩阵转置表达式语句（前缀）
    matrix1 :* matrix2;                 // 矩阵乘法表达式语句

    // 自增自减表达式语句
    counter++;                          // 后缀自增表达式语句
    working_set.length++;               // 对象成员自增表达式语句

    return array(
        "matrices": processed_results,
        "combined_sets": combined_sets,
        "total_operations": length(processed_results) + length(sets)
    );
end;
```

## 🔧 语法解析器使用

### 生成解析器

```bash
tree-sitter generate
```

### 运行测试

```bash
chmod +x test_tsf.sh
./test_tsf.sh
```

### 解析单个文件

```bash
tree-sitter parse your_file.tsf
```

### 调试语法

```bash
tree-sitter parse your_file.tsf --debug
```

## 📊 支持的特性总结

✅ **完整支持的特性：**

- 🔧 **函数定义和调用**（参数类型、默认值、重载）
- 🔗 **函数指针调用**（`##pointer(args)` 语法）
- 📊 **灵活的嵌套数组系统**（支持表达式、函数调用、元组、键值对混合）
- 📤 **解包（destructuring）赋值语法**（数组元素自动分配）
- 🔑 **关键字语句**（echo 输出、raise 异常抛出）
- 🔗 **$万能连接符**（任意类型自动转换连接）
- 🔍 **判断语法**（is class 类型检查、in 成员检查）
- 📊 **矩阵运算系统**（前缀转置、求逆、乘法、连接、乘方等）
- 🔢 **集合运算系统**（并集、交集、差集及其复合赋值）
- 📝 **表达式语句**（任何表达式都可以作为独立语句使用）
- 🏗️ **完整的类和对象系统**（继承、访问控制、方法重写、操作符重载）
- 📦 **Unit 模块系统**（接口、实现、初始化、析构）
- ➕ **丰富的运算符集合**（算术、逻辑、位运算、三元表达式）
- 🔀 **完整的控制流语句**（if/else、case、循环、跳转）
- 🔍 **特殊查询语法**（vselect/select/sselect）
- 🔢 **多种数字格式**（十进制、科学记数法、十六进制、二进制、八进制）
- 🗨️ **多种注释类型**（行注释、两种块注释）
- 📝 **数组索引和切片访问**（多维数组、嵌套访问、切片操作）
- 🆕 **对象创建和成员访问**（new 操作符、链式调用、成员操作）

**🆕 新增的高级特性：**

- **操作符重载**：`function operator[symbol]` 语法，支持类的自定义运算符行为
- **函数指针调用**：`##pointer(args)` 语法，支持动态函数调用
- **矩阵运算**：`` ` ``转置（前缀）、`!`求逆、`:*`乘法、`:\\`左除、`:^`乘方、`|`列连接、`Union`行连接
- **集合运算**：`union`并集、`intersect`交集、`minus`差集、`union2`特殊并集
- **复合赋值扩展**：`union=`、`intersect=`、`minus=`、`union2=`等集合运算复合赋值
- **表达式语句**：支持将任何表达式作为独立语句，便于函数调用和副作用操作

这个语法解析器为 TSF 语言提供了完整的语法支持，特别是在数组处理、类型检查、异常处理、字符串连接、矩阵运算、集合运算、操作符重载和函数指针调用方面具有强大的能力。这些特性使得 TSF 语言在科学计算、数据处理和面向对象编程领域更加强大和实用。
