《编译原理》
课程设计
院系信息科学与技术学院
专业软件工程
年级 2011级
学号
姓名林苾湲
西南交通大学信息科学与技术学院
2013年 12月
目录
课程设计1 词法分析器 (2)
1.1 设计题目 (2)
1.2 设计内容 (2)
1.3 设计目的 (2)
1.4 设计环境 (2)
1.5 需求分析 (2)
1.6 概要设计 (2)
1.7 详细设计 (4)
1.8 编程调试 (5)
1.9 测试 (11)
1.10 结束语 (13)
课程设计2 赋值语句的解释程序设计 (14)
2.1 设计题目 (14)
2.2 设计内容 (14)
2.3 设计目的 (14)
2.4 设计环境 (14)
2.5 需求分析 (15)
2.6 概要设计 (16)
2.7 详细设计 (16)
2.8 编程调试 (24)
2.9 测试 (24)
2.10 结束语 (25)
课程设计一词法分析器设计
一、设计题目
手工设计c语言的词法分析器（可以是c语言的子集）。
二、设计内容
处理c语言源程序，过滤掉无用符号，判断源程序中单词的合法性，并分解出正确的单词，以二元组形式存放在文件中。
三、设计目的
了解高级语言单词的分类，了解状态图以及如何表示并识别单词规则，掌握状态图到识别程序的编程。
四、设计环境
该课程设计包括的硬件和软件条件如下：
4.1.硬件
（1）Intel Core Duo CPU P8700
（2）内存4G
4.2.软件
（1）Window 7 32位操作系统
（2）Microsoft Visual Studio c#开发平台
4.3.编程语言
C#语言
五、需求分析
5.1.源程序的预处理：源程序中，存在许多编辑用的符号，他们对程序逻辑功能无任何影响。例如：回车，换行，多余空白符，注释行等。在词法分析之前，首先要先剔除掉这些符号，使得词法分析更为简单。
5.2.单词符号的识别并判断单词的合法性：将每个单词符号进行不同类别的划分。单词符号可以划分成5中。
(1)标识符：用户自己定义的名字，常量名，变量名和过程名。
(2)常数：各种类型的常数。
(3) 保留字（关键字）：如if、else、while、int、float等。
(4) 运算符：如+、-、*、<、>、=等。
(5)界符：如逗号、分号、括号等。
5.3.将所有合法的单词符号转化为便于计算机处理的二元组形式：（单词分类号，单词自身值）；以图形化界面显示出来。
5.4.可选择性地将结果保存到文件中。
六、概要设计
6.1．数据类型
6.1.1.单词的分类：本词法分析器演示的是C语言的一个子集，故字符集如下：
(1)标识符：以字母开头的字母数字串。
(2)整数或浮点型
(3)保留字：auto, break, case, char, const, continue, default, do, double, else, enum, extern, float, for, goto, if, int, long, register, return, short, signed, sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, while
(4)运算符：+、-、*、/、%、>、<、=、!=、==、<=、>=、++、--、!、&、&&、||；
(5)界符：[ ] { } ( ) : ; ‘“ # ,
6.1.2.单词二元组：（单词分类号，单词自身值）
表6.1单词分类表
单词分类号
标识符 1
常数 2
保留字 3
界符 4
运算符 5
6.2
图6.1 词法分析器的结构
6.3．部分单词的正规式与状态转换图
图6.2部分单词的状态转换图
6.4．功能模块
源程序输入缓冲区
预处理子程序
扫描缓冲区1 扫描缓冲区2
词法分析子程序
调用
数据
返回—单词
表6.2 词法分析器的C#程序过程或函数功能表
七、详细设计
7.1．总体流程图
图7.1程序总体流程图
7.2．主要分支选择算法介绍
7.2.1case0情况算法
图7.2 部分分支流程图
八、编程调试
8.1主要源代码
//逻辑操作类与函数
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace TokenAnalysis {
struct TokenNode {
public string type;
public string token;
}
class TokenAnalysis {
int cPosition = 0;
int lPosition = 0;
int ignorWs = 0;
int recordWs = 1;
output;
string source;
string[] kwList = { "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else","enum", "extern", "float", "for", "goto", "if", "int", "long", "register","return", "short", "signed", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while","printf","scanf","end","main"};
int Error = -2;
int Normal = -1;
int statue = -1;
bool isComment = false;
List
public List
TokenNode node2Add = new TokenNode();
int cp = 0;//current position
int lp = 0;//last position
string aCopy = source;
int length = aCopy.Length;
aCopy = aCopy.Trim();
while( cp < aCopy.Length ) {
//ID or KeyWords
node2Add = this.GetToken( ignorWs, aCopy, ref cp, ref lp );
if( node2Add.type == "cmtLeft" ) {
isComment = true;
}
if( node2Add.type == "cmtRight" ) {
isComment = false;
}
if( !isComment && node2Add.type != "cmtRight" ) {
resultTokenNodes.Add( node2Add );
}
}
return resultTokenNodes;
}
public TokenNode GetToken() {
if( cPosition < source.Length ) {
TokenNode token = this.GetToken( ignorWs, source, ref cPosition, ref lPosition );
return token;
}
else {
TokenNode token = new TokenNode();
token.token = "Error";
return token;
}
}
private TokenNode GetToken( int type, string aCopy, ref int cp, ref int lp ) { TokenNode token = new TokenNode();
string tempToken;
string tempType;
if( type == ignorWs ) {
if( Char.IsLetter( aCopy[ cp ] ) ) {
cp++;
while( cp < aCopy.Length &&
( Char.IsLetterOrDigit( aCopy[ cp ] ) ||
aCopy[ cp ] == '_' ) ) {
cp++;
}
tempToken = aCopy.Substring( lp, cp - lp );
tempType = "1 or 3";
tempType = GetTokenType( tempToken, tempType );
token.token = tempToken;
token.type = tempType;
lp = cp = NoWs( aCopy, cp );
}
//Num
else if( Char.IsDigit( aCopy[ cp ] ) ) {
cp++;
while( cp < aCopy.Length && ( ( Char.IsDigit( aCopy[ cp ] ) ) || ( aCopy[ cp ] == '.' && Char.IsDigit( aCopy[ cp + 1 ] ) ) ) ) {
cp++;
}
tempToken = aCopy.Substring( lp, cp - lp );
tempType = "2";
token.token = tempToken;
token.type = tempType;
lp = cp = NoWs( aCopy, cp );
}
//Border
else if( aCopy[ cp ] == '(' || aCopy[ cp ] == ')' || aCopy[ cp ] == '{' ||
aCopy[ cp ] == '}' || aCopy[ cp ] == '[' || aCopy[ cp ] == ']' ||
aCopy[ cp ] == ',' || aCopy[ cp ] == ';' || aCopy[ cp ] == '"' ||
aCopy[ cp ] == '\'' || aCopy[ cp ] == '\\' ) {
cp++;
tempToken = aCopy.Substring( lp, cp - lp );
tempType = "4";
token.token = tempToken;
token.type = tempType;
lp = cp = NoWs( aCopy, cp );
}
//Operation and other
else {
if( cp < aCopy.Length ) {
cp++;
}
switch( aCopy[ cp - 1 ] ) {
case '+':
cp = NoWs( aCopy, cp );
if( aCopy[ cp ] == '=' || aCopy[ cp ] == '+' ) {
cp++;
}
break;
case '-':
cp = NoWs( aCopy, cp );
if( aCopy[ cp ] == '=' || aCopy[ cp ] == '-' || aCopy[ cp ] ==
'>' ) {
cp++;
}
break;
case '*':
cp = NoWs( aCopy, cp );
if( aCopy[ cp ] == '=' || aCopy[ cp ] == '/' ) {
cp++;
}
break;
case '/':
cp = NoWs( aCopy, cp );
if( aCopy[ cp ] == '=' || aCopy[ cp ] == '*' ) {
cp++;
}
break;
case '=':
cp = NoWs( aCopy, cp );
if( aCopy[ cp ] == '=' ) {
cp++;
}
break;
case '>':
cp = NoWs( aCopy, cp );
if( aCopy[ cp ] == '=' ) {
cp++;
}
break;
case '<':
cp = NoWs( aCopy, cp );
if( aCopy[ cp ] == '=' ) {
cp++;
}
break;
case '!':
cp = NoWs( aCopy, cp );
if( aCopy[ cp ] == '=' ) {
cp++;
}
else {
statue = Error;
}
break;
case '|':
cp = NoWs( aCopy, cp );
if( aCopy[ cp ] == '|' ) {
cp++;
}
else {
statue = Error;
}
break;
case '&':
cp = NoWs( aCopy, cp );
if( aCopy[ cp ] == '&' ) {
cp++;
}
else {
statue = Error;
}
break;
default:
statue = Error;
break;
}
tempToken = aCopy.Substring( lp, cp - lp ); tempToken = tempToken.Replace( " ", "" ); tempType = "5";
tempType = GetTokenType( tempToken, tempType );
token.token = tempToken;
token.type = tempType;
lp = cp = NoWs( aCopy, cp );
}
}
return token;
}
public void GetInput( string get ) {
//source = "for( int i = 0; i < array -> length; i++ ) /* cmt */";
source = get;
}
private int NoWs( string aCopy, int cp ) {
if( cp < aCopy.Length ) {
while( Char.IsWhiteSpace( aCopy[ cp ] ) ) {
cp++;
}
}
return cp;
}
private string GetTokenType( string tk2anls, string iniType ) {
if( iniType == "1 or 3" ) {
foreach( string kw in kwList ) {
if( tk2anls == kw ) {
return "3";
}
}
return "1";
}
if( iniType == "5" ) {
if( tk2anls == "/*" ) {
return "cmtLeft";
}
if( tk2anls == "*/" ) {
return "cmtRight";
}
return iniType;
}
return "UnknownTpye";
}
public void OutPut( string ) {
outFile = new ( );
StreamWriter fw = out();
foreach( TokenNode tkNode in resultTokenNodes ) {
string show = string.Format( "{0,-25}{1,-40}", tkNode.token, tkNode.type );
System.Console.WriteLine( show );
fw.WriteLine( show );
}
fw.Close();
}
public void OutPut() {
outFile = new ( "result.txt" );
StreamWriter fw = out();
foreach( TokenNode tkNode in resultTokenNodes ) {
string show = string.Format( "{0,-25}{1,-40}", tkNode.token, tkNode.type );
System.Console.WriteLine( show );
fw.WriteLine( show );
}
fw.Close();
}
public List
List
foreach( TokenNode tkNode in resultTokenNodes ) {
string show = string.Format( "{0,-25}{1,-40}", tkNode.token, tkNode.type );
res.Add( show );
}
return res;
}
}
}
//前台控制类与函数
namespace TokenAnalysis_FormApp
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void btnAnalysis_Click(object sender, EventArgs e)
{
TokenAnalysis.TokenAnalysis ta = new TokenAnalysis.TokenAnalysis();
ta.GetInput(rtxtInput.Text);
ta.GetTokens();
List< string > res = ta.GetResult();
lstResult.Items.Clear();
lstResult.Items.AddRange(res.ToArray());
}
private void btnExit_Click(object sender, EventArgs e)
{
Application.Exit();
}
private void 保存SToolStripButton_Click(object sender, EventArgs e)
{
save = "保存分析结果";
save = "文本文件|*.txt";
if( ( save() ) == DialogResult.OK ) {
if( save. != null ) {
outFile = new ( save );
StreamWriter fw = out();
foreach( string tkString in lstResult.Items ) {
fw.WriteLine( tkString );
}
fw.Close();
}
}
}
private void btnsave_Click(object sender, EventArgs e)
{
save = "保存分析结果";
save = "文本文件|*.txt";
if ((save()) == DialogResult.OK)
{
if (save != null)
{
outFile = new (save);
StreamWriter fw = out();
foreach (string tkString in lstResult.Items)
{
fw.WriteLine(tkString);
}
fw.Close();
}
}
}
}
}
8.2调试
调试过程中存在保存不了输出结果的问题。最后调试发现是由于绝对路径与相对路径的区分。最后上网搜索解决方法，通过调用C#中提供的文件保存接口来解决保存的问题
九、测试
1.运行的主界面
图9.1 运行的主界面
2.输入想要分析的c语言源程序
图9.2 输入源程序
3.点击分析的按钮，显示分析后的结果，以二元组形式展示。
图9.3 分析结果
4.点击保存按钮，弹出选择保存文件的路径和名称
图9.4 保存过程
5.保存后的.txt文档
图9.5 保存后的文档
十、结束语
通过这次的课程设计，我学会了很多。让我学会了如何设计、编制并调试词法分析程序，加深对词法分析原理的理解；熟悉了构造词法分析器的手工方式的相关原理，也对状态图以及如何表示并识别单词规则有了更进一步的了解。并且在掌握状态图对识别程序的编程上有了更深层次的进步。除此之外，还复习了高级语言单词的分类，总之，通过这次的实验，从各方面提高了我的编程能力以及解决问题和bug的能力。但此次的课程设计还存在一定的缺陷，如只实现了c语言子集的词法分析器以及，对于错误的单词无法识别出其错误原因。因此，我在今后的学习中还需要再接再厉，争取编出更完美的程序。
课程设计二赋值语句的解释程序设计
一、设计题目
手工设计c语言的赋值语句解释程序（可以是c语言的子集）
二、设计内容
2.1.要求
用算符优先分析方法设计一个分析程序，对输入的赋值语句，输出语句，清除语句进行词法分析、语法分析、表达求值并存储于指定变量中；若存在错误，提示错误相关信息。
2.2.给定文法
S->V=E|E?|clear
E->E+T|E-T|T
T->T*F|T/F|F
F->(E)|V|c
V->i
2.3.给定单词种别码
表1 单词种别码表
2.4.
a=5
b=a+10
b?
b+a*a?
a=a+10
三、设计目的
1.了解掌握算符优先分析的基本方法；
2.理解并处理语法分析中的异常和错误
3学会科学思考并解决问题，提高程序设计能力
四、设计环境
该课程设计包括的硬件和软件条件如下：
4.1.硬件
（1）Intel Core Duo CPU P8700
（2）内存4G
4.2.软件
（1）Window 7 32位操作系统
（2）Microsoft Visual Studio c#开发平台
4.3.编程语言
C#语言
五、需求分析
5.1数据分析
5.1.1数据输入
(1)文法，即定义的语法单位，在进行语法分析时语句的规约必须遵循该文法定义。
(2)算数表达式，如a=5、b=a+10、b？
5.1.2数据输出
(1)四元式
语法分析器所输出的分析结果用如下的四元式表示：
（操作符，操作数1，操作数2，结果）
其中，操作符为文法定义中的=，？，+，-，*，/，（，）中的一个。
(2)算符优先关系表。
(3)变量表，包括变量的名称以及属性值。
(4)赋值表达式的结果输出。
(5)错误提示
若语法分析失败，则提示相应的错误信息。包括：输入错误；变量不存在或已清
除；输入非法字符等。
5.2功能分析
本课程设计的赋值语句解释器能实现的功能如下
(1)从外部输入或导入文法规则和测试的赋值语句、输出语句，清除语句
(2)对文法规则、赋值语句、输出语句以及清除语句进行词法分析
(3)计算每个非终结符的FIRSTVT和LASTVT，以及他们的算符优先关系表。
(4)在内存中申请一段空间，称为变量表，用于存放变量及其赋值，并按照声明次序
给变量添加索引。
(5)把输入的符号一个一个地移进栈里，当栈顶形成某个产生式的一个候选式时，把
栈顶的这一部分归约为该产生式的左部符号，重复这一过程直到归约栈中只剩下
文法开始的符号。其中，可归约串包括变量归约、常量归约、运算归约、括号归
约、赋值语句、输出语句、清除语句
六、概要设计
本程序主要分为四个模块，由主函数模块来调用输入串模块，归约栈模块，变量表模块。
其中，各模块的功能说明如下表所示
七、详细设计
7.1输入控制模块
static int in_index;
inuct *temp_ip;
char instr[40];
void in_init(char *in)
{
in_index = 0;
strcpy(instr, in);
}
inuct* in_get_uct()
{
int in_length = 0;
char *input = (char *)malloc(sizeof(char));
while(is_space()) {
in_index++;
}
if(is_end()) {
return NULL;
}
if(is_error_char()) {
temp_ip = (inuct *)malloc(sizeof(inuct));
temp_ip->type = INPUT_ERROR;
temp_ip->value.strv = (char *)malloc(sizeof(char) * 11);
memcpy(temp_ip->value.strv, &instr[in_index], sizeof(char));
return temp_ip;
}
if(is_char()) {
while(is_char() || is_num()) {
input[in_length++] = instr[in_index];
in_index ++;
input = (char *)realloc(input, sizeof(char) * (in_length + 1));
input[in_length] = '\0';
}
}
if(in_length) {
temp_ip = (inuct *)malloc(sizeof(inuct));
if(strcmp(input, "clear\0") == 0) {
temp_ip->type = CLEAR;
return temp_ip;
}
else if(strcmp(input, "quit") == 0) {
temp_ip->type = QUIT;
return temp_ip;
}
else {
temp_ip->type = V AR;
temp_ip->value.strv = (char *)malloc(sizeof(char) * (in_length + 1));
strcpy(temp_ip->value.strv, input);
return temp_ip;
}
}
while(is_num()) {
input[in_length++] = instr[in_index];
in_index ++;
input = (char *)realloc(input, sizeof(char) * (in_length + 1));
input[in_length] = '\0';
}
if(in_length) {
temp_ip = (inuct *)malloc(sizeof(inuct));
temp_ip->type = CONST;
temp_ip->value.intv = atoi(input);
return temp_ip;
}
if(is_leftbra()) {
temp_ip = (inuct *)malloc(sizeof(inuct));
temp_ip->type = LEFTBRA;
temp_ip->value.strv = (char *)malloc(sizeof(char));
strcpy(temp_ip->value.strv, "(");
in_index++;
return temp_ip;
}
if(is_rightbra()) {
temp_ip = (inuct *)malloc(sizeof(inuct));
temp_ip->type = RIGHTBRA;
temp_ip->value.strv = (char *)malloc(sizeof(char));
strcpy(temp_ip->value.strv, ")");
in_index++;
return temp_ip;
}
if(is_oper() || is_printsign()) {
temp_ip = (inuct *)malloc(sizeof(inuct));
if(instr[in_index] == '+') {
temp_ip->type = ADD_OPER;
} else if(instr[in_index] == '-') {
temp_ip->type = SUB_OPER;
} else if(instr[in_index] == '*') {
temp_ip->type = MULT_OPER;
} else if(instr[in_index] == '/') {
temp_ip->type = DIV_OPER;
} else if(instr[in_index] == '=') {
temp_ip->type = ASSIGN_OPER;
} else {
temp_ip->type = PRINTSIGN;
}
temp_ip->value.strv = (char *)malloc(sizeof(char));
temp_ip->value.strv[0] = instr[in_index++];
return temp_ip;
}
}
status is_error_char()
{
return !(is_num() || is_char() || is_oper() || is_end() || is_leftbra() || is_rightbra() || is_printsign());
}
status is_num()
{
if(instr[in_index] >= '0' && instr[in_index] <= '9') {
return YES;
}
return NO;
}
status is_char()
{
if(instr[in_index] >= 65 && instr[in_index] <= 90 || instr[in_index] >= 97 && instr[in_index] <= 122 || instr[in_index] == '_')
{
return YES;
}
return NO;
}
// is_'+-*/%='
status is_oper()
{
if(instr[in_index] == '+' || instr[in_index] == '-' || instr[in_index] == '*' || instr[in_index] == '/' || instr[in_index] == '%' || instr[in_index] == '=') {
return YES;
}
return NO;
}
// is_'('
status is_leftbra() {
return instr[in_index]== '(' ?YES:NO;
}
// is_')'
status is_rightbra() {
return instr[in_index]== ')' ?YES:NO;
}
// is_0
status is_end()
{
return instr[in_index] == 0 ?YES: NO;
// is_?
status is_printsign()
{
return instr[in_index] == '?'?YES:NO;
}
//is_space
status is_space()
{
return instr[in_index] == 32?YES:NO;
}
7.2归约过程控制模块
#define STACK_LENGTH 40
static int operlevel[14];
static inuct inuctstack1[STACK_LENGTH];
static inuct inuctstack2[STACK_LENGTH];
int now_oper_level ;
int pop_index_1;
int pop_index_2;
int shift_index;
void instack_init()
{
operlevel[LEFTBRA] = 0;
operlevel[MULT_OPER] = 1;
operlevel[DIV_OPER] = 1;
operlevel[ADD_OPER] = 2;
operlevel[SUB_OPER] = 2;
operlevel[RIGHTBRA] = 3;
operlevel[PRINTSIGN] = 4;
operlevel[ASSIGN_OPER] = 5;
operlevel[END_OPER] = 6;
pop_index_1 = 0;
pop_index_2 = 0;
shift_index = 0;
now_oper_level = 6;
}
void push(inuct *ip, int which)
{
if(which == 1) {
memcpy(&inuctstack1[pop_index_1++], ip, sizeof(*ip));
}
else {
memcpy(&inuctstack2[pop_index_2++], ip, sizeof(*ip));
}
}
void error_print(char *lang)
{
printf("syntax wrong:%5s\n", lang);
}
// 1 means ok , 0 means something wrong
int valid(inuct *ip)
{
int index ;
inuct *bip;
index = pop_index_1;
if(index != 0) {
bip = &inuctstack1[pop_index_1 -1];
编译原理实验--词法分析器 实验一词法分析器设计 【实验目的】 1(熟悉词法分析的基本原理，词法分析的过程以及词法分析中要注意的问题。 2(复习高级语言，进一步加强用高级语言来解决实际问题的能力。 3(通过完成词法分析程序，了解词法分析的过程。 【实验内容】 用C语言编写一个PL/0词法分析器，为语法语义分析提供单词，使之能把输入的字符 串形式的源程序分割成一个个单词符号传递给语法语义分析，并把分析结果(基本字， 运算符，标识符，常数以及界符)输出。 【实验流程图】
【实验步骤】 1(提取pl/0文件中基本字的源代码 while((ch=fgetc(stream))!='.') { int k=-1; char a[SIZE]; int s=0; while(ch>='a' && ch<='z'||ch>='A' && ch<='Z') { if(ch>='A' && ch<='Z') ch+=32; a[++k]=(char)ch; ch=fgetc(stream); } for(int m=0;m<=12&&k!=-1;m++) for(int n=0;n<=k;n++) {
if(a[n]==wsym[m][n]) ++s; else s=0; if(s==(strlen(wsym[m]))) {printf("%s\t",wsym[m]);m=14;n=k+1;} } 2(提取pl/0文件中标识符的源代码 while((ch=fgetc(stream))!='.') { int k=-1; char a[SIZE]=" "; int s=0; while(ch>='a' && ch<='z'||ch>='A' && ch<='Z') { if(ch>='A' && ch<='Z') ch+=32; a[++k]=(char)ch; ch=fgetc(stream); } for(int m=0;m<=12&&k!=-1;m++) for(int n=0;n<=k;n++) { if(a[n]==wsym[m][n]) ++s; else s=0; if(s==(strlen(wsym[m]))) {m=14;n=k+1;} } if(m==13) for(m=0;a[m]!=NULL;m++) printf("%c ",a[m]);
编译技术 班级网络0802 学号3080610052姓名叶晨舟 指导老师朱玉全2011年 7 月 4 日
一、目的 编译技术是理论与实践并重的课程，而其实验课要综合运用一、二年级所学的多门课程的内容，用来完成一个小型编译程序。从而巩固和加强对词法分析、语法分析、语义分析、代码生成和报错处理等理论的认识和理解；培养学生对完整系统的独立分析和设计的能力，进一步培养学生的独立编程能力。 二、任务及要求 基本要求： 1．词法分析器产生下述小语言的单词序列 这个小语言的所有的单词符号，以及它们的种别编码和内部值如下表： 单词符号种别编码助记符内码值 DIM IF DO STOP END 标识符 常数（整）= + * ** ， （ ）1 2 3 4 5 6 7 8 9 10 11 12 13 14 $DIM $IF $DO $STOP $END $ID $INT $ASSIGN $PLUS $STAR $POWER $COMMA $LPAR $RPAR - - - - - - 内部字符串 标准二进形式 - - - - - - 对于这个小语言，有几点重要的限制： 首先，所有的关键字（如IF﹑WHILE等）都是“保留字”。所谓的保留字的意思是，用户不得使用它们作为自己定义的标示符。例如，下面的写法是绝对禁止的： IF（5）=x 其次，由于把关键字作为保留字，故可以把关键字作为一类特殊标示符来处理。也就是说，对于关键字不专设对应的转换图。但把它们（及其种别编码）预先安排在一张表格中（此表叫作保留字表）。当转换图识别出一个标识符时，就去查对这张表，确定它是否为一个关键字。 再次，如果关键字、标识符和常数之间没有确定的运算符或界符作间隔，则必须至少用一个空白符作间隔（此时，空白符不再是完全没有意义的了）。例如，一个条件语句应写为
实验一词法分析器的设计 (2) 1.1 词法分析器的结构和主要任务 (2) 1.1.1 输入输出接口 (2) 1.1.2 条件限制 (2) 1.2 词法分析程序的总体设计 (3) 1.3 词法分析程序的详细设计 (4) 1.4实验步骤 (5) 1.5输入数据 (15) 1.6结果输出 (15)
实验一词法分析器的设计 实验目的：掌握词法分析的概念，设计方法，熟悉高级语言中词法的定义，词法分析程序的编写。 实验要求：在8学时内实现SAMPLE语言的词法分析器，要求用VC窗口界面实现。 实验内容：分为4次实验完成。 1.1 词法分析器的结构和主要任务 1.1.1 输入输出接口 图1-1词法分析器的输入输出界面 词法分析程序的主要任务是从左到右扫描每行源程序，拼成单词，换成统一的内部表示(token)输出，送给语法分析器。具体包括： 1.组织源程序的输入； 2.按规则拼单词，并转换成二元形式； 3.滤掉空白符，跳过注释、换行符及一些无用的符号(如字符常数的引号) 4.进行行列计数，用于指出出错的行列号，并复制出错部分； 5.列表打印源程序； 6.发现并定位词法错误； 7.生成符号表。 token文件和符号表用作语法分析的输入部分。 1.1.2 条件限制 本实验可以作如下假定： (1) 假定SAMPLE语言采用自由格式书写； (2) 可以使用注解，用/*……*/或者{……}标识，但注解不能插在单词内部，注解要在一行内结束，若一行结束，没有遇到注释后面的结束标记，自动认为注释也结束； (3) 一行可以有多个语句，一个语句也可以分布在多行中，单词之间和语句之间可以插入任意空格，单词中间不能有空白符号，单词中间也不能有回车换行符，即单词不能跨行书写； (4) 关键字都是保留字。
词法分析 三、词法分析程序的算法思想： 算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号。 3.1 主程序示意图： 扫描子程序主要部分流程图 其他
词法分析程序的C语言程序源代码： // 词法分析函数: void scan() // 数据传递: 形参fp接收指向文本文件头的文件指针； // 全局变量buffer与line对应保存源文件字符及其行号，char_num保存字符总数。 void scan() { char ch; int flag,j=0,i=-1; while(!feof(fp1)) { ch=fgetc(fp1); flag=judge(ch); printf("%c",ch);//显示打开的文件 if(flag==1||flag==2||flag==3) {i++;buffer[i]=ch;line[i]=row;} else if(flag==4) {i++;buffer[i]='?';line[i]=row;} else if(flag==5) {i++;buffer[i]='~';row++;} else if(flag==7) continue; else cout<<"\n请注意，第"< 词法分析 一、实验目的 设计、编制并调试一个词法分析程序，加深对词法分析原理的理解。 二、实验要求 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和sum 3.2 扫描子程序的算法思想： 首先设置3个变量：①token用来存放构成单词符号的字符串；②sum用来整型单词；③syn用来存放单词符号的种别码。扫描子程序主要部分流程如图3-2所示。 编译原理实验报告 ******************************************************************************* ******************************************************************************* PL0语言功能简单、结构清晰、可读性强，而又具备了一般高级程序设计语言的必须部分，因而PL0语言的编译程序能充分体现一个高级语言编译程序实现的基本方法和技术。PL/0语言文法的EBNF表示如下： <程序>::=<分程序>. <分程序> ::=[<常量说明>][<变量说明>][<过程说明>]<语句> <常量说明> ::=CONST<常量定义>{，<常量定义>}; <常量定义> ::=<标识符>=<无符号整数> <无符号整数> ::= <数字>{<数字>} <变量说明> ::=VAR <标识符>{, <标识符>}; <标识符> ::=<字母>{<字母>|<数字>} <过程说明> ::=<过程首部><分程序>{; <过程说明> }; <过程首部> ::=PROCEDURE <标识符>; <语句> ::=<赋值语句>|<条件语句>|<当循环语句>|<过程调用语句> |<复合语句>|<读语句><写语句>|<空> <赋值语句> ::=<标识符>:=<表达式> <复合语句> ::=BEGIN <语句> {;<语句> }END <条件语句> ::= <表达式> <关系运算符> <表达式> |ODD<表达式> <表达式> ::= [+|-]<项>{<加法运算符> <项>} <项> ::= <因子>{<乘法运算符> <因子>} <因子> ::= <标识符>|<无符号整数>| ‘(’<表达式>‘)’ <加法运算符> ::= +|- <乘法运算符> ::= *|/ <关系运算符> ::= =|#|<|<=|>|>= <条件语句> ::= IF <条件> THEN <语句> <过程调用语句> ::= CALL 标识符 <当循环语句> ::= WHILE <条件> DO <语句> <读语句> ::= READ‘(’<标识符>{,<标识符>}‘)’ <写语句> ::= WRITE‘(’<表达式>{,<表达式>}‘)’ <字母> ::= a|b|…|X|Y|Z <数字> ::= 0|1|…|8|9 【预处理】 对于一个pl0文法首先应该进行一定的预处理，提取左公因式，消除左递归（直接或间接），接着就可以根据所得的文法进行编写代码。 【实验一】词法分析 【实验目的】给出PL/0文法规，要求编写PL/0语言的词法分析程序。 【实验容】已给PL/0语言文法，输出单词（关键字、专用符号以及其它标记）。 集美大学计算机工程学院实验报告 课程名称：编译原理班级： 指导教师：： 实验项目编号：实验一学号： 实验项目名称：词法分析器的设计实验成绩： 一、实验目的 通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。 二、实验容 编写一个词法分析器，从输入的源程序（编写的语言为C语言的一个子集）中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。并依次输出各个单词的部编码及单词符号自身值。（遇到错误时可显示“Error”，然后跳过错误部分继续显示） 三、实验要求 1、词法分析器的功能和输出格式 词法分析器的功能是输入源程序，输出单词符号。词法分析器的单词符 2 别单词的类型，将标识符和常量分别插入到相应的符号表中，增加错误处理等。 3、编程语言不限。 四、实验设计方案 1、数据字典 本实验用到的数据字典如下表所示： 3、实验程序 #include 编译原理课程设计(词法分析，语法分析，语义分析，代码 生成） #include char left;// string right;// int len;// }; ivan css[20];// 20 struct pank// action { char sr;// int state;// }; pank action[46][18];//action int go_to[46][11];// go_to struct ike// { ike *pre; int num;// int word;// ike *next; }; ike *stack_head,*stack_tail;// struct L// { int k; string op;// string op1;// string op2;// string result;// L *next;// L *Ltrue;//true L *Lfalse;//false }; 题目：词法分析器的设计与实现 一、引言................................ 错误!未定义书签。 二、词法分析器的设计 (3) 2.1词的内部定义 (3) 2.2词法分析器的任务及功能 (3) 3 2.2.2 功能： (4) 2.3单词符号对应的种别码： (4) 三、词法分析器的实现 (5) 3.1主程序示意图： (5) 3.2函数定义说明 (6) 3.3程序设计实现及功能说明 (6) 错误!未定义书签。 7 7 四、词法分析程序的C语言源代码： (7) 五、结果分析： (12) 摘要：词法分析是中文信息处理中的一项基础性工作。词法分析结果的好坏将直接影响中文信息处理上层应用的效果。通过权威的评测和实际应用表明,IRLAS是一个高精度、高质量的、高可靠性的词法分析系统。众所周知,切分歧义和未登录词识别是中文分词中的两大难点。理解词法分析在编译程序中的作用，加深对有穷自动机模型的理解，掌握词法分析程序的实 现方法和技术，用c语言对一个简单语言的子集编制一个一遍扫描的编译程序，以加深对编译原理的理解,掌握编译程序的实现方法和技术。Abstract:lexical analysis is a basic task in Chinese information processing. The results of lexical analysis will directly affect the effectiveness of the application of Chinese information processing. The evaluation and practical application show that IRLAS is a high precision, high quality and high reliability lexical analysis system. It is well known that segmentation ambiguity and unknown word recognition are the two major difficulties in Chinese word segmentation. The understanding of lexical analyse the program at compile, deepen of finite automata model for understanding, master lexical analysis program implementation method and technology, using C language subset of a simple language compilation of a scanned again compiler, to deepen to compile the principle solution, master compiler implementation method and technology. 关键词：词法分析器?扫描器?单词符号?预处理 Keywords: lexical analyzer word symbol pretreatment scanner 一、引言 运用C语言设计词法分析器，由指定文件读入预分析的源程序，经过词法分析器的分析，将结果写入指定文件。本程序是在Visual?Studio环境下，使用C语言作为开发工具。基于实验任务 编译原理 C语言词法分析器 一、实验题目 编制并调试C词法分析程序。 a.txt源代码: ?main() { int sum=0 ,it=1;/* Variable declaration*/ if (sum==1) it++; else it=it+2; }? 设计其词法分析程序，能识别出所有的关键字、标识符、常数、运算符（包括复合运算符，如++）、界符；能过滤掉源程序中的注释、空格、制表符、换行符；并且能够对一些词法规则的错误进行必要的处理，如：标识符只能由字母、数字和下划线组成，且第一个字符必须为字母或下划线。实验要求:要给出所分析语言的词法说明，相应的状态转换图，单词的种别编码方案，词法分析程序的主要算法思想等。 二、实验目的 1、理解词法分析在编译程序中的作用； 2、掌握词法分析程序的实现方法和技术； 3、加深对有穷自动机模型的理解。 三、主要函数 四、设计 1.主函数void main ( ) 2. 初始化函数void load ( ) 3. 保留字及标识符判断函数void char_search(char *word) 4. 整数类型判断函数void inta_search(char *word) 5. 浮点类型判断函数void intb_search(char *word) 6. 字符串常量判断函数void cc_search(char *word) 7. 字符常量判断函数void c_search(char *word) 同4、5函数图 8.主扫描函数void scan ( ) 五、关键代码 #include 编译原理实验报告 实验一 一、实验名称：词法分析器的设计 二、实验目的：1，词法分析器能够识别简单语言的单词符号 2，识别出并输出简单语言的基本字.标示符.无符号整数.运算符.和界符。 三、实验要求：给出一个简单语言单词符号的种别编码词法分析器 四、实验原理： 1、词法分析程序的算法思想 算法的基本任务是从字符串表示的源程序中识别出具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号。 2、程序流程图 （1 （2）扫描子程序 3 五、实验内容： 1、实验分析 编写程序时，先定义几个全局变量a[]、token[]（均为字符串数组),c,s( char型)，i,j,k（int型），a[]用来存放输入的字符串，token[]另一个则用来帮助识别单词符号，s用来表示正在分析的字符。字符串输入之后，逐个分析输入字符，判断其是否‘#’，若是表示字符串输入分析完毕，结束分析程序，若否则通过int digit(char c)、int letter(char c)判断其是数字，字符还是算术符,分别为用以判断数字或字符的情况，算术符的判断可以在switch语句中进行，还要通过函数int lookup(char token[])来判断标识符和保留字。 2 实验词法分析器源程序： #include 本代码只供学习参考： 词法分析源代码： #include 编译原理课程设计报告 题目： 学院： 教师： 姓名： 学号： 班级： 评分： 签字： 编译原理课程设计一：设计c语言的词法分析器 一、实验目的 了解高级语言单词的分类，了解状态图以及如何表示并识别单词规则，掌握状态图到识别程序的编程，加深对词法原理的理解。 二、实验要求 了解高级语言单词的分类，了解状态图以及如何表示并识别单词规则，掌握状态图到识别程序的编程。 三、实验设计 3.1．单词分类及表示 3.1.1 C语言的子集分类 （1）标识符：以字母开头的字母数字串 （2）整数或浮点型。 （3）保留字：for,while,do,else,if,static,int,sizeof,break,continue （4）运算符：+，-，*，/，%,>,<,=,!=,==,<=,>=,!,&,&&,||; （5）界符："(",")",",",":",";","{","}" 3.1.2单词二元组（单词分类号、单词自身值） 3.2 词法分析器的设计 3.2.1算法设计 3.2.1.1概要设计 从文件中逐个读取字符，只要这五大类的状态序列则继续读取，否则回退字符，在对应类别进行查找，输出单元二次组至另一文件夹。 3.2.1.2状态图设计 3.2.2输入输出设计 输入：通过文件指针从文件中一个一个读取字符 输出：输出单词二元组至文件。格式为（种别码，值） 3.2.3主要函数 void Getchar(FILE *fp ) //读入一个字符 void GetBC(FILE *fp)//读入一个非空字符 void contacat()//连接字符 int letter()//判断是否为字母 int digit()//判断是否为字母 void retract(FILE *fp,char *c)//回退 int reserve (char **k)//处理保留字 int sysmbol(identifier *id)//处理标识符，查找符号表并存放位置若没有则添加int constant(constnumber *con)//存入常数表，并返回它在常数表中的位置 软件类课程设计报告 设计题目：词法分析器 学生学号： 专业班级：计算机科学与技术 学生姓名： 学生成绩： 指导教师（职称）： 课题工作时间：至 信息工程学院软件类课程设计任务书 指导教师： 日期：年月日 成绩评定表学生姓名：学号：专业/班级： 目录 目录.................................................................................................................................................................. I 第一章概述.. (2) 1.1词法分析器概述 (2) 1.2课程设计内容 (2) 第二章词法分析器课程设计 (3) 2.1课程设计内容 (3) 2.2课程设计思想 (3) 2.3设计目的及说明 (3) 2.3.1程序设计范畴 (3) 2.3.2程序设计说明 (3) 第三章程序详细设计 (4) 3.1主要算法的设计 (4) 3.2算法的实现 (4) 3.2.1数据类型 (4) 3.2.2函数模块功能 (4) 3.3程序设计流程图 (4) 3.3.1设计流程图 (5) 3.3.2状态转换图 (5) 第四章运行结果及分析 (6) 4.1运行结果 (6) 4.2结果分析 (6) 4.3设计总结 (6) 结束语 (8) 参考文献 (8) 附录源程序 (9) 第一章概述 1.1词法分析器概述 词法分析器是通过词法分析程序对构成源程序的字符串从左到右的扫描，逐个字符地读入源程序字符并按照构词规则切分成一个一个具有独立意义的单词。并确定其属性（如保留字、标识符、运算符、界限符和常量等）。再把它们转换称长度统一的标准形式——属性字（TOKEN）。而词法分析器的功能是输入源程序，输出单词符号，并且词法分析器有两种处理结构：一种是把词法分析器作为主程序;另一种是把词法分析器作为语法分析程序调用的子程序。编译器也一样，它的输入是语言的源文件（一般可以是文本文件）对于输入的文件，首先要分离出这个输入文件的每个元素（关键字、变量、符号、）然后根据语言的文法，分析这些元素的组合是否合法，以及这些组合所表达的意思。程序设计语言和自然语言不一样，都是用符号来描述，每个特定的符号表示特定的意思，而且程序设计语言是上下文无关的。上下文无关就是某一个特定语句所要表达的意思和它所处的上下文没有关系，只有它自身决定。词法分析器的功能就是把输入的符号串整理成特定的词素。 1.2课程设计内容 运用c++语言设计词法分析器，由指定文件读入预分析的源程序，经过词法分析器的分析，将结果写入指定文件。本程序是在Visual Studio环境下，使用c++语言作为开发工具。基于实验任务的内容及目的，实现初步的需求分析，具备词法分析器的基本功能和整体构架。逐步细化其功能，做到相应模块的具体化。画出未成熟的流程图，确定整体设计的走向，在一定范围内约束编程活动，确保没有大的问题及缺陷存在，然后通过将来的具体的编程设计完善流程图。 《编译原理》 课程设计 院系信息科学与技术学院 专业软件工程 年级 2011级 学号 20112723 姓名林苾湲 西南交通大学信息科学与技术学院 2013年 12月 目录 课程设计1 词法分析器 (2) 1.1 设计题目 (2) 1.2 设计容 (2) 1.3 设计目的 (2) 1.4 设计环境 (2) 1.5 需求分析 (2) 1.6 概要设计 (2) 1.7 详细设计 (4) 1.8 编程调试 (5) 1.9 测试 (11) 1.10 结束语 (13) 课程设计2 赋值语句的解释程序设计 (14) 2.1 设计题目 (14) 2.2 设计容 (14) 2.3 设计目的 (14) 2.4 设计环境 (14) 2.5 需求分析 (15) 2.6 概要设计 (16) 2.7 详细设计 (16) 2.8 编程调试 (24) 2.9 测试 (24) 2.10 结束语 (25) 课程设计一词法分析器设计 一、设计题目 手工设计c语言的词法分析器（可以是c语言的子集）。 二、设计容 处理c语言源程序，过滤掉无用符号，判断源程序中单词的合法性，并分解出正确的单词，以二元组形式存放在文件中。 三、设计目的 了解高级语言单词的分类，了解状态图以及如何表示并识别单词规则，掌握状态图到识别程序的编程。 四、设计环境 该课程设计包括的硬件和软件条件如下： 4.1.硬件 （1）Intel Core Duo CPU P8700 （2）存4G 4.2.软件 （1）Window 7 32位操作系统 （2）Microsoft Visual Studio c#开发平台 4.3.编程语言 C#语言 五、需求分析 5.1.源程序的预处理：源程序中，存在许多编辑用的符号，他们对程序逻辑功能无任何影响。例如：回车，换行，多余空白符，注释行等。在词法分析之前，首先要先剔除掉这些符号，使得词法分析更为简单。 5.2.单词符号的识别并判断单词的合法性：将每个单词符号进行不同类别的划分。单词符号可以划分成5中。 (1)标识符：用户自己定义的名字，常量名，变量名和过程名。 (2)常数：各种类型的常数。 (3) 保留字（关键字）：如if、else、while、int、float等。 (4) 运算符：如+、-、*、<、>、=等。 (5)界符：如逗号、分号、括号等。 5.3.将所有合法的单词符号转化为便于计算机处理的二元组形式：（单词分类号，单词自身值）；以图形化界面显示出来。 5.4.可选择性地将结果保存到文件中。 六、概要设计 6.1．数据类型 6.1.1.单词的分类：本词法分析器演示的是C语言的一个子集，故字符集如下： 一、实验目的 了解词法分析程序的两种设计方法：1.根据状态转换图直接编程的方式；2.利用DFA 编写通用的词法分析程序。 二、实验内容及要求 1．根据状态转换图直接编程 编写一个词法分析程序，它从左到右逐个字符的对源程序进行扫描，产生一个个的单词的二元式，形成二元式（记号）流文件输出。在此，词法分析程序作为单独的一遍，如下图所示。 具体任务有： （1）组织源程序的输入 （2）拼出单词并查找其类别编号，形成二元式输出，得到单词流文件 （3）删除注释、空格和无用符号 （4）发现并定位词法错误，需要输出错误的位置在源程序中的第几行。将错误信息输出到屏幕上。 （5）对于普通标识符和常量，分别建立标识符表和常量表（使用线性表存储），当遇到一个标识符或常量时，查找标识符表或常量表，若存在，则返回位置，否则返回0并且填写符号表或常量表。 标识符表结构：变量名，类型（整型、实型、字符型），分配的数据区地址 注：词法分析阶段只填写变量名，其它部分在语法分析、语义分析、代码生成等阶段逐步填入。 常量表结构：常量名，常量值 2．编写DFA模拟程序 算法如下： DFA（S=S0,MOVE[][],F[],ALPHABET[]） /*S为状态，初值为DFA的初态，MOVE[][]为状态转换矩阵，F[] 为终态集，ALPHABET[] 为字母表，其中的字母顺序与MOVE[][] 中列标题的字母顺序一致。*/ { Char Wordbuffer[10]=“”//单词缓冲区置空 Nextchar=getchar（）；//读 i=0； while（nextchar！=NULL）//NULL代表此类单词 { if （nextcha r！∈ALPHABET[]）{ERROR（“非法字符”），return（“非法字符”）；} S=MOVE[S][nextchar] //下一状态 if（S=NULL）return（“不接受”）；//下一状态为空，不能识别，单词错误 wordbuffer[i]=nextchar ；//保存单词符号 i++； nextchar=getchar（）； } Wordbuffer[i]=‘\0’; 词法分析器实验报告 一、实验目的 选择一种编程语言实现简单的词法分析程序,设计、编制并调试一个词法分析程序,加深对词法分析原理的理解。 二、实验要求 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 ”,}; (2)3、2 扫描子程序的算法思想: 首先设置3个变量:①token 用来存放构成单词符号的字符串;②sum 用来整型单词;③syn 用来存放单词符号的种别码。扫描子程序主要部分流程如图3-2所示。 南华大学 计算机科学与技术学院实验报告 （2018~2019学年度第二学期） 课程名称编译原理 实验名称词法分析器的设计与 实现 姓名学号 专业班级 地点教师 1.实验目的及要求 实验目的 加深对词法分析器的工作过程的理解；加强对词法分析方法的掌握；能够采用一种编程语言实现简单的词法分析程序；能够使用自己编写的分析程序对简单的程序段进行词法分析。 实验要求 1.对单词的构词规则有明确的定义； 2.编写的分析程序能够正确识别源程序中的单词符号； 3.识别出的单词以<种别码，值>的形式保存在符号表中，正确设计和维护 符号表； 4.对于源程序中的词法错误，能够做出简单的错误处理，给出简单的错误 提示，保证顺利完成整个源程序的词法分析； 2.实验步骤 1.词法分析规则 <标识符>::=<字母>|<标识符><字母>|<标识符><数字> <常数>::=<数字>|<数字序列><数字> <数字序列>::＝<数字序列><数字>|<数字>|<.> <字母>::=a|b|c|……|x|y|z <数字>::=0|1|2|3|4|5|6|7|8|9 <运算符>::=<关系运算符>|<算术运算符>|<逻辑运算符>|<位运算符>|<赋值运算符> <算数运算符>::＝+|-|*|／|...|-- <关系运算符>::＝<|>|!=|>=|<=|== <逻辑运算符>::=&&| || |！ <位运算符>::=&| | |！ <赋值运算符>::==|+=|-=|/=|*= <分界符>::＝,|;|(|)|{|}|：| // |/**/ <保留字>::＝main|if|else|while|do|for|...|void 编译原理 实验报告 实验名称：词法分析及语法分析专业班级： 姓名： 学号： 完成日期： 实验一、sample语言的词法分析 一、实验目的 给出SAMPLE文法规范，要求编写SAMPLE语言的词法分析程序。 二、实验准备 了解sample语言单词的定义，选择任一种编程语言实现词法分析。 三、实验内容 给出SAMPLE语言文法，输出单词（关键字、专用符号以及其它标记）。 1、格式 输入：源程序文件。输出：关键字、专用符号以及其它标记。 2、实现原理 程序中先判断这个句语句中每个单元为关键字、常数、运算符、界符，对与不同的单词符号给出不同编码形式的编码，用以区分之。 3、实验方法 读懂Sample源代码，自己重点独立实现对常量的判别。 四、实验设计 1、设计SAMPLE语言的词法分析器 A、字符集定义 1． <字符集> → <字母>│<数字>│<单界符> 2． <字母> → A│B│…│Z│a│b│…│z 3． <数字> → 0│1│2│…│9 4． <单界符> → +│-│*│/│=│<│>│(│)│[│]│:│. │; │, │' B、单词集定义 5．<单词集> → <保留字>│<双界符>│<标识符>│<常数>│<单界符> 6．<保留字> → and│array│begin│bool│call│case│char│constant│dim│do│else │end│false│for│if│input│integer│not│of│or│output│procedure│program │read│real│repeat│set│stop│then│to│true│until│var│while│write 7．<双界符> → <>│<=│>=│:= │/*│*/│.. 8．<标识符> → <字母>│<标识符> <数字>│<标识符> <字母> 9．<常数> → <整数>│<布尔常数>│<字符常数> 10．<整数> → <数字>│<整数> <数字> 11．<布尔常数> → true│false 12．<字符常数> → ' 除 {'} 外的任意字符串 ' 2、词法分析系统流程设计编译原理词法分析和语法分析报告+代码(C语言版)
编译原理实验 (词法语法分析报告 附源代码
编译原理实验-词法分析器的设计说明
编译原理课程设计(词法分析,语法分析,语义分析,代码生成)
词法分析器的实现与设计
编译原理C语言词法分析器
编译原理实验报告(词法分析器语法分析器)
编译原理实验词法分析语法分析
编译原理设计c语言的词法分析器
词法分析器课程设计
编译原理词法分析器语法分析课程设计报告书
编译原理词法分析器
编译原理词法分析实验报告
编译原理实验-词法分析器的设计与实现.docx
编译原理词法分析及语法分析
相关主题
文本预览