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