[词法分析]初始化DFA

最新推荐文章于 2021-11-29 15:09:23 发布
最新推荐文章于 2021-11-29 15:09:23 发布 · 274 阅读 · 0
文章标签：

#正则表达式 #C #C++ #C# #D语言

NFA这种东西似乎并不是特别重要，它应该是数学家关心的东西——对于一个词法并不复杂到变态的语言，直接画出其DFA也不是什么困难的事情。而作为无视正则表达式的代价，DFA的初始化显得非常重要。

上一篇文章《再见，正则表达式》给出了一点点建立DFA状态关系网络的例子，这篇文章则会终结DFA的初始化。

首先我们得获取一些状态，其实并不需要知道具体状态数量有多少，甚至不需要把DFA完全画好，大致估计一下，然后写下这样一些语句

#define NR_STATES (64)
struct State* jerryStates;    
jerryStates = (struct State*)malloc(NR_STATES * sizeof(struct State));
memset(jerryStates, 0, NR_STATES * sizeof(struct State));

jerryStates指向一个数组。但是因为DFA没画，所以不太方便给每个状态分配一个编号（就算画了，这样做也很繁），所以这里采取另一种手段，设置一个序列号变量，每分配一个状态，这个序列号增加一。下面演示一小段，初始化识别整数和实数的状态：

    int stateNr = 0, s;

    integer = jerryStates + (++stateNr);
    realnum = jerryStates + (++stateNr);
    integer->type = INTEGER;
    realnum->type = REAL;
    for(s = '0'; s <= '9'; ++s) {
        jerryStates->nextState[s] = integer;
        integer->nextState[s] = integer;
        realnum->nextState[s] = realnum;
    }
    jerryStates->nextState['.'] = realnum;
    integer->nextState['.'] = realnum;

stateNr就是序列号，首先是分配状态，然后确定类型，接下来将建立关系（从循环一直到结尾都是）。这样DFA就可以识别常整数和常实数了。

 

标识符跟这差不多，但是关键字跟标识符其实也差不多，鉴于此，这里把所有的关键字都认为是标识符。然后，在以后的分析中会以某种方式从一个关键字表中查找这个标识符是否是关键字，并作出对应处理。

    identifier = jerryStates + (++stateNr);
    identifier->type = IDENT;
    for(s = 'a'; s <= 'z'; ++s) {
        jerryStates->nextState[s] = identifier;
        identifier->nextState[s] = identifier;
    }
    for(s = 'A'; s <= 'Z'; ++s) {
        jerryStates->nextState[s] = identifier;
        identifier->nextState[s] = identifier;
    }
    for(s = '0'; s <= '9'; ++s) {
        identifier->nextState[s] = identifier;
    }

    jerryStates->nextState['_'] = identifier->nextState['_'] = identifier;

至于注释，特别是多行注释，我一向觉得正规式写起来似乎比直接构造自动机还麻烦……

("/*") ( (~("*")) | (("*")+ ~("*")) )* ("*")+ ("/")

多行注释的正规式似乎是这样的，而自动机则有3个状态，具体如下：

初始状态（jerryStates[0]） 遇到"/*"转到多行注释头状态（commentMultiLineStart），多行注释头遇到星号转移到多行注释第二状态（commentMultiLine2，这名字似乎很怪），而遇到其他状态则转移到自身，多行注释第二状态与之相同，不过遇到斜杠则转移到注释接受状态（comment）。这个过程并不复杂：

    commentInLineStart = jerryStates + (++stateNr);
    commentMultiLineStart = jerryStates + (++stateNr);
    commentMultiLine2 = jerryStates + (++stateNr);
    comment = jerryStates + (++stateNr);
    commentInLineStart->type = commentMultiLineStart->type
                             = commentMultiLine2->type = DENY;
    comment->type = SKIP;

    jerryStates->nextState['/']->nextState['/'] = commentInLineStart;
    jerryStates->nextState['/']->nextState['*'] = commentMultiLineStart;

    for(s = 0; s < (1 << 8); ++s) {
        commentInLineStart->nextState[s] = commentInLineStart;
        commentMultiLineStart->nextState[s] = commentMultiLineStart;
        commentMultiLine2->nextState[s] = commentMultiLineStart;
    }
    commentInLineStart->nextState['\n'] = comment;
    commentMultiLineStart->nextState['*'] = commentMultiLine2;
    commentMultiLine2->nextState['*'] = commentMultiLine2;
    commentMultiLine2->nextState['/'] = comment;

 commentInLineStart表示的是单行注释头（"//"）。

 

最后是棘手的符号了，这些琐碎的小东西不仅多，而且长度不一。这样的实现

    struct State* plus = jerryStates + (++i);
    struct State* minus = jerryStates + (++i);
    struct State* multiply = jerryStates + (++i);
    struct State* divide = jerryStates + (++i);

    jerryStates[0].nextState['+'] = plus;
    jerryStates[0].nextState['-'] = minus;
    jerryStates[0].nextState['*'] = multiply;
    jerryStates[0].nextState['/'] = divide;

显然会很痛苦，所以考虑再三，决定使用比较自动化的方式来进行——将符号与对应的接受类型绑定在一个结构内，遍历一个这样结构的数组来初始化符号，对于长度为2的符号，也可以这样弄：

    struct {
        char* symbol;
        AcceptType type;
    } SYMS[] = {
        {"+", PLUS}, {"-", MINUS}, {"*", MULTIPLY}, {"/", DIVIDE},
        {"=", ASSIGN}, {"!", NOT}, {"<", LT}, {">", GT}, {";", EOS},
        {",", COMMA}, {"(", LPARENT},
        {")", RPARENT}, {"[", LBRACKET}, {"]", RBRACKET}, {"{", LBRACE},
        {"}", RBRACE}, {"&", DENY}, {"|", DENY},
        {"==", EQ}, {"<=", LE}, {">=", GE}, {"!=", NE},
        {"&&", AND}, {"||", OR},
        {NULL, DENY}
    };
    struct State* iter;

    for(; NULL != SYMS[s].symbol; ++s) {
        iter = jerryStates;
//        printf("--INFO-- %d\n", s);
        for(character = SYMS[s].symbol; *character; ++character) {
//            printf("---CHAR-- %c %d\n", *character, SYMS[s].type);
            if(NULL == iter->nextState[(int)*character]) {
                iter->nextState[(int)*character] = jerryStates + (++stateNr);
                iter->nextState[(int)*character]->type = SYMS[s].type;
//                printf("---APPEND-- %c %d %d\n", *character, stateNr, SYMS[s].type);
            }
            iter = iter->nextState[(int)*character];
        }
    }

外层循环是用来遍历结构数组的，而内层循环则让接受长度为2的符号的状态衔接在接受长度为一的符号的状态之后。这样符号识别的自动机就搞定了。

 

附：初始化函数及相关变量、宏

/* dfa.c */

#define NR_STATES (64)

static struct State* initStates(void)
{
    int stateNr = 0, s = 0;
    char* character;
    struct {
        char* symbol;
        AcceptType type;
    } SYMS[] = {
        {"+", PLUS}, {"-", MINUS}, {"*", MULTIPLY}, {"/", DIVIDE},
        {"=", ASSIGN}, {"!", NOT}, {"<", LT}, {">", GT}, {";", EOS},
        {",", COMMA}, {"(", LPARENT},
        {")", RPARENT}, {"[", LBRACKET}, {"]", RBRACKET}, {"{", LBRACE},
        {"}", RBRACE}, {"&", DENY}, {"|", DENY},
        {"==", EQ}, {"<=", LE}, {">=", GE}, {"!=", NE},
        {"&&", AND}, {"||", OR},
        {NULL, DENY}
    };
    struct State* iter;
    struct State* commentInLineStart,* commentMultiLineStart,
                * commentMultiLine2,* comment;
    struct State* space;
    struct State* integer,* realnum;
    struct State* identifier;

    jerryStates = (struct State*)malloc(NR_STATES * sizeof(struct State));
    memset(jerryStates, 0, NR_STATES * sizeof(struct State));

    jerryStates[0].type = DENY;
    for(; NULL != SYMS[s].symbol; ++s) {
        iter = jerryStates;
//        printf("--INFO-- %d\n", s);
        for(character = SYMS[s].symbol; *character; ++character) {
//            printf("---CHAR-- %c %d\n", *character, SYMS[s].type);
            if(NULL == iter->nextState[(int)*character]) {
                iter->nextState[(int)*character] = jerryStates + (++stateNr);
                iter->nextState[(int)*character]->type = SYMS[s].type;
//                printf("---APPEND-- %c %d %d\n", *character, stateNr, SYMS[s].type);
            }
            iter = iter->nextState[(int)*character];
        }
    }
    commentInLineStart = jerryStates + (++stateNr);
    commentMultiLineStart = jerryStates + (++stateNr);
    commentMultiLine2 = jerryStates + (++stateNr);
    comment = jerryStates + (++stateNr);
    commentInLineStart->type = commentMultiLineStart->type
                             = commentMultiLine2->type = DENY;
    comment->type = SKIP;

    jerryStates->nextState['/']->nextState['/'] = commentInLineStart;
    jerryStates->nextState['/']->nextState['*'] = commentMultiLineStart;

    for(s = 0; s < (1 << 8); ++s) {
        commentInLineStart->nextState[s] = commentInLineStart;
        commentMultiLineStart->nextState[s] = commentMultiLineStart;
        commentMultiLine2->nextState[s] = commentMultiLineStart;
    }
    commentInLineStart->nextState['\n'] = comment;
    commentMultiLineStart->nextState['*'] = commentMultiLine2;
    commentMultiLine2->nextState['*'] = commentMultiLine2;
    commentMultiLine2->nextState['/'] = comment;

    identifier = jerryStates + (++stateNr);
    identifier->type = IDENT;
    for(s = 'a'; s <= 'z'; ++s) {
        jerryStates->nextState[s] = identifier;
        identifier->nextState[s] = identifier;
    }
    for(s = 'A'; s <= 'Z'; ++s) {
        jerryStates->nextState[s] = identifier;
        identifier->nextState[s] = identifier;
    }
    jerryStates->nextState['_'] = identifier->nextState['_'] = identifier;

    integer = jerryStates + (++stateNr);
    realnum = jerryStates + (++stateNr);
    integer->type = INTEGER;
    realnum->type = REAL;
    for(s = '0'; s <= '9'; ++s) {
        jerryStates->nextState[s] = integer;
        integer->nextState[s] = integer;
        realnum->nextState[s] = realnum;
        identifier->nextState[s] = identifier;
    }
    jerryStates->nextState['.'] = realnum;
    integer->nextState['.'] = realnum;

    space = jerryStates + (++stateNr);
    space->type = SKIP;
    jerryStates->nextState[' '] = space;
    jerryStates->nextState['\t'] = space;
    jerryStates->nextState['\r'] = space;
    jerryStates->nextState['\n'] = space;
    space->nextState[' '] = space;
    space->nextState['\t'] = space;
    space->nextState['\r'] = space;
    space->nextState['\n'] = space;

//    printf("--INFO-- DFA built. %d\n", stateNr);
    return jerryStates;
}
#undef NR_STATES

注释掉的都是调试信息输出语句。

iteye_10703
关注
词法分析程序之NFA转DFA和DFA的最小化
LH is programming hard
04-17 1897
原理（1）——NFA转DFA 转化方法 我们必须知道如何将DFA转化为DFA——利用子集构造法 步骤： 为NFA添加一个开始结点和终止结点（上一节的程序本来就是这样设计） 对NFA中的结点，对开始结点做闭包，得到结点集合，以该结点集合开始，计算该集合对每一种符号的Ia、Ib 观察这些Ia、Ib在第一列是否存在？存在则不需要添加，否则添加，然后对其计算Ia、Ib，重复操作，直到所有的都已经添加过了。 对上述的结点集合重新命名，得到确定化的DFA的状态转化表。 根据该表选出代表结点，连接边，得到确定化的DFA
基于DFA的词法分析（一）：程序框架及数据结构
Cheney ' blog
04-19 4166
背景： 题目描述： 一、 实验目的 设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。 二、 实验要求 2.1 待分析的简单的词法 （1）关键字： begin if then while do end 所有的关键字都是小写。 （2）运算符和界符 ： = + - * / < <= <> > >= = ; ( ) # （3）其他单词是标识符（ID）和整型常数（SUM），通过以下正规式定义： ID = letter (le
一个C语言的注释确定性自动机（DFA）的实现
01-09
这是一个C语言的注释的有限自动机的实现代码。这是一个测试代码，采用的是输入一个字符串，让程序判断是不是一个有效的C语言风格的注释，也就是这种形式：/**/的注释。输入的过程中，不要使用空格。这只是一个简单的测试代码。
Python源码学习九,dfa state的初始化
robin的专栏
11-10 1947
in  graminit.c定义了一些struct, 是理解和实现DFA的关键 static dfa dfas[81] = { {256, //d_type "single_input", //char *d_name 0, //d_initial 3, //d_nstates states_0, //state *d_state
构造能够识别c语言注释的DFA,第3章编译原理答案(主编张晶).ppt
weixin_39737951的博客
05-18 1375
第3章编译原理答案(主编张晶)词法分析程序的设计与实现？ 3.1 有穷自动机 1.状态图 (补充) 2. 正规文法(左线性文法)转换状态图(重点):教材3.3 ②以每个非终结符号做其它状态 ③对于形如Q→q的规则, 对于形如Q→Rq的规则, ④以文法开始符号为终止状态 例3-2： 文法G[Z]： Z→Za|Aa|Bb A→Ba|a ...
C语言注释的NFA,词法分析(NFA与DFA)
weixin_39800957的博客
05-19 2884
词法分析(1)---词法分析的有关概念以及转换图词法分析是编译的第一个阶段，前面简介中也谈到过词法分析器的任务就是：字符流------>词法记号流这里词法分析和语法分析会交错进行，也就是说，词法分析器不会读取所有的词法记号再使用语法分析器来处理，通常情况下，每取一个词法记号，就送入语法分析器进行分析，图解：词法分析器是编译器中与源程序直接接触的部分，因此词法分析器可以做诸如1).去掉注释，自...
消除注释_DFA实现代码
05-24
DFA实现消除注释代码，其中如果需要思路，就在上一个资源分享，其中包括ppt配套讲解。包括DFA图，函数讲解。
dfa词法分析.cpp
最新发布
10-30
词法分析是编译过程中的第一个阶段，它的重要性在于将源代码的文本形式转换成可以被后续编译阶段处理的结构化形式。这个过程减少了编译器需要处理的复杂度，因为后续阶段如语法分析、语义分析等都将基于这些被识别...
C++词法分析源码与DFA实现
结合标签“词法分析、C++、DFA、源码、编译、可执行程序、工程文件、深入学习、原工程、参考”以及压缩包内文件名为“myDFA”的子文件，可以推断该工程实现了一个基于确定有限自动机（DFA）的词法分析器，使用C++...
编译原理课程设计：词法分析器与DFA实现
本文件“编译原理课程设计，编译原理作业，编译原理实验，dfa，词法分析器，语法分析器-内含源码和说明书.zip”正是围绕编译器前端的核心组成部分——词法分析器与语法分析器展开的实践性教学资源，尤其聚焦于确定...
消除注释_DFA与实现的代码
05-24
ppt讲解DFA如何实现消除注释，包括函数如何实现，DFA转化图。
编译原理实验报告（含代码：状态转换图；DFA扫描；First集，follow集计算）
12-20
实验一：状态转换图 输入一串数据，利用状态转换图程序求出“关键字，标识符，整数，运算符，实数”。 实验二：DFA扫描 打开一个编写好的源代码，利用DFA扫描程序删除多行注释，单行注释，多余的行，多余的空格。 实验三：first集，follow集计算 输入一个不含左递归的文法，由此程序求出该文法的first集和follow集。
DFA识别程序
12-21
提供网页设计，是很好的，没有错误，可以满足你的需求。
编译原理--词法分析笔记
An_xx的博客
11-29 2707
词法分析 内容 将单词符号用有效的工具描述 单词识别机制 词法分析程序的设计和实现 词法分析程序的自动构造 3.1 词法分析程序的设计 3.1.1 功能和实现 词法分析程序(Lexical analyzer，简称Lexer)，负责从左到右逐个字符地对源程序进行扫描和分解，根据语言的词法规则识别出一个个的单词符号。 【单词】单词是语言中具有独立意义的最小语法单位。 1 功能 从左至右扫描构成源程序的字符流 识别出有词法意义的单词 返回单词记录，或词法错误信息 除以上主要任务外，常伴有如下任
数组跳过第一个，未初始化会出问题
Tog
03-14 369
JAVA中的DFA算法构建敏感词树，从0开始！
Run the ant
12-05 979
关于DFA算法构建敏感词树；应用于JAVA中，敏感词匹配查找，敏感词替换等等
基于DFA的C程序注释删除
MEMO的博客
11-01 1357
基于DFA的C程序注释删除
DFA敏感词过滤算法
蓝天之枫
09-04 1万+
运用DFA算法加密。 首先我先对敏感词库初始化，若我的敏感词库为 冰毒 白粉 大麻 大坏蛋 初始化之后得到的是下面这样。： {冰={毒={isEnd=1}, isEnd=0}, 白={粉={isEnd=1}, isEnd=0}, 大={麻={isEnd=1}, isEnd=0, 坏={蛋={isEnd=1}, isEnd=0}}}。 ok，我把初始化之后的数据用A来表示。假设待检测
正则表达式DFA构造方法
热门推荐
么刚的专栏
09-19 2万+
陈梓瀚 vczh@163.com http://www.cppblog.com/vczh/1、问题概述随着计算机语言的结构越来越复杂，为了开发优秀的编译器，人们已经渐渐感到将词法分析独立出来做研究的重要性。不过词法分析器的作用却不限于此。回想一下我们的老师刚刚开始向我们讲述程序设计的时候，总是会出一道题目：给出一个填入了四则运算式子的字符串，写程序计算该式子的结果。除此之外，我们有时候
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值