errors = new ArrayList<>();
-
- /**
- * 构造词法分析器，并指定源文件名（用于诊断信息）。
- * 构造时立即进行全量扫描，扫描结束后打印所有 Token 并报告词法错误。
- *
+ * 创建并立即执行扫描-校验-报告流程。
* @param source 源代码文本
- * @param sourceName 文件名或来源描述（如"Main.snow"）
+ * @param sourceName 文件名（诊断用）
*/
public LexerEngine(String source, String sourceName) {
- this.absPath = new File(sourceName).getAbsolutePath();
- this.context = new LexerContext(source);
+ this.absPath = new File(sourceName).getAbsolutePath();
+ this.context = new LexerContext(source);
this.scanners = List.of(
- new WhitespaceTokenScanner(), // 跳过空格、制表符等
- new NewlineTokenScanner(), // 处理换行符，生成 NEWLINE Token
- new CommentTokenScanner(), // 处理单行/多行注释
- new NumberTokenScanner(), // 识别整数与浮点数字面量
- new IdentifierTokenScanner(), // 识别标识符和关键字
- new StringTokenScanner(), // 处理字符串常量
- new OperatorTokenScanner(), // 识别运算符
- new SymbolTokenScanner(), // 识别括号、分号等符号
- new UnknownTokenScanner() // 捕捉无法识别的字符，最后兜底
+ new WhitespaceTokenScanner(),
+ new NewlineTokenScanner(),
+ new CommentTokenScanner(),
+ new NumberTokenScanner(),
+ new IdentifierTokenScanner(),
+ new StringTokenScanner(),
+ new OperatorTokenScanner(),
+ new SymbolTokenScanner(),
+ new UnknownTokenScanner()
);
- // 主扫描流程，遇到非法字符立即输出错误并终止进程
- try {
- scanAllTokens();
- } catch (LexicalException le) {
- // 输出：绝对路径: 行 x, 列 y: 错误信息
- System.err.printf(
- "%s: 行 %d, 列 %d: %s%n",
- absPath,
- le.getLine(),
- le.getColumn(),
- le.getReason()
- );
- System.exit(65); // 65 = EX_DATAERR
- }
- TokenPrinter.print(this.tokens);
- LexerEngine.report(this.getErrors());
+ /* 1. 扫描 */
+ scanAllTokens();
+ /* 2. 后置整体校验 */
+ validateTokens();
+ /* 3. 打印 token */
+ TokenPrinter.print(tokens);
+ /* 4. 统一报告错误 */
+ report(errors);
if (!errors.isEmpty()) {
- throw new LexicalException("Lexing failed with " + errors.size() + " error(s).", this.context.getLine(), this.context.getCol());
+ throw new LexicalException(
+ "Lexing failed with " + errors.size() + " error(s).",
+ context.getLine(), context.getCol()
+ );
}
}
- /**
- * 静态报告方法。
- *
- * 打印所有词法分析过程中收集到的错误信息。
- * 如果无错误，输出词法分析通过的提示。
- *
- * @param errors 词法错误列表
- */
public static void report(List errors) {
- if (errors != null && !errors.isEmpty()) {
- System.err.println("\n词法分析发现 " + errors.size() + " 个错误：");
- errors.forEach(err -> System.err.println(" " + err));
- } else {
+ if (errors == null || errors.isEmpty()) {
System.out.println("\n## 词法分析通过，没有发现错误\n");
+ return;
}
+ System.err.println("\n词法分析发现 " + errors.size() + " 个错误：");
+ errors.forEach(e -> System.err.println(" " + e));
}
+ public List getAllTokens() { return List.copyOf(tokens); }
+ public List getErrors() { return List.copyOf(errors); }
+
/**
- * 主扫描循环，将源代码转为 Token 序列。
- *
- * 依次尝试每个扫描器，直到找到可处理当前字符的扫描器为止。
- * 扫描到结尾后补充 EOF Token。
- * 若遇到词法异常则收集错误并跳过当前字符，避免死循环。
+ * 逐字符扫描：依次尝试各扫描器；扫描器抛出的
+ * {@link LexicalException} 被捕获并转为 {@link LexicalError}。
*/
private void scanAllTokens() {
while (!context.isAtEnd()) {
- char currentChar = context.peek();
+ char ch = context.peek();
boolean handled = false;
- for (TokenScanner scanner : scanners) {
- if (scanner.canHandle(currentChar, context)) {
- try {
- scanner.handle(context, tokens);
- } catch (LexicalException le) {
- // 收集词法错误，不直接退出
- errors.add(new LexicalError(
- absPath, le.getLine(), le.getColumn(), le.getReason()
- ));
- // 跳过当前字符，防止死循环
- context.advance();
- }
- handled = true;
- break;
+
+ for (TokenScanner s : scanners) {
+ if (!s.canHandle(ch, context)) continue;
+
+ try {
+ s.handle(context, tokens);
+ } catch (LexicalException le) {
+ errors.add(new LexicalError(
+ absPath, le.getLine(), le.getColumn(), le.getReason()
+ ));
+ context.advance(); // 跳过问题字符
}
+ handled = true;
+ break;
}
- if (!handled) {
- // 没有任何扫描器能处理，跳过一个字符防止死循环
- context.advance();
- }
+
+ if (!handled) context.advance(); // 理论不会走到，保险
}
tokens.add(Token.eof(context.getLine()));
}
/**
- * 获取全部 Token（包含 EOF），返回只读列表。
- *
- * @return 词法分析结果 Token 列表
+ * 目前包含三条规则：
+ * 1. Dot-Prefix'.' 不能作标识符前缀
+ * 2. Declare-Ident declare 后必须紧跟合法标识符，并且只能一个
+ * 3. Double-Ident declare 后若出现第二个 IDENTIFIER 视为多余
+ *
发现问题仅写入 {@link #errors}，不抛异常。
*/
- public List getAllTokens() {
- return List.copyOf(tokens);
+ private void validateTokens() {
+ for (int i = 0; i < tokens.size(); i++) {
+ Token tok = tokens.get(i);
+
+ /* ---------- declare 规则 ---------- */
+ if (tok.getType() == TokenType.KEYWORD
+ && "declare".equalsIgnoreCase(tok.getLexeme())) {
+
+ // 第一个非 NEWLINE token
+ Token id1 = findNextNonNewline(i);
+ if (id1 == null || id1.getType() != TokenType.IDENTIFIER) {
+ errors.add(err(
+ (id1 == null ? tok : id1),
+ "declare 后必须跟合法标识符 (以字母或 '_' 开头)"
+ ));
+ continue; // 若首标识符就错，后续检查可略
+ }
+
+ // 检查是否有第二个 IDENTIFIER
+ Token id2 = findNextNonNewline(tokens.indexOf(id1));
+ if (id2 != null && id2.getType() == TokenType.IDENTIFIER) {
+ errors.add(err(id2, "declare 声明中出现多余的标识符"));
+ }
+ }
+ }
}
- /**
- * 返回全部词法错误（返回只读列表）。
- *
- * @return 词法错误列表
- */
- public List getErrors() {
- return List.copyOf(errors);
+ /** index 右侧最近非 NEWLINE token；无则 null */
+ private Token findNextNonNewline(int index) {
+ for (int j = index + 1; j < tokens.size(); j++) {
+ Token t = tokens.get(j);
+ if (t.getType() != TokenType.NEWLINE) return t;
+ }
+ return null;
+ }
+
+ /** 构造统一的 LexicalError */
+ private LexicalError err(Token t, String msg) {
+ return new LexicalError(absPath, t.getLine(), t.getCol(), "非法的标记序列：" + msg);
}
}