编译原理_第3章_第1节_词法分析、DFA、NFA和其转换
编译原理第三章_有穷自动机
例 过河问题 分析（续）
初始状态：MWGC-φ；终止状态：φ-MWGC。 g
MWGC-φ
WC-MG
问题：
6
例 过河问题 状态转换图
起始 g
MWGC-φ g
g φ-MWGC
g
7
WC-MG
m
m MWC-G
w
w
c
C-MWG
c W-MGC
g
g
MGC-W c
MG-WC
w
m
c G-MWC
m
gg MWG-C
+dd. ddd;
输入符号串
数字 数字
SB
.
数字
+
A
H
-.
数字
.G
接收：若扫描完输入串， 且在一个终止状态上结 束。
数字 阻塞：若扫描结束但未 停止在终止状态上；或 者为能扫描完输入串 （如遇不合法符号）。
不完全描述：某些状态 对于某些输入符号不存 在转换。
练习：+34.567 .123 3.4.5
w
有穷自动机（FA）
数字系统：可以从一个状态移动到另一个状态；每次 状态转换，都上由当前状态及一组输入符号确定的；可以 输出某些离散的值集。
FA：一个状态集合；状态间的转换规则；通过读头来 扫描的一个输入符号串。
读头：从左到右扫描符号串。移动（扫描）是由状态 转换规则来决定的。
8
读头
一个FA的例子
(3)运行： 串f(，Q,且t1tt21)∈= Σf(，f(Qt1,t2t1∈), Σt2*)，其中Q∈K， t1t2为输入字符
17
例３
题：试证abba可为例1的DFA M所识别（所接受）。
编译原理词法NFADFA的确定化和化简
编译原理词法NFADFA的确定化和化简编译原理中的词法分析主要包括以下步骤：词法分析器将输入的源程序文本转化为一个个单词（token），即词法单元。
在词法分析过程中，使用的主要工具是有限自动机(NFA)和确定的有限自动机(DFA)。
NFA(DFA)的确定化是指将一个非确定的有限自动机转化为一个确定的有限自动机。
非确定有限自动机具有多个可能的转换路径，而确定有限自动机每个状态只能有一个转换路径。
确定化的目的是简化自动机的状态图，减少转换的复杂性，便于理解和实现。
确定化的过程一般包括以下步骤：1）初始化：将NFA的起始状态作为DFA的起始状态，并为其创建一个新的DFA状态。
2）闭包运算：对于DFA中的每个状态，根据NFA的ε-转换，计算其ε-闭包（即能够通过ε-转换到达的状态集合）。
3）转换运算：对于DFA中的每个状态和每个输入符号，根据NFA的转换函数，计算DFA中该输入下的状态转移集合。
4）如果新生成的DFA状态集合不在已有的DFA状态集合中，则将其加入到DFA状态集合中，并进行闭包和转换运算；如果已存在，则继续下一个输入符号的转换运算。
5）重复步骤4，直到不再生成新的DFA状态集合。
化简是指对于一个确定的有限自动机(DFA)，将其中无用的状态进行合并，得到一个更加简洁的自动机。
化简的目的是减少状态数目，提高运行效率和存储效率。
化简的过程一般包括以下步骤：1）初始化：将DFA状态分为两个集合，一个是终止状态集合，一个是非终止状态集合。
2）将所有的等价状态划分到同一个等价类中。
3）不断迭代以下步骤，直到不能再划分等价类为止：a）对于每对不同的状态p和q，若存在一个输入符号a，通过转移函数计算得到的状态分别位于不同的等价类中，则将该状态划分到不同的等价类中。
b）对于每个等价类中的状态集合，将其进一步划分为更小的等价类。
最终，得到的化简DFA状态图比原始DFA状态图要小，且功能等价。
nfa转换为dfa编译原理 c++
nfa转换为dfa编译原理 c++有限自动机（NFA）和确定有限自动机（DFA）是计算机科学中有限状态自动机的两种形式。
NFA可以接受多个转移状态，而DFA则只能有一个转移状态。
NFA到DFA的转换是一个重要的编译原理问题。
以下是NFA转换为DFA的步骤：1. 确定NFA的开始状态和接受状态。
2. 对于每个输入符号，确定NFA的转换规则和转换后的状态。
3. 重复第二步，直到我们不能获得新的状态。
4. 标记DFA中的状态，即从NFA的多个状态中派生出的状态。
5. 为DFA添加开始状态和接受状态。
开始状态是NFA的开始状态的ε闭包。
6. 对于每个输入符号，使用NFA的转移规则来定义DFA中的转移。
7. 扫描DFA的状态表，并删除不可到达的状态。
下面是在C++中实现的NFA到DFA转换过程的伪代码：//定义状态类class State{public:string name;unordered_map<char, set<string>> transitions;bool is_final_state;};//定义NFA类class NFA{public:State start_state;set<State> final_states;unordered_set<State> all_states;};//定义DFA类class DFA{public:State start_state;set<State> final_states;unordered_set<State> all_states;};//NFA转换为DFADFA ConvertToDFA(NFA nfa){//创建DFA对象DFA dfa;//确定开始状态dfa.start_state = nfa.start_state;//确定接受状态dfa.final_states = nfa.final_states;//添加开始状态到DFA的所有状态dfa.all_states.insert(dfa.start_state);while (有新的状态可以加入DFA){//从DFA中选择一个未标记的状态State current_state = 选择一个未标记的状态;for (每个输入符号a){//根据当前状态的a过渡创建新状态State new_state = 创建新状态;//从当前状态开始，获得状态a的ε闭包set<State> epsilon_closure = current_state.获取状态a的ε闭包;//通过NFA的规则从当前状态和ε闭包中跳转到新状态set<State> transition_states = 通过NFA规则从当前状态和ε闭包中跳转到新状态;//确定新状态是否应该成为DFA的接受状态bool is_final_state = 确定新状态应该成为DFA的接受状态;//设置新状态的属性new_ = 新状态的名称;new_state.transitions = 转移函数;new_state.is_final_state = is_final_state;//将状态添加到DFA中dfa.all_states.insert(new_state);}}return dfa;}这是将NFA转换为DFA的基本伪代码。
[编译原理代码][NFA转DFA并最小化DFA并使用DFA进行词法分析]
![[编译原理代码][NFA转DFA并最小化DFA并使用DFA进行词法分析]](https://img.taocdn.com/s3/m/4706449103d276a20029bd64783e0912a2167c14.png)
[编译原理代码][NFA转DFA并最⼩化DFA并使⽤DFA进⾏词法分析]#include <iostream>#include <vector>#include <cstring>#include "stack"#include "algorithm"using namespace std;int NFAStatusNum,AlphabetNum,StatusEdgeNum,AcceptStatusNum;char alphabet[1000];int accept[1000];int StartStatus;int isDFAok=1;int isDFA[1000][1000];/** NFA状态图的邻接表*/vector<vector<int>> Dstates;int Dstatesvisit[1000];int Dtran[1000][1000];vector<int> Dtranstart;vector<int> Dtranend;int isDtranstart[1000];int isDtranend[1000];class Edge{public:int to,w,next;} ;Edge edge[10000];int edgetot=0;int Graph[1000];void link(int u,int v,int w){edge[++edgetot].to=v;edge[edgetot].w=w;edge[edgetot].next=Graph[u];Graph[u]=edgetot;}void input(){int u,v,w;memset(Dtran,-1,sizeof(Dtran));scanf("%d %d %d %d\n",&NFAStatusNum,&AlphabetNum,&StatusEdgeNum,&AcceptStatusNum);for(int i=1;i<=AlphabetNum;i++){ //读⼊字母表scanf("%c",&alphabet[i]);}for(int i=1;i<=AcceptStatusNum;i++){scanf("%d",&accept[i]);}//开始状态序号scanf("%d",&StartStatus);for(int i=0;i<StatusEdgeNum;i++){scanf("%d%d%d\n",&u,&v,&w);link(u,v,w);if(isDFA[u][v]==0){isDFA[u][v]=1;}else{isDFAok=0;}if(w==0){isDFAok=0;}}//读⼊测试字符串}void e_clouser(vector<int> &T,vector<int> &ans){int visit[1000];memset(visit,0,sizeof(visit));stack<int> Stack;//T all push in Stack and copy to ansfor (int i=0;i < T.size();++i){Stack.push(T[i]);ans.push_back(T[i]);visit[T[i]]=1;while(Stack.empty()!=1){int t = Stack.top(); Stack.pop();for(int p=Graph[t];p!=0;p=edge[p].next){if(edge[p].w==0){if(visit[edge[p].to]==0){visit[edge[p].to]=1;Stack.push(edge[p].to);ans.push_back(edge[p].to);}}}}sort(ans.begin(),ans.end());}void move(vector<int> &T,int a,vector<int> &ans){ int visit[1000];memset(visit,0,sizeof(visit));for(int i=0;i<T.size();i++) {int t=T[i];for (int p = Graph[t]; p != 0; p = edge[p].next) { if (edge[p].w == a) {if (visit[edge[p].to] == 0) {visit[edge[p].to] = 1;ans.push_back(edge[p].to);}}}}}bool notin(vector<int> &a,int &U){for(int i=0;i<Dstates.size();i++){int ok=1;if(Dstates[i].size()==a.size()){for(int j=0;j<a.size();j++){if(Dstates[i][j]!=a[j]){ok=0;break;}}if(ok==1) {U=i;return false;}}}U=Dstates.size();return true;}void nfatodfa(){vector<int> s,t;s.push_back(StartStatus);e_clouser(s,t);Dstates.push_back(t);stack<int> Stack;Stack.push(Dstates.size()-1);while(Stack.empty()!=1){int T=Stack.top();Stack.pop();int U;for(int i=1;i<=AlphabetNum;i++){vector<int> ans,ans2;move(Dstates[T],i,ans2);e_clouser(ans2,ans);if(notin(ans,U)){Dstates.push_back(ans);Stack.push(Dstates.size()-1);}Dtran[T][i]=U;}}}void getDtranStartEnd(){for(int i=0;i<Dstates.size();i++){int ok=1;for(int j=0;j<Dstates[i].size();j++){if(Dstates[i][j]==StartStatus){Dtranstart.push_back(i);isDtranstart[i]=1;}for(int k=1;k<=AcceptStatusNum;k++){if(Dstates[i][j]==accept[k]){ok=0;Dtranend.push_back(i);isDtranend[i]=1;}}}}}}vector<vector<int>> newDstates;int newDstatesvisit[1000];int newDtran[1000][1000];int set[1000];vector<int> newDtranstart;vector<int> newDtranend;int isnewDtranstart[1000];int isnewDtranend[1000];void simple(){int visit[1000];memset(visit,0,sizeof(visit));vector<int> a,b;//接受结点加⼊afor(int i=0;i<Dtranend.size();i++){a.push_back(Dtranend[i]);visit[Dtranend[i]]=1;set[Dtranend[i]]=0;}//剩余结点加⼊bfor(int i=0;i<Dstates.size();i++){if(visit[i]==0){b.push_back(i);set[i]=1;}}newDstates.push_back(a);newDstates.push_back(b);while(1){int ok=0;for(int i=0;i<newDstates.size();i++){for (int k = 1; k <= AlphabetNum; k++) {for(int j=1;j<newDstates[i].size();j++) {int pp= Dtran[newDstates[i][0]][k];int u = newDstates[i][j], v = Dtran[u][k];if (set[v] != set[pp] ) {//将u剥离newDstates[i].erase(newDstates[i].begin() + j); vector<int> temp;temp.push_back(u);set[u] = newDstates.size();newDstates.push_back(temp);ok = 1;break;}if (ok == 1) break;}if(ok==1) break;}if(ok==1) break;}if(ok==0) break;}//isnewDtranstart,isnewDtranend,newDtranfor(int i=0;i<Dstates.size();i++) {for (int j = 1; j <= AlphabetNum; j++) {newDtran[set[i]][j]=set[Dtran[i][j]];}if(isDtranend[i]==1)isnewDtranend[set[i]]=1;if(isDtranstart[i]==1)isnewDtranstart[set[i]]=1;}//isnewDtranstart,isnewDtranend}bool dfa(char *S){int status=0;for(int i=0;i<newDstates.size();i++){if(isnewDtranstart[i]==1){status=i;}}for(int i=0;i<strlen(S);i++) {//这⾥我偷懒了,懒得弄个map存映射,直接对这个例⼦进⾏操作,就是 S[i]-'a'+1; int p=S[i]-'a'+1;status=newDtran[status][p];}if(isnewDtranend[status]==1) return true;else return false;}int main() {freopen("E:\\NFATODFA\\a.in","r",stdin);input();if(isDFAok==0){printf("This is NFA\n");nfatodfa();}else{printf("This is DNA\n");}//打印DFAprintf("\nPrint DFA's Dtran:\n");printf(" DFAstatu a b");getDtranStartEnd();for(int i=0;i<Dstates.size();i++){printf("\n");if(isDtranstart[i]==1)printf("start ");else if(isDtranend[i]==1)printf("end ");else printf(" ");printf("%5c ",i+'A');for(int j=1;j<=AlphabetNum;j++)printf("%5c ",Dtran[i][j]+'A');}printf("\nPrint simple DFA's Dtran:\n");simple();printf(" DFAstatu a b");for(int i=0;i<newDstates.size();i++){printf("\n");if(isnewDtranstart[i]==1)printf("start ");else if(isnewDtranend[i]==1)printf("end ");else printf(" ");printf("%5c ",i+'A');for(int j=1;j<=AlphabetNum;j++)printf("%5c ",newDtran[i][j]+'A');}printf("\n");char S[1000];while(scanf("%s\n",S)!=EOF){if(dfa(S)){printf("%s belongs to the DFA\n",S);}elseprintf("%s don't belong to the DFA\n",S);}return 0;}。
编译原理第三版 第三章 词法分析
超前搜索
例：FORTRAN语言中关键字的识别: DO99K=1,10 识别DO为关键字要搜 DO99K=1.10 索到“，” FORTRAN语言中常数的识别：
5.EQ.M, 5.E08
识别5为常数要搜索到Q
2、状态转换图
大多数程序设计语言中单词符号的词法规则可 以用正规文法描述。如： <标识符>→ 字母|<标识符>字母|<标识符>数字 <整数>→数字|<整数>数字 <运算符>→+|－|×|÷„ <界符>→; |, |( | )|„
#
3.3 正规表达式与有限自动机
目的： 形式化地描述词法规则和词法分析程序 词法分析程序的自动生成 主要内容 正规式与正规集 确定有限自动机 (DFA) 非确定有限自动机(NFA) 正规式与有限自动机的等价性 确定有限自动机的化简
正规文法
多数程序设计语言单词的语法都能用正规文法 (3型文法)描述 正规文法回顾 文法的任一产生式α→β的形式都为
单词符号的种类
(3) 常数 常数的类型一般有整型、实型、布 尔型、字符型等。
(4) 运算符 如 +，-，*，/等，对具体语言个 数是确定的。 (5) 界符 如 , ；（）等，对具体语言个数是 确定的。
单词符号的表示形式
词法分析器所输出的单词符号常常表示成如下的 二元式：<单词种别，单词符号的属性值> 单词种别:由语法分析阶段使用的抽象符号。如： 用整数编码。 最简单的编码方案为一类一码，种别编码可设为： 1,2,3,4,5。 另一种编码方案（如本教材中）： 标识符:列为一种，用一个整数编码表示； 常数:按类型分种编码； 关键字、运算符、界符:采用一字一种编码。
《编译原理实践及应用》第3章词法分析—DFA与NFA
其中 Κ ={ S 0 ,S1 ,S 2 } Σ ={a,b}
Ѕ={ S 0 , S1 } ( S0 ,a)={ S1 }
F={ S 2 }
( S 0 ,b)={ S 0 ,S 2 }
( S1 ,a)= Φ
(S1 ,b)={S 2 }
( S 2 ,a)= Φ
(S 2 ,b)={S1 }
②以每个非终结符号做其它状态
③对于形如Q→q的规则,
q
S
Q
对于形如Q→Rq的规则,
Rq Q
④以文法开始符号为终止状态。
例3-1： 文法G[Z]： Z→Za|Aa|Bb
aA
a
A→Ba|a B→Ab|b
Sb a
Za
b
Bb
2.应用状态转换图识别句子
识别句子：从开始状态到终止状态经过的边上的符号序列。 识别句子的步骤： ①从开始状态出发，以欲识别符号串的最左字符开始，寻找标
Z→Cb C→b|Bb B→Ab A→a|Ba
有限自动机(FA)
FA可看作一个机器模型，由一个带读头的有限控制器和 一条字符输入带组成。
#
a b a ba
…
输入带
控制器
工作原理：读头从左到右扫描输入带，读到一个字符，状态改
变，同时读头右移一个字符，…，直到读头读到
“#”，状态进入终止状态。
控制器中包括有限个状态，读入一个字符形成状态转换。
( S1 ,a)= S0 ( S1 ,c)= S3 ( S 2 ,b)= S1
( S3 ,b)= S3
a
b
S2 a
S0 a S1
ba
C
S3 b
定义: 所接收的语言（正则集）
L( AD)={β | S β S, S∈ F },
编译原理chapter3 词法分析
一 设计一个奇偶校验器
DFA是由集合，序列和函数定义的数学模型， 它对于 上的w，判定是可接受的还是不可 接受的。例如，设计一个DFA m ，奇偶校验 器，首先，w是由0，1组成的字符串，因此， 1. ={0 ,1}且w在一条输入带上。
0 1 0 1 1$
读头
精品文档
11
2. 状态集：它记忆已读入w子串的状态,m是 奇偶校验器，它应该记住，初始序列是奇数 个1还是偶数个1。因此，m有even和odd两个 状态. 3 .even为开始状态。
词法分析器
‘while’，‘i’，‘＜＞’，‘j’， ‘do’， ‘if’，‘i’，‘＞’，‘j’,‘then’, 'i', ':=’ , 'i', ’-’ , 'j', 'else', 'j', ':=', 'j', '-', ‘i'
精品文档
4
词类和属性
computator n. Calcculating machine.
3.1.1 词法分析程序的功能 源程序 单词词序法列分析器
3.1.2 单词的词类和属性 （词类符号，单词的属性值）
3.1.3 词法分析程序作为一个独立子程序 （1）语法分析程序的子程序； （2）组 织成一遍扫描。
精品文档
3
While i＜＞j do if i＞j then i:＝i-j else j:=j－I
三 一个ＤＦＡ有三种表示：
（1）象上面，用转换函数；
精品文档
14
转移矩阵
状态转换图
a
b
0
1
2
a
编译原理NFA的确定化优秀文档
(2)M的输入字母表∑M 和N′是相同的， 即∑M ＝ ∑
(3)转换函数δM δM([S1 S2... Sj], a)
=ε-closure(move([S1, S2,... Sj],a))
即集合[S1 S2... Sj]的a弧转换
(4)M的初态 S0M = ε-closure(S0), 从N的初态S0出发, 经过任意条ε弧所能 到达的状态所组成的集合
(5)M的终态集合FM FM ={[Sj Sk... Se]， 其中[Sj Sk... Se]∈SM 且 {Sj , Sk,,.Байду номын сангаас. Se}∩F≠φ }，
即构造的子集族中凡是含有原NFA终态 的子集都是DFA的终态。
= {5, 4, 3, 6, 2, 7, 8}
而能到达的任何状态q′都属于 {
标记T；
(4)M的初态 S0M = ε-closure(S0),
有穷自动机等价的定义
ε_CLOSURE(I)； 使状态转换图中的每条箭弧上的标记
= {5, 4, 3, 6, 2, 7, 8}
或为ε, 或为∑中的单个字母.
3 非确定有限自动机
补充例: NFA的确定化 – 子集法
确定化后的DFA也以状态转换图（矩阵）给出。
即: 把从S0出发经过一条标记为a的弧所能到达的状态(其前其后可经过若干条ε矢线)所组成的集合作为下一个状态置于SM中.
I＝{1, 5}, ε-closure(I)={1, 2, 5, 6}
补充例 :
I＝{1}, ε-closure(I)={1, 2} I＝{5}, ε-closure(I)={5, 6, 2} I＝{1, 5}, ε-closure(I)={1, 2, 5, 6}
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
3.1.1 单词符号的表示
单词的分类
单词分类的原则
❖ 保留字（关键字）：可以看作一类，也可以一字一类； ❖ 算符和界符：可以一符一类，算符还可以把有一定共性算
符分为一类； ❖ 常数：可以按照数据类型分类； ❖ 标识符：统一归为一类。
3.1.1 单词符号的表示
语法分析器
使整个编译程序的结构更简洁、清晰和条理化； 编译程序效率更高； 增强编译程序的可移植性。
符号表
3.1.2 词法分析器的结构
扫描缓冲区
1.预处理程序：取消注解，剔除无用的空白、 跳格、回车、换行等 2.输入缓冲区：源程序输入缓冲区
3.1.2 词法分析器的结构
预处理程序
❖主要是为方便单词的识别工作：
int
3056
int
3060
3.1.2 词法分析器的结构
词法分析器与语法分析器的联系
（1）词法分析作为单独的一遍
字符
字符串形式的源程序
词法分析器
单词串形式的源程序
3.1.2 词法分析器的结构
词法分析器与语法分析器的联系
(2)词法分析作为子程序
输入串
词法分析器
返
取
回
下
下
一
一
单
单
词
词
将词法分析器分离的考虑
例3.1 令∑={a，b}
正规式 a a|b ab (a|b)(a|b) a* (a|b) * (a|b) *(aa|bb) (a|b) *
缓冲区长度：256
缓冲区长度：256
标识符起 搜索指 点(252) 示器
小结
❖词法分析器的任务； ❖单词符号的分类； ❖单词符号的表示； ❖词法分析预处理； ❖词法分析器的工作方式； ❖扫描缓冲区的双缓冲策略。
3.2.1 正规式与正规集
正规式和正规表达式
正规式（正规表达式）：用以描述单词符号的工 具，是说明单词的模式的一种重要的表示法, 是定 义正规集的工具。
仅由有限次使用上述三步骤得到的表达式才是正规式，仅由这些正规式 所表示的字集才是∑上的正规集。
例3.1 令∑={a，b}
ba*
∑上所有以b为首，后跟任意多个a的字符串；
a(a|b)* ∑上所有以a为首的字符串；
(a|b)*(aa|bb)(a|b)* ∑上含两个连续a或两个连续b的字符串。
3.2.1 正规式与正规集
（1）剔除无用的空白符、跳格符、回车符、换行符。 ‘ ‘, ‘\t’, ‘\r’, ‘\n’
（2）剔除注释：/*…………*/, //
（3）合并空白符。
3.1.2 词法分析器的结构
预处理程序
例：
int max(int x, int y) // 求x,y的最大值 {
int z; z = (x > y ? x : y); return z; }
预处理后： int max(int x,int y) {int z; z=(x>y ? x : y); return z;}
3.1.2 词法分析器的结构
缓冲区的设计
扫描缓冲区：从输入缓冲区输入固定长度的字符串到另一个缓冲区（扫 描缓冲区），词法分析可以直接在此缓冲区中进行符号识别。扫描缓冲 区的结构：
例：while (i >=j) i--; 输出：
编号 类别
(3, “while”)
1
标识符
(5, “(“)
2
常数
(1, 指向i的符号表入口)
3
保留字
(4, “>=“)
4
算符
(1, 指向j的符号表入口)
5
界符
(5, “)”)
(1, 指向i的符号表入口)
(4, “--”)
(5, “;”)
数据类型 存储地址
单词的表示
单词经常表示为二元组：(单词类别,单词值) 对某些单词来说，不仅需要它们的值，还需要一些其它信息，
这些都记录在符号表中，所以相应表示为：(标识符，指向该标 识符所在符号表中位置的指针)
(单词类别,单词的属性)
区分单词所属的类 (整数编码)
单词的值
3.1.1 单词符号的表示
单词的表示：举例
起点指针：用来指示正在扫描的单词的起点； 搜索指针：用于向前搜索，寻找单词的结束； 缓冲区结构
假设标识符和常数的最大长度为256
缓冲区长度：512
标识符起 搜索指 点(500) 示器
3.1.2 词法分析器的结构
缓冲区的设计
：设置左右两个缓冲区，当左缓冲区读完后，新读入的字符存 入右缓冲区；反之，存放在左缓冲区；Βιβλιοθήκη 3.1.1 单词符号的表示
单词的分类
单词的分类，如：while (i < 10) i++;
❖ 基本字：也称关键字，如C语言中的int, void, if, while等； ❖ 标识符：用来表示各种名字，如变量名、常量名、函数名等； ❖ 常数：如25, 3.1415926, ‘a’, “hello”, TRUE等； ❖ 算符：如+, =, ~等； ❖ 界符：如逗号，分号，括号等。 ❖ 基本字、运算符和界符一般确定； ❖ 标识符和常数的数量一般不加限制。 注： （1）程序设计语言单词的分类纯属技术性问题，可以有不同的方法
第三章 词法分析
源程序
词法分析
语法分析
表
格
语义分析
管
理
中间代码生成
错 误 检 测
代码优化
目标代码生成 目标程序
第三章 词法分析
主要内容
1.介绍词法分析的过程 2.讨论词法分析器的设计与实现 3.介绍实现词法分析器的主要工具：状态转换图
3.1 词法分析器的任务
❖ 人们理解一篇文章（或程序）起码是先在单词级别上思考。
一个正规式对应一个正规集
3.2.1 正规式与正规集
正规式和正规表达式
对字母表∑：
(1) ε和Φ都是∑上的正规式，它们所表示的正规集分别为{ε}和Φ；
(2) a∈∑，a是∑上的一个正规式，它所表示的正规集为{a}；
(3) 假定U和V都是∑上的正规式，它们所表示的正规集分别记为L(U)和L(V)， 那么(U|V)、(UV)和(U)*也是正规式，它们所对应的正规集分别为 L(U)∪L(V)、L(U)L(V)和(L(U))*。
❖ 编译程序要分析和翻译源程序，也先要区分一个一个的单词。
❖ 词法分析程序的任务是：从左到右逐个字符对源程序扫描，产生一 个单词序列，把作为字符串的源程序改造为单词符号串的中间程序。
❖ 词法分析程序又称词法分析器或扫描器。
除了识别单词的基本任务外，词法分析还可以完成以下任务： （1）组织源程序的输入 （2）删除注释、空格及无用符号（如回车等） （3）行、列计数 （4）列表打印源程序 （5）发现并定位词法错误 （6）建立、查填符号表