编译原理实验(词法分析)
《编译原理(实验部分)》实验2_PL0词法分析
《编译原理》(实验部分)实验2_PL0 词法分析一、实验目的加深和巩固对于词法分析的了解和掌握；初步认识PL/0 语言的基础和简单的程序编写；通过本实验能够初步的了解和掌握程序词法分析的整个过程；提高自己上机和编程过程中处理具体问题的能力。
二、实验设备1、P C兼容机一台；操作系统为WindowsWindowsX P2、Visual C++ 6.0 或以上版本，Windows 2000 或以上版本，汇编工具 (在Software 子目录下)。
三、实验原理PL/O语言的编译程序，是用高级语言PASCAL语言书写的。
整个编译过程是由一些嵌套及并列的过程或函数完成。
词法分析程序是独立的过程GETSY完成，供语法分析读单词时使用。
四、实验步骤阅读所给出的词法分析程序( pl0_lexical.c )，搞懂程序中每一个变量的含义，以及每一个过程的作用，并在该过程中进行中文注释；阅读完程序后，画出各过程的流程图；给出的程序包含两处输入错误，利用所给的pl/0 源程序(test.pl0) 对程序进行调试，使其能正确对所给文件进行分析并能够解释运行；在阅读懂所给出的词法分析程序后，将你对词法分析的理解写在实验报告上。
实验代码#include<stdio.h>main(){ printf ("my name is 08061118 yuchaofeng ");}主程序：#include <stdio.h>#include <ctype.h>#include <alloc.h>#include <stdlib.h>#include <string.h>#define NULL 0FILE *fp;char cbuffer;char *key[8]={"DO","BEGIN","ELSE","END","IF","THEN","VAR","WHILE"}; 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(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);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("skh.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");};}。
编译原理词法分析实验报告
编译原理词法分析实验报告实验一词法分析一、实验目的通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。
并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。
编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
二、实验内容（1）功能描述：该程序是实现一个词法分析器，词法分析器的功能是输入源程序，输出单词符号。
词法分析器的单词符号常常表示成以下的二元式(单词种别码，单词符号的属性值)。
本实验中，采用的是将单词分为五种的方法。
识别关键字：main、if、int、for、while、do、return、break、continue；单词种别码为1。
标识符：单词种别码为2。
常数：为无符号整形数；单词种别码为3。
运算符：包括：+、-、*、/、=、>、<、>=、<=、!= ；单词种别码为4。
分隔符：包括：,、;、{、}、(、)；单词种别码为5。
（2）程序结构描述：输入：从控制台输入一段源程序代码，对输入的代码进行词法分析,处理：分离出关键字、标识符、数值、运算符和界符。
输出：在词法分析结果表中输出每个单词所在行号、类型以及它所对应的编码。
其中，编码是自定义的,一种类型对应一个编码。
词法分析结果显示在控制台上。
（3）程序设计思路1、定义编码表，用ArrayList集合存放单词，如：关键字、运算符、分界符。
这三种单词是固定的，标示符和数字这两种单词不存放在集合中。
编码表是固定的，只需要初始化一次就够了，所以将集合定义为static类型，使其在类加载时，进行一次初始化。
2、static char allstr[] = new char[100000];该数组用于存储用户从控制台输入的所有字符。
3、//从键盘获取一个一个的字符public char Getchar() {try {ch = (char) System.in.read();} catch (Exception e) {e.printStackTrace();}return ch;}4、用while循环遍历allstr数组中存放的字符，判断分离出关键字、标示符、数字、运算符、标示符。
编译原理实验一 词法分析
实验一词法分析一、实验目的：通过本实验理解词法分析的整个过程，处理对象和处理的结果，了解词法分析在整个编译过程中的作用。
二、实验学时：2学时。
三、实验内容根据给出的简单语言的词法构成规则和单词集合，编制词法分析程序，要求能用给定的简单语言书写的源程序进行词法分析，同时建立相应的符号表文件存放正确的单词。
输出分析结果于文件中，包括：（1）正确的单词符号及其单词种类的序对二元组。
具体输出形式为：二元组：（单词种类，单词内码值）单词种类见五。
四、实验方法构造识别单词集的自动机，编写程序实现。
五、实验的处理单词集（注：单词种类统一分类如下：）七、实验报告要求给出单词识别的状态转换图;带有注释（简单说明）的源程序。
程序运行截图，要求运行结果内有输出自己的名字和学号.状态转换图源程序#include<iostream>#include<string>using namespace std;//单词结构定义struct WordType{int code;string pro;};//关键字表和对应的编码string codestring[6]={"main","int","if","then","else","return"};int codebook[6]={26,21,22,23,24,25};//全局变量char ch;int flag=0;//函数声明WordType get_w();void getch();void getBC();bool isLetter();bool isDigit();void retract();int Reserve(string str);string concat(string str);//主函数int main(){WordType word;cout<<"请输入源程序列:";word=get_w();while(word.pro!="#")//为自己设置的结束标志{cout<<word.code<<'\t'<<word.pro<<endl;word=get_w();};return 0;}WordType get_w(){string str="";int code;WordType wordtmp;getch();//读一个字符getBC();//去掉空白符if(isLetter()){//以字母开头while(isLetter()||isDigit()){str=concat(str);getch();}retract();code=Reserve(str);if(code==-1){wordtmp.code=0;wordtmp.pro=str;}//不是关键字else{ wordtmp.code=code;wordtmp.pro=str;}//是关键字}else if(isDigit()){//以数字开头while(isDigit()){str=concat(str);getch();}retract();wordtmp.code=30;wordtmp.pro=str;}else if(ch=='('){ wordtmp.code=1; wordtmp.pro="(";}else if(ch==')'){ wordtmp.code=2; wordtmp.pro=")";}else if(ch=='{'){ wordtmp.code=3; wordtmp.pro="{";}else if(ch=='}'){ wordtmp.code=4; wordtmp.pro="}";}else if(ch==';'){ wordtmp.code=5; wordtmp.pro=";";}else if(ch=='='){ wordtmp.code=6; wordtmp.pro="=";}else if(ch=='+'){ wordtmp.code=7; wordtmp.pro="+";}else if(ch=='*'){ wordtmp.code=8; wordtmp.pro="*";}else if(ch=='>'){ wordtmp.code=9; wordtmp.pro=">";}else if(ch=='<'){ wordtmp.code=10; wordtmp.pro="<";}else if(ch==','){ wordtmp.code=11; wordtmp.pro=",";}else if(ch=='\''){ wordtmp.code=12; wordtmp.pro="\'";}else {wordtmp.code=100;wordtmp.pro=ch;}return wordtmp;}void getch(){if(flag==0)//没有回退的字符ch=getchar();else//有回退字符，用回退字符，并重置标志flag=0;}void getBC(){while( ch==' '||ch=='\t'||ch=='\n')ch=getchar();}bool isLetter(){if(ch>='a'&&ch<='z'||(ch>='A'&&ch<='Z'))return true;elsereturn false;}bool isDigit(){if(ch>='0'&&ch<='9')return true;elsereturn false;}string concat(string str){return str+ch;}void retract(){flag=1;}int Reserve(string str){int i;for(i=0;i<=5;i++){if(codestring[i]==str)//是某个关键字，返回对应的编码return codebook[i];}if(i==6)//不是关键字return -1;}截图实验心得此次实验让我了解了如何设计、编制并调试词法分析程序，并加深了我对词法分析器原理的理解；熟悉了直接构造词法分析器的方法和相关原理。
编译原理词法分析,语法分析实验报告
编译原理实验报告一．LL(1)文法分析1.设计要求（1）对输入文法，它能判断是否为LL(1)文法，若是，则转（2）；否则报错并终止；（2）输入已知文法，由程序自动生成它的LL(1)分析表；（3）对于给定的输入串，应能判断识别该串是否为给定文法的句型。
2.分析该程序可分为如下几步：（1）读入文法（2）判断正误（3）若无误，判断是否为LL(1)文法（4）若是，构造分析表；（5）由总控算法判断输入符号串是否为该文法的句型。
3.流程图开始读入文法有效？是是LL(1)文法？是判断句型报错结束4.源程序/*******************************************语法分析程序作者：xxx学号：xxx********************************************/#include<stdlib.h>#include<stdio.h>#include<string.h>/*******************************************/int count=0; /*分解的产生式的个数*/int number; /*所有终结符和非终结符的总数*/char start; /*开始符号*/char termin[50]; /*终结符号*/char non_ter[50]; /*非终结符号*/char v[50]; /*所有符号*/char left[50]; /*左部*/char right[50][50]; /*右部*/char first[50][50],follow[50][50]; /*各产生式右部的FIRST和左部的FOLLOW集合*/ char first1[50][50]; /*所有单个符号的FIRST集合*/char select[50][50]; /*各单个产生式的SELECT集合*/char f[50],F[50]; /*记录各符号的FIRST和FOLLOW是否已求过*/char empty[20]; /*记录可直接推出^的符号*/char TEMP[50]; /*求FOLLOW时存放某一符号串的FIRST集合*/int validity=1; /*表示输入文法是否有效*/int ll=1; /*表示输入文法是否为LL(1)文法*/int M[20][20]; /*分析表*/char choose; /*用户输入时使用*/char empt[20]; /*求_emp()时使用*/char fo[20]; /*求FOLLOW集合时使用*//*******************************************判断一个字符是否在指定字符串中********************************************/int in(char c,char *p){int i;if(strlen(p)==0)return(0);for(i=0;;i++){if(p[i]==c)return(1); /*若在，返回1*/if(i==strlen(p))return(0); /*若不在，返回0*/}}/*******************************************得到一个不是非终结符的符号********************************************/char c(){char c='A';while(in(c,non_ter)==1)c++;return(c);}/*******************************************分解含有左递归的产生式********************************************/void recur(char *point){ /*完整的产生式在point[]中*/int j,m=0,n=3,k;char temp[20],ch;ch=c(); /*得到一个非终结符*/k=strlen(non_ter);non_ter[k]=ch;non_ter[k+1]='\0';for(j=0;j<=strlen(point)-1;j++){if(point[n]==point[0]){ /*如果‘|’后的首符号和左部相同*/ for(j=n+1;j<=strlen(point)-1;j++){while(point[j]!='|'&&point[j]!='\0')temp[m++]=point[j++];left[count]=ch;memcpy(right[count],temp,m);right[count][m]=ch;right[count][m+1]='\0';m=0;count++;if(point[j]=='|'){n=j+1;break;}}}else{ /*如果‘|’后的首符号和左部不同*/ left[count]=ch;right[count][0]='^';right[count][1]='\0';count++;for(j=n;j<=strlen(point)-1;j++){if(point[j]!='|')temp[m++]=point[j];else{left[count]=point[0];memcpy(right[count],temp,m);right[count][m]=ch;right[count][m+1]='\0';printf(" count=%d ",count);m=0;count++;}}left[count]=point[0];memcpy(right[count],temp,m);right[count][m]=ch;right[count][m+1]='\0';count++;m=0;}}}/*******************************************分解不含有左递归的产生式********************************************/void non_re(char *point){int m=0,j;char temp[20];for(j=3;j<=strlen(point)-1;j++){if(point[j]!='|')temp[m++]=point[j];else{left[count]=point[0];memcpy(right[count],temp,m);right[count][m]='\0';m=0;count++;}}left[count]=point[0];memcpy(right[count],temp,m);right[count][m]='\0';count++;m=0;}/*******************************************读入一个文法********************************************/ char grammer(char *t,char *n,char *left,char right[50][50]) {char vn[50],vt[50];char s;char p[50][50];int i,j,k;printf("\n请输入文法的非终结符号串：");scanf("%s",vn);getchar();i=strlen(vn);memcpy(n,vn,i);n[i]='\0';printf("请输入文法的终结符号串：");scanf("%s",vt);getchar();i=strlen(vt);memcpy(t,vt,i);t[i]='\0';printf("请输入文法的开始符号：");scanf("%c",&s);getchar();printf("请输入文法产生式的条数：");scanf("%d",&i);getchar();for(j=1;j<=i;j++){printf("请输入文法的第%d条（共%d条）产生式：",j,i);scanf("%s",p[j-1]);getchar();}for(j=0;j<=i-1;j++)if(p[j][1]!='-'||p[j][2]!='>'){ printf("\ninput error!");validity=0;return('\0');} /*检测输入错误*/for(k=0;k<=i-1;k++){ /*分解输入的各产生式*/if(p[k][3]==p[k][0])recur(p[k]);elsenon_re(p[k]);}return(s);}/*******************************************将单个符号或符号串并入另一符号串********************************************/void merge(char *d,char *s,int type){ /*d是目标符号串，s是源串，type＝1，源串中的‘^ ’一并并入目串；type＝2，源串中的‘^ ’不并入目串*/int i,j;for(i=0;i<=strlen(s)-1;i++){if(type==2&&s[i]=='^');else{for(j=0;;j++){if(j<strlen(d)&&s[i]==d[j])break;if(j==strlen(d)){d[j]=s[i];d[j+1]='\0';}}}}}/*******************************************求所有能直接推出^的符号********************************************/void emp(char c){ /*即求所有由‘^ ’推出的符号*/ char temp[10];int i;for(i=0;i<=count-1;i++){if(right[i][0]==c&&strlen(right[i])==1){temp[0]=left[i];temp[1]='\0';merge(empty,temp,1);emp(left[i]);}}}/*******************************************求某一符号能否推出‘^ ’********************************************/int _emp(char c){ /*若能推出，返回1；否则，返回0*/ int i,j,k,result=1,mark=0;char temp[20];temp[0]=c;temp[1]='\0';merge(empt,temp,1);if(in(c,empty)==1)return(1);for(i=0;;i++){if(i==count)return(0);if(left[i]==c) /*找一个左部为c的产生式*/{j=strlen(right[i]); /*j为右部的长度*/if(j==1&&in(right[i][0],empty)==1)else if(j==1&&in(right[i][0],termin)==1)return(0);else{for(k=0;k<=j-1;k++)if(in(right[i][k],empt)==1)mark=1;if(mark==1)continue;else{for(k=0;k<=j-1;k++){result*=_emp(right[i][k]);temp[0]=right[i][k];temp[1]='\0';merge(empt,temp,1);}}}if(result==0&&i<count)continue;else if(result==1&&i<count)return(1);}}}/*******************************************判断读入的文法是否正确********************************************/int judge(){int i,j;for(i=0;i<=count-1;i++){if(in(left[i],non_ter)==0){ /*若左部不在非终结符中，报错*/ printf("\nerror1!");validity=0;return(0);}for(j=0;j<=strlen(right[i])-1;j++){if(in(right[i][j],non_ter)==0&&in(right[i][j],termin)==0&&right[i][j]!='^'){ /*若右部某一符号不在非终结符、终结符中且不为‘^ ’，报错*/ printf("\nerror2!");validity=0;return(0);}}}return(1);}/*******************************************求单个符号的FIRST********************************************/void first2(int i){ /*i为符号在所有输入符号中的序号*/char c,temp[20];int j,k,m;c=v[i];char ch='^';emp(ch);if(in(c,termin)==1) /*若为终结符*/{first1[i][0]=c;first1[i][1]='\0';}else if(in(c,non_ter)==1) /*若为非终结符*/{for(j=0;j<=count-1;j++){if(left[j]==c){if(in(right[j][0],termin)==1||right[j][0]=='^'){temp[0]=right[j][0];temp[1]='\0';merge(first1[i],temp,1);}else if(in(right[j][0],non_ter)==1){if(right[j][0]==c)continue;for(k=0;;k++)if(v[k]==right[j][0])break;if(f[k]=='0'){first2(k);f[k]='1';}merge(first1[i],first1[k],2);for(k=0;k<=strlen(right[j])-1;k++){empt[0]='\0';if(_emp(right[j][k])==1&&k<strlen(right[j])-1){for(m=0;;m++)if(v[m]==right[j][k+1])break;if(f[m]=='0'){first2(m);f[m]='1';}merge(first1[i],first1[m],2);}else if(_emp(right[j][k])==1&&k==strlen(right[j])-1){temp[0]='^';temp[1]='\0';merge(first1[i],temp,1);}elsebreak;}}}}}f[i]='1';}/*******************************************求各产生式右部的FIRST********************************************/void FIRST(int i,char *p){int length;int j,k,m;char temp[20];length=strlen(p);if(length==1) /*如果右部为单个符号*/ {if(p[0]=='^'){if(i>=0){first[i][0]='^';first[i][1]='\0';}else{TEMP[0]='^';TEMP[1]='\0';}}else{for(j=0;;j++)if(v[j]==p[0])break;if(i>=0){memcpy(first[i],first1[j],strlen(first1[j]));first[i][strlen(first1[j])]='\0';}else{memcpy(TEMP,first1[j],strlen(first1[j]));TEMP[strlen(first1[j])]='\0';}}}else /*如果右部为符号串*/{for(j=0;;j++)if(v[j]==p[0])break;if(i>=0)merge(first[i],first1[j],2);elsemerge(TEMP,first1[j],2);for(k=0;k<=length-1;k++){empt[0]='\0';if(_emp(p[k])==1&&k<length-1){for(m=0;;m++)if(v[m]==right[i][k+1])break;if(i>=0)merge(first[i],first1[m],2);elsemerge(TEMP,first1[m],2);}else if(_emp(p[k])==1&&k==length-1){temp[0]='^';temp[1]='\0';if(i>=0)merge(first[i],temp,1);elsemerge(TEMP,temp,1);}else if(_emp(p[k])==0)break;}}}/*******************************************求各产生式左部的FOLLOW********************************************/ void FOLLOW(int i){int j,k,m,n,result=1;char c,temp[20];c=non_ter[i]; /*c为待求的非终结符*/ temp[0]=c;temp[1]='\0';merge(fo,temp,1);if(c==start){ /*若为开始符号*/temp[0]='#';temp[1]='\0';merge(follow[i],temp,1);}for(j=0;j<=count-1;j++){if(in(c,right[j])==1) /*找一个右部含有c的产生式*/{for(k=0;;k++)if(right[j][k]==c)break; /*k为c在该产生式右部的序号*/for(m=0;;m++)if(v[m]==left[j])break; /*m为产生式左部非终结符在所有符号中的序号*/ if(k==strlen(right[j])-1){ /*如果c在产生式右部的最后*/if(in(v[m],fo)==1){merge(follow[i],follow[m],1);continue;}if(F[m]=='0'){FOLLOW(m);F[m]='1';}merge(follow[i],follow[m],1);}else{ /*如果c不在产生式右部的最后*/for(n=k+1;n<=strlen(right[j])-1;n++){empt[0]='\0';result*=_emp(right[j][n]);}if(result==1){ /*如果右部c后面的符号串能推出^*/if(in(v[m],fo)==1){ /*避免循环递归*/merge(follow[i],follow[m],1);continue;}if(F[m]=='0'){FOLLOW(m);F[m]='1';}merge(follow[i],follow[m],1);}for(n=k+1;n<=strlen(right[j])-1;n++)temp[n-k-1]=right[j][n];temp[strlen(right[j])-k-1]='\0';FIRST(-1,temp);merge(follow[i],TEMP,2);}}}F[i]='1';}/*******************************************判断读入文法是否为一个LL(1)文法********************************************/int ll1(){int i,j,length,result=1;char temp[50];for(j=0;j<=49;j++){ /*初始化*/first[j][0]='\0';follow[j][0]='\0';first1[j][0]='\0';select[j][0]='\0';TEMP[j]='\0';temp[j]='\0';f[j]='0';F[j]='0';}for(j=0;j<=strlen(v)-1;j++)first2(j); /*求单个符号的FIRST集合*/ printf("\nfirst1:");for(j=0;j<=strlen(v)-1;j++)printf("%c:%s ",v[j],first1[j]);printf("\nempty:%s",empty);printf("\n:::\n_emp:");for(j=0;j<=strlen(v)-1;j++)printf("%d ",_emp(v[j]));for(i=0;i<=count-1;i++)FIRST(i,right[i]); /*求FIRST*/printf("\n");for(j=0;j<=strlen(non_ter)-1;j++){ /*求FOLLOW*/if(fo[j]==0){fo[0]='\0';FOLLOW(j);}}printf("\nfirst:");for(i=0;i<=count-1;i++)printf("%s ",first[i]);printf("\nfollow:");for(i=0;i<=strlen(non_ter)-1;i++)printf("%s ",follow[i]);for(i=0;i<=count-1;i++){ /*求每一产生式的SELECT集合*/ memcpy(select[i],first[i],strlen(first[i]));select[i][strlen(first[i])]='\0';for(j=0;j<=strlen(right[i])-1;j++)result*=_emp(right[i][j]);if(strlen(right[i])==1&&right[i][0]=='^')result=1;if(result==1){for(j=0;;j++)if(v[j]==left[i])break;merge(select[i],follow[j],1);}}printf("\nselect:");for(i=0;i<=count-1;i++)printf("%s ",select[i]);memcpy(temp,select[0],strlen(select[0]));temp[strlen(select[0])]='\0';for(i=1;i<=count-1;i++){ /*判断输入文法是否为LL(1)文法*/ length=strlen(temp);if(left[i]==left[i-1]){merge(temp,select[i],1);if(strlen(temp)<length+strlen(select[i]))return(0);}else{temp[0]='\0';memcpy(temp,select[i],strlen(select[i]));temp[strlen(select[i])]='\0';}}return(1);}/*******************************************构造分析表M********************************************/void MM(){int i,j,k,m;for(i=0;i<=19;i++)for(j=0;j<=19;j++)M[i][j]=-1;i=strlen(termin);termin[i]='#'; /*将#加入终结符数组*/termin[i+1]='\0';for(i=0;i<=count-1;i++){for(m=0;;m++)if(non_ter[m]==left[i])break; /*m为产生式左部非终结符的序号*/for(j=0;j<=strlen(select[i])-1;j++){if(in(select[i][j],termin)==1){for(k=0;;k++)if(termin[k]==select[i][j])break; /*k为产生式右部终结符的序号*/ M[m][k]=i;}}}}/*******************************************总控算法********************************************/void syntax(){int i,j,k,m,n,p,q;char ch;char S[50],str[50];printf("请输入该文法的句型：");scanf("%s",str);getchar();i=strlen(str);str[i]='#';str[i+1]='\0';S[0]='#';S[1]=start;S[2]='\0';j=0;ch=str[j];while(1){if(in(S[strlen(S)-1],termin)==1){if(S[strlen(S)-1]!=ch){printf("\n该符号串不是文法的句型！");return;}else if(S[strlen(S)-1]=='#'){printf("\n该符号串是文法的句型.");return;}else{S[strlen(S)-1]='\0';j++;ch=str[j];}}else{for(i=0;;i++)if(non_ter[i]==S[strlen(S)-1])break;for(k=0;;k++){if(termin[k]==ch)break;if(k==strlen(termin)){printf("\n词法错误！");return;}}if(M[i][k]==-1){printf("\n语法错误！");return;}else{m=M[i][k];if(right[m][0]=='^')S[strlen(S)-1]='\0';else{p=strlen(S)-1;q=p;for(n=strlen(right[m])-1;n>=0;n--)S[p++]=right[m][n];S[q+strlen(right[m])]='\0';}}}printf("\nS:%s str:",S);for(p=j;p<=strlen(str)-1;p++)printf("%c",str[p]);printf(" ");}}/*******************************************一个用户调用函数********************************************/void menu(){syntax();printf("\n是否继续？(y or n):");scanf("%c",&choose);getchar();while(choose=='y'){menu();}}/*******************************************主函数********************************************/void main(){int i,j;start=grammer(termin,non_ter,left,right); /*读入一个文法*/ printf("count=%d",count);printf("\nstart:%c",start);strcpy(v,non_ter);strcat(v,termin);printf("\nv:%s",v);printf("\nnon_ter:%s",non_ter);printf("\ntermin:%s",termin);printf("\nright:");for(i=0;i<=count-1;i++)printf("%s ",right[i]);printf("\nleft:");for(i=0;i<=count-1;i++)printf("%c ",left[i]);if(validity==1)validity=judge();printf("\nvalidity=%d",validity);if(validity==1){printf("\n文法有效");ll=ll1();printf("\nll=%d",ll);if(ll==0)printf("\n该文法不是一个LL1文法！");else{MM();printf("\n");for(i=0;i<=19;i++)for(j=0;j<=19;j++)if(M[i][j]>=0)printf("M[%d][%d]=%d ",i,j,M[i][j]);printf("\n");menu();}}}5.执行结果（1）输入一个文法（2）输入一个符号串（3）再次输入一个符号串，然后退出程序二．词法分析一、问题描述识别简单语言的单词符号识别简单语言的基本字、标识符、无符号整数、运算符和界符。
编译原理实验 词法分析&语法分析程序
编译原理实验词法分析程序实验一：词法分析程序1、实验目的从左至右逐个字符的对源程序进行扫描，产生一个个单词符号，把字符串形式的源程序改造成单词符号形式的中间程序。
2、实验内容表C语言子集的单词符号及内码值单词符号种别编码助记符内码值while 1 while --if 2 if --else 3 else --switch 4 switch --case 5 case --标识符 6 id id在符号表中的位置常数7 num num在常数表中的位置+ 8 + --- 9 - --* 10 * --<= 11 relop LE< 11 relop LT== 11 relop LQ= 12 = --; 13 ; --输入源程序如下if a==1 a=a+1;else a=a+2;输出对应的单词符号形式的中间程序3、实验过程实验上机程序如下：#include "stdio.h"#include "string.h"int i,j,k;char s ,a[20],token[20];int letter(){if((s>=97)&&(s<=122))return 1;else return 0;}int Digit(){if((s>=48)&&(s<=57))return 1;else return 0;}void get(){s=a[i];i=i+1;}void retract(){i=i-1;}int lookup(){if(strcmp(token, "while")==0)return 1;else if(strcmp(token, "if")==0)return 2;else if(strcmp(token,"else")==0)return 3;else if(strcmp(token,"switch")==0)return 4;else if(strcmp(token,"case")==0)return 5;else return 0;}void main(){printf("please input you source program,end('#'):\n");i=0;do{i=i+1;scanf("%c",&a[i]);}while(a[i]!='#');i=1;memset(token,0,sizeof(char)*10);j=0;get();while(s!='#'){if(s==' '||s==10||s==13)get();else{switch(s){case'a':case'b':case'c':case'd':case'e':case'f':case'g':case'h':case'i':case'j':case'k':case'l':case'm':case'n':case'o':case'p':case'q':case'r':case's':case't':case'u':case'v':case'w':case'x':case'y':case'z':while(Digit()||letter()){token[j]=s;j=j+1;get();}retract();k=lookup();if(k==0)printf("(6,%s)\n",token); elseprintf("(%d,null)\n",k); break;case'0':case'1':case'2':case'3':case'4':case'5':case'6':case'7':case'8':case'9':while(Digit()){token[j]=s;j=j+1;get();}retract();printf("(%d,%s)\n",7,token); break;case'+':printf("(+,null)\n"); break;case'-':printf("(-,null)\n"); break;case'*':printf("(*,null)\n"); break;case'<':get();if(s=='=')printf("(relop,LE)\n"); else{retract();printf("(relop,LT)\n");}break;case'=':get();if(s=='=')printf("(relop,EQ)\n"); else{retract();printf("(=,null)\n");}break;case';':printf("(;,null)\n"); break;default:printf("(%c,error)\n",s);break;}memset(token,0,sizeof(char)*10);j=0;get();}}}4、实验结果实验结果分析：if是关键字，对应种别编码为2，输出（2，null）a是标识符，对应种别编码为6，值为a，输出（6，a）==的助记符是relop，内码值为LE，输出（relop，LE）1是常数，对应种别编码为7，值为1，输出（7，1）a是标识符，对应种别编码为6，值为a，输出（6，a）=是赋值符号，直接输出，（=，null）a是标识符，对应种别编码为6，值为a，输出（6，a）+是运算符，直接输出（=，null）1是常数，对应种别编码为7，值为1，输出（7，1）；是语句结束符号，直接输出（；，null）else是关键字，对应种别编码为3，输出（3，null）a是标识符，对应种别编码为6，值为a，输出（6，a）=是赋值符号，直接输出，（=，null）a是标识符，对应种别编码为6，值为a，输出（6，a）+是运算符，直接输出（=，null）2是常数，对应种别编码为7，值为2，输出（7，2）；是语句结束符号，直接输出（；，null）#是输入结束标志编译原理实验语法分析程序实验二：语法分析程序1、实验目的：将单词组成各类语法单位，讨论给类语法的形成规则，判断源程序是否符合语法规则3、实验内容：给定文法：G[E]:E→E+E|E-E|E*E|E/E|(E)E→0|1|2|3|4|5|6|7|8|9首先把G[E]构造为算符优先文法，即：G’[E]:E→E+T|TT→T-F|FF→F*G|GG→G/H|HH→(E)|i得到优先关系表如下：+ - * / i ( ) # + ·><·<·<·<·<··>·> - ·>·><·<·<·<··>·> * ·>·>·><·<·<··>·> / ·>·>·>·><·<··>·>i ·>·>·>·>·>·>( <·<·<·<·<·<·=) ·>·>·>·>·>·> # <·<·<·<·<·<·=构造出优先函数+ - * / i ( ) #f 6 8 10 12 12 2 12 2g 5 7 9 11 13 13 2 2要求输入算术表达式：（1+2）*3+2*（1+2）-4/2输出其对应的语法分析结果4、实验过程：上机程序如下：#include "stdio.h"#include "string.h"char a[20],optr[10],s,op;int i,j,k,opnd[10],x1,x2,x3;int operand(char s){if((s>=48)&&(s<=57))return 1;else return 0;}int f(char s){switch(s){case'+':return 6;case'-':return 8;case'*':return 10;case'/':return 12;case'(':return 2;case')':return 12;case'#':return 2;default:printf("error");}}int g(char s){switch(s){case'+':return 5;case'-':return 7;case'*':return 9;case'/':return 11;case'(':return 13;case')':return 2;case'#':return 2;default:printf("error");}}void get(){s=a[i];i=i+1;}void main(){printf("请输入算数表达式，并以‘#’结束:\n");i=0;do{scanf("%c",&a[i]);i++;}while(a[i-1]!='#');i=0;j=0;k=0;optr[j]='#';get();while((optr[j]!='#')||(s!='#')){if(operand(s)){opnd[k]=s-48;k=k+1;get();}else if(f(optr[j])<g(s)){j=j+1;optr[j]=s;get();}else if(f(optr[j])==g(s)){if(optr[j]=='('&&s==')'){j=j-1;get();}else if(optr[j]=='('&&s=='#'){printf("error\n");break;}else if(optr[j]=='#'&&s==')'){printf("error\n");break;}}else if(f(optr[j])>g(s)){op=optr[j];j=j-1;x2=opnd[k-1];x1=opnd[k-2];k=k-2;switch(op){case'+':x3=x1+x2;break;case'-':x3=x1-x2;break;case'*':x3=x1*x2;break;case'/':x3=x1/x2;break;}opnd[k]=x3;k=k+1;printf("(%c,%d,%d,%d)\n",op,x1,x2,x3);}else{printf("error\n");break;}}if(j!=0||k!=1)printf("error\n");}5、实验结果：实验结果分析：（1+2）*3+2*（1+2）-4/2#因为‘）’优先级大于‘*’，先计算1+2=3，并输出（+，1，2，3）原式变为：3*3+2*（1+2）-4/2#因为‘*’优先级大于‘+’，先计算3*3=9，并输出（*，3，3，9）原式变为：9+2*（1+2）-4/2#因为‘）’优先级大于‘-’，先计算1+2=3，并输出（+，1，2，3）原式变为：9+2*3-4/2#因为‘*’优先级大于‘-’，先计算2*3=6，并输出（*，2，3，6）原式变为：9+6-4/2#因为‘/’优先级大于‘#’，先计算4/2=2，并输出（/，4，2，2）原式变为：9+6-2#因为‘-’优先级大于‘#’，先计算6-2=4，并输出（-，6，2，4）原式变为：9+4#因为‘+’优先级大于‘#’，计算9+4=13，并输出（+，9，4，13）原式变为13#优先级等于#，跳出while循环，运算结束！。
编译原理-词法分析
词法分析是编译原理中的重要阶段，负责将源代码分解为词法单元，为后续 的语法分析准备输入。
词法分析的定义和作用
词法分析是编译器的第一阶段，其主要目的是将源代码转换为有意义的词法 单元，如标识符、关键字、操作符等，以便后续的语法分析和语义分析使用。
词法分析的流程
1
扫描
将源代码分割为符号序列。
2
识别
将符号序列映射到相应的词法单元。
归类
将词法单元分为不同的类别，如标识符、关键字、操作符等。
常见的词法分析技术
正则表达式
用于描述词法单元的模式。
有限自动机
用于识别符号序列并生成词法 单元。
词法分析器生成器
自动生成词法分析器的工具。
词法分析的应用场景
词法分析广泛应用于编译器、解释器和语言处理工具等领域，确保源代码的正确解析和语义分析。
词法分析的挑战和解决方案
错误处理
如何处理错误输入和不合法的词法 单元。
性能优化
如何提高词法分析的速度和效率。
跨平台兼容
如何处理不同编程语言和操作系统 的词法规则。
结论和总结
词法分析是编译原理中不可或缺的一部分，对于编译器的正确性和性能有着 重要影响。了解词法分析的流程和技术，可帮助开发者构建更高效的编译器 和语言处理工具。
编译原理 实验一 词法分析
《编译系统设计实践》实验项目一：词法分析指导老师：陈晖组长：许堃组员：一、实验目的词法分析的目的是将输入的源程序进行划分，给出基本符号（token）的序列，并掠过注解和空格等分隔符号。
基本符号是与输入的语言定义的词法所规定的终结符。
二、实验内容本实验要求学生编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
（遇到错误时可显示“Error”，然后跳过错误部分继续进行）三、程序设计与实现程序功能描述：程序从文本读入一段程序代码，对每一个字符进行分析，识别出各个具有独立意义的单词，并依次输出各个单词的内部编码及单词符号自身值。
过程描述：过程描述：先从文本中读入字符，定义两个指针begin和forward，begin指向每一个词素的首个字符，forward一直向前扫描，直到发现某个单词被匹配为止，一旦确定了下一个单词，forward指针将指向该词素结尾的字符，确定词素后，根据内部编号输出其编号和自身值。
数据结构：数组程序流程图：正则表达式：标识符 id->letter_(letter_|digit)*无符号数 number->digit optitionalfraction optionalexponent 空白符 ws->(blank|tab|newline)+ 关系运算符 relop-> <|>|<=|>=|=|<> 运算符 operator->+|-|*|/DFA 图：=|<>|<|>|<=|>=|+|-|*|/ a —z A--Z0--9;| ( | ) | ,| [ | ] | .开始（每个词素首个字符）符号转化 符号转化符号转化符号转化关键字？标识符？结束startdelim22other24 23*19 12141316151817 startotherdigit. digit E+ | -digitdigit digitdigit Edigit *startletter9other 11 10letter/dig*start<other= 67 8return(relop, LE) 54>= 123other>=* * return(relop, NE)return(relop, LT)return(relop, EQ)return(relop, GE)return(relop, GT)10四、程序测试第一组测试：输入：输出：第二组测试：输入：输出：第三组测试：输入：输出：五、小组成员分工与实验小结由于有一段时间没有编程序，而且实验本身也有些难度，所以在实验初期遇到了很大阻碍，不知道该从何下手。
(完整word版)编译原理词法分析程序实现实验报告
(完整word版)编译原理词法分析程序实现实验报告实验一词法分析程序实现一、实验内容选取无符号数的算术四则运算中的各类单词为识别对象，要求将其中的各个单词识别出来。
输入：由无符号数和+，－，*，/, ( , ) 构成的算术表达式，如1.5E+2－100。
输出：对识别出的每一单词均单行输出其类别码（无符号数的值暂不要求计算）。
二、设计部分因为需要选取无符号数的算术四则运算中的各类单词为识别对象，要求将其中的各个单词识别出来，而其中的关键则为无符号数的识别，它不仅包括了一般情况下的整数和小数，还有以E为底数的指数运算，其中关于词法分析的无符号数的识别过程流程图如下：GOTO 1:(完整word版)编译原理词法分析程序实现实验报告GOTO 2:三、源程序代码部分#include <stdio.h>#include<stdlib.h>#include <math.h>#define MAX 100#define UNSIGNEDNUMBER 1#define PLUS 2#define SUBTRACT 3#define MULTIPLY 4#define DIVIDE 5#define LEFTBRACKET 6#define RIGHTBRACKET 7#define INEFFICACIOUSLABEL 8#define FINISH 111int count=0;int Class;void StoreType();int Type[100];char Store[20]={'\0'};void ShowStrFile();//已经将要识别的字符串存在文件a中void Output(int a,char *p1,char *p2);//字符的输出过程int Sign(char *p);//'+''-''*''/'整体识别过程int UnsignedNum(char *p);//是否适合合法的正整数0~9int LegalCharacter(char *p);//是否是合法的字符：Sign(p)||UnsignedNum(p)||'E'||'.' void DistinguishSign(char *p);//'+''-''*''/'具体识别过程void TypyDistinguish();//字符的识别过程void ShowType();//将类别码存储在Type[100]中，为语法分析做准备void ShowStrFile()//已经将要识别的字符串存在文件a中{FILE *fp_s;char ch;if((fp_s=fopen("a.txt","r"))==NULL){printf("The FILE cannot open!");exit(0);}elsech=fgetc(fp_s);while(ch!=EOF){putchar(ch);ch=fgetc(fp_s);}printf("\n");}void StoreStr()//将文件中的字符串存储到数组Store[i] {FILE *fp=fopen("a.txt","r");char str;int i=0;while(!feof(fp)){fscanf(fp,"%c",&str);if(str=='?'){Store[i]='\0';break;}Store[i]=str;i++;}Store[i]='\0';}void ShowStore(){int i;for (i=0;Store[i]!='\0';i++)printf("%c",Store[i]);printf("\n");}void Output(int a,char *p1,char *p2){printf("%3s\t%d\t%s\t","CLASS",a,"VALUE");while(p1<=p2){printf("%c",*p1);p1++;}printf("\n");}int Sign(char *p){char ch=*p;if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')') return 1;elsereturn 0;}int UnsignedNum(char *p){char ch=*p;if('0'<=ch&&ch<='9')return 1;elsereturn 0;}int LegalCharacter(char *p){char ch=*p;if(Sign(p)||UnsignedNum(p)||ch=='E'||ch=='.')。
编译原理词法分析报告
实验一：词法分析一、实验目的：1、通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。
并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。
2、编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本关键字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
（遇到错误时可显示“Error”，然后跳过错误部分继续显示）二、实验预习提示1、词法分析器的功能和输出格式词法分析器的功能是输入源程序，输出单词符号。
词法分析器的单词符号常常表示成以下的二元式(单词种别码，单词符号的属性值)。
本实验中，采用的是一类符号一种别码的方式。
2、单词的BNF表示<标识符>-> <字母><字母数字串><字母数字串>-><字母><字母数字串>|<数字><字母数字串>|<下划线><字母数字串>|ε<无符号整数>-> <数字><数字串><数字串>-> <数字><数字串> |ε<加法运算符>-> +<减法运算符>->-<大于关系运算符>->><大于等于关系运算符>-> >=3、“超前搜索”方法词法分析时，常常会用到超前搜索方法。
如当前待分析字符串为“a>+”,当前字符为’>’，此时，分析器到底是将其分析为大于关系运算符还是大于等于关系运算符呢？显然，只有知道下一个字符是什么才能下结论。
于是分析器读入下一个字符’+’，这时可知应将’>’解释为大于运算符。
但此时，超前读了一个字符’+’，所以要回退一个字符，词法分析器才能正常运行。
在分析标识符，无符号整数等时也有类似情况。
编译原理实验词法分析实验报告
编译技术实验报告实验题目：词法分析学院：信息学院专业：计算机科学与技术学号：姓名：一、实验目的理解词法分析的功能；理解词法分析的实现方法；二、实验内容PL0的文法如下‘< >’为非终结符。
‘::=’ 该符号的左部由右部定义，可读作“定义为”。
‘|’ 表示‘或’，为左部可由多个右部定义。
‘{ }’ 表示花括号内的语法成分可以重复。
在不加上下界时可重复0到任意次数，有上下界时可重复次数的限制。
‘[ ]’ 表示方括号内的成分为任选项。
‘( )’ 表示圆括号内的成分优先。
上述符号为“元符号”，文法用上述符号作为文法符号时需要用引号‘’括起。
〈程序〉∷=〈分程序〉．〈分程序〉∷= [〈变量说明部分〉][〈过程说明部分〉]〈语句〉〈变量说明部分〉∷=VAR〈标识符〉{，〈标识符〉}：INTEGER；〈无符号整数〉∷=〈数字〉{〈数字〉}〈标识符〉∷=〈字母〉{〈字母〉|〈数字〉}〈过程说明部分〉∷=〈过程首部〉〈分程序〉{；〈过程说明部分〉}；〈过程首部〉∷=PROCEDURE〈标识符〉；〈语句〉∷=〈赋值语句〉|〈条件语句〉|〈过程调用语句〉|〈读语句〉|〈写语句〉|〈复合语句〉|〈空〉〈赋值语句〉∷=〈标识符〉∶=〈表达式〉〈复合语句〉∷=BEGIN〈语句〉{；〈语句〉}END〈条件〉∷=〈表达式〉〈关系运算符〉〈表达式〉〈表达式〉∷=〈项〉{〈加法运算符〉〈项〉}〈项〉∷=〈因子〉{〈乘法运算符〉〈因子〉}〈因子〉∷=〈标识符〉|〈无符号整数〉|'('〈表达式〉')'〈加法运算符〉∷=+|-〈乘法运算符〉∷=*〈关系运算符〉∷=<>|=|<|<=|>|>=〈条件语句〉∷=IF〈条件〉THEN〈语句〉〈字母〉∷=a|b|…|X|Y|Z〈数字〉∷=0|1|2|…|8|9实现PL0的词法分析三、实验分析与设计PL0词法分析程序是一个独立的过程，其功能是为语法语义分析提供单词，把输入的字符串形式的源程序分割成一个个单词符号传递给语法语义分析。
编译原理词法分析器实验报告
编译原理词法分析器实验报告1. 引言编译原理是计算机科学中的重要概念，它涉及将高级语言程序转换为计算机可执行的低级指令。
词法分析是编译过程中的第一个阶段，它负责将源代码分解为词法单元，为后续的语法分析做准备。
本实验旨在设计和实现一个基本的词法分析器，以了解词法分析的原理和实际应用。
2. 实验目标本实验的主要目标是实现一个基本的词法分析器，能够识别并提取源代码中的各种词法单元。
具体而言，我们将设计一个针对某种编程语言的词法分析器，能够识别关键字、标识符、算术运算符、括号、常量等。
3. 实验环境为了完成本实验，我们需要使用以下工具和环境：•一种编程语言，例如Python、Java或C++•一个文本编辑器，例如Visual Studio Code或Sublime Text•一个命令行终端4. 实验步骤4.1 定义词法规则首先，我们需要定义词法分析器的词法规则。
这些规则描述了编程语言中各种词法单元的模式。
例如，关键字可以被定义为由特定字符组成的字符串，标识符可以被定义为以字母开头并由字母和数字组成的字符串。
4.2 实现词法分析器接下来，我们将根据定义的词法规则，使用编程语言实现一个词法分析器。
在实现过程中，我们可以使用正则表达式来匹配和提取各种词法单元。
4.3 编写测试用例完成词法分析器的实现后，我们需要编写一些测试用例来验证其正确性。
测试用例应该包含各种可能的输入情况，以确保词法分析器能够正确地识别和提取词法单元。
4.4 运行测试用例最后，我们将使用编写的测试用例来运行词法分析器，并检查输出是否符合预期。
如果测试通过，说明词法分析器能够正常工作；否则，我们需要检查代码并进行调试。
5. 实验结果经过实验，我们成功地设计并实现了一个基本的词法分析器。
该词法分析器能够按照预定义的词法规则，正确地识别和提取源代码中的各种词法单元。
在运行测试用例时，词法分析器能够产生符合预期的输出，表明其具有良好的准确性和可靠性。
编译原理实验-词法分析器
编译原理实验-词法分析器⼀、实验⽬的设计、编制、调试⼀个词法分析程序，对单词进⾏识别和编码，加深对词法分析原理的理解。
⼆、实验内容1.选定语⾔，编辑任意的源程序保存在⽂件中；2.对⽂件中的代码预处理，删除制表符、回车符、换⾏符、注释、多余的空格并将预处理后的代码保存在⽂件中；3.扫描处理后的源程序，分离各个单词符号，显⽰分离的单词类型。
三、实验思路对于实验内容1，选择编写c语⾔的源程序存放在code.txt中，设计⼀个c语⾔的词法分析器，主要包含三部分，⼀部分是预处理函数，第⼆部分是扫描判断单词类型的函数，第三部分是主函数，调⽤其它函数；对于实验内容2，主要实现在预处理函数processor()中，使⽤⽂档操作函数打开源程序⽂件(code.txt)，去除两种类型（“//”,“/*…*/”）的注释、多余的空格合并为⼀个、换⾏符、回车符等，然后将处理后的保存在另⼀个新的⽂件(afterdel.txt)中，最后关闭⽂档。
对于实验内容3，打开处理后的⽂件，然后调⽤扫描函数，从⽂件⾥读取⼀个单词调⽤判断单词类型的函数与之前建⽴的符号表进⾏对⽐判断，最后格式化输出。
四、编码设计代码参考了两篇博主的，做了部分改动，添加了预处理函数等1 #include<iostream>2 #include<fstream>3 #include<cstdio>4 #include<cstring>5 #include<string>6 #include<cstdlib>78using namespace std;910int aa;// fseek的时候⽤来接着的11string word="";12string reserved_word[20];//保留13char buffer;//每次读进来的⼀个字符14int num=0;//每个单词中当前字符的位置15int line=1; //⾏数16int row=1; //列数，就是每⾏的第⼏个17bool flag; //⽂件是否结束了18int flag2;//单词的类型192021//预处理函数22int processor(){//预处理函数23 FILE *p;24int falg = 0,len,i=0,j=0;25char str[1000],str1[1000],c;26if((p=fopen("code.txt","rt"))==NULL){27 printf("⽆法打开要编译的源程序");28return0;29 }30else{31//fgets(str,1000,p);32while((c=getc(p))!=EOF){33 str[i++] = c;34 }35 fclose(p);36 str[i] = '\0';37for(i=0;i<strlen(str);i++){38if(str[i]=='/'&&str[i+1]=='/'){39while(str[i++]!='\n'){}40 }//单⾏注释41else if(str[i]=='/'&&str[i+1]=='*'){42while(!(str[i]=='*'&&str[i+1]=='/')){i++;}43 i+=2;44 }//多⾏注释45else if(str[i]==''&&str[i+1]==''){46while(str[i]==''){i++;}47 i--;48if(str1[j-1]!='')49 str1[j++]='';50 }//多个空格，去除空格51else if(str[i]=='\n') {52if(str1[j-1]!='')53 str1[j++]='';54 }//换⾏处理，55else if(str[i]==9){56while(str[i]==9){57 i++;58 }59if(str1[j-1]!='')60 str1[j++]='';61 i--;62 }//tab键处理63else str1[j++] = str[i];//其他字符处理64 }65 str1[j] = '\0';66if((p = fopen("afterdel.txt","w"))==NULL){ 67 printf("can not find it!");68return0;69 }70else{71if(fputs(str1,p)!=0){72 printf("预处理失败！");73 }74else printf("预处理成功！");75 }76 fclose(p);77 }78return0;79 }8081//设置保留字82void set_reserve()83 {84 reserved_word[1]="return";85 reserved_word[2]="def";86 reserved_word[3]="if";87 reserved_word[4]="else";88 reserved_word[5]="while";89 reserved_word[6]="return";90 reserved_word[7]="char";91 reserved_word[8]="for";92 reserved_word[9]="and";93 reserved_word[10]="or";94 reserved_word[11]="int";95 reserved_word[12]="bool";96 }9798//看这个字是不是字母99bool judge_word(char x)100 {101if(x>='a' && x<='z' || x>='A' && x<='Z' ){ 102return true;103 }104else return false;105 }106107//看这个字是不是数字108bool judge_number(char x)109 {110if(x>='0' && x<='9'){111return true;112 }113else return false;114 }115116//看这个字符是不是界符117bool judge_jiefu(char x)118 {119if(x=='('||x==')'||x==','||x==';'||x=='{'||x=='}'){ 120return true;121 }122else return false;123 }124125126//加减乘127bool judge_yunsuanfu1(char x)128 {129if(x=='+'||x=='-'||x=='*')130 {131return true;132 }133else return false;134 }135136//等于赋值，⼤于⼩于⼤于等于，⼩于等于，⼤于⼩于137bool judge_yunsuannfu2(char x)138 {139if(x=='='|| x=='>'||x=='<'||x=='&'||x=='||'){140return true;141 }142else return false;143 }144145146//这个最⼤的函数的总体作⽤是从⽂件⾥读⼀个单词147int scan(FILE *fp)148 {149 buffer=fgetc(fp);//读取⼀个字符150if(feof(fp)){//检测结束符151 flag=0;return0;152 }153else if(buffer=='')154 {155 row++;156return0;157 }158else if(buffer=='\n')159 {160 row=1;161return0;162 }163//如果是字母开头或'_' 看关键字还是普通单词164else if(judge_word(buffer) || buffer=='_')165 {166 word+=buffer;167 row++;168while((buffer=fgetc(fp)) && (judge_word(buffer) || judge_number(buffer) || buffer=='_'))169 {170 word+=buffer;171 row++;172 }173if(feof(fp)){174 flag=0;175return1;176 }177for(int i=1;i<=12;i++){178if(word==reserved_word[i]){179 aa=fseek(fp,-1,SEEK_CUR);//如果执⾏成功，stream将指向以fromwhere为基准，偏移offset（指针偏移量）个字节的位置，函数返回0。
编译词法分析实验报告
一、实验目的1. 理解词法分析的基本概念和原理。
2. 掌握词法分析器的实现方法。
3. 熟悉C语言在词法分析中的应用。
4. 提高编程能力和问题解决能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C3. 开发环境：Visual Studio 2019三、实验内容1. 设计词法分析器，实现对源代码的词法分析。
2. 将源代码分解为单词序列。
3. 输出单词序列及对应的词法类型。
四、实验步骤1. 分析源代码中的词法单位，确定词法类型。
2. 设计词法分析器的状态转换表。
3. 编写词法分析器代码。
4. 测试词法分析器，验证其正确性。
五、实验过程1. 分析源代码中的词法单位在C语言中，词法单位包括标识符、关键字、运算符、分隔符、常量等。
本实验以C语言为例，分析源代码中的词法单位，确定词法类型。
2. 设计词法分析器的状态转换表根据词法单位，设计词法分析器的状态转换表。
状态转换表包括当前状态、输入字符、下一状态、输出词法类型和对应动作。
3. 编写词法分析器代码根据状态转换表，编写词法分析器代码。
以下为词法分析器的主要功能模块：（1）初始化：设置初始状态、词法类型和单词长度。
（2）读取字符：从源代码中读取字符，并判断字符类型。
（3）状态转换：根据状态转换表，更新当前状态、输出词法类型和单词长度。
（4）输出结果：将单词序列及对应的词法类型输出到屏幕。
4. 测试词法分析器编写测试用例，验证词法分析器的正确性。
测试用例包括以下几种情况：（1）包含各种词法单位的源代码。
（2）包含注释的源代码。
（3）包含错误标识符的源代码。
六、实验结果与分析1. 实验结果通过测试，词法分析器能够正确识别源代码中的各种词法单位，并将单词序列及对应的词法类型输出到屏幕。
以下为部分测试结果：```int a = 10; // 输出：int, 标识符if (a > 0) // 输出：if, 关键字{// 输出：{, 分隔符// ...// 输出：}, 分隔符}// 输出：//, 注释开始注释内容// 输出：//, 注释结束```2. 实验分析（1）实验过程中，通过对词法分析原理的学习，加深了对编译原理的理解。
编译原理实验：词法分析
编译原理实验报告课题名称：词法分析院系：计算机科学系实验一：词法分析1.实验目的设计，编制并调试一个词法分析程序，加深对词法分析原理的理解。
2.实验要求2.1 待分析的简单语言的词法（1）关键字：begin if then while do end所有的关键字都是小写。
（2）运算符和界符：：= + - * / < <= > >= = ; ( ) #(3) 其他单词标识符（ID）和整型常数（NUM），通过以下正规是定义：ID= letter(letter | digit)*NUM = digit digit*(4)空白由空白，制表符和换行符组成。
空格一般用来分隔ID，NUM，运算符，界符和关键字，词法分析阶段通常被忽略。
2.2 各单词符号所对应的种别码单词符号种别码单词符号种别码begin 1 : 17 if 2 := 18 then 3 < 20 while 4 <> 21 do 5 <= 22 end 6 > 23 letter(letter| digit)*10 >= 24 digit dihit* 11 = 25 + 12 ; 26 - 14 ( 27 * 15 ) 28 / 16 # 02.3 词法分析程序的功能输入：所给文法的源程序字符串。
输出：二元组（syn，token或sum）构成的序列。
其中：syn 为单词种别码；token 为存放单词自身的字符；sum 为整型常数。
例如：对源程序begin x :=9；if x>0 then x := 2*x+1/3; end # 的源文件，经词法分析后输出如下序列：（1，begin）（10，’x’）(18,:=) ( 11,9) (26, ;) (2,if)……3.词法分析程序的算法思想该算法的基本任务是从字符串表示的源程序中只别处具有独立意义的单词符号，其基本思想是根据扫描到单词符号的第一个字符的种类，拼出相应的单词符号。
编译原理实验报告 词法分析
编译原理实验一·词法分析一、实验目的通过动手实践，使学生对构造编译系统的基本理论、编译程序的基本结构有更为深入的理解和掌握；使学生掌握编译程序设计的基本方法和步骤；能够设计实现编译系统的重要环节。
同时增强编写和调试程序的能力。
二、实验内容及要求对某特定语言A ，构造其词法规则。
该语言的单词符号包括：保留字(见左下表)、标识符（字母大小写不敏感）、整型常数、界符及运算符(见右下表) 。
功能要求如下所示：·按单词符号出现的顺序，返回二元组序列，并输出。
·出现的标识符存放在标识符表，整型常数存放在常数表，并输出这两个表格。
·如果出现词法错误，报出：错误类型，位置（行，列）。
·处理段注释（/* */），行注释（//）。
·有段注释时仍可以正确指出词法错误位置（行，列）。
三、实验过程1、词法形式化描述使用正则文法进行描述，则可以得到如下的正规式:其中ID表示标识符，NUM表示整型常量，RES表示保留字，DEL表示界符，OPR表示运算符。
A→(ID | NUM | RES | DEL | OPR) *ID→letter(letter | didit)*NUM→digit digit*letter→a | …| z | A | …| Zdigit→0 | …| 9RES→program | begin | end | var | int | and | or | not | if | then | else | while | doDEL→( | ) | . | ; | ,OPR→+ | * | := | > | < | = | >= | <= | <>如果关键字、标识符和常数之间没有确定的算符或界符作间隔，则至少用一个空格作间隔。
空格由空白、制表符和换行符组成。
2、单词种别定义；3、状态转换图；语言A的词法分析的状态转换图如下所示：空格符，制表符或回车符字母或数字4、运行环境介绍；本次实验采用win-tc进行代码的编写和编译及运行程序的运行环境为windows5、关键算法的流程图及文字解释；程序中用到的函数列表：变量ch储存当前最新读进的字符的地址strToken存放当前字符串voidmain（） //主函数struct binary *lexicalAnalyze(); //词法分析的主函数，返回一个二元组的指针void GetBC(); //检查ch指向的字符是否为空格、制表或回车符，如果是则调用GetChar（）直至不是上述字符void GetChar(); //ch前移一个地址单元int ConCat(); //将ch指向的字符连接到strToken之后int isLetter(); //判断ch指向的字符是否字母int isDigit(); //判断ch指向的字符是否数字int insertId(); //向标识符表中插入当前strToken的字符串int insertConst(); //将strToken的常数插入常数表中int Reserved(); //检测当前strToken中的字符串是否保留字,若是,则返回编码,否则返回0int isId(); //检测当前strToken中的字符串是否在标识符表中已存在,若是,则返回其编号,否则返回0int isConst(); //检测当前strToken中的字符串是否在常数表中已存在,若是,则返回其编号,否则返回0void errProc(int errType); //出错处理过程,errType是错误类型,将错误信息加入错误表中main（）函数的流程图如下:lexicalAnalyze（）函数的流程图如下所示：Reserved()、isId()和isConst()函数均采用了对链表的遍历算法，errProc()函数通过识别不同的错误编号，向错误链表中添加相应的错误信息。
编译原理_实验一_词法分析
实习一词法分析一、实验目的：根据活动状态转换图，设计并实现一个具体的C语言的词法分析程序，加深对词法分析原理的理解。
并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。
编写一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。
并依次输出各个单词的内部编码及单词符号自身值。
（遇到错误时可显示“Error”，然后跳过错误部分继续显示）。
二、实验过程1.活动状态转化图2.设计思路本C语言词法分析器使用JAVA语言编写。
（1）C语言词法分析●关键字将C语言32关键字"auto", "double", "int", "struct", "break","else","long", "switch", "case", "enum", "register", "typedef","char", " extern", "return", "union", "const", "float", "short"," unsigned", "continue", "for", "signed", "void","default", "goto","sizeof", "volatile", "do", "if", "while", "static"存储在keyword[]字符串数组中；●专用符号= + -* / ＜＝＞＞＝ == ！= ；：， { } [ ] （ )将读入的字符与ASCLL表进行比较判断；对于像“==”，“<=”等字符进行超前搜索；●空格和空白、制表符和换行符。
(完整)编译原理实验报告(词法分析器 语法分析器)
编译原理实验报告实验一一、实验名称：词法分析器的设计二、实验目的：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 〈stdio.h〉＃include <math.h>#include <string。
h>int i,j,k;char c,s,a［20]，token[20]=｛’0’｝;int letter(char s){if（(s〉=97)&&（s〈=122）) return(1);else return（0);｝int digit（char s）｛if（(s〉=48）＆＆（s<=57）) return(1)；else return(0);}void get(){s=a［i];i=i+1；｝void retract()｛i=i-1；}int lookup（char token[20］)｛if（strcmp（token，"while"）==0） return（1）;else if(strcmp(token,"if"）==0) return（2）;else if(strcmp(token,"else”）==0） return(3）;else if（strcmp（token，"switch”)==0） return(4）；else if（strcmp（token,"case")==0） return（5）;else return（0）;｝void main(）｛printf（”please input string ：\n"）；i=0;do{i=i+1；scanf("%c",＆a［i]）;｝while（a[i］!=’#’)；i=1;j=0;get();while(s!=’#')｛ memset(token，0，20);switch（s)｛case 'a':case ’b'：case ’c'：case ’d':case ’e’：case ’f’:case 'g’:case ’h'：case 'i'：case ’j'：case 'k’:case ’l':case 'm’：case 'n':case ’o'：case ’p'：case ’q’：case 'r’:case 's’：case 't’:case ’u’：case ’v’:case ’w’:case ’x'：case ’y':case ’z’：while（letter(s）||digit(s)）{token[j］=s;j=j+1；get()；｝retract();k=lookup（token）;if（k==0)printf（"（%d,％s）”,6,token）;else printf("（%d,—)"，k);break;case ’0':case ’1’:case ’2'：case ’3':case '4’：case '5’：case ’6'：case ’7’：case ’8’:case '9’：while（digit(s）)｛token[j]=s;j=j+1；get（）;｝retract(）;printf(”％d,％s",7,token）；break;case '+'：printf(”（’+',NULL)”）；break;case ’-':printf("（’-'，null）"）;break；case ’＊':printf（”（'＊’，null）"）;break;case '<':get()；if(s=='=’） printf（”（relop,LE)”）；else｛retract(）；printf（"（relop，LT)"）;｝break;case ’='：get（）;if(s=='=’）printf（"(relop,EQ)"）；else{retract（）；printf(”('=',null）”)；｝break；case ’；'：printf（”（；,null)")；break；case ' ’：break；default:printf（"！\n”)；}j=0;get(）；｝ }六：实验结果：实验二一、实验名称：语法分析器的设计二、实验目的：用C语言编写对一个算术表达式实现语法分析的语法分析程序，并以四元式的形式输出，以加深对语法语义分析原理的理解,掌握语法分析程序的实现方法和技术.三、实验原理：1、算术表达式语法分析程序的算法思想首先通过关系图法构造出终结符间的左右优先函数f(a)，g(a）。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
编译原理实验报告实验一实验题目：词法分析指导老师：任姚鹏专业班级：计算机科学与技术系网络工程方向1002班姓名：xxxx2013年 4月13日实验类型__验证性__ 实验室_软件实验室三__一、实验项目的目的和任务：了解和掌握词法分析的方法，编程实现给定源语言程序的词法分析器，并利用该分析器扫描源语言程序的字符串，按照给定的词法规则，识别出单词符号作为输出，发现其中的词法错误。
二、实验内容：1．设计一个简单的程序设计语言（语言中有若干运算符和分界符；有若干关健字；若干标识符及若干常数）2．确定编译中使用的表格、词法分析器的输出形式、标识符与关键字的区分方法。
3．把词法分析器设计成一个独立的过程。
三、实验要求:1.从键盘上输入源程序；2.处理各单词，计算个单词的值和类型；3.输出个单词名、单词的值和类型。
四、实验代码#include <stdio.h>#include <string.h>char file[1024];int length=0;int index;char keywords[][10]={"auto","short","int","long","float","double","char","struct","union","enum","typedef","const","unsigned","signed","extern","register","static","volatile","void","default","if","else","switch","case","for","do","while","goto","continue","break","sizeof","return"};char limits[]={'(',')','[',']','{','}',',',';'};char operators[]={'+', '-', '*', '/', '%','>','<','&','|','^','~','!','='}; //13int IsChar(char ch) //是否是字符{ if ( (ch>='a'&&ch<='z') || (ch>='A'&&ch<='Z'))return 1;return 0;}int IsNumber(char ch) {if ( (ch>='0'&& ch<='9'))return 1;return 0;}int IsKeyWord(int idx) //关键字和标示符识别{ char tmp[30];int i=0;while(IsChar(file[idx])) tmp[i++]=file[idx++]; //将单词拷贝tmp[i]='\0';if(i==0)return 0;for (i=0;i<32;i++){ if (0==strcmp(keywords[i],tmp)) //相等{ printf("(关键字 %d, %s )\n",1,tmp); //打印结果,关键字index=idx-1; //新的index的值return 1;} }return 0; }int IsConst(int idx){ char tmp[30];int i=0;if (IsChar(file[idx]) && (file[idx-1]=='\'')) //单个字符判断{ if(file[idx+1]=='\'') //是单个的字符{ tmp[i++]=file[idx++];tmp[i]='\0';printf("(常数 %d, %s )\n",3,tmp);//打印结果index=idx-1;return 1; }else{ return 0; } }else if(IsNumber(file[idx])) //一串数字判断{ while(IsNumber(file[idx]))tmp[i++]=file[idx++];tmp[i++]=file[idx++];tmp[i]='\0';printf("(常数 %d, %s )\n",3,tmp);//打印结果index=idx-1;return 1; }return 0; }int IsWord(int idx) //是否是标示符{ char tmp[30];int i=0;if(IsKeyWord(idx)) //是关键字就不做处理return 0;if(IsConst(idx)) //是常量不做处理return 0;if( (file[idx]=='_') ||(IsNumber(file[idx])) ||(IsChar(file[idx]))) tmp[i++]=file[idx++];if(i==0) return 0;while((IsNumber(file[idx])) ||(IsChar(file[idx])))tmp[i++]=file[idx++]; //将单词拷贝tmp[i]='\0';printf("(标示符 %d, %s )\n",2,tmp); //打印结果index=idx-1;return 1; }int IsOperator(int idx) //是否是运算符{char tmp[30];int k=0;int i=0;for (k=0;k<13;k++){ if(operators[k]==file[idx]){ tmp[i++]=file[idx];index=idx;if( (file[idx+1]=='=') ||((file[idx]=='+') &&(file[idx+1]=='+'))||((file[idx]=='-') &&(file[idx+1]=='-'))){ tmp[i++]=file[++idx];index=idx;}tmp[i]='\0';printf("(运算符 %d, %s )\n",4,tmp); //打印结果return 1;} }return 1; }int IsLimit(int idx) //限界符{ int i;for(i=0;i<8;i++){ if(limits[i]==file[idx]){ printf("(界限符 %d, %c )\n",4,file[idx]);return 1;} }return 0; }int ReadFile(char * name){ int i=0;int length;char ch;FILE *fp =fopen(name,"r");if(fp==NULL){ printf("can't open file %s\n",name);return -1; }length=0;while ( (ch=fgetc(fp))!=EOF)file[length++]=ch;for(i=0;i<length;i++)putchar(file[i]);fclose(fp);return length; }int main(){ if((length=ReadFile("TestDemo.c"))==-1) //读取文件失败return -1;index=0;while(index<length){ while ( (file[index]==' ') && (index<length)) index++; //去除空格if(index>=length) return 0;if(IsKeyWord(index)) //考查是不是关键字{}else if (IsConst(index)){}else if(IsWord(index)) //考查是不是符号{}else if (IsLimit(index)){}else if(IsOperator(index)){}index++; //考查下一个字符 }return 0; }五、运行结果六、实验总结实验一是关于词法分析的实验项目，本次实验中所涉及到的词法分析是编译原理课程中最基本也是特别重要的知识，是学习编译原理的基础。
在实验中需要用C语言编写一个程序模拟出词法分析的过程，这就需要用到前面所学的一系列课程的知识。
通过本次实验内容，使我自己进一步熟悉了编译原理这门课程，也对课程的基本知识和语法有了更加深刻的认识和理解，同时也将前面所学课程得到巩固，使自己发现了一些不足之处，在今后需要加强的地方还有很多很多。