词法分析器源代码

词法分析器原理词法分析器（Lexical Analyzer）是编译器中的重要组成部分，用于将输入的源代码分解为一个个词法单元（Token），为语法分析器（Syntax Analyzer）提供分析的基础。

本文将介绍词法分析器的原理和工作流程。

一、概述词法分析器通过扫描源代码字符流，并识别出其中的合法词法单元。

它将源代码转化为一个个标识符、关键字、常数、运算符等基本构件，以供后续阶段进行进一步的处理和分析。

二、工作原理1. 自动机词法分析器通常使用有限自动机（Finite Automaton）来实现。

有限自动机由一系列状态组成，每个状态所接受的输入决定了自动机的状态转移。

利用状态转移规则，自动机可以根据输入字符逐步分析源代码并产生相应的词法单元。

2. 正则表达式为了方便描述词法分析器对输入的词法单元进行匹配，可以使用正则表达式。

正则表达式是一种描述字符模式的工具，它可以定义一类字符串的集合。

词法分析器将正则表达式与状态机相结合，通过模式匹配的方式识别输入字符流中的词法单元。

3. 词法规则词法分析器通过预先定义的词法规则来描述源代码中的不同词法单元。

例如，某个编程语言的词法规则可能包含关键字、标识符、数字、字符串等。

词法规则的定义中常常使用正则表达式来指定某个词法单元的模式。

4. 符号表为了方便后续的语义处理和编译过程，词法分析器通常会维护一个符号表（Symbol Table）。

符号表记录了源代码中出现的标识符、常量等信息，以供后续的语法分析和语义分析使用。

三、工作流程词法分析器的工作流程可以分为以下几个步骤：1. 读取源代码字符流，并初始化状态机。

2. 通过状态转移规则，逐个输入字符进行状态转移，直到达到某个终止状态。

3. 判断当前状态是否为某个词法单元的终止状态，如果是，产生相应的词法单元，并将其记录在符号表中。

4. 继续读取源代码字符流，重复以上过程，直到扫描完整个源代码。

五、总结词法分析器作为编译器的重要组成部分，负责将源代码分解为一个个词法单元，并提供给语法分析器进行进一步的处理。

一、实验目的1. 理解词法分析的概念和作用。

2. 掌握词法分析器的设计和实现方法。

3. 通过实验加深对编译原理中词法分析阶段的理解。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 设计一个简单的词法分析器，能够识别并输出源代码中的单词。

2. 实现词法分析器的关键功能，包括：- 字符串预处理- 单词识别- 生成词法分析表四、实验步骤1. 字符串预处理- 读取源代码字符串。

- 移除字符串中的空白字符（空格、制表符、换行符等）。

- 转义字符串中的特殊字符。

2. 单词识别- 使用正则表达式匹配单词。

- 根据正则表达式匹配结果，将单词分类为关键字、标识符、常量等。

3. 生成词法分析表- 创建一个列表，用于存储词法分析表中的每个单词及其对应的类别。

- 遍历源代码字符串，将识别出的单词添加到词法分析表中。

五、实验代码```pythonimport re# 定义词法分析表结构class Token:def __init__(self, type, value):self.type = typeself.value = value# 单词识别函数def tokenize(source_code):# 移除空白字符source_code = re.sub(r'\s+', '', source_code)# 转义特殊字符source_code = re.sub(r'\\', '\\\\', source_code)# 使用正则表达式匹配单词tokens = re.findall(r'\b\w+\b', source_code)# 生成词法分析表token_table = []for token in tokens:if re.match(r'\bint\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\bfloat\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\bchar\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\bif\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\belse\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\breturn\b', token):token_table.append(Token('KEYWORD', token))elif re.match(r'\b\w+\b', token):token_table.append(Token('IDENTIFIER', token)) else:token_table.append(Token('CONSTANT', token)) return token_table# 主函数def main():# 读取源代码source_code = '''int main() {int a = 10;float b = 3.14;char c = 'A';if (a > b) {return a;} else {return b;}}'''# 进行词法分析token_table = tokenize(source_code)# 输出词法分析结果for token in token_table:print(f'Type: {token.type}, Value: {token.value}') if __name__ == '__main__':main()```六、实验结果运行实验代码后，输出如下：```Type: KEYWORD, Value: intType: IDENTIFIER, Value: mainType: KEYWORD, Value: (Type: KEYWORD, Value: )Type: KEYWORD, Value: intType: IDENTIFIER, Value: a Type: KEYWORD, Value: = Type: CONSTANT, Value: 10 Type: KEYWORD, Value: ; Type: KEYWORD, Value: float Type: IDENTIFIER, Value: b Type: KEYWORD, Value: = Type: CONSTANT, Value: 3.14 Type: KEYWORD, Value: ; Type: KEYWORD, Value: char Type: IDENTIFIER, Value: c Type: KEYWORD, Value: = Type: CONSTANT, Value: A Type: KEYWORD, Value: ; Type: KEYWORD, Value: if Type: IDENTIFIER, Value: ( Type: IDENTIFIER, Value: a Type: KEYWORD, Value: > Type: IDENTIFIER, Value: b Type: KEYWORD, Value: ) Type: KEYWORD, Value: { Type: KEYWORD, Value: return Type: IDENTIFIER, Value: aType: KEYWORD, Value: ;Type: KEYWORD, Value: }Type: KEYWORD, Value: elseType: KEYWORD, Value: {Type: KEYWORD, Value: returnType: IDENTIFIER, Value: bType: KEYWORD, Value: ;Type: KEYWORD, Value: }```七、实验总结通过本次实验，我们成功地设计并实现了一个简单的词法分析器，能够识别并输出源代码中的单词。

词法分析c实现一、实验目的设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。

二、实验要求2.1 待分析的简单的词法（1）关键字：begin if then while do end所有的关键字都是小写。

（2）运算符和界符：= + - * / < <= <> > >= = ; ( ) #（3）其他单词是标识符（ID）和整型常数（SUM），通过以下正规式定义：ID = letter (letter | digit)*NUM = digit digit*（4）空格有空白、制表符和换行符组成。

空格一般用来分隔ID、SUM、运算符、界符和关键字，词法分析阶段通常被忽略。

2.2 各种单词符号对应的种别码：输入：所给文法的源程序字符串。

输出：二元组（syn,token或sum）构成的序列。

其中：syn为单词种别码；token为存放的单词自身字符串；sum为整型常数。

例如：对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件，经过词法分析后输出如下序列：(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的C语言程序源代码：#include <stdio.h>#include <string.h>char prog[80],token[8],ch;int syn,p,m,n,sum;char *rwtab[6]={"begin","if","then","while","do","end"};scaner();main(){p=0;printf("\n please input a string(end with '#'):/n");do{scanf("%c",&ch);prog[p++]=ch;}while(ch!='#');p=0;do{scaner();switch(syn){case 11:printf("( %-10d%5d )\n",sum,syn);break;case -1:printf("you have input a wrong string\n");getch();exit(0);default: printf("( %-10s%5d )\n",token,syn);break;}}while(syn!=0);getch();}scaner(){ sum=0;for(m=0;m<8;m++)token[m++]=NULL;ch=prog[p++];m=0;while((ch==' ')||(ch=='\n'))ch=prog[p++];if(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A'))){ while(((ch<='z')&&(ch>='a'))||((ch<='Z')&&(ch>='A'))||((ch>='0')&&(ch<='9'))) {token[m++]=ch;ch=prog[p++];}p--;syn=10;for(n=0;n<6;n++)if(strcmp(token,rwtab[n])==0){ syn=n+1;break;}}else if((ch>='0')&&(ch<='9')) { while((ch>='0')&&(ch<='9')) { sum=sum*10+ch-'0';ch=prog[p++];}p--;syn=11;}else switch(ch){ case '<':token[m++]=ch;ch=prog[p++];if(ch=='='){ syn=22;token[m++]=ch;}else{ syn=20;p--;}break;case '>':token[m++]=ch;ch=prog[p++];if(ch=='='){ syn=24;token[m++]=ch;}else{ syn=23;p--;}break;case '+': token[m++]=ch;ch=prog[p++];if(ch=='+'){ syn=17;token[m++]=ch;}else{ syn=13;p--;}break;ch=prog[p++];if(ch=='-'){ syn=29;token[m++]=ch;}else{ syn=14;p--;}break;case '!':ch=prog[p++];if(ch=='='){ syn=21;token[m++]=ch;}else{ syn=31;p--;}break;case '=':token[m++]=ch;ch=prog[p++];if(ch=='='){ syn=25;token[m++]=ch;}else{ syn=18;p--;}break;case '*': syn=15;token[m++]=ch;break;case '/': syn=16;token[m++]=ch;break;case '(': syn=27;token[m++]=ch;break;case ')': syn=28;break;case '{': syn=5;token[m++]=ch;break;case '}': syn=6;token[m++]=ch;break;case ';': syn=26;token[m++]=ch;break;case '\"': syn=30;token[m++]=ch;break;case '#': syn=0;token[m++]=ch;break;case ':':syn=17;token[m++]=ch;break;default: syn=-1;break;}token[m++]='\0';}四、结果分析：输入begin x:=9: if x>9 then x:=2*x+1/3; end # 后经词法分析输出如下序列：(begin 1)(x 10)(：17)(= 18)(9 11)(；26)(if 2)……如图5-1所示：。

理解编译原理与解释型语言的工作原理编译原理是指将高级语言编写的程序转化为计算机能够理解和执行的机器语言的过程，也即编译器如何将源代码转化为目标代码的原理和方法。

解释型语言是一种在程序运行过程中逐行翻译并执行源代码的语言，也即解释器如何对源代码逐行解析和执行的原理和方法。

两者的工作原理有一些相似之处，也有一些明显的差异。

一、编译原理的工作原理编译原理的基本过程可以分为以下几个阶段：词法分析、语法分析、语义分析、中间代码生成、代码优化和目标代码生成。

1.词法分析：词法分析器将源代码的字符序列划分为一个个的词法单元（Token）。

词法单元是编程语言中最小的有意义的单位，如标识符、关键字、操作符、常量等。

词法分析器会按照一定的规则对源代码进行逐个字符扫描，并将扫描到的字符组成的词法单元进行识别和分类。

2.语法分析：语法分析器根据词法单元序列和语法规则，将源代码按照语法结构进行解析，构造出语法分析树或抽象语法树（AST）。

语法分析器使用的主要手段是上下文无关文法，通过判断输入的词法单元序列是否满足产生式规则，递归地构建语法分析树或AST。

3.语义分析：语义分析器对语法分析生成的语法树或AST进行语义检查，识别和处理语言中的语义错误。

语义分析的过程主要包括类型检查、作用域分析、常量折叠等。

语义分析器会根据编程语言的语义规则，对源代码进行静态分析，以确保程序在运行时不会出现语义错误。

4.中间代码生成：中间代码生成器将语法树或AST转化为一种中间表示形式，以便于后续的代码优化和目标代码生成。

中间代码通常是一种类似于汇编语言的低级语言，屏蔽了具体的机器细节，同时又保留了源代码的结构性和表达能力。

5.代码优化：代码优化器对中间代码进行优化，以提高程序的运行效率和资源利用率。

代码优化的目标包括减少代码的执行时间、减少代码的空间占用、降低程序的功耗等。

代码优化器使用各种优化技术，如常量传播、公共子表达式消除、循环优化等。

词法分析器实验报告一、实验目的及要求本次实验通过用C语言设计、编制、调试一个词法分析子程序，识别单词，实现一个C语言词法分析器，经过此过程可以加深对编译器解析单词流的过程的了解。

运行环境：硬件：windows xp软件：visual c++6.0二、实验步骤1.查询资料，了解词法分析器的工作过程与原理。

2.分析题目，整理出基本设计思路。

3.实践编码，将设计思想转换用c语言编码实现，编译运行。

4.测试功能，多次设置包含不同字符，关键字的待解析文件，仔细察看运行结果，检测该分析器的分析结果是否正确。

通过最终的测试发现问题，逐渐完善代码中设置的分析对象与关键字表，拓宽分析范围提高分析能力。

三、实验内容本实验中将c语言单词符号分成了四类：关键字key（特别的将main说明为主函数）、普通标示符、常数和界符。

将关键字初始化在一个字符型指针数组*key[]中，将界符分别由程序中的case列出。

在词法分析过程中，关键字表和case列出的界符的内容是固定不变的（由程序中的初始化确定），因此，从源文件字符串中识别出现的关键字，界符只能从其中选取。

标识符、常数是在分析过程中不断形成的。

对于一个具体源程序而言，在扫描字符串时识别出一个单词，若这个单词的类型是关键字、普通标示符、常数或界符中之一，那么就将此单词以文字说明的形式输出．每次调用词法分析程序，它均能自动继续扫描下去，形成下一个单词，直到整个源程序全部扫描完毕，从而形成相应的单词串。

输出形式例如：void $关键字流程图、程序流程图：程序：#include<string.h>#include<stdio.h>#include<stdlib.h>#include<ctype.h>//定义关键字char*Key[10]={"main","void","int","char","printf","scanf","else","if","return"}; char Word[20],ch; // 存储识别出的单词流int IsAlpha(char c) { //判断是否为字母if(((c<='z')&&(c>='a'))||((c<='Z')&&(c>='A'))) return 1;else return 0;}int IsNum(char c){ //判断是否为数字if(c>='0'&&c<='9') return 1;else return 0;}int IsKey(char *Word){ //识别关键字函数int m,i;for(i=0;i<9;i++){if((m=strcmp(Word,Key[i]))==0){if(i==0)return 2;return 1;}}return 0;}void scanner(FILE *fp){ //扫描函数char Word[20]={'\0'};char ch;int i,c;ch=fgetc(fp); //获取字符，指针fp并自动指向下一个字符if(IsAlpha(ch)){ //判断该字符是否是字母Word[0]=ch;ch=fgetc(fp);i=1;while(IsNum(ch)||IsAlpha(ch)){ //判断该字符是否是字母或数字Word[i]=ch;i++;ch=fgetc(fp);}Word[i]='\0'; //'\0' 代表字符结束(空格)fseek(fp,-1,1); //回退一个字符c=IsKey(Word); //判断是否是关键字if(c==0) printf("%s\t$普通标识符\n\n",Word);//不是关键字else if(c==2) printf("%s\t$主函数\n\n",Word);else printf("%s\t$关键字\n\n",Word); //输出关键字 }else //开始判断的字符不是字母if(IsNum(ch)){ //判断是否是数字Word[0]=ch;ch=fgetc(fp);i=1;while(IsNum(ch)){Word[i]=ch;i++;ch=fgetc(fp);}Word[i]='\0';fseek(fp,-1,1); //回退printf("%s\t$无符号实数\n\n",Word);}else //开始判断的字符不是字母也不是数字{Word[0]=ch;switch(ch){case'[':case']':case'(':case')':case'{':case'}':case',':case'"':case';':printf("%s\t$界符\n\n",Word); break;case'+':ch=fgetc(fp);Word[1]=ch;if(ch=='='){printf("%s\t$运算符\n\n",Word);//运算符“+=”}else if(ch=='+'){printf("%s\t$运算符\n\n",Word); //判断结果为“++”}else {fseek(fp,-1,1);printf("%s\t$运算符\n\n",Word); //判断结果为“+”}break;case'-':ch=fgetc(fp);Word[1]=ch;if(ch=='='){printf("%s\t$运算符\n\n",Word); }else if(ch=='-'){printf("%s\t$运算符\n\n",Word); //判断结果为“--”}else {fseek(fp,-1,1);printf("%s\t$运算符\n\n",Word); //判断结果为“-”}break;case'*':case'/':case'!':case'=':ch=fgetc(fp);if(ch=='='){printf("%s\t$运算符\n\n",Word);}else {fseek(fp,-1,1);printf("%s\t$运算符\n\n",Word);}break;case'<':ch=fgetc(fp);Word[1]=ch;if(ch=='='){printf("%s\t$运算符\n\n",Word); //判断结果为运算符“<=”}else if(ch=='<'){printf("%s\t$运算符\n\n",Word); //判断结果为“<<”}else {fseek(fp,-1,1);printf("%s\t$运算符\n\n",Word); //判断结果为“<”}break;case'>':ch=fgetc(fp);Word[1]=ch;if(ch=='=') printf("%s\t$运算符\n\n",Word);else {fseek(fp,-1,1);printf("%s\t$运算符\n\n",Word);}break;case'%':ch=fgetc(fp);Word[1]=ch;if(ch=='='){printf("%s\t$运算符\n\n",Word);}if(IsAlpha(ch)) printf("%s\t$类型标识符\n\n",Word);else {fseek(fp,-1,1);printf("%s\t$取余运算符\n\n",Word);}break;default:printf("无法识别字符!\n\n"); break;}}}main(){char in_fn[30]; //文件路径FILE *fp;printf("\n请输入源文件名（包括路径和后缀名）:");while(1){gets(in_fn);//scanf("%s",in_fn);if((fp=fopen(in_fn,"r"))!=NULL) break; //读取文件内容，并返回文件指针，该指针指向文件的第一个字符else printf("文件路径错误!请重新输入:");}printf("\n******************* 词法分析结果如下 *******************\n");do{ch=fgetc(fp);if(ch=='#') break; //文件以#结尾，作为扫描结束条件else if(ch==' '||ch=='\t'||ch=='\n'){} //忽略空格，空白，和换行else{fseek(fp,-1,1); //回退一个字节开始识别单词流scanner(fp);}}while(ch!='#');return(0);}4.实验结果解析源文件：void main(){int a=3;a+=b;printf("%d",a);return;}#解析结果：5.实验总结分析通过本次实验，让再次浏览了有关c语言的一些基本知识，特别是对文件，字符串进行基本操作的方法。

1.实验目的及要求设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。

2.实验要求一、词法分析程序的功能：二、输入：所给文法的源程序字符串。

三、输出：二元组（syn,token或sum）构成的序列。

四、其中：syn为单词种别码；五、token为存放的单词自身字符串；六、sum为整型常数。

各种单词符号对应的种别码单词符号种别码单词符号种别码begin 1 : 17if 2 := 18then 3 > 20while 4 <> 21do 5 <= 22end 6 < 23 letter(letter| digit)* 10 >= 24 digit digit * 11 = 25 * 13 ; 26/ 14 ( 27+ 15 ) 28- 16 # 03源代码#include<stdio.h>#include<string.h>#include<iostream.h>char prog[80],token[8];char ch;int syn,p,m=0,n,row,sum=0;char *rwtab[6]={"begin","if","then","while","do","end"};void scaner(){for(n=0;n<8;n++) token[n]=NULL;ch=prog[p++];while(ch==' '){ch=prog[p];p++;}if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')){m=0;while((ch>='0'&&ch<='9')||(ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')){token[m++]=ch;ch=prog[p++];}token[m++]='\0';p--;syn=10;for(n=0;n<6;n++)if(strcmp(token,rwtab[n])==0){syn=n+1;break;}}else if((ch>='0'&&ch<='9')){{sum=0;while((ch>='0'&&ch<='9')){sum=sum*10+ch-'0';ch=prog[p++];}}p--;syn=11;if(sum>32767)syn=-1;}else switch(ch){case'<':m=0;token[m++]=ch;ch=prog[p++];if(ch=='>'){syn=21;token[m++]=ch;}else if(ch=='='){syn=22;token[m++]=ch;}else{syn=23;p--;}break;case'>':m=0;token[m++]=ch;ch=prog[p++];if(ch=='='){syn=24;token[m++]=ch;}else{syn=20;p--;}break;case':':m=0;token[m++]=ch;ch=prog[p++];if(ch=='='){syn=18;token[m++]=ch;}else{syn=17;p--;}break;case'*':syn=13;token[0]=ch;break; case'/':syn=14;token[0]=ch;break; case'+':syn=15;token[0]=ch;break; case'-':syn=16;token[0]=ch;break; case'=':syn=25;token[0]=ch;break; case';':syn=26;token[0]=ch;break; case'(':syn=27;token[0]=ch;break; case')':syn=28;token[0]=ch;break;case'#':syn=0;token[0]=ch;break;case'\n':syn=-2;break;default: syn=-1;break;}}void main(){p=0;row=1;cout<<"请输入字符串:"<<endl;do{cin.get(ch);prog[p++]=ch;}while(ch!='#');p=0;do{scaner();switch(syn){case 11: cout<<"("<<syn<<","<<sum<<")"<<endl; break;case -1: cout<<"Error in row "<<row<<"!"<<endl; break;case -2: row=row++;break;default: cout<<"("<<syn<<","<<token<<")"<<endl;break;}}while (syn!=0);}4 结果验证给定源程序begin x:=12; if x>0 then x:=3-4*2+3/2; end#源程序（包括上式未有的while、do以及判断错误语句）：begin x<=$; while a<0 do b<..>9-x; end#5 心得体会通过此次实验，我更加深入的了解了词法构造，词法分析编制程序并调试，熟悉了构造词法分析程序的手工方式的相关原理，还有特别要注意种别码不能写错，必须一一对应，否则会很难检查出来。

TINY部分源码分析报告TINY是一种简单的编程语言，用于教学目的。

它的语法规则非常简单，只有几个基本的关键字和语句。

在这篇报告中，我将对TINY的部分源码进行分析。

首先，让我们来看一下TINY的词法分析器部分的源码。

TINY的词法分析使用了一种基于有限自动机的方法。

源码中定义了几个关键字和运算符的正则表达式模式，并使用这些模式进行匹配。

如果匹配成功，就返回对应的记号。

接下来是语法分析器部分的源码。

TINY的语法分析使用了递归下降的方法。

源码中定义了几个非终结符的函数，每个函数对应语法中的一个产生式。

函数根据当前输入的记号，选择适当的产生式，并继续递归下降，直到匹配整个输入。

TINY的语法规则非常简单，只有if语句、while语句、表达式、赋值语句等几个基本的语法结构。

在语法分析器的源码中，每个函数都对应一个语法规则。

例如，函数parseStatement用于解析语句，它根据当前输入的记号，选择适当的产生式，例如if语句的产生式或赋值语句的产生式。

为了简化语法分析过程，TINY使用了LL(1)文法。

LL(1)文法是指，对于任意一个非终结符X和一个记号a，最多只有一个产生式可以选择。

这样可以使得语法分析过程更加简单和高效。

除了词法分析器和语法分析器，TINY还包括了一个解释器部分的源码。

解释器使用了递归下降的方法，根据语法分析的结果进行解释执行。

解释器遵循TINY的语义规则，例如执行赋值语句将变量的值更新为表达式的值。

总结起来，TINY是一种简单的编程语言，它的源码包括词法分析器、语法分析器和解释器部分。

词法分析器负责将源代码转化为记号序列，语法分析器负责根据记号序列生成抽象语法树，解释器负责执行抽象语法树中的操作。

TINY的源码采用了有限自动机和递归下降的方法，通过正则表达式模式和LL(1)文法来进行匹配和选择。

整个源码非常简洁，适合用于教学和学习。

一、目的编译技术是理论与实践并重的课程，而其实验课要综合运用一、二年级所学的多门课程的内容，用来完成一个小型编译程序。

从而巩固和加强对词法分析、语法分析、语义分析、代码生成和报错处理等理论的认识和理解；培养学生对完整系统的独立分析和设计的能力，进一步培养学生的独立编程能力。

二、任务及要求基本要求：1．词法分析器产生下述小语言的单词序列这个小语言的所有的单词符号，以及它们的种别编码和内部值如下表：单词符号种别编码助记符内码值DIMIFDO STOP END标识符常数（整）=+***，（）1234567891011121314$DIM$IF$DO$STOP$END$ID$INT$ASSIGN$PLUS$STAR$POWER$COMMA$LPAR$RPAR------内部字符串标准二进形式------对于这个小语言，有几点重要的限制：首先，所有的关键字（如IF﹑WHILE等）都是“保留字”。

所谓的保留字的意思是，用户不得使用它们作为自己定义的标示符。

例如，下面的写法是绝对禁止的：IF（5）=x其次，由于把关键字作为保留字，故可以把关键字作为一类特殊标示符来处理。

也就是说，对于关键字不专设对应的转换图。

但把它们（及其种别编码）预先安排在一张表格中（此表叫作保留字表）。

当转换图识别出一个标识符时，就去查对这张表，确定它是否为一个关键字。

再次，如果关键字、标识符和常数之间没有确定的运算符或界符作间隔，则必须至少用一个空白符作间隔（此时，空白符不再是完全没有意义的了）。

例如，一个条件语句应写为IF i>0 i= 1;而绝对不要写成IFi>0 i=1;因为对于后者，我们的分析器将无条件地将IFI看成一个标识符。

这个小语言的单词符号的状态转换图，如下图：2．语法分析器能识别由加+ 减- 乘* 除/ 乘方^ 括号（）操作数所组成的算术表达式，其文法如下：E→E+T|E-T|TT→T*F|T/F|FF→P^F|Pp→(E)|i使用的算法可以是：预测分析法；递归下降分析法；算符优先分析法；LR分析法等。

}//error
void Scanner(char ch[],int chLen,Table table[Max],int nLine) {
int chIndex = 0;
while(chIndex < chLen) //对输入的字符扫描 { /**************************处理空格和 tab ************************/
六、总结：
词法分析是构造编译器的起始阶段，也是相应比较简单的一个环节。词法分析的主要任 务是：根据构造的状态转换图，从左到右逐个字符地対源程序进行扫描，识别开源程序中具 有独立含义的最小语法单位——符号或单词，如变量标识符，关键字，常量，运算符，界符 等。
然后将提取出的标识符以内码的形式表示，即用 int 类型的数字来表示其类型和在 display 表中的位置，而无须保留原来标识符本身的字符串，这不仅节省了内存空间，也有 利于下一阶段的分析工作。
typedef struct DisplayTable {
int Index; //标识符所在表的下标 int type; //标识符的类型 int line; //标识符所在表的行数 char symbol[20]; //标识符所在表的名称 }Table;
int TableNum = 0; //display 表的下标 char Word[WordMaxNum][20]; //标识符表 char Digit[WordMaxNum][20]; //数字表 int WordNum = 0; //变量表的下标 int DigNum = 0; //常量表的下标 bool errorFlag = 0; //错误标志
当然，在扫描源程序串的同时，进行一些简单的处理，如删除空格、tab、换行等无效 字符，也进行了一些基本的错误处理，如变量长度的判别，有些不合词法规则的标识符判别 等。总之，严格说来，词法分析程序只进行和词法分析相关的工作。

词法分析一、实验目的设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。

二、实验要求2.1 待分析的简单的词法（1）关键字：begin if then while do end所有的关键字都是小写。

（2）运算符和界符：= + - * / < <= <> > >= = ; ( ) #（3）其他单词是标识符（ID）和整型常数（SUM），通过以下正规式定义：ID = letter (letter | digit)*NUM = digit digit*（4）空格有空白、制表符和换行符组成。

空格一般用来分隔ID、SUM、运算符、界符和关键字，词法分析阶段通常被忽略。

2.2 各种单词符号对应的种别码：输入：所给文法的源程序字符串。

输出：二元组（syn,token或sum）构成的序列。

其中：syn为单词种别码；token为存放的单词自身字符串；sum为整型常数。

例如：对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件，经过词法分析后输出如下序列：(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的算法思想：算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号。

3.1 主程序示意图：主程序示意图如图3-1所示。

其中初始包括以下两个方面：⑴关键字表的初值。

关键字作为特殊标识符处理，把它们预先安排在一张表格中（称为关键字表），当扫描程序识别出标识符时，查关键字表。

如能查到匹配的单词，则该单词为关键字，否则为一般标识符。

关键字表为一个字符串数组，其描述如下：Char *rwtab[6] = {“begin”, “if”, “then”, “while”, “do”, “end”,};图3-1（2）程序中需要用到的主要变量为syn,token和sum3.2 扫描子程序的算法思想：首先设置3个变量：①token用来存放构成单词符号的字符串；②sum用来整型单词；③syn用来存放单词符号的种别码。

编译程序的前端名词解释编译程序是一种将高级语言转换为机器语言的工具。

它由两个主要的组成部分组成：前端和后端。

前端负责将用户编写的源代码进行词法分析、语法分析和语义分析，生成一个称为中间代码的表示形式。

而后端则负责将中间代码翻译成目标机器可执行的机器代码。

前端在编译程序中起着至关重要的作用。

它主要包括词法分析器、语法分析器和语义分析器。

词法分析器将源代码分解为一个个的标识符（如变量名、函数名等）和关键字，形成一个记号流。

语法分析器则负责根据语法规则检查记号流的结构，并将其转换为一棵语法树。

语义分析器则进一步验证源代码的语义正确性，并生成中间代码。

词法分析器将源代码转换为一个个记号，这些记号是编译器理解和处理源代码所必需的基本元素。

例如，在C语言中，标识符和关键字是记号的一种。

标识符指的是由字母、数字和下划线组成的变量名或函数名，而关键字则是由编程语言定义的特殊单词，具有特定的意义。

语法分析器会根据语法规则检查记号流的结构，并将其转换为一棵语法树。

语法规则定义了语言中合法的语法结构，例如条件语句、循环语句等。

语法分析器可以根据这些规则来分析源代码，判断其是否符合语法规范。

如果不符合规范，语法分析器将抛出一个语法错误。

语义分析器的主要任务是验证源代码的语义正确性。

它会检查变量的声明和使用是否一致，函数调用的参数是否匹配等。

例如，在C语言中，如果一个变量在使用之前没有声明，语义分析器将发出一个错误提示。

语义分析器还可以执行类型推导，将编译器自动推断出表达式中的数据类型。

词法、语法和语义分析器紧密合作，它们共同构建了编译程序的前端。

通过这些分析，编译程序可以根据源代码生成中间代码，中间代码是一个与具体机器无关的表示形式。

它通常采用一种称为三地址码的形式，其中每个语句最多包含三个操作数。

生成中间代码是编译程序的一项重要工作，因为它将源代码转换成了更加抽象和独立于机器的形式。

这样一来，即使计算机架构发生变化，后端只需要负责将中间代码翻译成新架构的机器代码，而无需对前端进行修改。

};
/*****************************重要数据结构的声明结束*************************/
/*********************************全局变量声明开始**************************/
int place=1;
/*26*/{999,12,999,999,999,999,999,9,999,999,999,11,13,999,999,999,33,10,999,999},
/*27*/{999,999,68,999,999,68,68,999,999,20,21,999,999,999,999,999,999,999,999,999},
#define op_add 9 //+
#define op_mul 10 //*
#define op_2star 11 //**
#define div_fenhao 12 //;
#define syl_ls 13 //(
#define syl_rs 14 //)
#define syl_lb 15 //{
/*4*/{999,999,999,999,7,999,999,999,999,999,999,999,999,999,999,999,999,999,999,999},
/*5*/{999,999,999,999,999,999,999,999,999,999,999,999,999,61,999,999,999,999,999,999},
/*30*/{999,999,72,72,999,72,72,999,72,72,72,999,999,72,999,999,999,999,999,999},

词法分析一、实验目的设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。

二、实验要求2.1 待分析的简单的词法（1）关键字：begin if then while do end所有的关键字都是小写。

（2）运算符和界符：= + - * / < <= <> > >= = ; ( ) #（3）其他单词是标识符（ID）和整型常数（SUM），通过以下正规式定义：ID = letter (letter | digit)*NUM = digit digit*（4）空格有空白、制表符和换行符组成。

空格一般用来分隔ID、SUM、运算符、界符和关键字，词法分析阶段通常被忽略。

2.2 各种单词符号对应的种别码：表2.1 各种单词符号对应的种别码2.3 词法分析程序的功能：输入：所给文法的源程序字符串。

输出：二元组（syn,token或sum）构成的序列。

其中：syn为单词种别码；token为存放的单词自身字符串；sum为整型常数。

例如：对源程序begin x:=9: if x>9 then x:=2*x+1/3; end #的源文件，经过词法分析后输出如下序列：(1,begin)(10,x)(18,:=)(11,9)(26,;)(2,if)……三、词法分析程序的算法思想：算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号。

3.1 主程序示意图：主程序示意图如图3-1所示。

其中初始包括以下两个方面：⑴关键字表的初值。

关键字作为特殊标识符处理，把它们预先安排在一张表格中（称为关键字表），当扫描程序识别出标识符时，查关键字表。

如能查到匹配的单词，则该单词为关键字，否则为一般标识符。

关键字表为一个字符串数组，其描述如下：Char *rwtab[6] = {“begin”, “if”, “then”, “while”, “do”, “end”,};是图3-1（2）程序中需要用到的主要变量为syn,token和sum3.2 扫描子程序的算法思想：首先设置3个变量：①token用来存放构成单词符号的字符串；②sum用来整型单词；③syn用来存放单词符号的种别码。

C 语言词法分析器构造实验报告02计算机（2） 2002374203 冯绍欣一、题目要求：完成一个C 语言的词法分析器的构造。

此词法分析器能识别附值语句、循环语句、条件语句、并能处理注释。

二、设计方案：这个词法分析器分析的主要关键字有：main, int, float, char, if, else, for, while, do, switch, case, break; default 。

选择要分析的c 文件，首先对其去掉注释和与空格处理，再根据字符的不同类型分析。

1、全局数据结构：字符数组 set[ ]：存放从文件中读到的所有字符；str[ ]：存放经过注释处理和预空格处理的字符；strtoken[ ]：存放当前分析的字符；结构体 KEYTABLE ：存放关键字及其标号；全局字符变量 ch ：当前读入字符；全局整型变量 sr, to ：数组str, strtoken 的指针。

2、以层次图形式描述模块的组成及调用关系3、主要函数的设计要求（功能、参数、返回值）：openfile ：打开文件；GetChar ：将下一个输入字符读到ch 中，搜索指示器前移一字符位置；GetBC ：检查ch 中的字符是否为空白。

若是，则调用GetChar 直至ch 中进入一个非空白字符； Main ( )Openfile ( ) Analysis ( )Reflesh() Process()Set32()GetChar() GetBC()Concat()Reserve()IsLetter() IsDigit()Retract()GetChar()Concat ：将ch 中的字符连接到strtoken 之后；IsLetter 和IsDigit ：布尔函数过程，分别判断ch 中的字符是否为字母和数字；Reserve ：整型函数过程，对strtoken 中的字符串查找关键字表，若是关键字则返回编码，否则返回-1；Retract ：将搜索指示器回调一个字符位置，将ch 置为空白字符；reflesh ：刷新，把strtoken 数组置为空；prearrange1：将注释部分置为空格；prearrange2：预处理空格，去掉多余空格；analysis:词法分析；main ：主函数。

院系：计算机学院实验课程：编译原理实验项目：C++源代码单词扫描程序（词法分析）指导老师：陈寅开课时间：2014～2015年度第1学期专业：数据库班级：2班学生：雷楚楚学号：20122100158C++源代码单词扫描程序（词法分析）一、实验目的设计并实现一个词法分析器，深刻理解编译原理中词法分析器的原理。

二、实验内容1、C++源代码扫描程序识别C++记号。

C++语言包含了几种类型的记号：标识符，关键字，数（包括整数、浮点数），字符串，注释，特殊符号（分解符）和运算符号等。

2、打开一个C++源文件，打印出所有以上的记号。

3、选作部分：为了提高C++源程序的可读性，C++程序在书写过程中加入了空行、空格、缩进、注释等。

假设你想牺牲可读性，以节省磁盘空间，那么你可以存贮一个删除了所有不必要空格和注释的C++源程序的压缩文本。

因此，程序中还看可以有这样的压缩功能。

4、进一步实现减少源文件大小的压缩功能。

5、完善软件文档。

二、实验过程１、对C++文法中的各类单词分类（1）保留字：asm、do、if、return、typedef、auto、double、inline、short、typeid、bool、try、include、long、sizeof、union、case、enum、mutable、static、unsigned、long、sizeof、union、case、enum、mutable、static、unsigned、catch、explicit、namespace、using、char、export、int、signed、break、else、new、struct、virtual、class、extern、operator、switch、void、const、false、private、template、volatile、float、protected、this、continue、for、public、throw、while、default、friend、register、true、delete、goto、try、include、std、iomanip、setw、setprecision、endl、setiosflags、ios （2）数字：包括整数和浮点数（3）标识符：由字母打头的字母和数字的字符串，可包含下划线（4）运算符："&="、"^="、"、="、"<<="、">>="、"*="、"/="、"%="、"+="、"-="、"="、"?:"、"、、"、"&&"、"、"、"^"、"&"、"=="、"!="、">"、">="、"<"、"<="、"<<"、">>"、"+"、"-"、"*"、"/"、"%"、".*"、"->*"、"&"、"+"、"-"、"++"、"--"、"->"、"::"（5）界符："{"、"}"、"("、")"、"#"、","、":"、";"、"."、"\""（6）注释：包括//和/**/两种类型的注释(7）字符串:包含在“”里面的内容２、将各类单词对应到Flex中：（1）保留字：asm|do|if|return|typedef|auto|double|inline|short|typeid|bool|try|include|long|sizeof|union|case|enum|mutable|static|unsigned|long|sizeof|union|case|enum|mutable|static|unsigned|catch|explicit|namespace|using|char|export|int|signed|break|else|new|struct|virtual|class|extern|operator|switch|void|const|false|private|template|volatile|float|protected|this|continue|for|public|throw|while|default|friend|register|true|delete|goto|try|include|std|iomanip|setw|setprecision|endl|setiosflags|ios（2）数字：包括整数和浮点数（正负）[+-]?([0-9]*|0|([0-9]*\.[0-9]*))（3）标识符：由字母打头的字母和数字的字符串，包含下划线[A-Za-z]([A-Za-z]|[0-9]|_)*（4）运算符："&="|"^="|"|="|"<<="|">>="|"*="|"/="|"%="|"+="|"-="|"="|"?:"|"||"|"&&"|"|"|"^"|"&"|"=="|"!="|">"|">="|"<"|"<="|"<<"|">>"|"+"|"-"|"*"|"/"|"%"|".*"|"->*"|"&"|"+"|"-"|"++"|"--"|"->"|"::"（5）界符："{"|"}"|"("|")"|"#"|","|":"|";"|"."|"\""（6）注释：包括//和/**/两种类型的注释\/\*(\s|.)*?\*\/（/**/）\/\/[^\n]*（//）(7）字符串:包含在“”里面的内容'[^'\n]*'|\"[^\"]*\"(8)除其他情况之外判断为出错３、跳过空行和空格[\t]+{}/*空格*/ \n|.{}/*空行*/４、为lex制定一些规则5、写子程序让用户输入要进行词法扫描的文件，当lex读完输入文件之后就会调用函数yywrap。

源代码：1、词法分析/*cifa fenxi chengxu*/#include <stdio.h>#include <ctype.h>#include <alloc.h>#include <stdlib.h>#include <string.h>#define NULL 0FILE *fp;char cbuffer;char*key[8]={"if","else","for","while","do","return","break","continue"}; char *border[6]={",",";","{","}","(",")"};char *arithmetic[4]={"+","-","*","/"};char *relation[6]={"<","<=","=",">",">=","<>"};char *consts[20];char *label[20];int constnum=0,labelnum=0;int search(char searchchar[],int wordtype){int i=0;switch (wordtype) {case 1:for (i=0;i<=7;i++){if (strcmp(key[i],searchchar)==0)return(i+1);}case 2:{for (i=0;i<=5;i++){if (strcmp(border[i],searchchar)==0)return(i+1);} return(0);}case 3:{for (i=0;i<=3;i++){if (strcmp(arithmetic[i],searchchar)==0){return(i+1);}}return(0);}case 4:{for (i=0;i<=5;i++){if (strcmp(relation[i],searchchar)==0){return(i+1);}}return(0);}case 5:{for (i=0;i<=constnum;i++){if (strcmp(consts[i],searchchar)==0){return(i+1);}}consts[i-1]=(char *)malloc(sizeof(searchchar));strcpy(consts[i-1],searchchar);constnum++;return(i);}case 6:{for (i=0;i<=labelnum;i++){if (strcmp(label[i],searchchar)==0){return(i+1);}}label[i-1]=(char *)malloc(sizeof(searchchar));strcpy(label[i-1],searchchar);labelnum++;return(i);}}}char alphaprocess(char buffer){int atype;int i=-1;char alphatp[20];while ((isalpha(buffer))||(isdigit(buffer))) {alphatp[++i]=buffer;buffer=fgetc(fp);}alphatp[i+1]='\0';if (atype=search(alphatp,1))printf("%s (1,%d)\n",alphatp,atype-1);else{atype=search(alphatp,6);printf("%s (6,%d)\n",alphatp,atype-1);}return(buffer);}char digitprocess(char buffer){int i=-1;char digittp[20];int dtype;while ((isdigit(buffer))){digittp[++i]=buffer;buffer=fgetc(fp);}digittp[i+1]='\0';dtype=search(digittp,5);printf("%s (5,%d)\n",digittp,dtype-1);return(buffer);}char otherprocess(char buffer){int i=-1;char othertp[20];int otype,otypetp;othertp[0]=buffer;othertp[1]='\0';if (otype=search(othertp,3)){printf("%s (3,%d)\n",othertp,otype-1);buffer=fgetc(fp);goto out;}if (otype=search(othertp,4)){buffer=fgetc(fp);othertp[1]=buffer;othertp[2]='\0';if (otypetp=search(othertp,4)){printf("%s (4,%d)\n",othertp,otypetp-1);goto out;}elseothertp[1]='\0';printf("%s (4,%d)\n",othertp,otype-1);goto out;}if (buffer==':'){buffer=fgetc(fp);if (buffer=='=')printf(":= (2,2)\n");buffer=fgetc(fp);goto out;}else{if (otype=search(othertp,2)){printf("%s (2,%d)\n",othertp,otype-1);buffer=fgetc(fp);goto out;}}if ((buffer!='\n')&&(buffer!=' '))printf("%c error,not a word\n",buffer);buffer=fgetc(fp);out: return(buffer);}void main(){int i;for (i=0;i<=20;i++){label[i]=NULL;consts[i]=NULL;};if ((fp=fopen("c:\\example.c","r"))==NULL)printf("error");else{cbuffer = fgetc(fp);while (cbuffer!=EOF){if (isalpha(cbuffer))cbuffer=alphaprocess(cbuffer);else if (isdigit(cbuffer))cbuffer=digitprocess(cbuffer);else cbuffer=otherprocess(cbuffer);}printf("over\n");getchar();}}2、递归向下分析#include <stdio.h>#include<dos.h>#include<stdlib.h>#include<string.h>char a[50] ,b[50],d[200],e[10];char ch;int n1,i1=0,flag=1,n=5;int E();int E1();int T();int G();int S();int F();void input();void input1();void output();void main() /*递归分析*/{int f,p,j=0;char x;d[0]='E';d[1]='=';d[2]='>';d[3]='T';d[4]='G';d[5]='#';printf("请输入字符串(长度<50,以#号结束）\n");do{scanf("%c",&ch);a[j]=ch;j++;}while(ch!='#');n1=j;ch=b[0]=a[0];printf("文法\t分析串\t\t分析字符\t剩余串\n");f=E1();if (f==0) return;if (ch=='#'){ printf("accept\n");p=0;x=d[p];while(x!='#') {printf("%c",x);p=p+1;x=d[p]; /*输出推导式*/}}else {printf("error\n");printf("回车返回\n");getchar();getchar();return;}printf("\n");printf("回车返回\n");getchar();getchar();}int E1(){ int f,t;printf("E TG\t");flag=1;input();input1();f=T();if (f==0) return(0);t=G();if (t==0) return(0);else return(1);}int E(){ int f,t;printf("E→TG\t");e[0]='E';e[1]='=';e[2]='>';e[3]='T';e[4]='G';e[5]='#';output();flag=1;input();input1();f=T();if (f==0) return(0);t=G();if (t==0) return(0);else return(1);}int T(){ int f,t;printf("T→FS\t");e[0]='T';e[1]='=';e[2]='>';e[3]='F';e[4]='S';e[5]='#';output();flag=1;input();input1();f=F();if (f==0) return(0);t=S();if (t==0) return(0);else return(1);}int G(){ int f;if(ch=='+') {b[i1]=ch;printf("G→+TG\t");e[0]='G';e[1]='=';e[2]='>';e[3]='+';e[4]='T';e[5]='G';e[6]='#';output();flag=0;input();input1();ch=a[++i1];f=T();if (f==0) return(0);G();return(1);}printf("G→^\t");e[0]='G';e[1]='=';e[2]='>';e[3]='^';e[4]='#';output();flag=1;input();input1();return(1);}int S(){int f,t;if(ch=='*') {b[i1]=ch;printf("S→*FS\t");e[0]='S';e[1]='=';e[2]='>';e[3]='*';e[4]='F';e[5]='S';e[6]='#';output();flag=0;input();input1();ch=a[++i1];f=F();if (f==0) return(0);t=S();if (t==0) return(0);else return(1);}printf("S→^\t");e[0]='S';e[1]='=';e[2]='>';e[3]='^';e[4]='#';output();flag=1;a[i1]=ch;input();input1();return(1);}int F(){ int f;if(ch=='(') {b[i1]=ch;printf("F→(E)\t");e[0]='F';e[1]='=';e[2]='>';e[3]='(';e[4]='E';e[5]=')';e[6]='#';output();flag=0;input();input1();ch=a[++i1];f=E();if (f==0) return(0);if(ch==')') {b[i1]=ch;printf("F→(E)\t");flag=0;input();input1();ch=a[++i1];}else {printf("error\n");return(0);}}else if(ch=='i') {b[i1]=ch;printf("F→i\t");e[0]='F';e[1]='=';e[2]='>';e[3]='i';e[4]='#';output();flag=0;input();input1();ch=a[++i1];}else {printf("error\n");return(0);}return(1);}void input(){int j=0;for (;j<=i1-flag;j++)printf("%c",b[j]); /*输出分析串*/printf("\t\t");printf("%c\t\t",ch); /*输出分析字符*/ }void input1(){int j;for (j=i1+1-flag;j<n1;j++)printf("%c",a[j]); /*输出剩余字符*/ printf("\n");void output(){ /*推导式计算*/ int m,k,j,q;int i=0;m=0;k=0;q=0;i=n;d[n]='=';d[n+1]='>';d[n+2]='#';n=n+2;i=n;i=i-2;while(d[i]!='>'&&i!=0) i=i-1;i=i+1;while(d[i]!=e[0]) i=i+1;q=i;m=q;k=q;while(d[m]!='>') m=m-1;m=m+1;while(m!=q) {d[n]=d[m];m=m+1;n=n+1;}d[n]='#';for(j=3;e[j]!='#';j++){d[n]=e[j];n=n+1;}k=k+1;while(d[k]!='=') {d[n]=d[k];n=n+1;k=k+1;}d[n]='#';}3、LL（1）/*LL(1)分析法源程序，只能在VC++中运行 */#include<stdio.h>#include<stdlib.h>#include<string.h>#include<dos.h>char A[20];/*分析栈*/char B[20];/*剩余串*/char v1[20]={'i','+','*','(',')','#'};/*终结符 */char v2[20]={'E','G','T','S','F'};/*非终结符 */int j=0,b=0,top=0,l;/*L为输入串长度 */typedef struct type/*产生式类型定义 */ {char origin;/*大写字符 */char array[5];/*产生式右边字符 */int length;/*字符个数 */}type;type e,t,g,g1,s,s1,f,f1;/*结构体变量 */ type C[10][10];/*预测分析表 */void print()/*输出分析栈 */{int a;/*指针*/for(a=0;a<=top+1;a++)printf("%c",A[a]);printf("\t\t");}/*print*/void print1()/*输出剩余串*/{int j;for(j=0;j<b;j++)/*输出对齐符*/printf(" ");for(j=b;j<=l;j++)printf("%c",B[j]);printf("\t\t\t");}/*print1*/void main(){int m,n,k=0,flag=0,finish=0;char ch,x;type cha;/*用来接受C[m][n]*//*把文法产生式赋值结构体*/e.origin='E';strcpy(e.array,"TG");e.length=2;t.origin='T';strcpy(t.array,"FS");t.length=2;g.origin='G';strcpy(g.array,"+TG");g.length=3;g1.origin='G';g1.array[0]='^';g1.length=1;s.origin='S';strcpy(s.array,"*FS");s.length=3;s1.origin='S';s1.array[0]='^';s1.length=1;f.origin='F';strcpy(f.array,"(E)");f.length=3;f1.origin='F';f1.array[0]='i';f1.length=1;for(m=0;m<=4;m++)/*初始化分析表*/for(n=0;n<=5;n++)C[m][n].origin='N';/*全部赋为空*//*填充分析表*/C[0][0]=e;C[0][3]=e;C[1][1]=g;C[1][4]=g1;C[1][5]=g1;C[2][0]=t;C[2][3]=t;C[3][1]=s1;C[3][2]=s;C[3][4]=C[3][5]=s1;C[4][0]=f1;C[4][3]=f;printf("提示:本程序只能对由'i','+','*','(',')'构成的以'#'结束的字符串进行分析,\n");printf("请输入要分析的字符串:");do/*读入分析串*/{scanf("%c",&ch);if ((ch!='i') &&(ch!='+')&&(ch!='*')&&(ch!='(')&&(ch!=')')&&(ch!='#')){printf("输入串中有非法字符\n");exit(1);}B[j]=ch;j++;}while(ch!='#');l=j;/*分析串长度*/ch=B[0];/*当前分析字符*/A[top]='#'; A[++top]='E';/*'#','E'进栈*/printf("步骤\t\t分析栈 \t\t剩余字符 \t\t所用产生式 \n"); do{x=A[top--];/*x为当前栈顶字符*/printf("%d",k++);printf("\t\t");for(j=0;j<=5;j++)/*判断是否为终结符*/if(x==v1[j]){flag=1;break;}if(flag==1)/*如果是终结符*/{if(x=='#'){finish=1;/*结束标记*/printf("acc!\n");/*接受 */getchar();getchar();exit(1);}/*if*/if(x==ch){print();print1();printf("%c匹配\n",ch);ch=B[++b];/*下一个输入字符*/flag=0;/*恢复标记*/}/*if*/else/*出错处理*/{print();print1();printf("%c出错\n",ch);/*输出出错终结符*/exit(1);}/*else*/}/*if*/else/*非终结符处理*/{for(j=0;j<=4;j++)if(x==v2[j]){m=j;/*行号*/break;}for(j=0;j<=5;j++)if(ch==v1[j]){n=j;/*列号*/break;}cha=C[m][n];if(cha.origin!='N')/*判断是否为空*/{print();print1();printf("%c->",cha.origin);/*输出产生式*/for(j=0;j<cha.length;j++)printf("%c",cha.array[j]);printf("\n");for(j=(cha.length-1);j=0;j--)/*产生式逆序入栈*/A[++top]=cha.array[j];if(A[top]=='^')/*为空则不进栈*/top--;}/*if*/else/*出错处理*/{print();print1();printf("%c出错\n",x);/*输出出错非终结符*/exit(1);}/*else*/}/*else*/}while(finish==0);}/*main*/4、LL（2）/*LL(1)分析法源程序，只能在VC++中运行 */#include<stdio.h>#include<stdlib.h>#include<string.h>#include<dos.h>char A[20];/*分析栈*/char B[20];/*剩余串*/char v1[20]={'i','+','*','(',')','#'};/*终结符 */ char v2[20]={'E','G','T','S','F'};/*非终结符 */int j=0,b=0,top=0,l;/*L为输入串长度 */typedef struct type/*产生式类型定义 */{char origin;/*大写字符 */char array[5];/*产生式右边字符 */int length;/*字符个数 */}type;type e,t,g,g1,s,s1,f,f1;/*结构体变量 */type C[10][10];/*预测分析表 */void print()/*输出分析栈 */{int a;/*指针*/for(a=0;a<=top;a++)printf("%c",A[a]);printf("\t\t");}/*print*/void print1()/*输出剩余串*/{int j;for(j=0;j<b;j++)/*输出对齐符*/printf(" ");for(j=b;j<=l;j++)printf("%c",B[j]);printf("\t\t\t");}/*print1*/void main(){int m,n,k=0,flag=0;char ch,x;type cha;/*用来接受C[m][n]*//*把文法产生式赋值结构体*/e.origin='E';strcpy(e.array,"TG");e.length=2;t.origin='T';strcpy(t.array,"FS");t.length=2;g.origin='G';strcpy(g.array,"+TG");g.length=3;g1.origin='G';g1.array[0]='^';g1.length=1;s.origin='S';strcpy(s.array,"*FS");s.length=3;s1.origin='S';s1.array[0]='^';s1.length=1;f.origin='F';strcpy(f.array,"(E)");f.length=3;f1.origin='F';f1.array[0]='i';f1.length=1;for(m=0;m<=4;m++)/*初始化分析表*/for(n=0;n<=5;n++)C[m][n].origin='N';/*全部赋为空*/ /*填充分析表*/C[0][0]=e;C[0][3]=e;C[1][1]=g;C[1][4]=g1;C[1][5]=g1;C[2][0]=t;C[2][3]=t;C[3][1]=s1;C[3][2]=s;C[3][4]=C[3][5]=s1;C[4][0]=f1;C[4][3]=f;printf("提示:本程序只能对由'i','+','*','(',')'构成的以'#'结束的字符串进行分析,\n");printf("请输入要分析的字符串:");do/*读入分析串*/{scanf("%c",&ch);if ((ch!='i') &&(ch!='+')&&(ch!='*')&&(ch!='(')&&(ch!=')')&&(ch!='#')){printf("输入串中有非法字符\n");exit(1);}B[j]=ch;j++;}while(ch!='#');l=j;/*分析串长度*/ch=B[0];/*当前分析字符*/A[top]='#';A[++top]='E';/*'#','E'进栈*/x=A[top];/*x为当前栈顶字符*/printf("步骤\t\t分析栈 \t\t剩余字符 \t\t所用产生式 \n");loop: printf("%d",k++);printf("\t\t");for(j=0;j<=5;j++)/*判断是否为终结符*/if(x==v1[j]) flag=1;if(flag==1)/*如果是终结符*/{if(x=='#'){printf("acc!\n");/*接受 */getchar();getchar();exit(1);}/*if*/if(x==ch){print();print1();printf("%c匹配\n",ch);top--;/*栈顶出栈*/ch=B[++b];/*下一个输入字符*/x=A[top];flag=0;/*恢复标记*/goto loop;}/*if*/else/*出错处理*/{print();print1();printf("%c出错\n",ch);/*输出出错终结符*/exit(0);}/*else*/}/*if*/else/*非终结符处理*/{for(j=0;j<=4;j++)if(x==v2[j])m=j;/*行号*/for(j=0;j<=5;j++)if(ch==v1[j])n=j;/*列号*/cha=C[m][n];if(cha.origin!='N')/*判断是否为空*/{print();print1();printf("%c-",cha.origin);/*输出产生式*/for(j=0;j<cha.length;j++)printf("%c",cha.array[j]);printf("\n");top--;for(j=(cha.length-1);j=0;j--)/*产生式逆序入栈*/A[++top]=cha.array[j];if(A[top]=='^')/*为空则不进栈*/top--;x=A[top];goto loop;}/*if*/else/*出错处理*/{print();print1();printf("%c出错\n",x);/*输出出错非终结符*/exit(0);}/*else*/}/*else*/}/*main*/5、逆波兰式include<stdio.h>#include<math.h>#define max 100char ex[max]; /*存储后缀表达式*/void trans(){ /*将算术表达式转化为后缀表达式*/char str[max]; /*存储原算术表达式*/char stack[max]; /*作为栈使用*/char ch;int sum,i,j,t,top=0;printf("*****************************************\n");printf("*输入一个求值的表达式，以#结束。

词法分析实验报告一、实验目的与要求：1、了解字符串编码组成的词的内涵,感觉一下字符串编码的方法和解读2、了解和掌握自动机理论和正规式理论在词法分析程序和控制理论中的应用二、实验内容：构造一个自己设计的小语言的词法分析器：1、这个小语言能说明一些简单的变量识别诸如begin，end，if，while等保留字；识别非保留字的一般标识符（有下划线、字符、数字，且第一个字符不能是数字）。

识别数字序列（整数和小数）；识别:=，<=，>=之类的特殊符号以及；，（，）等界符。

2、相关过程（函数）：Scanner()词法扫描程序，提取标识符并填入display表中3、这个小语言有顺序结构的语句4、这个小语言能表达分支结构的语句5、这个小语言能够输出结果总之这个小语言词法分析器能提供以上所说明到的语法描述的功能……三、实验步骤：1、测试评价（1）、测试1：能说明一些简单的变量，如关键字、一般标识符、界符等；（2）、测试2：能输出结果：单词符号(内码形式)、各种信息表(如符号表、常量表等)；（3）、测试程序：var x,y,z;beginx:=2;y:=3;if (x+5>=y*y) thenbeginz:=y*y-x;z:=z+x*x;endelsez:=x+y;prn z;end.（4）、结果：①、从键盘读入；部分结果如下：（类型：该标识符所属的类型，如关键字，变量等；下标：该标识符所对应表（如变量标识符表，常量标识符表等）中其相应的位置，下同）②、从文件读入，输出到文件；部分结果如下：其他测试及结果如下：③、出错处理；注：若有错误，则只指出错误，不输出各个表；（5）、评价：这个小语言程序基本上能完成词法分析阶段的工作，识别诸如begin，if等保留字；识别非保留字的一般标识符（有下划线、字符、数字，且第一个字符不能是数字）。

识别数字序列（整数和小数）；识别:=，<=，>=之类的特殊符号以及；，（，）等界符。