编译原理之基于扫描器的表达式语法分析+逆波兰表达式生成

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

模拟法

Preset.h

#ifndef PRESET_H_INCLUDED
#define PRESET_H_INCLUDED

#define AnsNum 100010
#define AnsLen 110
#define TableNum 110
#define DeliNum 12
#define KeyNum 7

int consttop=0;
int identtop=0;
int cconsttop=0;
int sconsttop=0;
int top;

const int DelimeterNum=22;
const int Keynum=9;

//界符表
char Delimeters[TableNum][TableNum]={"(",")","<<","{","}",";","=","+","-","*","_","[","]",".","==","<=","<",">",">=",",","/","\""}; //i+4
//关键字表
char Key[TableNum][TableNum]={"int", "main", "void", "if", "else", "char", "cout","double","float"};    //i+26
//字符常数表
char Char_Constant[TableNum];
//字符串常数表
char String_Constant[TableNum][TableNum];
//常数表
char Constant[TableNum][TableNum];
//符号表总表(SYNBL)
char Identifier[TableNum][TableNum];

std::string Str;
int Syntax_top;

void Handle();
void HandleE();
void HandleA();
void HandleT();
void HandleB();
void HandleF();

int Syn_top;
int Sem_top;
char SYN[TableNum][TableNum];
char SEM[TableNum][TableNum];

#endif // PRESET_H_INCLUDED

main.c

#include <iostream>
#include <cstring>
#include <windows.h>
#include <cstdio>
#include "Preset.h"

using namespace std;

typedef struct token
{
    char target[AnsLen];
    int num;    //Token类别 Identifier——0 Char_Constant——1 String_Constant——2 Constant——3 Key——4...25 Delimeters——26...34
}Token;

Token AnsToken[AnsNum];

int main()
{
    top=0;
    char TempToken[AnsNum];
    int TempTop=0;
    bool quotation=false;

    freopen("input.c","r",stdin);
    freopen("output.c","w",stdout);

    while(cin >> Str)   //输入源代码
    {
        if(Str[0]=='#')break;
        for(int p=0;Str[p]!='#';)
        {
            if(Str[p]==' ')
            {
                p++;
                continue;
            }
            //判断标识符
            else if(Str[p]=='_' || isalpha(Str[p]))
            {
                for(;Str[p]!=0 && Str[p]!=' ';p++)  //结束标志-1即为0或者' '
                {
                    if(Str[p]=='_' || isalpha(Str[p]) || isdigit(Str[p]))
                    {
                        TempToken[TempTop++]=Str[p];
                    }
                    else
                    {
                        break;
                    }
                }
                //给AnsToken.target赋值
                strcpy(AnsToken[top].target,TempToken);
                //查找关键字
                for(int i=0;i<Keynum;i++)
                {
                    if(!strcmp(TempToken,Key[i]))
                    {
                        //给AnsToken.num赋值
                        AnsToken[top].num=i+26;
                        break;
                    }
                }
                //如果不是关键字,查找标识符表
                if(AnsToken[top].num<26)
                {
                    AnsToken[top].num=26;//标识符为0
                    for(int i=0;i<identtop;i++)
                    {
                        if(!strcmp(TempToken,Identifier[i]))
                        {
                            //给AnsToken.num赋值
                            AnsToken[top].num=0;
                            break;
                        }
                    }
                    if(AnsToken[top].num)
                    {
                        AnsToken[top].num=0;
                        strcpy(Identifier[identtop++],TempToken);
                    }
                }
                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                top++;
            }
            else if(isdigit(Str[p]))    //只能识别常数
            {
                bool Point=false;
                for(;Str[p]!=0 && Str[p]!=' ';p++)  //结束标志-1即为0或者' '
                {
                    if(isdigit(Str[p]))
                    {
                        TempToken[TempTop++]=Str[p];
                    }
                    else if(Str[p]=='.')
                    {
                        if(!Point)
                        {
                            TempToken[TempTop++]=Str[p];
                            Point=true;
                        }
                        else
                        {
                            putchar(7);
                            cout << "Compile Error!!!!!" << endl;
                            cout << "Wrong number." << endl;
                            exit(0xffffffff);
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                //给AnsToken.target赋值
                strcpy(AnsToken[top].target,TempToken);
                //查找常数表
                for(int i=0;i<identtop;i++)
                {
                    if(!strcmp(TempToken,Constant[i]))
                    {
                        //给AnsToken.num赋值
                        AnsToken[top].num=3;
                        break;
                    }
                }
                if(AnsToken[top].num!=3)
                {
                    AnsToken[top].num=3;
                    strcpy(Constant[consttop++],TempToken);
                }
                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                top++;
            }
            else if(Str[p]==' ')
            {
                p++;
            }
            else if(Str[p]=='\'')
            {
                quotation=!quotation;
                TempToken[TempTop]=Str[p];
                strcpy(AnsToken[top].target,TempToken);
                AnsToken[top++].num=24;

                TempToken[TempTop]=Str[++p];
                strcpy(AnsToken[top].target,TempToken);
                for(int i=0;i<cconsttop;i++)
                {
                    if(TempToken[0]==Char_Constant[i])
                    {
                        AnsToken[top].num=1;
                    }
                }
                if(AnsToken[top].num!=1)
                {
                    AnsToken[top].num=1;
                    Char_Constant[cconsttop++]=TempToken[0];
                }
                top++;

                if(Str[p+1]!='\'')
                {
                    putchar(7);
                    cout << "Compile Error!!!!!" << endl;
                    cout << "Wrong Character." << endl;
                    exit(0xffffffff);
                }
                else
                {
                    p++;
                    quotation=!quotation;
                    TempToken[TempTop]=Str[p];
                    strcpy(AnsToken[top].target,TempToken);
                    AnsToken[top++].num=24;
                    TempToken[0]=0;
                    p++;
                }
            }
            else if(Str[p]=='\"')
            {
                quotation=!quotation;
                TempToken[TempTop]=Str[p];
                strcpy(AnsToken[top].target,TempToken);
                AnsToken[top++].num=25;
                p++;

                //识别字符串常量
                while(Str[p]!='\"')
                {
                    if(Str[p]=='#')
                    {
                        putchar(7);
                        cout << "Compile Error!!!!!" << endl;
                        cout << "Wrong Character." << endl;
                        exit(0xffffffff);
                    }
                    TempToken[TempTop++]=Str[p];
                    p++;
                }

                strcpy(AnsToken[top].target,TempToken);
                for(int i=0;i<sconsttop;i++)
                {
                    if(strcmp(!TempToken,String_Constant[i]))
                    {
                        AnsToken[top].num=2;
                    }
                }
                if(AnsToken[top].num!=2)
                {
                    AnsToken[top].num=2;
                    strcpy(String_Constant[sconsttop++],TempToken);
                }
                top++;

                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));

                quotation=!quotation;
                TempToken[TempTop]=Str[p];
                strcpy(AnsToken[top].target,TempToken);
                AnsToken[top++].num=25;
                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                p++;
            }
            else if((Str[p]=='<' && (Str[p+1]=='<' || Str[p+1]=='=')) || ((Str[p]=='>' || Str[p]=='=') && Str[p+1]=='='))
            {
                TempToken[0]=Str[p++];
                TempToken[1]=Str[p++];
                TempToken[2]=0;

                //给AnsToken.target赋值
                strcpy(AnsToken[top].target,TempToken);
                //查找界符表
                for(int i=0;i<DelimeterNum;i++)
                {
                    if(!strcmp(TempToken,Delimeters[i]))
                    {
                        //给AnsToken.num赋值
                        AnsToken[top].num=i+4;
                        break;
                    }
                }

                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                top++;
            }
            else
            {
                //识别单目运算符
                if(Str[p]!=0 && Str[p]!=' ' && !isalpha(Str[p]) && !isdigit(Str[p]) && Str[p]!='_' && Str[p]!='#')  //结束标志-1即为0或者' '
                {
                    TempToken[TempTop++]=Str[p++];
                }
                else
                {
                   break;
                }
                TempToken[TempTop]=0;
                for(int j=0;j<DelimeterNum;j++)
                {
                    if(!strcmp(TempToken,Delimeters[j]))
                    {
                        strcpy(AnsToken[top].target,TempToken);
                        AnsToken[top++].num=j+4;
                        break;
                    }
                }
                TempTop=0;
            }
        }
    }
    AnsToken[top].target[0]='#';
    AnsToken[top++].num=-1;
    for(int i=0;i<top;i++)
        cout << "< " << AnsToken[i].target << " , " << AnsToken[i].num << " >" << endl;
    Handle();
    return 0;
}

void Handle()
{
    Syntax_top=0;
    HandleE();
    cout << endl;
    if(AnsToken[Syntax_top].target[0]=='#')
    {
        cout << "Yes" << endl;
        Syn_top=-1;
        Sem_top=-1;
        strcpy(SYN[++Syn_top],"#");
        for(int i=0;i<top;i++)
        {
            int flag=0;
            switch(SYN[Syn_top][0])
            {
            case '#':
                if(AnsToken[i].target[0]=='#')
                {
                    flag=1;
                }
                else if(AnsToken[i].target[0]=='+' || AnsToken[i].target[0]=='-' || AnsToken[i].target[0]=='*' || AnsToken[i].target[0]=='/')
                {
                    strcpy(SYN[++Syn_top],AnsToken[i].target);
                }
                else
                {
                    strcpy(SEM[++Sem_top],AnsToken[i].target);
                }
                break;
            case '+':
            case '-':
                if(AnsToken[i].target[0]=='#' || AnsToken[i].target[0]==')' || AnsToken[i].target[0]=='+' || AnsToken[i].target[0]=='-')
                {
                    strcpy(SEM[++Sem_top],SYN[Syn_top--]);
                    i--;
                }
                else if(AnsToken[i].target[0]=='(' || AnsToken[i].target[0]=='*' || AnsToken[i].target[0]=='/')
                {
                    strcpy(SYN[++Syn_top],AnsToken[i].target);
                }
                else
                {
                    strcpy(SEM[++Sem_top],AnsToken[i].target);
                }
                break;
            case '*':
            case '/':
                if(AnsToken[i].target[0]=='#' || AnsToken[i].target[0]==')' || AnsToken[i].target[0]=='+' || AnsToken[i].target[0]=='-' || AnsToken[i].target[0]=='*' || AnsToken[i].target[0]=='/')
                {
                    strcpy(SEM[++Sem_top],SYN[Syn_top--]);
                    i--;
                }
                else if(AnsToken[i].target[0]=='(')
                {
                    strcpy(SYN[++Syn_top],AnsToken[i].target);
                }

                else
                {
                    strcpy(SEM[++Sem_top],AnsToken[i].target);
                }
                break;
            case '(':
                if(AnsToken[i].target[0]=='+' || AnsToken[i].target[0]=='-' || AnsToken[i].target[0]=='*' || AnsToken[i].target[0]=='/')
                {
                    strcpy(SYN[++Syn_top],AnsToken[i].target);
                }
                else if(AnsToken[i].target[0]==')')
                {
                    Syn_top--;
                }
                else
                {
                    strcpy(SEM[++Sem_top],AnsToken[i].target);
                }
                break;
            }
        }
        for(int i=0;i<=Sem_top;i++)
            cout << SEM[i] << '\t';
    }
    else cout << "No" << endl;
}

void HandleE()
{
    HandleT();
    HandleA();
}

void HandleA()
{
    if(AnsToken[Syntax_top].target[0]=='+' || AnsToken[Syntax_top].target[0]=='-')
    {
        Syntax_top++;
        HandleT();
        HandleA();
    }
}

void HandleT()
{
    HandleF();
    HandleB();
}

void HandleB()
{
    if(AnsToken[Syntax_top].target[0]=='*' || AnsToken[Syntax_top].target[0]=='/')
    {
        Syntax_top++;
        HandleF();
        HandleB();
    }
}

void HandleF()
{
    if(AnsToken[Syntax_top].num==0 || AnsToken[Syntax_top].num==3)
    {
        Syntax_top++;
    }
    else if(AnsToken[Syntax_top].target[0]=='(')
    {
        Syntax_top++;
        HandleE();
        if(AnsToken[Syntax_top].target[0]==')')
        {
            Syntax_top++;
        }
    }
}

翻译文法法

文法1

Preset.h

#ifndef PRESET_H_INCLUDED
#define PRESET_H_INCLUDED

#define AnsNum 100010
#define AnsLen 110
#define TableNum 110
#define DeliNum 12
#define KeyNum 7

int consttop=0;
int identtop=0;
int cconsttop=0;
int sconsttop=0;
int top;

const int DelimeterNum=22;
const int Keynum=9;

//界符表
char Delimeters[TableNum][TableNum]={"(",")","<<","{","}",";","=","+","-","*","_","[","]",".","==","<=","<",">",">=",",","/","\""}; //i+4
//关键字表
char Key[TableNum][TableNum]={"int", "main", "void", "if", "else", "char", "cout","double","float"};    //i+26
//字符常数表
char Char_Constant[TableNum];
//字符串常数表
char String_Constant[TableNum][TableNum];
//常数表
char Constant[TableNum][TableNum];
//符号表总表(SYNBL)
char Identifier[TableNum][TableNum];

std::string Str;
int Syntax_top;

void Handle();
void HandleE();
void HandleT();
void HandleF();


#endif // PRESET_H_INCLUDED

main.c

#include <iostream>
#include <cstring>
#include <windows.h>
#include <cstdio>
#include "Preset.h"

using namespace std;

typedef struct token
{
    char target[AnsLen];
    int num;    //Token类别 Identifier——0 Char_Constant——1 String_Constant——2 Constant——3 Key——4...25 Delimeters——26...34
}Token;

Token AnsToken[AnsNum];

int main()
{
    top=0;
    char TempToken[AnsNum];
    int TempTop=0;
    bool quotation=false;

    freopen("input.c","r",stdin);
    freopen("output.c","w",stdout);

    while(cin >> Str)   //输入源代码
    {
        if(Str[0]=='#')break;
        for(int p=0;Str[p]!='#';)
        {
            if(Str[p]==' ')
            {
                p++;
                continue;
            }
            //判断标识符
            else if(Str[p]=='_' || isalpha(Str[p]))
            {
                for(;Str[p]!=0 && Str[p]!=' ';p++)  //结束标志-1即为0或者' '
                {
                    if(Str[p]=='_' || isalpha(Str[p]) || isdigit(Str[p]))
                    {
                        TempToken[TempTop++]=Str[p];
                    }
                    else
                    {
                        break;
                    }
                }
                //给AnsToken.target赋值
                strcpy(AnsToken[top].target,TempToken);
                //查找关键字
                for(int i=0;i<Keynum;i++)
                {
                    if(!strcmp(TempToken,Key[i]))
                    {
                        //给AnsToken.num赋值
                        AnsToken[top].num=i+26;
                        break;
                    }
                }
                //如果不是关键字,查找标识符表
                if(AnsToken[top].num<26)
                {
                    AnsToken[top].num=26;//标识符为0
                    for(int i=0;i<identtop;i++)
                    {
                        if(!strcmp(TempToken,Identifier[i]))
                        {
                            //给AnsToken.num赋值
                            AnsToken[top].num=0;
                            break;
                        }
                    }
                    if(AnsToken[top].num)
                    {
                        AnsToken[top].num=0;
                        strcpy(Identifier[identtop++],TempToken);
                    }
                }
                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                top++;
            }
            else if(isdigit(Str[p]))    //只能识别常数
            {
                bool Point=false;
                for(;Str[p]!=0 && Str[p]!=' ';p++)  //结束标志-1即为0或者' '
                {
                    if(isdigit(Str[p]))
                    {
                        TempToken[TempTop++]=Str[p];
                    }
                    else if(Str[p]=='.')
                    {
                        if(!Point)
                        {
                            TempToken[TempTop++]=Str[p];
                            Point=true;
                        }
                        else
                        {
                            putchar(7);
                            cout << "Compile Error!!!!!" << endl;
                            cout << "Wrong number." << endl;
                            exit(0xffffffff);
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                //给AnsToken.target赋值
                strcpy(AnsToken[top].target,TempToken);
                //查找常数表
                for(int i=0;i<identtop;i++)
                {
                    if(!strcmp(TempToken,Constant[i]))
                    {
                        //给AnsToken.num赋值
                        AnsToken[top].num=3;
                        break;
                    }
                }
                if(AnsToken[top].num!=3)
                {
                    AnsToken[top].num=3;
                    strcpy(Constant[consttop++],TempToken);
                }
                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                top++;
            }
            else if(Str[p]==' ')
            {
                p++;
            }
            else if(Str[p]=='\'')
            {
                quotation=!quotation;
                TempToken[TempTop]=Str[p];
                strcpy(AnsToken[top].target,TempToken);
                AnsToken[top++].num=24;

                TempToken[TempTop]=Str[++p];
                strcpy(AnsToken[top].target,TempToken);
                for(int i=0;i<cconsttop;i++)
                {
                    if(TempToken[0]==Char_Constant[i])
                    {
                        AnsToken[top].num=1;
                    }
                }
                if(AnsToken[top].num!=1)
                {
                    AnsToken[top].num=1;
                    Char_Constant[cconsttop++]=TempToken[0];
                }
                top++;

                if(Str[p+1]!='\'')
                {
                    putchar(7);
                    cout << "Compile Error!!!!!" << endl;
                    cout << "Wrong Character." << endl;
                    exit(0xffffffff);
                }
                else
                {
                    p++;
                    quotation=!quotation;
                    TempToken[TempTop]=Str[p];
                    strcpy(AnsToken[top].target,TempToken);
                    AnsToken[top++].num=24;
                    TempToken[0]=0;
                    p++;
                }
            }
            else if(Str[p]=='\"')
            {
                quotation=!quotation;
                TempToken[TempTop]=Str[p];
                strcpy(AnsToken[top].target,TempToken);
                AnsToken[top++].num=25;
                p++;

                //识别字符串常量
                while(Str[p]!='\"')
                {
                    if(Str[p]=='#')
                    {
                        putchar(7);
                        cout << "Compile Error!!!!!" << endl;
                        cout << "Wrong Character." << endl;
                        exit(0xffffffff);
                    }
                    TempToken[TempTop++]=Str[p];
                    p++;
                }

                strcpy(AnsToken[top].target,TempToken);
                for(int i=0;i<sconsttop;i++)
                {
                    if(strcmp(!TempToken,String_Constant[i]))
                    {
                        AnsToken[top].num=2;
                    }
                }
                if(AnsToken[top].num!=2)
                {
                    AnsToken[top].num=2;
                    strcpy(String_Constant[sconsttop++],TempToken);
                }
                top++;

                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));

                quotation=!quotation;
                TempToken[TempTop]=Str[p];
                strcpy(AnsToken[top].target,TempToken);
                AnsToken[top++].num=25;
                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                p++;
            }
            else if((Str[p]=='<' && (Str[p+1]=='<' || Str[p+1]=='=')) || ((Str[p]=='>' || Str[p]=='=') && Str[p+1]=='='))
            {
                TempToken[0]=Str[p++];
                TempToken[1]=Str[p++];
                TempToken[2]=0;

                //给AnsToken.target赋值
                strcpy(AnsToken[top].target,TempToken);
                //查找界符表
                for(int i=0;i<DelimeterNum;i++)
                {
                    if(!strcmp(TempToken,Delimeters[i]))
                    {
                        //给AnsToken.num赋值
                        AnsToken[top].num=i+4;
                        break;
                    }
                }

                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                top++;
            }
            else
            {
                //识别单目运算符
                if(Str[p]!=0 && Str[p]!=' ' && !isalpha(Str[p]) && !isdigit(Str[p]) && Str[p]!='_' && Str[p]!='#')  //结束标志-1即为0或者' '
                {
                    TempToken[TempTop++]=Str[p++];
                }
                else
                {
                   break;
                }
                TempToken[TempTop]=0;
                for(int j=0;j<DelimeterNum;j++)
                {
                    if(!strcmp(TempToken,Delimeters[j]))
                    {
                        strcpy(AnsToken[top].target,TempToken);
                        AnsToken[top++].num=j+4;
                        break;
                    }
                }
                TempTop=0;
            }
        }
    }
    AnsToken[top].target[0]='#';
    AnsToken[top++].num=-1;
    for(int i=0;i<top;i++)
        cout << "< " << AnsToken[i].target << " , " << AnsToken[i].num << " >" << endl;
    Handle();
    return 0;
}

void Handle()
{
    Syntax_top=0;
    HandleE();
    cout << endl;
    if(AnsToken[Syntax_top].target[0]=='#')
        cout << "Yes" << endl;
    else cout << "No" << endl;
}

void HandleE()
{
    HandleT();
    while(AnsToken[Syntax_top].target[0]=='+' || AnsToken[Syntax_top].target[0]=='-')
    {
        if(AnsToken[Syntax_top].target[0]=='+' )
        {
            Syntax_top++;
            HandleT();
            cout << '+' << '\t';
        }
        else if(AnsToken[Syntax_top].target[0]=='-')
        {
            Syntax_top++;
            HandleT();
            cout << '-' << '\t';
        }
    }
}


void HandleT()
{
    HandleF();
    while(AnsToken[Syntax_top].target[0]=='*' || AnsToken[Syntax_top].target[0]=='/')
    {
        if(AnsToken[Syntax_top].target[0]=='*' )
        {
            Syntax_top++;
            HandleT();
            cout << '*' << '\t';
        }
        else if(AnsToken[Syntax_top].target[0]=='/')
        {
            Syntax_top++;
            HandleT();
            cout << '/' << '\t';
        }
    }
}

void HandleF()
{
    if(AnsToken[Syntax_top].num==0 || AnsToken[Syntax_top].num==3)
    {
        cout << AnsToken[Syntax_top].target << '\t';
        Syntax_top++;
    }
    else if(AnsToken[Syntax_top].target[0]=='(')
    {
        Syntax_top++;
        HandleE();
        if(AnsToken[Syntax_top].target[0]==')')
            Syntax_top++;
    }
}

文法2

Preset.h

#ifndef PRESET_H_INCLUDED
#define PRESET_H_INCLUDED

#define AnsNum 100010
#define AnsLen 110
#define TableNum 110
#define DeliNum 12
#define KeyNum 7

int consttop=0;
int identtop=0;
int cconsttop=0;
int sconsttop=0;
int top;

const int DelimeterNum=22;
const int Keynum=9;

//界符表
char Delimeters[TableNum][TableNum]={"(",")","<<","{","}",";","=","+","-","*","_","[","]",".","==","<=","<",">",">=",",","/","\""}; //i+4
//关键字表
char Key[TableNum][TableNum]={"int", "main", "void", "if", "else", "char", "cout","double","float"};    //i+26
//字符常数表
char Char_Constant[TableNum];
//字符串常数表
char String_Constant[TableNum][TableNum];
//常数表
char Constant[TableNum][TableNum];
//符号表总表(SYNBL)
char Identifier[TableNum][TableNum];

std::string Str;
int Syntax_top;

void Handle();
void HandleE();
void HandleA();
void HandleT();
void HandleB();
void HandleF();

#endif // PRESET_H_INCLUDED

main.c

#include <iostream>
#include <cstring>
#include <windows.h>
#include <cstdio>
#include "Preset.h"

using namespace std;

typedef struct token
{
    char target[AnsLen];
    int num;    //Token类别 Identifier——0 Char_Constant——1 String_Constant——2 Constant——3 Key——4...25 Delimeters——26...34
}Token;

Token AnsToken[AnsNum];

int main()
{
    top=0;
    char TempToken[AnsNum];
    int TempTop=0;
    bool quotation=false;

    freopen("input.c","r",stdin);
    freopen("output.c","w",stdout);

    while(cin >> Str)   //输入源代码
    {
        if(Str[0]=='#')break;
        for(int p=0;Str[p]!='#';)
        {
            if(Str[p]==' ')
            {
                p++;
                continue;
            }
            //判断标识符
            else if(Str[p]=='_' || isalpha(Str[p]))
            {
                for(;Str[p]!=0 && Str[p]!=' ';p++)  //结束标志-1即为0或者' '
                {
                    if(Str[p]=='_' || isalpha(Str[p]) || isdigit(Str[p]))
                    {
                        TempToken[TempTop++]=Str[p];
                    }
                    else
                    {
                        break;
                    }
                }
                //给AnsToken.target赋值
                strcpy(AnsToken[top].target,TempToken);
                //查找关键字
                for(int i=0;i<Keynum;i++)
                {
                    if(!strcmp(TempToken,Key[i]))
                    {
                        //给AnsToken.num赋值
                        AnsToken[top].num=i+26;
                        break;
                    }
                }
                //如果不是关键字,查找标识符表
                if(AnsToken[top].num<26)
                {
                    AnsToken[top].num=26;//标识符为0
                    for(int i=0;i<identtop;i++)
                    {
                        if(!strcmp(TempToken,Identifier[i]))
                        {
                            //给AnsToken.num赋值
                            AnsToken[top].num=0;
                            break;
                        }
                    }
                    if(AnsToken[top].num)
                    {
                        AnsToken[top].num=0;
                        strcpy(Identifier[identtop++],TempToken);
                    }
                }
                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                top++;
            }
            else if(isdigit(Str[p]))    //只能识别常数
            {
                bool Point=false;
                for(;Str[p]!=0 && Str[p]!=' ';p++)  //结束标志-1即为0或者' '
                {
                    if(isdigit(Str[p]))
                    {
                        TempToken[TempTop++]=Str[p];
                    }
                    else if(Str[p]=='.')
                    {
                        if(!Point)
                        {
                            TempToken[TempTop++]=Str[p];
                            Point=true;
                        }
                        else
                        {
                            putchar(7);
                            cout << "Compile Error!!!!!" << endl;
                            cout << "Wrong number." << endl;
                            exit(0xffffffff);
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                //给AnsToken.target赋值
                strcpy(AnsToken[top].target,TempToken);
                //查找常数表
                for(int i=0;i<identtop;i++)
                {
                    if(!strcmp(TempToken,Constant[i]))
                    {
                        //给AnsToken.num赋值
                        AnsToken[top].num=3;
                        break;
                    }
                }
                if(AnsToken[top].num!=3)
                {
                    AnsToken[top].num=3;
                    strcpy(Constant[consttop++],TempToken);
                }
                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                top++;
            }
            else if(Str[p]==' ')
            {
                p++;
            }
            else if(Str[p]=='\'')
            {
                quotation=!quotation;
                TempToken[TempTop]=Str[p];
                strcpy(AnsToken[top].target,TempToken);
                AnsToken[top++].num=24;

                TempToken[TempTop]=Str[++p];
                strcpy(AnsToken[top].target,TempToken);
                for(int i=0;i<cconsttop;i++)
                {
                    if(TempToken[0]==Char_Constant[i])
                    {
                        AnsToken[top].num=1;
                    }
                }
                if(AnsToken[top].num!=1)
                {
                    AnsToken[top].num=1;
                    Char_Constant[cconsttop++]=TempToken[0];
                }
                top++;

                if(Str[p+1]!='\'')
                {
                    putchar(7);
                    cout << "Compile Error!!!!!" << endl;
                    cout << "Wrong Character." << endl;
                    exit(0xffffffff);
                }
                else
                {
                    p++;
                    quotation=!quotation;
                    TempToken[TempTop]=Str[p];
                    strcpy(AnsToken[top].target,TempToken);
                    AnsToken[top++].num=24;
                    TempToken[0]=0;
                    p++;
                }
            }
            else if(Str[p]=='\"')
            {
                quotation=!quotation;
                TempToken[TempTop]=Str[p];
                strcpy(AnsToken[top].target,TempToken);
                AnsToken[top++].num=25;
                p++;

                //识别字符串常量
                while(Str[p]!='\"')
                {
                    if(Str[p]=='#')
                    {
                        putchar(7);
                        cout << "Compile Error!!!!!" << endl;
                        cout << "Wrong Character." << endl;
                        exit(0xffffffff);
                    }
                    TempToken[TempTop++]=Str[p];
                    p++;
                }

                strcpy(AnsToken[top].target,TempToken);
                for(int i=0;i<sconsttop;i++)
                {
                    if(strcmp(!TempToken,String_Constant[i]))
                    {
                        AnsToken[top].num=2;
                    }
                }
                if(AnsToken[top].num!=2)
                {
                    AnsToken[top].num=2;
                    strcpy(String_Constant[sconsttop++],TempToken);
                }
                top++;

                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));

                quotation=!quotation;
                TempToken[TempTop]=Str[p];
                strcpy(AnsToken[top].target,TempToken);
                AnsToken[top++].num=25;
                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                p++;
            }
            else if((Str[p]=='<' && (Str[p+1]=='<' || Str[p+1]=='=')) || ((Str[p]=='>' || Str[p]=='=') && Str[p+1]=='='))
            {
                TempToken[0]=Str[p++];
                TempToken[1]=Str[p++];
                TempToken[2]=0;

                //给AnsToken.target赋值
                strcpy(AnsToken[top].target,TempToken);
                //查找界符表
                for(int i=0;i<DelimeterNum;i++)
                {
                    if(!strcmp(TempToken,Delimeters[i]))
                    {
                        //给AnsToken.num赋值
                        AnsToken[top].num=i+4;
                        break;
                    }
                }

                //清空TempToken
                TempTop=0;
                memset(TempToken,0,sizeof(TempToken));
                top++;
            }
            else
            {
                //识别单目运算符
                if(Str[p]!=0 && Str[p]!=' ' && !isalpha(Str[p]) && !isdigit(Str[p]) && Str[p]!='_' && Str[p]!='#')  //结束标志-1即为0或者' '
                {
                    TempToken[TempTop++]=Str[p++];
                }
                else
                {
                   break;
                }
                TempToken[TempTop]=0;
                for(int j=0;j<DelimeterNum;j++)
                {
                    if(!strcmp(TempToken,Delimeters[j]))
                    {
                        strcpy(AnsToken[top].target,TempToken);
                        AnsToken[top++].num=j+4;
                        break;
                    }
                }
                TempTop=0;
            }
        }
    }
    AnsToken[top].target[0]='#';
    AnsToken[top++].num=-1;
    for(int i=0;i<top;i++)
        cout << "< " << AnsToken[i].target << " , " << AnsToken[i].num << " >" << endl;
    Handle();
    return 0;
}

void Handle()
{
    Syntax_top=0;
    HandleE();
    cout << endl;
    if(AnsToken[Syntax_top].target[0]=='#')
        cout << "Yes" << endl;
    else 
        cout << "No" << endl;
}

void HandleE()
{
    HandleT();
    HandleA();
}

void HandleA()
{
    if(AnsToken[Syntax_top].target[0]=='+' || AnsToken[Syntax_top].target[0]=='-')
    {
        char temp=AnsToken[Syntax_top].target[0];
        Syntax_top++;
        HandleT();
        HandleA();
        cout << temp << '\t';
    }
}

void HandleT()
{
    HandleF();
    HandleB();
}

void HandleB()
{
    if(AnsToken[Syntax_top].target[0]=='*' || AnsToken[Syntax_top].target[0]=='/')
    {
        char temp=AnsToken[Syntax_top].target[0];
        Syntax_top++;
        HandleF();
        HandleB();
        cout << temp << '\t';
    }
}

void HandleF()
{
    if(AnsToken[Syntax_top].num==0 || AnsToken[Syntax_top].num==3)
    {
        cout << AnsToken[Syntax_top].target << '\t';
        Syntax_top++;
    }
    else if(AnsToken[Syntax_top].target[0]=='(')
    {
        Syntax_top++;
        HandleE();
        if(AnsToken[Syntax_top].target[0]==')')
        {
            Syntax_top++;
        }
    }
}
夜羽灵
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
中缀表达式转后缀表达式
Asia52的博客
08-22 385
1 . 初 始 化 俩 个 栈 ：运算符栈s1和储存中间结果栈； 2 . 从左到右依次扫描中缀表达式 3.遇到操作数时，将其压入s2 4）.遇到运算符时，比较其与s1栈顶运算符的优先级： 1.如果s1为空，或栈顶运算符’ ( ’ 直接将此运算符压入栈； 2.否则，如优先级比栈顶运算符的高，也将此运算符压入s1 3.否则，将s1栈顶的运算符弹出并压入s2中，再次转到(4.1)与s1中新的栈顶运...
编译原理(中间代码生成)-逆波兰表示(后缀表达式)
Cainell的博客
05-16 7653
1.需求 1、编制一个中间代码生成程序，能将算术表达式等翻译成逆波兰形式, 即从中缀表达式转换成后缀表达式； 2、程序具有通用性，即能接受各种不同的算术表达式等语法成分。 3、对于语法正确的算术表达式，能生成逆波兰表示，并输出结果； 1+2, 是中缀表达式. 后缀表达式即运算符在后面的表达式. 逆波兰表达式，它的语法规定，表达式必须以逆波兰表达式的方式给出。逆波兰表达式又叫做后缀表达式，下面是一些具体的例子： 正常的表达式 逆波兰表达式 a+b —> a,b,+ a+(b-c) —> a,b,c
逆波兰表达式
熙煦泽伯
07-04 158
逆波兰表达式 　　逆波兰表达式 rpn（Reverse Polish Notation） 　　逆波兰表达式，它的语法规定，表达式必须以逆波兰表达式的方式给出。逆波兰表达式又叫做后缀表达式。这个知识点在数据结构和编译原理这两门课程中都有介绍，下面是一些例子： 　　正常的表达式 逆波兰表达式 　　a+b ---> a,b,+ 　　a+(b-c) ---> a,b,c,-,+ 　　a+(b-...
波兰式与逆波兰式的转换和表达式求值
热门推荐
ityanger的技术栈
11-22 2万+
文章目录一、前言二、表达式1.中缀表达式1.1 定义2.前缀表达式2.1 定义2.2 求值3.后缀表达式3.1 定义3.2 求值三、表达式转换1.中缀表达式转换成后缀表达式1.1 算法1.2 例子2.中缀表达式转换成前缀表达式四、END 一、前言 逆波兰表示法（Reverse Polish notation，RPN，或逆波兰记法），是一种是由波兰数学家扬·武卡谢维奇1920年引入的数学表达式方式...
编译原理 —— 逆波兰式
starter_____的博客
05-12 6372
逆波兰式除去了原表达式中的括号，并将运算对象写在前面，运算符写在后面，因而又称为后缀式。用逆波兰式表示表达式的最大优点是易于计算处理。 逆波兰式只使用一个工作栈，当计算机自左向右顺序扫描逆波兰式时，若当前符号是运算对象则进栈，若当前符号是运算符，并且为K元运算符，则将栈顶的K个元素依次取出，同时进行K元运算，并将运算结果置于栈顶，表达式处理完毕时，其计算结果自然呈现在栈顶。 逆波兰式的定义 ...
编译原理 语法分析 语法树生成
12-30
压缩包中的“编译原理语法树”文件可能包含了使用yacc和lex构建的C++语法分析器的示例，以及它分析C++源代码后生成的语法树的可视化表示。通过查看这些示例，开发者可以更深入地理解编译器的工作原理，学习如何构建...
南华大学编译原理实验 词法分析器代码报告+语法分析器+期末复习PPT
05-10
词法分析，也称扫描器或词法生成器，是编译器的第一步。它的主要任务是识别源代码中的基本构成单元，即词素（tokens），这些词素包括保留字、标识符、常数、运算符和分隔符。在实验中，同学们需要选择一种特定的语言...
编译原理词法分析+语法分析课设
04-09
在编程领域，编译原理是理解计算机语言处理过程的关键部分，它涉及词法分析和语法分析等核心概念。本课设旨在让学生深入理解和实践这些概念。 词法分析，也称为扫描或分词，是编译器设计的第一步。在这个阶段，输入...
编译原理实验报告 表达式语法分析设计
06-23
在本实验报告中，我们关注的是“表达式语法分析设计”，这是编译原理的一个重要组成部分。实验目的是通过设计和实现一个表达式的语法分析器来熟悉这一过程。这涉及到形式语言的基础知识，包括文法运算，以及四种常见...
yufa.zip_C语言_编译原理作业_编译语法分析_语法分析_语法分析器
09-24
《C语言编译原理作业：深入理解语法分析与解析器》 在计算机科学领域，编译原理是理解和创建编译器的关键。C语言作为广泛使用的编程语言，其编译过程中的语法分析环节对于理解程序的结构和逻辑至关重要。本文将探讨...
编译原理实验 （计算器 语法树 逆波兰表达式）
07-02
实现了中缀式变后缀,语法树的生成,可以进行简单的计算
编译原理 逆波兰、三四元式转换
06-29
编写环境：VS2013 运算式可转换逆波兰式、三元式、四元式、汇编语句（简单运算）
编译原理-扫描器
12-12
(1) 设计扫描器的有限自动机（识别器）； (2) 设计翻译、生成Token的算法（翻译器）； (3) 编写代码并上机调试运行通过。 •输入——源程序文件或源程序字符串； •输出——相应的Token序列； 关键字表和界符表； 符号表和常数表；
编译原理中逆波兰式的转换算法
05-17
编译原理中的中间语言翻译器的构造所使用的将一个表达式转换为逆波兰式的算法实现，我用的是vc++6.0写的，程序挺简单的
编译原理实验报告 完整代码 完美运行 逆波兰式 无符号数
07-03
编译原理实验报告 完整代码 完美运行 逆波兰式 无符号数
编译原理-----逆波兰表示法,四元式，三元式，间接三元式
最新发布
weixin_69884785的博客
12-27 3808
编译原理-----逆波兰表示法,四元式，三元式，间接三元式
编译原理 | 实验四 | 逆波兰式
IronBull_Zhang的博客
06-15 3316
map:查找元素: 定义了 multimap<string, string>Prod; 想要获取某个元素的值时,使用 string RightPart = Prod.find(Vn[i])->second; 注意是"->"符号,因为find()的返回值是一个iterator,本质上是一个指针. first是key; second是值 ...
编译原理逆波兰式的实现（java）
my_stardream的博客
03-17 1047
基本原理： 利用栈的后进先出以及运算符优先级表。 判断几个情况： 1.如果不是运算符直接输出； 2.栈顶是左括号，在来的字符不是右括号的情况下直接入栈； 3.来的是右括号时，将栈内字符出栈病输出直到遇到左括号，左括号也出栈，但不入栈 4.来的运算符优先级低于栈顶运算符时，将栈顶运算符出栈直到栈顶运算符优先级低于新来的运算符，然后新来的入栈 5....
编译原理之逆波兰表达式
成长的足迹
06-21 8585
逆波兰表达式就是所谓的后缀表达式，运算符号都在运算变量的后面，这样计算机进行计算的时候是非常方便和快捷的。将中缀表达式转换成后缀表达式的算法如下图所示： 根据上图可以直接出来代码，另外转换为后缀表达式之后，对逆波兰表达式的计算就会很方便了，看下图： 需要注意的是，重点不在写程序，重点在于这些个图是怎么出来的，这些也都是前人的总结啊，示例代码如下： #inc
编译原理：语法分析详解与方法
"本资源主要涉及编译原理中的语法分析部分，涵盖了语法分析在编译过程中的位置、作用以及各种分析方法。课程旨在使学生掌握句柄、最左素短语、活前缀和项目等核心概念，以及消除文法左递归、构造LL(1)、优先关系和LR...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值