一个极简的词法分析器实现

已于 2025-04-01 09:50:46 修改
阅读量341 收藏 4
点赞数 7
分类专栏： C/C++ 文章标签： c语言 算法 linux
于 2025-03-31 22:44:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jgku/article/details/146888004
版权

文章目录


最近两天搞一个DSL，不得不重温了一把antlr4和编译原理之词法分析。

推荐：Tiny Lexer - 一个极简的C语言词法分析器

推荐一个非常小巧但完整的C语言词法分析器实现 - Tiny Lexer。它具有以下优点：

特点

  • 代码量极小（约100行核心代码）
  • 纯C实现，无外部依赖
  • 易于理解和学习
  • 包含完整的功能：标识符、数字、运算符识别等

核心代码实现

#include <stdio.h>
#include <ctype.h>
#include <string.h>

typedef enum {
    TOKEN_EOF,
    TOKEN_NUMBER,
    TOKEN_IDENTIFIER,
    TOKEN_OPERATOR,
    TOKEN_UNKNOWN
} TokenType;

typedef struct {
    TokenType type;
    char value[32];
} Token;

Token get_next_token(const char** input) {
    Token token = {TOKEN_UNKNOWN, {0}};
    
    // 跳过空白字符
    while (isspace(**input)) {
        (*input)++;
    }
    
    // 检查文件结束
    if (**input == '\0') {
        token.type = TOKEN_EOF;
        return token;
    }
    
    // 处理数字
    if (isdigit(**input)) {
        token.type = TOKEN_NUMBER;
        int i = 0;
        while (isdigit(**input) && i < sizeof(token.value)-1) {
            token.value[i++] = *(*input)++;
        }
        token.value[i] = '\0';
        return token;
    }
    
    // 处理标识符（字母开头）
    if (isalpha(**input)) {
        token.type = TOKEN_IDENTIFIER;
        int i = 0;
        while ((isalnum(**input) || **input == '_') && i < sizeof(token.value)-1) {
            token.value[i++] = *(*input)++;
        }
        token.value[i] = '\0';
        return token;
    }
    
    // 处理运算符
    if (strchr("+-*/=(){};", **input)) {
        token.type = TOKEN_OPERATOR;
        token.value[0] = *(*input)++;
        token.value[1] = '\0';
        return token;
    }
    
    // 未知字符
    token.value[0] = *(*input)++;
    return token;
}

int main() {
    const char* input = "int x = 42 + y;";
    const char* p = input;
    
    while (1) {
        Token token = get_next_token(&p);
        if (token.type == TOKEN_EOF) break;
        
        const char* type_str;
        switch (token.type) {
            case TOKEN_NUMBER: type_str = "NUMBER"; break;
            case TOKEN_IDENTIFIER: type_str = "IDENTIFIER"; break;
            case TOKEN_OPERATOR: type_str = "OPERATOR"; break;
            default: type_str = "UNKNOWN"; break;
        }
        
        printf("Token: %-12s Value: %s\n", type_str, token.value);
    }
    
    return 0;
}

学习价值

  1. 词法分析基本原理：展示了如何将输入流分解为token
  2. 状态机概念：通过条件判断实现了简单的状态转移
  3. 可扩展性：可以轻松添加更多token类型和规则
  4. 实用性：虽然简单，但包含了词法分析的核心功能

扩展建议

学习这个基本实现后，你可以尝试：

  1. 添加更多运算符和关键字识别
  2. 实现更复杂的数字格式（如浮点数）
  3. 添加错误处理机制
  4. 将其扩展为递归下降语法分析器

这个实现去除了所有不必要的复杂性，是学习编译原理前端技术的理想起点。

用Java实现一个简单的词法分析器

下面我将实现一个最简的词法分析器（Lexer），它可以识别以下类型的词法单元（Token）：

  • 整数（如 123）
  • 浮点数（如 3.14）
  • 标识符（如 variable）
  • 运算符（如 +, -, *, /）
  • 分隔符（如 (, ), ;）

完整实现代码

import java.util.ArrayList;
import java.util.List;

public class SimpleLexer {
    
    // Token类型枚举
    public enum TokenType {
        INTEGER,    // 整数
        FLOAT,      // 浮点数
        IDENTIFIER, // 标识符
        OPERATOR,   // 运算符
        DELIMITER,  // 分隔符
        EOF         // 文件结束
    }
    
    // Token类
    public static class Token {
        public final TokenType type;
        public final String value;
        
        public Token(TokenType type, String value) {
            this.type = type;
            this.value = value;
        }
        
        @Override
        public String toString() {
            return String.format("Token(%s, '%s')", type, value);
        }
    }
    
    private final String input;
    private int position = 0;
    
    public SimpleLexer(String input) {
        this.input = input;
    }
    
    // 词法分析主方法
    public List<Token> tokenize() {
        List<Token> tokens = new ArrayList<>();
        
        while (position < input.length()) {
            char current = peek();
            
            // 跳过空白字符
            if (Character.isWhitespace(current)) {
                consume();
                continue;
            }
            
            // 处理数字
            if (Character.isDigit(current)) {
                tokens.add(readNumber());
                continue;
            }
            
            // 处理标识符（以字母或下划线开头）
            if (Character.isLetter(current) || current == '_') {
                tokens.add(readIdentifier());
                continue;
            }
            
            // 处理运算符
            if (isOperator(current)) {
                tokens.add(new Token(TokenType.OPERATOR, Character.toString(consume())));
                continue;
            }
            
            // 处理分隔符
            if (isDelimiter(current)) {
                tokens.add(new Token(TokenType.DELIMITER, Character.toString(consume())));
                continue;
            }
            
            throw new RuntimeException("Unexpected character: " + current);
        }
        
        tokens.add(new Token(TokenType.EOF, ""));
        return tokens;
    }
    
    // 读取数字（整数或浮点数）
    private Token readNumber() {
        StringBuilder sb = new StringBuilder();
        boolean hasDecimal = false;
        
        while (position < input.length() && 
               (Character.isDigit(peek()) || (!hasDecimal && peek() == '.'))) {
            if (peek() == '.') {
                hasDecimal = true;
            }
            sb.append(consume());
        }
        
        return new Token(hasDecimal ? TokenType.FLOAT : TokenType.INTEGER, sb.toString());
    }
    
    // 读取标识符
    private Token readIdentifier() {
        StringBuilder sb = new StringBuilder();
        
        while (position < input.length() && 
               (Character.isLetterOrDigit(peek()) || peek() == '_')) {
            sb.append(consume());
        }
        
        return new Token(TokenType.IDENTIFIER, sb.toString());
    }
    
    // 辅助方法：查看当前字符但不消耗
    private char peek() {
        return input.charAt(position);
    }
    
    // 辅助方法：消耗当前字符并返回
    private char consume() {
        return input.charAt(position++);
    }
    
    // 判断是否是运算符
    private boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/';
    }
    
    // 判断是否是分隔符
    private boolean isDelimiter(char c) {
        return c == '(' || c == ')' || c == ';';
    }
    
    // 测试
    public static void main(String[] args) {
        String input = "x = 123 + (y * 3.14);";
        SimpleLexer lexer = new SimpleLexer(input);
        List<Token> tokens = lexer.tokenize();
        
        for (Token token : tokens) {
            System.out.println(token);
        }
    }
}

代码解析

  1. Token类型定义：

    • 使用枚举TokenType定义了各种词法单元类型
    • Token类封装了类型和实际值

  2. 核心方法：

    • tokenize()：主方法，逐个字符分析输入字符串
    • readNumber()：读取整数或浮点数
    • readIdentifier()：读取标识符

  3. 辅助方法：

    • peek()：查看当前字符但不移动指针
    • consume()：读取当前字符并移动指针
    • isOperator()和isDelimiter()：判断字符类型

  4. 处理流程：

    • 跳过空白字符
    • 按优先级识别数字、标识符、运算符和分隔符
    • 遇到无法识别的字符抛出异常

示例输出

对于输入"x = 123 + (y * 3.14);"，输出结果为：

Token(IDENTIFIER, 'x')
Token(OPERATOR, '=')
Token(INTEGER, '123')
Token(OPERATOR, '+')
Token(DELIMITER, '(')
Token(IDENTIFIER, 'y')
Token(OPERATOR, '*')
Token(FLOAT, '3.14')
Token(DELIMITER, ')')
Token(DELIMITER, ';')
Token(EOF, '')

扩展建议

这个简单词法分析器可以进一步扩展：

  1. 支持更多运算符（如==, !=等）
  2. 添加关键字识别（如if, while等）
  3. 支持字符串字面量
  4. 添加注释处理
  5. 改进错误处理机制

这个实现是编译器前端的基础组件，可以作为更复杂词法分析器的起点。

用Go实现极简词法分析器

下面是一个用Go语言实现的极简词法分析器，它可以识别以下词法单元：

  • 整数（如 123）
  • 标识符（如 variable）
  • 运算符（如 +, -, *, /）
  • 分隔符（如 (, ), ;）

完整实现代码

package main

import (
	"fmt"
	"unicode"
)

// TokenType 表示词法单元类型
type TokenType int

const (
	EOF TokenType = iota // 文件结束
	INTEGER             // 整数
	IDENTIFIER          // 标识符
	OPERATOR            // 运算符
	DELIMITER           // 分隔符
)

// Token 表示一个词法单元
type Token struct {
	Type  TokenType
	Value string
}

// String 实现Stringer接口
func (t Token) String() string {
	return fmt.Sprintf("Token(%v, '%s')", t.Type, t.Value)
}

// Lexer 词法分析器结构体
type Lexer struct {
	input    string
	position int
}

// NewLexer 创建新的词法分析器
func NewLexer(input string) *Lexer {
	return &Lexer{input: input}
}

// NextToken 获取下一个词法单元
func (l *Lexer) NextToken() Token {
	// 跳过空白字符
	l.skipWhitespace()

	// 检查是否到达输入末尾
	if l.position >= len(l.input) {
		return Token{Type: EOF, Value: ""}
	}

	current := l.peek()

	// 处理数字
	if unicode.IsDigit(current) {
		return l.readNumber()
	}

	// 处理标识符
	if unicode.IsLetter(current) || current == '_' {
		return l.readIdentifier()
	}

	// 处理运算符
	if isOperator(current) {
		token := Token{Type: OPERATOR, Value: string(l.consume())}
		return token
	}

	// 处理分隔符
	if isDelimiter(current) {
		token := Token{Type: DELIMITER, Value: string(l.consume())}
		return token
	}

	panic(fmt.Sprintf("未知字符: %c", current))
}

// 读取数字
func (l *Lexer) readNumber() Token {
	start := l.position
	for l.position < len(l.input) && unicode.IsDigit(l.peek()) {
		l.consume()
	}
	return Token{Type: INTEGER, Value: l.input[start:l.position]}
}

// 读取标识符
func (l *Lexer) readIdentifier() Token {
	start := l.position
	for l.position < len(l.input) && (unicode.IsLetter(l.peek()) || unicode.IsDigit(l.peek()) || l.peek() == '_') {
		l.consume()
	}
	return Token{Type: IDENTIFIER, Value: l.input[start:l.position]}
}

// 跳过空白字符
func (l *Lexer) skipWhitespace() {
	for l.position < len(l.input) && unicode.IsSpace(l.peek()) {
		l.consume()
	}
}

// 查看当前字符但不消耗
func (l *Lexer) peek() rune {
	if l.position >= len(l.input) {
		return 0
	}
	return rune(l.input[l.position])
}

// 消耗当前字符并返回
func (l *Lexer) consume() rune {
	if l.position >= len(l.input) {
		return 0
	}
	char := rune(l.input[l.position])
	l.position++
	return char
}

// 判断是否是运算符
func isOperator(r rune) bool {
	return r == '+' || r == '-' || r == '*' || r == '/'
}

// 判断是否是分隔符
func isDelimiter(r rune) bool {
	return r == '(' || r == ')' || r == ';'
}

func main() {
	input := "x = 123 + (y * 456);"
	lexer := NewLexer(input)

	for {
		token := lexer.NextToken()
		fmt.Println(token)
		if token.Type == EOF {
			break
		}
	}
}

代码解析

  1. Token类型定义：

    • 使用TokenType枚举定义词法单元类型
    • Token结构体包含类型和实际值

  2. Lexer结构体：

    • 保存输入字符串和当前位置
    • 提供NextToken()方法逐个生成词法单元

  3. 核心方法：

    • readNumber()：读取整数
    • readIdentifier()：读取标识符
    • skipWhitespace()：跳过空白字符

  4. 辅助方法：

    • peek()：查看当前字符但不移动指针
    • consume()：读取当前字符并移动指针
    • isOperator()和isDelimiter()：判断字符类型

示例输出

对于输入"x = 123 + (y * 456);"，输出结果为：

Token(IDENTIFIER, 'x')
Token(OPERATOR, '=')
Token(INTEGER, '123')
Token(OPERATOR, '+')
Token(DELIMITER, '(')
Token(IDENTIFIER, 'y')
Token(OPERATOR, '*')
Token(INTEGER, '456')
Token(DELIMITER, ')')
Token(DELIMITER, ';')
Token(EOF, '')

扩展建议

这个基础词法分析器可以进一步扩展：

  1. 添加浮点数支持
  2. 支持更多运算符（如==, !=等）
  3. 添加关键字识别
  4. 支持字符串字面量
  5. 添加注释处理
  6. 改进错误处理机制

这个实现展示了Go语言简洁高效的特点，适合作为更复杂词法分析器的基础。

TinyC编译器5—词法分析
l1894的博客
08-22 741
词法分析也称为分词，此阶段编译器从左向右扫描源文件，将其字符流扫描分割成一个个的词（记号、token）。所谓token，就是源文件中不可再进一步分割的一串字符，类似英语中的单词，汉语中的词。
【C++】TINY语言的词法分析器以及为实现C++编译器而进行的拓展
LIG452338558的博客
08-14 1030
学习编译原理课程时写的词法分析器，先写了TINY语言的词法分析器，然后针对C++语言的特点做了一些拓展。
用 Python 编写的 Python 解释器
weixin_33841503的博客
04-17 563
Allison是Dropbox的工程师，在那里她维护着世界上最大的由Python客户组成的网络。在Dropbox之前，她是Recurse Center的引导师, … 她在北美的PyCon做过关于Python内部机制的演讲，并且她喜欢奇怪的bugs。她的博客地址是akaptur.com. Introduction Byterun是一个用Python实现的Python解释器。随着我在Byterun...
编译原理实验1——TINY语言的词法分析
代码笔记本
11-19 3583
一、 实验目的 构造tiny语言的词法分析器（扫描器），要求利用第三方的lex工具进行构造。构造出的扫描器，能够读入教材样例中给出的tiny语言的示例代码，分解成token输出。 掌握使用lex工具 掌握构造词法分析器 掌握LEX的输入文件的编写 二、 实验设计 掌握词法分析器的构造和使用，学会使用 fex 工具来构造词法分析程序。 1.选择教材《程序清单2-3 TINY语言中的样本程序》作为输入 2.选择教材中《程序清单2-4》作为输出 3.程序分析与设计 由TINY语言的样本程序可得，主要有注释，数字标
编译原理之Tiny C 词法分析器
cg_Amaz1ng的博客
04-17 4622
最近学编译原理，其中一个实验是完成Tiny C词法分析器，写实验报告之前先贴上来。Tiny C语言编译程序实验一 ScannerTiny C词法规定： - 仅允许整数类型，不允许实数类型 - 标识符由大小写英文字母组成，最多52个。其识别按最长匹配原则 - 整数后紧跟非数字，或标识符后紧跟非字母认为是一个新Token开始 - 由{ }括起来符号串都认为是注释部分，该部分在词法分析时被
编译原理正式报告 实验一 TINY语言的词法分析
SaiSaizi_的博客
06-29 677
a.建立起win_flex工作环境，将教材样例中给出的tiny语言的示例代码保存到input.txt文件中，然后将代码写好，保存到lex文件中，利用win_flex生成.c文件（直接将lex文件拖到win_flex.exe上会生成默认文件名的lex.yy.c的源文件）；另外，它既无过程也无声明。c.性能高：WinFlex生成的词法分析器采用了高效的算法和数据结构，能够快速地扫描和识别输入文件中的标记。a.灵活性：WinFlex是一个灵活的词法分析器生成器，可以根据不同的需求生成不同的词法分析器。
PL0词法分析器（java实现）
12-15
在这个项目中，我们关注的是一个用Java实现的PL0词法分析器。词法分析器是编译器的第一阶段，它负责识别输入源代码中的单词标记（tokens），这是编译过程的基石。 **词法分析器的作用** 词法分析器，也称为扫描器或...
编译原理，C语言开发的PL0词法分析器源代码
06-16
总结来说，这份资源包含了一个C语言编写的PL0词法分析器源代码，适用于在Visual Studio环境下学习和实践编译原理。通过对这个项目的研究，读者能够深入理解词法分析过程，掌握正则表达式在识别标记中的应用，以及...
90分钟实现一门编程语言(极简解释器教程)
12-31
本文介绍了如何使用 C# 实现一个简化 Scheme——iScheme 及其解释器。 如果你对下面的内容感兴趣： 实现基本的词法分析，语法分析并生成抽象语法树。 实现嵌套作用域和函数调用。 解释器的基本原理。 以及一些 ...
bcalc: 极简主义的纯Bash计算器与自定义词法分析器
编写者不仅实现了基本的数学运算功能，还进一步地为计算器编写了一个自定义的词法分析器。该词法分析器的加入允许用户在进行数学表达式输入时无需在数字之间加入空格，如直接输入'1+1'，而不是'1 + 1'。程序除了支持...
实验三_用C语言编写TINY语言的词法分析器
06-17
实验三_用C语言编写TINY语言的词法分析器,供大家学习编译参考！
cifafenxi.rar_PL/0词法分析_pl/0 词法
09-20
"cifafenxi.rar" 提供的程序是针对 PL/0 语言的一个词法分析器实现。PL/0 是一种极简的编程语言，由 Alfred Aho、Peter Weinberger 和 Brian Kernighan 在《编译器设计》一书中提出，作为教学示例。 PL/0 词法分析...
编译原理实验一 TINY词法分析器
XMPTFQ的博客
11-22 6275
本次实验之前看了很多学长的代码，给了我很多的思路和解决方法，灰常感谢。 编译原理实验一词法分析器实验报告 一、实验目的 学习和掌握词法分析程序手工构造状态图及其代码实现方法。 二、实验任务 ⑴阅读已有编译器的经典词法分析源程序； ⑵用C或C++语言编写一门语言的词法分析器。 三、实验内容 ① 我选择的编译器以及需要分析的语言是TINY TINY语言的详细定义： TINY的程序结构很简单，它在语法上与 Ada或Pascal的语法相似：仅是一个由分号分隔开的语句序列。另外，它既无过程也无声明。所有的变量都是整型
Tiny词法分析器
最新发布
2303_80341227的博客
04-10 332
tiny词法分析器（含flex和gcc压缩包）包教包会
C++实现C语言语法分析器源代码解析
weixin_31620365的博客
09-12 1862
本文还有配套的精品资源，点击获取 简介：语法分析器是编译器设计中的关键组件，负责将源代码转换成抽象语法树（AST）。本文将详细讲解如何使用C++实现C语言的语法分析器，包括词法分析、LL和LR解析策略、抽象语法树（AST）的构建、错误处理、文法定义、递归下降解析和符号表管理。开发者需要理解编译原理和C++编程技巧，以构建高效、健壮的语法分析器。 1. 语法分析器的...
编译原理——实验壹——TINY语言的词法分析
weixin_45102232的博客
02-04 2170
一、 实验目的 构造tiny语言的词法分析器（扫描器），要求利用第三方的lex工具进行构造。构造出的扫描器，能够读入tiny语言的示例代码，分解成token输出。 掌握使用lex工具 掌握构造词法分析器 掌握lex的输入文件的编写 二、 实验设计 掌握词法分析器的构造和使用，学会使用 lex 工具来构造词法分析程序。 1.选择教材《程序清单2-3 TINY语言中的样本程序》作为输入 2.选择教材中《程序清单2-4》作为输出并做一些输入输出文件格式的改进 3.准备好了实验所需工具 4.程序设计 4-1：将
编译原理 实验二 词法分析程序设计
Ruik@SZTU的博客
05-16 3114
1. 实验内容 ● TINY语言的词法由TINY Syntax.ppt描述； ● TINY语言的词法分析器由TINY Scanner.rar的C语言代码实现； ● TINY+语言的词法由TINY+ Syntax.doc描述。 任务：理解TINY语言的词法及词法分析器的实现，并基于该词法分析器，实现拓展语言TINY+的词法分析器。 要求： （1） TINY+词法分析器以TINY+源代码为输入，输出为识别出的token序列； （2） 词法分析器以最长匹配为原则，例如‘:=’应识别为赋值符号而非单独
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北极象

如果觉得对您有帮助，鼓励一下

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值