编译原理 第二次实验 语法分析 按照崔老师上午授课内容写出来框架

最新推荐文章于 2022-07-14 11:16:27 发布
最新推荐文章于 2022-07-14 11:16:27 发布
阅读量489 收藏 1
点赞数
分类专栏： 编译原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nyist_yangguang/article/details/116753930
版权

 

老师授课内容：

 

注意：

调用advance(),依次读取一个词法分析得到的结果，得到的结果形式为 （种别码，D）   其中D 可以为  +  -  *  /   数字  。

定义：

sym 得到的是每次取得结果   （   和  ，前面中间的值，即种别码。  种别码时string类型。

 

举例： 

以下程序用来判断是+  或者  -  

 

以下程序用来判断 *  或者 /

 

以下程序用来判断  （

 

以下程序用来判断  ）

 

以下程序用来判断数字（注意数字不用管数值是多少）

 

以下程序用来报错：

 printf("Error!\n");
 exit(1);

 

 

程序框架1如下：

如果运行不了，可以试试框架2

#include<bits/stdc++.h>
#include <iostream>
#include <map>
#include <algorithm>
#include <string>
#include<string.h>
#include<stdio.h>
#include<time.h>
#include<sstream>

using namespace std;

template <class Type> Type stringToNum(const string& str)
{
    istringstream iss(str);
    Type num;
    iss >> num;
    return num;
}

int num=0;
int sum=0;

ifstream infile("d.txt");//词法分析的结果或语法分析的输入
string str;//string变量进行字符识别
string sym; //指针
string sym1;
int temp=0;

//int expressionAnalysis();//表达式分析
//int termAnaysis();//项分析
//int factorAnalysis();//因子分析
//int advance();
int E();
int E_plus();
int T();
int T_plus();
int F();


int conterr=0;//记录错误
int lpnum=0;//记录左括号
int found;//提取字符串中指针的位置
string sym2;
int found1;
int flag=0;//记录往后移动一个指针SYM是否正确
string s;//用来保存要分析的字符串
struct _2tup
{
    string token;
    int id;
};

int advance() //SYM的移动
{
    if(!getline(infile,str)) //从文件中提取字符
    {
        return 0;
    }
//    cout<<str<<endl;
    s+=str;
//    cout<<s<<endl;
    found=str.find(',',0);
    found1=str.find(')',0);
//    cout<<found1<<endl;

    if(found==-1) //当为error的时候，没有‘，’
    {
        conterr++;
        return 0;
//        cout<<"语法错误 识别字符错误"<<endl;
//        return -1;
    }
    if(temp==1)
        sym1=sym;
    sym=str.substr(1,found-1);
    sym2=str.substr(found+1,found1-found-1);

    num=stringToNum<int>(sym2);
//    cout<<num<<endl;

    return 1;
}

int F()
{
 

}
int T_plus()
{
 
}
int T()
{

  

}

int E_plus()
{
  
}



int E()
{

    T();
    E_plus();

}
void yufafenxi()//语法分析
{
//    freopen("CON", "w", stdout);//结果在控制台上输出
//    flag=advance();
//    if(flag)-
//    {
    advance();
    E();
//    advance();
    if(strcmp(str.data(),"#")!=0)
    {
        printf("%s\n",s.data());
        printf("Error\n");
    }
    else
    {
        cout<<"OK:   "<<s<<endl;
    }
//    }
//    if(flag!=-1 && !conterr)
//    {
//    cout<<"正确："<<s<<endl;
//    }

}



string instr;//输入符号串
int index;//当前输入符号读入字符的位置
char character;//全局变量字符，存放最新读入的字符
string token;//字符数组，存放已读入的字符序列
map<string, int> Symbol;//标识符集
map<string, int> Digit;//常数集
map<string, int> other;//other
map<string, int>::iterator ite;
const int len = 100;
string Reserve[len];//保留字表
map<string,int> type;
//void init_Reserve()  //构造保留字表的函数
//{
//    Reserve[1] = "begin";
//    Reserve[2] = "end";
//    Reserve[3] = "if";
//    Reserve[4] = "then";
//    Reserve[5] = "while";
//    Reserve[6] = "do";
//    Reserve[7] = "const";
//    Reserve[8] = "var";
//    Reserve[9] = "call";
//    Reserve[10] = "procedure";
//
//}
void getChar()  //读入一个字符
{
    character = instr[index++];
}
void getnbc()  //读入非空白字符
{
    while (character == ' ')
    {
        getChar();
    }
}
void concat()  //连接字符串
{
    token = token + character;
}
bool letter()  //判断是否为字母
{
    if ((character >= 'A'&&character <= 'Z') || (character >= 'a'&&character <= 'z'))
        return true;
    return false;
}
bool digit()  //判断是否为数字
{
    if (character >= '0'&&character <= '9')
        return true;
    return false;
}
void retract() //回退字符的函数
{
//    character = ' ';
    index--;
}
int reserve()  //匹配保留字符
{
    for (int i = 0; i < len; i++)
        if (Reserve[i] == token)
            return i;
    return -1;
}
void symbol()
{
    ite = Symbol.find(token);
    if (ite != Symbol.end())
    {
//        return ite->first;
        return ;
    }
    else
    {
        Symbol[token] = Symbol.size();
        return ;
//        return token;
    }
}
void constant()
{
    ite = Digit.find(token);
    if (ite != Digit.end())
    {
//        return ite->first;
        return ;
    }
    else
    {
        Digit[token] = Digit.size();
        return ;
//        return token;

    }
}
void Three()
{
    ite = other.find(token);
    if (ite != other.end())
    {
        return ;
//        return ite->first;
    }
    else
    {
        other[token] = other.size();
        return ;
//        return token;
    }
}
void error()
{
    cout << token << "\t-->\t该单词不存在" << endl;
}
//词法分析函数，逐个识别单词
string LexAnalyze()
{
    token = "";
    getChar();
    getnbc();
    string val;
//    int num = -1;
    if(character>='a'&&character<='z' || character>='A'&&character<='Z')
    {
        while (letter() || digit())  //为字母或数字
        {
            concat();//追加到token末尾

//            if(token=="odd")
//            {
//                getChar();
//                Three();
//                return ;
//            }
            getChar();//读取下一个字符
        }
        if(token=="odd")
        {
            getChar();
            Three();
            return 0;
        }
        retract();//回退一个字符
        {
//            val = symbol();//查看标识符表
            symbol();

        }
    }
    else if(character>='0' && character<='9')
    {
        int flag=0;
        while (character>='0' && character<='9' || character>='a' && character<='z' || character>='A' && character <='Z')
        {
            if(character>='0' && character<='9')
                concat();

            if(character>='a' && character<='z' || character>='A' && character <='Z')
            {
                concat();
                flag=1;
            }
            getChar();
        }
        if(flag==1)
        {
            error();
            return 0;
        }
        retract();
//        val = constant();//查看常数表
        constant();

    }
    else if(character=='<')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();
//返回<=符号
        }
        else if(character=='>')
        {
            concat();
            Three();
        }
        else
        {
            retract();
            Three();
//返回<符号
        }
    }
    else if(character=='>')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();
//返回>=符号
        }
        else
        {
            retract();
            Three();
//返回>符号
        }
    }
    else if(character=='=')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();
//返回==符号
        }
        else
        {
            retract();
            Three();
//返回=符号
        }
    }

    else if(character==':')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();

        }
        else
        {
            cout<<token<<endl;
            error();
            return 0;
        }
    }

    else if(character=='+')
    {
        concat();
        Three();
    }


    else if(character=='-')
    {
        concat();
        Three();
    }

    else if(character=='*')
    {
        concat();
        Three();
    }


    else if(character=='/')
    {
        concat();
        Three();
    }


    else if(character=='(')
    {
        concat();
        Three();
    }

    else if(character==')')
    {
        concat();
        Three();
    }

    else if(character==',')
    {
        concat();
        Three();
    }

    else if(character=='.')
    {
        concat();
        Three();
    }

    else if(character==';')
    {
        concat();
        Three();
    }

    else if(character=='#')
    {
        concat();
        return token;
    }
    else
    {
        error();
        return 0;
    }

    return token;

}
void show_table()
{
    cout << "\n==================" << "标识符" << "==================" << endl;
//    cout << "标识符\t\t类别编码\t表中位置" << endl;
    for (ite=Symbol.begin(); ite != Symbol.end(); ite++)
    {
//        int flag=0;
//        for (int i = 0; i < len; i++)
//        {
               cout<<Reserve[i]<<endl;
//            if (Reserve[i] == ite->first)
//            {
//                cout<<ite->first<<"是保留字"<<"   ";
//                cout << "("<<ite->first <<","<<ite->second<<")" << endl;
//                flag=1;
//                break;
//            }
//
//
//        }
//        if(flag==0)
//            cout << "("<<ite->first <<","<<ite->second<<")" << endl;

        map<string,int>::iterator iter;
        iter=type.find(ite->first);
        if(iter!=type.end())
            cout << "("<<iter->second <<","<<ite->second<<")" << endl;
        else
            cout << "("<<type.size() <<","<<ite->second<<")" << endl;
    }
    cout << "\n==================" << "常数表" << "==================" << endl;
//    cout << "常量值\t\t类别编码\t表中位置" << endl;
    for (ite = Digit.begin(); ite != Digit.end(); ite++)
    {
//        cout << "("<<ite->first <<","<<ite->second<<")" << endl;
        map<string,int>::iterator iter;
        iter=type.find(ite->first);
//        if(iter!=type.end())
//            cout << "("<<iter->second <<","<<ite->second<<")" << endl;
//        else
        cout << "("<<type.size()-1 <<","<<ite->second<<")" << endl;
    }
    cout << "\n==================" << "算符、界符" << "==================" << endl;
    for (ite = other.begin(); ite != other.end(); ite++)
    {
//        cout << "("<<ite->first <<","<<ite->second<<")" << endl;
        map<string,int>::iterator iter;
        iter=type.find(ite->first);
        cout << "("<<iter->second <<","<<ite->second<<")" << endl;
//           cout<<iter->second<<endl;
    }
}
int main()
{
//    clock_t start,finish;
//    double totaltime;
//    start=clock();


    type["begin"]=type.size();
    type["end"]=type.size();
    type["if"]=type.size();
    type["then"]=type.size();
    type["while"]=type.size();
    type["do"]=type.size();
    type["const"]=type.size();
    type["var"]=type.size();
    type["call"]=type.size();
    type["procedure"]=type.size();
    type["+"]=type.size();
    type["-"]=type.size();
    type["*"]=type.size();
    type["/"]=type.size();
    type["odd"]=type.size();
    type["="]=type.size();
    type["<>"]=type.size();
    type["<"]=type.size();
    type[">"]=type.size();
    type["<="]=type.size();
    type[">="]=type.size();
    type[":="]=type.size();
    type["("]=type.size();
    type[")"]=type.size();
    type[","]=type.size();
    type["."]=type.size();
    type[";"]=type.size();
    type["常数"]=type.size();
    type["标识符"]=type.size();



//    init_Reserve();//保留字表初始化
    Symbol.clear();//标识符集初始化
    Digit.clear();//常数集初始化
    index = 0;
    character = ' ';
    token = "";
    cout << "请输入待词法分析的源程序代码：输入文件结束符结束输入\n" << endl;
    //源程序代码输入处理
//    instr="var a,b,c; a:=1; b:=2; c:=a+b";


    char ch[1000];
    string ins;
//    printf("%d\n",gets(ch));
//    printf("\n%d",&ch[1]);
//    cout<<gets(ch)<<endl;
    while(gets(ch))
    {
        FILE *fp;
//        char str[1000];
        map<string,int>::iterator iter;
        if((fp=fopen("d.txt","w"))==NULL)
        {
            printf("error occur!\n");
            exit(1);
        }
        if((fp=fopen("d.txt","a"))==NULL)
        {
            printf("error occur!\n");
            exit(1);
        }

//        ins=ch;


        instr=ch;
        index=0;
        while (index < instr.size())
        {
            char* str=(char*)LexAnalyze().data();
//                    fprintf(fp,"%s\n",str);
//            cout<<str<<endl;
            if(strcmp(str,"#")==0)
            {
//                printf("*");
                fprintf(fp,"%s",str);
            }
            else
            {
                iter=type.find(str);
                if(iter!=type.end())

//                if(index==instr.size())
                    fprintf(fp,"(%d,%s)\n",iter->second,str);
//                else
//                    fprintf(fp,"(%d,%s)\n",iter->second,str);
                else
                {
                    iter=Digit.find(str);
                    if(iter!=Digit.end())

//                if(index==instr.size())
                        fprintf(fp,"(28,%s)\n",str);
//                else
//                    fprintf(fp,"(28,%s)\n",str);


                }
            }
        }

        fclose(fp);


//        cout<<instr<<endl;
        memset(ch,0,sizeof(ch));
    }
    yufafenxi();

//    cout<<instr<<endl;
//    string in;
//    while (cin >> in&&in != "@")
//    {
//        instr = instr + " " + in;
//    }
    //识别二元组初始化
//    while (index < instr.size())
//    {
//        LexAnalyze();
//    }
    //展示构造的各种词汇表
    show_table();

//    finish=clock();
//    totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
//    cout<<totaltime<<endl;
//    //system("pause");
    return 0;

}

 

框架2

//#include<bits/stdc++.h>
#include <fstream>
#include <iostream>
#include <map>
#include <algorithm>
#include <string>
#include<string.h>
#include<stdio.h>
#include<time.h>
#include<sstream>

using namespace std;

template <class Type> Type stringToNum(const string& str)
{
    istringstream iss(str);
    Type num;
    iss >> num;
    return num;
}

int num=0;
int sum=0;

ifstream infile("d.txt");//词法分析的结果或语法分析的输入
string str;//string变量进行字符识别
string sym; //指针
string sym1;
int temp=0;

//int expressionAnalysis();//表达式分析
//int termAnaysis();//项分析
//int factorAnalysis();//因子分析
//int advance();
int E();
int E_plus();
int T();
int T_plus();
int F();


int conterr=0;//记录错误
int lpnum=0;//记录左括号
int found;//提取字符串中指针的位置
string sym2;
int found1;
int flag=0;//记录往后移动一个指针SYM是否正确
string s;//用来保存要分析的字符串
struct _2tup
{
    string token;
    int id;
};

int advance() //SYM的移动
{
    if(!getline(infile,str)) //从文件中提取字符
    {
        return 0;
    }
//    cout<<str<<endl;
    s+=str;
//    cout<<s<<endl;
    found=str.find(',',0);
    found1=str.find(')',0);
//    cout<<found1<<endl;

    if(found==-1) //当为error的时候，没有‘，’
    {
        conterr++;
        return 0;
//        cout<<"语法错误 识别字符错误"<<endl;
//        return -1;
    }
    if(temp==1)
        sym1=sym;
    sym=str.substr(1,found-1);
    sym2=str.substr(found+1,found1-found-1);

    num=stringToNum<int>(sym2);
//    cout<<num<<endl;

    return 1;
}

int F()
{


}
int T_plus()
{

}
int T()
{



}

int E_plus()
{

}



int E()
{

    T();
    E_plus();

}
void yufafenxi()//语法分析
{
//    freopen("CON", "w", stdout);//结果在控制台上输出
//    flag=advance();
//    if(flag)-
//    {
    advance();
    E();
//    advance();
    if(strcmp(str.data(),"#")!=0)
    {
        printf("%s\n",s.data());
        printf("Error\n");
    }
    else
    {
        cout<<"OK:   "<<s<<endl;
    }
//    }
//    if(flag!=-1 && !conterr)
//    {
//    cout<<"正确："<<s<<endl;
//    }

}



string instr;//输入符号串
int index;//当前输入符号读入字符的位置
char character;//全局变量字符，存放最新读入的字符
string token;//字符数组，存放已读入的字符序列
map<string, int> Symbol;//标识符集
map<string, int> Digit;//常数集
map<string, int> other;//other
map<string, int>::iterator ite;
const int len = 100;
string Reserve[len];//保留字表
map<string,int> type;
//void init_Reserve()  //构造保留字表的函数
//{
//    Reserve[1] = "begin";
//    Reserve[2] = "end";
//    Reserve[3] = "if";
//    Reserve[4] = "then";
//    Reserve[5] = "while";
//    Reserve[6] = "do";
//    Reserve[7] = "const";
//    Reserve[8] = "var";
//    Reserve[9] = "call";
//    Reserve[10] = "procedure";
//
//}
void getChar()  //读入一个字符
{
    character = instr[index++];
}
void getnbc()  //读入非空白字符
{
    while (character == ' ')
    {
        getChar();
    }
}
void concat()  //连接字符串
{
    token = token + character;
}
bool letter()  //判断是否为字母
{
    if ((character >= 'A'&&character <= 'Z') || (character >= 'a'&&character <= 'z'))
        return true;
    return false;
}
bool digit()  //判断是否为数字
{
    if (character >= '0'&&character <= '9')
        return true;
    return false;
}
void retract() //回退字符的函数
{
//    character = ' ';
    index--;
}
int reserve()  //匹配保留字符
{
    for (int i = 0; i < len; i++)
        if (Reserve[i] == token)
            return i;
    return -1;
}
void symbol()
{
    ite = Symbol.find(token);
    if (ite != Symbol.end())
    {
//        return ite->first;
        return ;
    }
    else
    {
        Symbol[token] = Symbol.size();
        return ;
//        return token;
    }
}
void constant()
{
    ite = Digit.find(token);
    if (ite != Digit.end())
    {
//        return ite->first;
        return ;
    }
    else
    {
        Digit[token] = Digit.size();
        return ;
//        return token;

    }
}
void Three()
{
    ite = other.find(token);
    if (ite != other.end())
    {
        return ;
//        return ite->first;
    }
    else
    {
        other[token] = other.size();
        return ;
//        return token;
    }
}
void error()
{
    cout << token << "\t-->\t该单词不存在" << endl;
}
//词法分析函数，逐个识别单词
string LexAnalyze()
{
    token = "";
    getChar();
    getnbc();
    string val;
//    int num = -1;
    if(character>='a'&&character<='z' || character>='A'&&character<='Z')
    {
        while (letter() || digit())  //为字母或数字
        {
            concat();//追加到token末尾

//            if(token=="odd")
//            {
//                getChar();
//                Three();
//                return ;
//            }
            getChar();//读取下一个字符
        }
        if(token=="odd")
        {
            getChar();
            Three();
            return 0;
        }
        retract();//回退一个字符
        {
//            val = symbol();//查看标识符表
            symbol();

        }
    }
    else if(character>='0' && character<='9')
    {
        int flag=0;
        while (character>='0' && character<='9' || character>='a' && character<='z' || character>='A' && character <='Z')
        {
            if(character>='0' && character<='9')
                concat();

            if(character>='a' && character<='z' || character>='A' && character <='Z')
            {
                concat();
                flag=1;
            }
            getChar();
        }
        if(flag==1)
        {
            error();
            return 0;
        }
        retract();
//        val = constant();//查看常数表
        constant();

    }
    else if(character=='<')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();
//返回<=符号
        }
        else if(character=='>')
        {
            concat();
            Three();
        }
        else
        {
            retract();
            Three();
//返回<符号
        }
    }
    else if(character=='>')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();
//返回>=符号
        }
        else
        {
            retract();
            Three();
//返回>符号
        }
    }
    else if(character=='=')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();
//返回==符号
        }
        else
        {
            retract();
            Three();
//返回=符号
        }
    }

    else if(character==':')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();

        }
        else
        {
            cout<<token<<endl;
            error();
            return 0;
        }
    }

    else if(character=='+')
    {
        concat();
        Three();
    }


    else if(character=='-')
    {
        concat();
        Three();
    }

    else if(character=='*')
    {
        concat();
        Three();
    }


    else if(character=='/')
    {
        concat();
        Three();
    }


    else if(character=='(')
    {
        concat();
        Three();
    }

    else if(character==')')
    {
        concat();
        Three();
    }

    else if(character==',')
    {
        concat();
        Three();
    }

    else if(character=='.')
    {
        concat();
        Three();
    }

    else if(character==';')
    {
        concat();
        Three();
    }

    else if(character=='#')
    {
        concat();
        return token;
    }
    else
    {
        error();
        return 0;
    }

    return token;

}
void show_table()
{
    cout << "\n==================" << "标识符" << "==================" << endl;
//    cout << "标识符\t\t类别编码\t表中位置" << endl;
    for (ite=Symbol.begin(); ite != Symbol.end(); ite++)
    {
//        int flag=0;
//        for (int i = 0; i < len; i++)
//        {
//               cout<<Reserve[i]<<endl;
//            if (Reserve[i] == ite->first)
//            {
//                cout<<ite->first<<"是保留字"<<"   ";
//                cout << "("<<ite->first <<","<<ite->second<<")" << endl;
//                flag=1;
//                break;
//            }
//
//
//        }
//        if(flag==0)
//            cout << "("<<ite->first <<","<<ite->second<<")" << endl;

        map<string,int>::iterator iter;
        iter=type.find(ite->first);
        if(iter!=type.end())
            cout << "("<<iter->second <<","<<ite->second<<")" << endl;
        else
            cout << "("<<type.size() <<","<<ite->second<<")" << endl;
    }
    cout << "\n==================" << "常数表" << "==================" << endl;
//    cout << "常量值\t\t类别编码\t表中位置" << endl;
    for (ite = Digit.begin(); ite != Digit.end(); ite++)
    {
//        cout << "("<<ite->first <<","<<ite->second<<")" << endl;
        map<string,int>::iterator iter;
        iter=type.find(ite->first);
//        if(iter!=type.end())
//            cout << "("<<iter->second <<","<<ite->second<<")" << endl;
//        else
        cout << "("<<type.size()-1 <<","<<ite->second<<")" << endl;
    }
    cout << "\n==================" << "算符、界符" << "==================" << endl;
    for (ite = other.begin(); ite != other.end(); ite++)
    {
//        cout << "("<<ite->first <<","<<ite->second<<")" << endl;
        map<string,int>::iterator iter;
        iter=type.find(ite->first);
        cout << "("<<iter->second <<","<<ite->second<<")" << endl;
//           cout<<iter->second<<endl;
    }
}
int main()
{
//    clock_t start,finish;
//    double totaltime;
//    start=clock();


    type["begin"]=type.size();
    type["end"]=type.size();
    type["if"]=type.size();
    type["then"]=type.size();
    type["while"]=type.size();
    type["do"]=type.size();
    type["const"]=type.size();
    type["var"]=type.size();
    type["call"]=type.size();
    type["procedure"]=type.size();
    type["+"]=type.size();
    type["-"]=type.size();
    type["*"]=type.size();
    type["/"]=type.size();
    type["odd"]=type.size();
    type["="]=type.size();
    type["<>"]=type.size();
    type["<"]=type.size();
    type[">"]=type.size();
    type["<="]=type.size();
    type[">="]=type.size();
    type[":="]=type.size();
    type["("]=type.size();
    type[")"]=type.size();
    type[","]=type.size();
    type["."]=type.size();
    type[";"]=type.size();
    type["常数"]=type.size();
    type["标识符"]=type.size();



//    init_Reserve();//保留字表初始化
    Symbol.clear();//标识符集初始化
    Digit.clear();//常数集初始化
    index = 0;
    character = ' ';
    token = "";
    cout << "请输入待词法分析的源程序代码：输入文件结束符结束输入\n" << endl;
    //源程序代码输入处理
//    instr="var a,b,c; a:=1; b:=2; c:=a+b";


    char ch[1000];
    string ins;
//    printf("%d\n",gets(ch));
//    printf("\n%d",&ch[1]);
//    cout<<gets(ch)<<endl;
    while(gets(ch))
    {
        FILE *fp;
//        char str[1000];
        map<string,int>::iterator iter;
        if((fp=fopen("d.txt","w"))==NULL)
        {
            printf("error occur!\n");
            exit(1);
        }
        if((fp=fopen("d.txt","a"))==NULL)
        {
            printf("error occur!\n");
            exit(1);
        }

//        ins=ch;


        instr=ch;
        index=0;
        while (index < instr.size())
        {
            char* str=(char*)LexAnalyze().data();
//                    fprintf(fp,"%s\n",str);
//            cout<<str<<endl;
            if(strcmp(str,"#")==0)
            {
//                printf("*");
                fprintf(fp,"%s",str);
            }
            else
            {
                iter=type.find(str);
                if(iter!=type.end())

//                if(index==instr.size())
                    fprintf(fp,"(%d,%s)\n",iter->second,str);
//                else
//                    fprintf(fp,"(%d,%s)\n",iter->second,str);
                else
                {
                    iter=Digit.find(str);
                    if(iter!=Digit.end())

//                if(index==instr.size())
                        fprintf(fp,"(28,%s)\n",str);
//                else
//                    fprintf(fp,"(28,%s)\n",str);


                }
            }
        }

        fclose(fp);


//        cout<<instr<<endl;
        memset(ch,0,sizeof(ch));
    }
    yufafenxi();

//    cout<<instr<<endl;
//    string in;
//    while (cin >> in&&in != "@")
//    {
//        instr = instr + " " + in;
//    }
    //识别二元组初始化
//    while (index < instr.size())
//    {
//        LexAnalyze();
//    }
    //展示构造的各种词汇表
    show_table();

//    finish=clock();
//    totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
//    cout<<totaltime<<endl;
//    //system("pause");
    return 0;

}

 

 

词法分析得到的结果存放在同级目录  d.txt 中。 

 

 

 

程序：

//#include<bits/stdc++.h>
#include <fstream>
#include <iostream>
#include <map>
#include <algorithm>
#include <string>
#include<string.h>
#include<stdio.h>
#include<time.h>
#include<sstream>

using namespace std;

template <class Type> Type stringToNum(const string& str)
{
    istringstream iss(str);
    Type num;
    iss >> num;
    return num;
}

int num=0;
int sum=0;

ifstream infile("d.txt");//词法分析的结果或语法分析的输入
string str;//string变量进行字符识别
string sym; //指针
string sym1;
int temp=0;

//int expressionAnalysis();//表达式分析
//int termAnaysis();//项分析
//int factorAnalysis();//因子分析
//int advance();
int E();
int E_plus();
int T();
int T_plus();
int F();


int conterr=0;//记录错误
int lpnum=0;//记录左括号
int found;//提取字符串中指针的位置
string sym2;
int found1;
int flag=0;//记录往后移动一个指针SYM是否正确
string s;//用来保存要分析的字符串
struct _2tup
{
    string token;
    int id;
};

int advance() //SYM的移动
{
    if(!getline(infile,str)) //从文件中提取字符
    {
        return 0;
    }
//    cout<<str<<endl;
    s+=str;
//    cout<<s<<endl;
    found=str.find(',',0);
    found1=str.find(')',0);
//    cout<<found1<<endl;

    if(found==-1) //当为error的时候，没有‘，’
    {
        conterr++;
        return 0;
//        cout<<"语法错误 识别字符错误"<<endl;
//        return -1;
    }
    if(temp==1)
        sym1=sym;
    sym=str.substr(1,found-1);
    sym2=str.substr(found+1,found1-found-1);

    num=stringToNum<int>(sym2);
//    cout<<num<<endl;

    return 1;
}

int F()
{
    if(sym=="28")
    {
        advance();
    }
    else
    {
        if(sym=="23")
        {
            advance();
            E();
            if(sym=="24")
            {
                advance();
            }
            else
            {
                printf("Error!\n");
                exit(1);
            }
        }
        else
        {
            printf("Error!\n");
            exit(1);
        }

    }
    return 0;

}
int T_plus()
{
    if(sym=="13" || sym=="14") // 如果是 *  /
    {
        advance();
        T();
        E_plus();
    }
}
int T()
{

   F();
   T_plus();

}

int E_plus()
{
    if(sym=="11" || sym=="12")  // 如果是+ 或者 -
    {
        advance();
        T();
        E_plus();
    }
}



int E()
{

    T();
    E_plus();

}
void yufafenxi()//语法分析
{
//    freopen("CON", "w", stdout);//结果在控制台上输出
//    flag=advance();
//    if(flag)-
//    {
    advance();
    E();
//    advance();
    if(strcmp(str.data(),"#")!=0)
    {
        printf("%s\n",s.data());
        printf("Error\n");
    }
    else
    {
        cout<<"OK:   "<<s<<endl;
    }
//    }
//    if(flag!=-1 && !conterr)
//    {
//    cout<<"正确："<<s<<endl;
//    }

}



string instr;//输入符号串
int index;//当前输入符号读入字符的位置
char character;//全局变量字符，存放最新读入的字符
string token;//字符数组，存放已读入的字符序列
map<string, int> Symbol;//标识符集
map<string, int> Digit;//常数集
map<string, int> other;//other
map<string, int>::iterator ite;
const int len = 100;
string Reserve[len];//保留字表
map<string,int> type;
//void init_Reserve()  //构造保留字表的函数
//{
//    Reserve[1] = "begin";
//    Reserve[2] = "end";
//    Reserve[3] = "if";
//    Reserve[4] = "then";
//    Reserve[5] = "while";
//    Reserve[6] = "do";
//    Reserve[7] = "const";
//    Reserve[8] = "var";
//    Reserve[9] = "call";
//    Reserve[10] = "procedure";
//
//}
void getChar()  //读入一个字符
{
    character = instr[index++];
}
void getnbc()  //读入非空白字符
{
    while (character == ' ')
    {
        getChar();
    }
}
void concat()  //连接字符串
{
    token = token + character;
}
bool letter()  //判断是否为字母
{
    if ((character >= 'A'&&character <= 'Z') || (character >= 'a'&&character <= 'z'))
        return true;
    return false;
}
bool digit()  //判断是否为数字
{
    if (character >= '0'&&character <= '9')
        return true;
    return false;
}
void retract() //回退字符的函数
{
//    character = ' ';
    index--;
}
int reserve()  //匹配保留字符
{
    for (int i = 0; i < len; i++)
        if (Reserve[i] == token)
            return i;
    return -1;
}
void symbol()
{
    ite = Symbol.find(token);
    if (ite != Symbol.end())
    {
//        return ite->first;
        return ;
    }
    else
    {
        Symbol[token] = Symbol.size();
        return ;
//        return token;
    }
}
void constant()
{
    ite = Digit.find(token);
    if (ite != Digit.end())
    {
//        return ite->first;
        return ;
    }
    else
    {
        Digit[token] = Digit.size();
        return ;
//        return token;

    }
}
void Three()
{
    ite = other.find(token);
    if (ite != other.end())
    {
        return ;
//        return ite->first;
    }
    else
    {
        other[token] = other.size();
        return ;
//        return token;
    }
}
void error()
{
    cout << token << "\t-->\t该单词不存在" << endl;
}
//词法分析函数，逐个识别单词
string LexAnalyze()
{
    token = "";
    getChar();
    getnbc();
    string val;
//    int num = -1;
    if(character>='a'&&character<='z' || character>='A'&&character<='Z')
    {
        while (letter() || digit())  //为字母或数字
        {
            concat();//追加到token末尾

//            if(token=="odd")
//            {
//                getChar();
//                Three();
//                return ;
//            }
            getChar();//读取下一个字符
        }
        if(token=="odd")
        {
            getChar();
            Three();
            return 0;
        }
        retract();//回退一个字符
        {
//            val = symbol();//查看标识符表
            symbol();

        }
    }
    else if(character>='0' && character<='9')
    {
        int flag=0;
        while (character>='0' && character<='9' || character>='a' && character<='z' || character>='A' && character <='Z')
        {
            if(character>='0' && character<='9')
                concat();

            if(character>='a' && character<='z' || character>='A' && character <='Z')
            {
                concat();
                flag=1;
            }
            getChar();
        }
        if(flag==1)
        {
            error();
            return 0;
        }
        retract();
//        val = constant();//查看常数表
        constant();

    }
    else if(character=='<')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();
//返回<=符号
        }
        else if(character=='>')
        {
            concat();
            Three();
        }
        else
        {
            retract();
            Three();
//返回<符号
        }
    }
    else if(character=='>')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();
//返回>=符号
        }
        else
        {
            retract();
            Three();
//返回>符号
        }
    }
    else if(character=='=')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();
//返回==符号
        }
        else
        {
            retract();
            Three();
//返回=符号
        }
    }

    else if(character==':')
    {
        concat();
        getChar();
        if (character == '=')
        {
            concat();
            Three();

        }
        else
        {
            cout<<token<<endl;
            error();
            return 0;
        }
    }

    else if(character=='+')
    {
        concat();
        Three();
    }


    else if(character=='-')
    {
        concat();
        Three();
    }

    else if(character=='*')
    {
        concat();
        Three();
    }


    else if(character=='/')
    {
        concat();
        Three();
    }


    else if(character=='(')
    {
        concat();
        Three();
    }

    else if(character==')')
    {
        concat();
        Three();
    }

    else if(character==',')
    {
        concat();
        Three();
    }

    else if(character=='.')
    {
        concat();
        Three();
    }

    else if(character==';')
    {
        concat();
        Three();
    }

    else if(character=='#')
    {
        concat();
        return token;
    }
    else
    {
        error();
        return 0;
    }

    return token;

}
void show_table()
{
    cout << "\n==================" << "标识符" << "==================" << endl;
//    cout << "标识符\t\t类别编码\t表中位置" << endl;
    for (ite=Symbol.begin(); ite != Symbol.end(); ite++)
    {
//        int flag=0;
//        for (int i = 0; i < len; i++)
//        {
//               cout<<Reserve[i]<<endl;
//            if (Reserve[i] == ite->first)
//            {
//                cout<<ite->first<<"是保留字"<<"   ";
//                cout << "("<<ite->first <<","<<ite->second<<")" << endl;
//                flag=1;
//                break;
//            }
//
//
//        }
//        if(flag==0)
//            cout << "("<<ite->first <<","<<ite->second<<")" << endl;

        map<string,int>::iterator iter;
        iter=type.find(ite->first);
        if(iter!=type.end())
            cout << "("<<iter->second <<","<<ite->second<<")" << endl;
        else
            cout << "("<<type.size() <<","<<ite->second<<")" << endl;
    }
    cout << "\n==================" << "常数表" << "==================" << endl;
//    cout << "常量值\t\t类别编码\t表中位置" << endl;
    for (ite = Digit.begin(); ite != Digit.end(); ite++)
    {
//        cout << "("<<ite->first <<","<<ite->second<<")" << endl;
        map<string,int>::iterator iter;
        iter=type.find(ite->first);
//        if(iter!=type.end())
//            cout << "("<<iter->second <<","<<ite->second<<")" << endl;
//        else
        cout << "("<<type.size()-1 <<","<<ite->second<<")" << endl;
    }
    cout << "\n==================" << "算符、界符" << "==================" << endl;
    for (ite = other.begin(); ite != other.end(); ite++)
    {
//        cout << "("<<ite->first <<","<<ite->second<<")" << endl;
        map<string,int>::iterator iter;
        iter=type.find(ite->first);
        cout << "("<<iter->second <<","<<ite->second<<")" << endl;
//           cout<<iter->second<<endl;
    }
}
int main()
{
//    clock_t start,finish;
//    double totaltime;
//    start=clock();


    type["begin"]=type.size();
    type["end"]=type.size();
    type["if"]=type.size();
    type["then"]=type.size();
    type["while"]=type.size();
    type["do"]=type.size();
    type["const"]=type.size();
    type["var"]=type.size();
    type["call"]=type.size();
    type["procedure"]=type.size();
    type["+"]=type.size();
    type["-"]=type.size();
    type["*"]=type.size();
    type["/"]=type.size();
    type["odd"]=type.size();
    type["="]=type.size();
    type["<>"]=type.size();
    type["<"]=type.size();
    type[">"]=type.size();
    type["<="]=type.size();
    type[">="]=type.size();
    type[":="]=type.size();
    type["("]=type.size();
    type[")"]=type.size();
    type[","]=type.size();
    type["."]=type.size();
    type[";"]=type.size();
    type["常数"]=type.size();
    type["标识符"]=type.size();



//    init_Reserve();//保留字表初始化
    Symbol.clear();//标识符集初始化
    Digit.clear();//常数集初始化
    index = 0;
    character = ' ';
    token = "";
    cout << "请输入待词法分析的源程序代码：输入文件结束符结束输入\n" << endl;
    //源程序代码输入处理
//    instr="var a,b,c; a:=1; b:=2; c:=a+b";


    char ch[1000];
    string ins;
//    printf("%d\n",gets(ch));
//    printf("\n%d",&ch[1]);
//    cout<<gets(ch)<<endl;
    while(gets(ch))
    {
        FILE *fp;
//        char str[1000];
        map<string,int>::iterator iter;
        if((fp=fopen("d.txt","w"))==NULL)
        {
            printf("error occur!\n");
            exit(1);
        }
        if((fp=fopen("d.txt","a"))==NULL)
        {
            printf("error occur!\n");
            exit(1);
        }

//        ins=ch;


        instr=ch;
        index=0;
        while (index < instr.size())
        {
            char* str=(char*)LexAnalyze().data();
//                    fprintf(fp,"%s\n",str);
//            cout<<str<<endl;
            if(strcmp(str,"#")==0)
            {
//                printf("*");
                fprintf(fp,"%s",str);
            }
            else
            {
                iter=type.find(str);
                if(iter!=type.end())

//                if(index==instr.size())
                    fprintf(fp,"(%d,%s)\n",iter->second,str);
//                else
//                    fprintf(fp,"(%d,%s)\n",iter->second,str);
                else
                {
                    iter=Digit.find(str);
                    if(iter!=Digit.end())

//                if(index==instr.size())
                        fprintf(fp,"(28,%s)\n",str);
//                else
//                    fprintf(fp,"(28,%s)\n",str);


                }
            }
        }

        fclose(fp);


//        cout<<instr<<endl;
        memset(ch,0,sizeof(ch));
    }
    yufafenxi();

//    cout<<instr<<endl;
//    string in;
//    while (cin >> in&&in != "@")
//    {
//        instr = instr + " " + in;
//    }
    //识别二元组初始化
//    while (index < instr.size())
//    {
//        LexAnalyze();
//    }
    //展示构造的各种词汇表
    show_table();

//    finish=clock();
//    totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
//    cout<<totaltime<<endl;
//    //system("pause");
    return 0;

}

 

 

要求实现以下效果：

 

 

 

程序猿的探索之路
关注
专栏目录
2023年09月CCF-GESP编程能力等级认证Python编程六级真题解析
人生就是一个不断学习的过程
02-02 279
近年来，线上授课变得普遍，很多有助于改善教学效果的设备也逐渐流行，其中包括比较常用的手写板，那么它属于哪类设备？（ ）A：输入B：输出C：控制D：记录。
神经网络 深度神经网络,主流的神经网络的框架
ynca67269的博客
08-20 2630
图：从具体特征到抽象特征逐级深入的多级神经网络6，RNN和神经图灵机如果时间序列数据里的模式也包含复杂的多层级结构，这里和我之前说的复杂系统往往由于反馈导致复杂的时间依赖是一致的，那么要挖掘这种系统里的模式，我们通常的工具就是超级前卫的循环神经网络RNN，这种工具对处理高维具有复杂反馈的系统有神效，因为它本身就是一个高维具有复杂时间反馈的动力学系统。然后要学会梳理自身学习情况，以课本为基础，结合自己做的笔记、试卷、掌握的薄弱环节、存在的问题等，合理的分配时间，有针对性、具体的去一点一点的去攻克、落实。
0916 编译原理第二次上机作业
weixin_30377461的博客
09-21 88
#include<stdio.h> #include<string.h> void Fenxi(char c,char b); void word(char a[]); void number(char a[]); int i; //定义全局变量i int s=1; //用来记录是否存在非法字符 main(){ char a[50]; ...
编译原理第二次试验
weixin_30814329的博客
09-21 137
#include<stdio.h> #include<string.h> void Fenxi(char c,char b); void word(char a[]); void number(char a[]); int i; int s=1; main(){ char a[100]; printf("请输入源程序:"); gets(a)...
编译原理 实验2
大锤
07-14 1595
写在前面 纯粹，为了记录. 以后某一天，回过头来看看.给大学留些痕迹hh. PS:很多思路也都是学习前辈们的，如果能顺便帮到你，不客气！ 内容 编译原理 实验2 通过编制调试一个具体的词法分析程序，加深对词法分析原理的理解。并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。 本实验以用户指定的想编译的以C语言编写的文件作为词法分析程序的输入数据。 在进行词法分析中，先自文件头开始以行为单位扫描程序，将该行的字符读入预先设定的一个数组缓冲区中，然后对该数组的字符逐词分割，进行词法分析
编译原理实验二分析
一窍不通只会复制粘贴的Java工程师
01-18 3051
对于 编译原理实验二 实验二主要分析实验一中的得到的多元式是进行计算器的语义分析 需要从实验1中获取分析成功的多元（种别码，字符串原貌，Value属性，Type属性）式序列 根据多元式中的Type属性获取类型（int、double、运算符等）然后逐步分析所有的多元式，是否符合语义 如果符合则分析下一个，如果不符合，则跳出 如：2+4.2*（5+6） 编写代码控制台将依次输出一下信息 ...
编译原理之词法分析和语法分析
tasty
09-08 2022
花了一天写出的程序没有顾及很多层面，但对于理解基本的实验道理和交上实验还是有点帮助的。代码实现了基于有限自动机的词法分析，采用递归下降分析法和EBNF文法实现语法分析并生成中间代码。from sdu lexAnalysis.h [cpp] view plain copy /*  * lexAnalysis.h  *  *  Created on: 2
Java_se基础毕向东老师全程笔记
10-09
### 第二章：数组 - **定义**：一组有序元素的集合。 - **初始化**：创建数组并为元素赋值。 - **访问**：通过索引访问数组元素。 - **遍历**：使用循环结构遍历数组。 ### 第三章：面向对象程序开发 - **封装**：...
MySQL、JDBC、HTML、CSS、JavaScript、jQuery、tomcat、Http、Servlet、JSP、EL、JSTL、Maven、Cookie、Session（框架第一部分）
wrh0740的博客
07-10 5063
第一章 MySQL 1. 数据库 1、什么是数据库？ 所谓的数据库就是指存储和管理数据的仓库 2、数据库有哪些分类？ 3、什么是关系型数据库？ 底层以二维表的形式保存数据的库就是关系型数据库 stu-学生表 4、常见的关系型数据库有哪些？ Sql Server：微软提供，收费，适用于一些中型或大型的项目中，在java中的使用占比不高（.NET中使用的较多） Oracle：甲骨文公司提供，收费，适用于一些大型或者超大型的项目中，在java中的使用占比非常高 mysql：瑞典MySQLAB公司提
21天学通python-21天学通Python（第2版）_PDF电子书
q6q6q的专栏
10-28 2498
因资源下载地址容易失效，请加微信号359049049直接领取，直接发最新下载地址。前言=============================================================="21 天学编程系列”自2009 年1 月上市以来一直受到广大读者的青睐。该系列中的大部分图书从一上市就登上了编程类图书销售排行榜的前列，很多大、中专院校也将该系列中的一些图书作为...
编译原理实验一【词法分析程序设计】
今天你AC了吗
12-30 4843
基本要求： ①掌握程序语言的词法结构。 ②掌握状态转换图的使用。 ③掌握设计词法分析程序的一般方法。 ④学会熟练调式程序。 重点及难点：掌握用状态转换图描述程序词法结构的一般方法，并在此基础上完成简版C语言子集词法分析程序的设计和调试运行。 一、 C语言子集的单词符号表示 一个非常重要的事实是：大多数程序语言的单词符号都可以用状态转换图予以识别。作为本次实验，我们来构造一个C语言子集的简单词法分析器。下表列出了这个C语言子集的所有单词符号以及它们的种别编码和内码值。由于直接使用整数编码不利于记忆，故该程序中
【编译原理】【C语言】实验一：手动构造词法分析器
zoxiii的博客
01-11 1万+
词法分析器 1、实验内容 2、前期准备 2.1 待分析的C语言子集的词法 2.2 C语言子集的单词符号表示表 2.3 C语言子集对应的状态转换图 3、分析过程 3.1 词法分析子程序 3.2 主程序 3.3 源代码 4、测试 5、遇到的问题
[编译原理]词法分析器的分析与实现
童凌的技术博客
06-16 5万+
词法分析概述：编译程序要对高级语言编写的源程序进行分析和合成，生成目标程序。词法分析是对源程序进行的首次分析，实现词法分析的程序成为词法分析程序(或词法分析器)，也称扫描器。 像用自然语言书写的文章一样，源程序是由一系列的句子组成的，句子是由单词符号按一定的规则构成的，而单词符号又是由字符按照一定的规则构成。因此，源程序实际上是由满足程序语言规范发字符按照一定的规则组合起来构成的一个字符串。 词法
编译原理（三、词法分析）
jerryzhou的博客
04-13 4425
编译程序是在单词的级别上来分析和翻译源程序的。词法分析的任务是：从左至右逐个字符串地对源程序进行扫描，产生一个个的单词符号，把作为字符串的源程序改造成为单词符号串的中间程序。 词法分析器的功能是输入源程序，输出单词符号。单词符号是一个程序语言的基本语法符号。程序语言的单词符号一般可分为下列五种。 （1）关键字是由程序语言定义的具有固定意义的标识符。有时称这些标识符为保留字或基本字。 ...
编译原理基本概念和术语
肉丸不肉
03-26 7583
一、字母表（有穷符号集合） 1.1 字母表定义 字母表也即符号集，用∑表示，它是一个包含各种符号的有穷非空集合。 以汉语为例，汉语字母表就是各种汉字、数字、标点符号的集合；以英语为例，英语字母表就是各种字母、数字、标点符号的集合…那么到了编程，字母表就可能是字母、数字、各种专用符号和保留字了。 1.2 字母表上的运算： 乘积 n次幂 正闭包 克林闭包 二、符号串/串 2.1 符号串相关...
编译原理学习总结
m0_49359388的博客
06-12 2986
大三下学的《编译原理》，包括词法分析（递归下降子程序，预测分析LL(1)）、语法分析（自上而下分析法，自下而上分析法），中间代码产生（三元式、四元式等），优化
map常用用法详解
热门推荐
ZMST的博客
08-24 6万+
map翻译为映射，也是常见的STL容器 在定义数组时（如int array[100]），其实是定义了一个从int型到int型的映射 比如array[0]=25、array[4]=36就分别是将0映射到25、将4映射到36 一个double型数组则是将int型映射到double型， 如db[0]=3.14,double[1]=0.01 但是，无论是什么类型 它总是将int型映射到其他类型...
map＜string，int＞
It is me 的博客
12-11 4153
#include <map> #include <string> #include <iostream> using namespace std; int main() { map<string, string> strings; strings["key"] = 88; // surprisingly compiles //map<string, string>::mapped_type s = 88; /...
东北大学编译原理实验2：表达式语法分析器设计与实现
在东北大学编译原理实验2中，学生们需要进行语法分析的学习和实践。本次实验的目标是设计并实现一个表达式的语法分析器，旨在让学生们熟悉语法分析的基本原理和过程。实验内容主要包括以下几个方面： 1. 实验目的：...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序猿的探索之路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值