# 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 语言在科学计算、数据处理和面向对象编程领域更加强大和实用。