body,
NodeContext _
) -> {
System.out.println(pad + "loop {");
- print(initializer, indent + 1);
- System.out.println(pad + " condition: " + condition);
- System.out.println(pad + " update: " + update);
+ print(init, indent + 1);
+ System.out.println(pad + " cond: " + cond);
+ System.out.println(pad + " step: " + step);
System.out.println(pad + " body {");
for (StatementNode stmt : body) {
print(stmt, indent + 2);
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/function/FunctionParser.java b/src/main/java/org/jcnc/snow/compiler/parser/function/FunctionParser.java
index 17597c0..39d928a 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/function/FunctionParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/function/FunctionParser.java
@@ -22,7 +22,7 @@ import java.util.*;
* 实现 {@link TopLevelParser} 接口，用于将源代码中的函数块解析为抽象语法树（AST）中的 {@link FunctionNode}。
*
*
- * 本类使用 {@link FlexibleSectionParser} 机制，按照语义区块结构对函数进行模块化解析，支持以下部分：
+ * 本类使用 {@link FlexibleSectionParser} 机制，按照语义区块结构对函数进行模块化解析，支持以下部分:
*
*
*
@@ -110,7 +110,7 @@ public class FunctionParser implements TopLevelParser {
* 构造函数定义中各区块的解析规则（parameter、return_type、body）。
*
*
- * 每个 {@link SectionDefinition} 包含两个部分：区块起始判断器（基于关键字）与具体的解析逻辑。
+ * 每个 {@link SectionDefinition} 包含两个部分: 区块起始判断器（基于关键字）与具体的解析逻辑。
*
*
* @param params 参数节点收集容器，解析结果将存入此列表。
@@ -180,7 +180,7 @@ public class FunctionParser implements TopLevelParser {
* 解析函数参数列表。
*
*
- * 支持声明后附加注释，格式示例：
+ * 支持声明后附加注释，格式示例:
*
* parameter:
* declare x: int // 说明文字
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/module/ImportParser.java b/src/main/java/org/jcnc/snow/compiler/parser/module/ImportParser.java
index 10ca4d5..d46abd3 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/module/ImportParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/module/ImportParser.java
@@ -11,7 +11,7 @@ import java.util.List;
/**
* {@code ImportParser} 类用于解析源码中的 import 导入语句。
*
- * 支持以下格式的语法：
+ * 支持以下格式的语法:
*
* import: module1, module2, module3
*
@@ -23,7 +23,7 @@ public class ImportParser {
/**
* 解析 import 语句，并返回表示被导入模块的语法树节点列表。
*
- * 该方法会依次执行以下操作：
+ * 该方法会依次执行以下操作:
*
* - 确认当前语句以关键字 {@code import} 开头。
* - 确认后跟一个冒号 {@code :}。
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/module/ModuleParser.java b/src/main/java/org/jcnc/snow/compiler/parser/module/ModuleParser.java
index fc8ff02..5cc7335 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/module/ModuleParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/module/ModuleParser.java
@@ -22,7 +22,7 @@ import java.util.List;
*
*
*
- * 典型模块语法结构：
+ * 典型模块语法结构:
*
* module: mymod
* import ...
@@ -37,7 +37,7 @@ public class ModuleParser implements TopLevelParser {
/**
* 解析一个模块定义块，返回完整的 {@link ModuleNode} 语法树节点。
*
- * 解析过程包括：
+ * 解析过程包括:
*
* - 匹配模块声明起始 {@code module: IDENTIFIER}。
* - 收集模块体内所有 import 和 function 语句，允许穿插空行。
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java b/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java
index a7e6fa3..5cbcc40 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/statement/DeclarationStatementParser.java
@@ -10,12 +10,12 @@ import org.jcnc.snow.compiler.parser.expression.PrattExpressionParser;
/**
* {@code DeclarationStatementParser} 类负责解析变量声明语句，是语句级解析器的一部分。
*
- * 本解析器支持以下两种形式的声明语法：
+ * 本解析器支持以下两种形式的声明语法:
*
{@code
* declare myVar:Integer
* declare myVar:Integer = 42 + 3
* }
- * 其中：
+ * 其中:
*
* - {@code myVar} 为变量名（必须为标识符类型）；
* - {@code Integer} 为类型标注（必须为类型标记）；
@@ -29,7 +29,7 @@ public class DeclarationStatementParser implements StatementParser {
/**
* 解析一条 {@code declare} 声明语句，并返回对应的抽象语法树节点 {@link DeclarationNode}。
*
- * 解析流程如下：
+ * 解析流程如下:
*
* - 匹配关键字 {@code declare}；
* - 读取变量名称（标识符类型）；
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/statement/ExpressionStatementParser.java b/src/main/java/org/jcnc/snow/compiler/parser/statement/ExpressionStatementParser.java
index 36af619..7e80851 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/statement/ExpressionStatementParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/statement/ExpressionStatementParser.java
@@ -14,7 +14,7 @@ import org.jcnc.snow.compiler.parser.expression.PrattExpressionParser;
/**
* {@code ExpressionStatementParser} 用于解析通用表达式语句（赋值或普通表达式）。
*
- * 支持以下两种语法结构：
+ * 支持以下两种语法结构:
*
{@code
* x = 1 + 2 // 赋值语句
* doSomething() // 一般表达式语句
@@ -51,7 +51,7 @@ public class ExpressionStatementParser implements StatementParser {
int column = ts.peek().getCol();
String file = ctx.getSourceName();
- // 赋值语句：IDENTIFIER = expr
+ // 赋值语句: IDENTIFIER = expr
if (ts.peek().getType() == TokenType.IDENTIFIER && "=".equals(ts.peek(1).getLexeme())) {
String varName = ts.next().getLexeme();
ts.expect("=");
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/statement/IfStatementParser.java b/src/main/java/org/jcnc/snow/compiler/parser/statement/IfStatementParser.java
index 24d6556..aaff612 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/statement/IfStatementParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/statement/IfStatementParser.java
@@ -15,7 +15,7 @@ import java.util.List;
/**
* {@code IfStatementParser} 类负责解析 if 条件语句，是语句级解析器中的条件分支处理器。
*
- * 本解析器支持以下结构的条件语法：
+ * 本解析器支持以下结构的条件语法:
*
{@code
* if then
*
@@ -23,7 +23,7 @@ import java.util.List;
* ]
* end if
* }
- * 其中：
+ * 其中:
* {@code
* loop:
- * initializer:
- * declare i:int = 0
- * condition:
- * i < 10
- * update:
- * i = i + 1
- * body:
- * print(i)
- * end body
+ * init:
+ * declare i: int = 0
+ * cond:
+ * i < 10
+ * step:
+ * i = i + 1
+ * body:
+ * …
+ * end body
* end loop
* }
*
- * 各区块说明：
+ * 各区块说明:
*
- * - {@code initializer}：初始化语句，通常为变量声明。
- * - {@code condition}：循环判断条件，必须为布尔或数值表达式。
- * - {@code update}：每轮执行后更新逻辑，通常为赋值语句。
- * - {@code body}：主执行语句块，支持任意多条语句。
+ * - {@code init}: 初始化语句，通常为变量声明。
+ * - {@code cond}: 循环判断条件，必须为布尔或数值表达式。
+ * - {@code step}: 每轮执行后更新逻辑，通常为赋值语句。
+ * - {@code body}: 主执行语句块，支持任意多条语句。
*
* 本类依赖 {@link FlexibleSectionParser} 实现各区块的统一处理，确保结构明确、可扩展。
*/
@@ -50,7 +50,7 @@ public class LoopStatementParser implements StatementParser {
/**
* 解析 {@code loop} 语句块，构建出对应的 {@link LoopNode} 抽象语法树节点。
*
- * 本方法会按顺序检查各个命名区块（可乱序书写），并分别绑定其对应语义解析器：
+ * 本方法会按顺序检查各个命名区块（可乱序书写），并分别绑定其对应语义解析器:
*
* - 通过 {@link ParserUtils#matchHeader} 匹配区块开头；
* - 通过 {@link FlexibleSectionParser} 派发区块逻辑；
@@ -75,54 +75,54 @@ public class LoopStatementParser implements StatementParser {
ParserUtils.matchHeader(ts, "loop");
// 使用数组模拟引用以便在 lambda 中写入（Java 不支持闭包内修改局部变量）
- final StatementNode[] initializer = new StatementNode[1];
- final ExpressionNode[] condition = new ExpressionNode[1];
- final AssignmentNode[] update = new AssignmentNode[1];
+ final StatementNode[] init = new StatementNode[1];
+ final ExpressionNode[] cond = new ExpressionNode[1];
+ final AssignmentNode[] step = new AssignmentNode[1];
final List body = new ArrayList<>();
// 定义各命名区块的识别与处理逻辑
Map sections = new HashMap<>();
- // initializer 区块：仅支持一条语句，通常为 declare
- sections.put("initializer", new FlexibleSectionParser.SectionDefinition(
- ts1 -> ts1.peek().getLexeme().equals("initializer"),
+ // init 区块: 仅支持一条语句，通常为 declare
+ sections.put("init", new FlexibleSectionParser.SectionDefinition(
+ ts1 -> ts1.peek().getLexeme().equals("init"),
(ctx1, ts1) -> {
- ParserUtils.matchHeader(ts1, "initializer");
- initializer[0] = StatementParserFactory.get(ts1.peek().getLexeme()).parse(ctx1);
+ ParserUtils.matchHeader(ts1, "init");
+ init[0] = StatementParserFactory.get(ts1.peek().getLexeme()).parse(ctx1);
ParserUtils.skipNewlines(ts1);
}
));
- // condition 区块：支持任意可解析为布尔的表达式
- sections.put("condition", new FlexibleSectionParser.SectionDefinition(
- ts1 -> ts1.peek().getLexeme().equals("condition"),
+ // cond 区块: 支持任意可解析为布尔的表达式
+ sections.put("cond", new FlexibleSectionParser.SectionDefinition(
+ ts1 -> ts1.peek().getLexeme().equals("cond"),
(ctx1, ts1) -> {
- ParserUtils.matchHeader(ts1, "condition");
- condition[0] = new PrattExpressionParser().parse(ctx1);
+ ParserUtils.matchHeader(ts1, "cond");
+ cond[0] = new PrattExpressionParser().parse(ctx1);
ts1.expectType(TokenType.NEWLINE);
ParserUtils.skipNewlines(ts1);
}
));
- // update 区块：目前仅支持单一变量赋值语句
- sections.put("update", new FlexibleSectionParser.SectionDefinition(
- ts1 -> ts1.peek().getLexeme().equals("update"),
+ // step 区块: 目前仅支持单一变量赋值语句
+ sections.put("step", new FlexibleSectionParser.SectionDefinition(
+ ts1 -> ts1.peek().getLexeme().equals("step"),
(ctx1, ts1) -> {
// 获取当前 token 的行号、列号
int line = ctx.getTokens().peek().getLine();
int column = ctx.getTokens().peek().getCol();
- ParserUtils.matchHeader(ts1, "update");
+ ParserUtils.matchHeader(ts1, "step");
String varName = ts1.expectType(TokenType.IDENTIFIER).getLexeme();
ts1.expect("=");
ExpressionNode expr = new PrattExpressionParser().parse(ctx1);
ts1.expectType(TokenType.NEWLINE);
- update[0] = new AssignmentNode(varName, expr, new NodeContext(line, column, file));
+ step[0] = new AssignmentNode(varName, expr, new NodeContext(line, column, file));
ParserUtils.skipNewlines(ts1);
}
));
- // body 区块：支持多条语句，直到遇到 end body
+ // body 区块: 支持多条语句，直到遇到 end body
sections.put("body", new FlexibleSectionParser.SectionDefinition(
ts1 -> ts1.peek().getLexeme().equals("body"),
(ctx1, ts1) -> {
@@ -151,6 +151,6 @@ public class LoopStatementParser implements StatementParser {
ParserUtils.matchFooter(ts, "loop");
// 返回构造完成的 LoopNode
- return new LoopNode(initializer[0], condition[0], update[0], body, new NodeContext(loop_line, loop_column, file));
+ return new LoopNode(init[0], cond[0], step[0], body, new NodeContext(loop_line, loop_column, file));
}
}
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/statement/ReturnStatementParser.java b/src/main/java/org/jcnc/snow/compiler/parser/statement/ReturnStatementParser.java
index 3b4c6c1..f344b80 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/statement/ReturnStatementParser.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/statement/ReturnStatementParser.java
@@ -10,7 +10,7 @@ import org.jcnc.snow.compiler.parser.expression.PrattExpressionParser;
/**
* {@code ReturnStatementParser} 负责解析 return 语句，是语句级解析器的一部分。
*
- * 支持以下两种 return 语句形式：
+ * 支持以下两种 return 语句形式:
*
{@code
* return // 无返回值
* return expression // 带返回值
@@ -23,7 +23,7 @@ public class ReturnStatementParser implements StatementParser {
/**
* 解析一条 return 语句，并返回对应的 {@link ReturnNode} 抽象语法树节点。
*
- * 解析逻辑如下：
+ * 解析逻辑如下:
*
* - 匹配起始关键字 {@code return}。
* - 判断其后是否为 {@code NEWLINE}，若否则表示存在返回值表达式。
diff --git a/src/main/java/org/jcnc/snow/compiler/parser/utils/ASTJsonSerializer.java b/src/main/java/org/jcnc/snow/compiler/parser/utils/ASTJsonSerializer.java
index 278a42c..9091af8 100644
--- a/src/main/java/org/jcnc/snow/compiler/parser/utils/ASTJsonSerializer.java
+++ b/src/main/java/org/jcnc/snow/compiler/parser/utils/ASTJsonSerializer.java
@@ -14,7 +14,7 @@ import java.util.*;
* 并可借助 {@code JSONParser.toJson(Object)} 方法将其序列化为 JSON 字符串，用于调试、
* 可视化或跨语言数据传输。
*
- * 支持的节点类型包括（新增对 {@code BoolLiteralNode}、{@code UnaryExpressionNode} 的完整支持）：
+ * 支持的节点类型包括（新增对 {@code BoolLiteralNode}、{@code UnaryExpressionNode} 的完整支持）:
*
* - {@link ModuleNode}
* - {@link FunctionNode}
@@ -121,7 +121,7 @@ public class ASTJsonSerializer {
Map map = newNodeMap("Declaration");
map.put("name", d.getName());
map.put("varType", d.getType());
- map.put("initializer", d.getInitializer().map(ASTJsonSerializer::exprToMap).orElse(null));
+ map.put("init", d.getInitializer().map(ASTJsonSerializer::exprToMap).orElse(null));
yield map;
}
// 赋值语句节点
@@ -132,7 +132,7 @@ public class ASTJsonSerializer {
// 条件语句节点
case IfNode i -> {
Map map = newNodeMap("If");
- map.put("condition", exprToMap(i.condition()));
+ map.put("cond", exprToMap(i.condition()));
List
-
- 
+
+ 
@@ -53,12 +53,12 @@ Snow 语言受到 LLM 驱动代码生成趋势的启发,强调简单而清晰的
| 类别 | 关键特性 |
|----------|---------------------------------------------------------------------------------------------------|
-| 语言层 | `module` / `import` / `function` / `loop` / `if–else` / Pratt 表达式解析