精华内容
下载资源
问答
  • 编译原理简单优先分析算法
    千次阅读
    2017-06-02 18:36:48

    简单优先分析算法

           编译原理简单优先分析算法是一种自下而上的分析算法,本例是编译原理第三版何炎祥中一个简单优先分析算法的例子,未给出分析过程分析代码,读者可以参考我的语法分析器中输出代码,写出此算法的输出部分。下附加代码:

    /*
    Name: 简单优先分析算法
    Copyright: 
    Author: cc 
    Date: 15/05/16 18:20
    Description:  根据固定的分析表(自定义添加b>$),对输入以$结尾的字符串进行判断是否符合语法 
    */
    #include<iostream>
    #include<stdlib.h>
    using namespace std;
    typedef struct
    {
    char data[10];
    int top;
    } message;//栈内元素对象 
    void create(message *&m)
    {
    m=(message *)malloc(sizeof(message));
    m->top=-1;
    }
    void push(message *&m,char i)//进栈操作 
    {
    if(m->top<10)
    {
    m->top++;
    m->data[m->top]=i;
    }
    else
    cout<<"栈满"; 
    }
    char pop(message *&m) //出栈操作 
    {
    char i;
    if(m->top!=-1)
    {
    i=m->data[m->top];
    m->top--;
    return i;
    }
    else
    cout<<"栈空"; 
    }
    void getStr(char str[]) //将输入的以$结尾的字符串 保存于字符串数组中 
    {
    int j=0;
    while(true)
    {
    cin>>str[j];
    if(str[j]=='$')
    break;
    else
    j++;
    }
    }
    int main()
    {
    char b[9][9]={{' ',' ',' ',' ',' ',' ',' ','=','>'},//分析表 
    {' ',' ',' ',' ',' ','=',' ','>','>'},
    {' ',' ',' ',' ',' ',' ',' ','>','>'},
    {' ',' ',' ',' ',' ','>',' ','>','>'},
    {' ',' ',' ',' ',' ','>',' ','>','>'}, 
    {' ','<','=','<','<',' ','<',' ','>'},
    {'=','<','<','<','<',' ','<',' ','>'},
    {' ',' ',' ',' ',' ','>',' ','>','>'},
    {'<','<','<','<','<','<','<','<','='}}; 
    message *m;
    int n;
    create(m);
        cout<<"输入字符串,字符串以$结尾,例如 ((a),a)$"<<endl; 
        char str[20];
        getStr(str); //获取以$结尾字符串 
        char *j=str;
    push(m,'$');
    while(true)
    {
    if(m->data[m->top-1]=='$'&&m->data[m->top]=='S')
    {
    if(*j=='$')
    {
    cout<<"这是一个句子";
    break; 
    }
    else
    {
    cout<<"这不是一个句子"; 
       break; 
    }
    }
    if(m->data[m->top]=='T'&& m->data[m->top-1]==',' && m->data[m->top-2]=='S')//产生式 (S,T) 
      {
      pop(m);
      pop(m);
      pop(m);
      push(m,'T');
      }
       else if(m->data[m->top]==')' && m->data[m->top-1]=='R' && m->data[m->top-2]=='(')//产生式(R) 
      {
      pop(m);
      pop(m);
      pop(m);
      push(m,'S');
      }
    
    
      //外层等于RRR
      else if(m->data[m->top]=='R')
        {
        int m1=0;
        switch(*j)
        {
        case 'R':n=0;break;
        case 'S':n=1;break;
        case 'T':n=2;break;
        case 'a':n=3;break;
        case '^':n=4;break;
        case ',':n=5;break;
        case '(':n=6;break;
        case ')':n=7;break;
        case '$':n=8;break;
        }
        if(b[m1][n]=='>')
        {
           cout<<"这不是一个句子"; 
             break;
        }
        else if(b[m1][n]==' ')
         {
             cout<<"这不是一个句子"; 
             break;
         } 
         else
         {
          push(m,*j);
          j++;
         }
        }
        //外层等于RRR 
         
        //外层等于SSS
      else if(m->data[m->top]=='S')
        {
        int m1=1;
        switch(*j)
        {
        case 'R':n=0;break;
        case 'S':n=1;break;
        case 'T':n=2;break;
        case 'a':n=3;break;
        case '^':n=4;break;
        case ',':n=5;break;
        case '(':n=6;break;
        case ')':n=7;break;
        case '$':n=8;break;
        }
        if(b[m1][n]=='>')
        {
            pop(m);
            push(m,'T');
        }
        else if(b[m1][n]==' ')
         {
             cout<<"这不是一个句子"; 
             break;
         } 
         else
         {
          push(m,*j);
          j++;
         }
        }
        //外层等于SSS
        
        //外层等于TTT
      else if(m->data[m->top]=='T')
        {
        int m1=2;
        switch(*j)
        {
        case 'R':n=0;break;
        case 'S':n=1;break;
        case 'T':n=2;break;
        case 'a':n=3;break;
        case '^':n=4;break;
        case ',':n=5;break;
        case '(':n=6;break;
        case ')':n=7;break;
        case '$':n=8;break;
        }
        if(b[m1][n]=='>')
        {
            pop(m);
            push(m,'R');
        }
        else if(b[m1][n]==' ')
         {
             cout<<"这不是一个句子"; 
             break;
         } 
         else
         {
          push(m,*j);
          j++;
         }
        }
        //外层等于TTT
         
        //外层等于aaa
      else if(m->data[m->top]=='a')
        {
        int m1=3;
        switch(*j)
        {
        case 'R':n=0;break;
        case 'S':n=1;break;
        case 'T':n=2;break;
        case 'a':n=3;break;
        case '^':n=4;break;
        case ',':n=5;break;
        case '(':n=6;break;
        case ')':n=7;break;
        case '$':n=8;break;
        }
        if(b[m1][n]=='>')
        {
            pop(m);
            push(m,'S');
        }
        else if(b[m1][n]==' ')
         {
             cout<<"这不是一个句子"; 
             break;
         } 
         else
         {
          push(m,*j);
          j++;
         }
        }
        //外层等于aaa
        
        //外层等于^^^
      else if(m->data[m->top]=='^')
        {
        int m1=4;
        switch(*j)
        {
        case 'R':n=0;break;
        case 'S':n=1;break;
        case 'T':n=2;break;
        case 'a':n=3;break;
        case '^':n=4;break;
        case ',':n=5;break;
        case '(':n=6;break;
        case ')':n=7;break;
        case '$':n=8;break;
        }
        if(b[m1][n]=='>')
        {
        cout<<"这不是一个句子"; 
             break;
        }
        else if(b[m1][n]==' ')
         {
             cout<<"这不是一个句子"; 
             break;
         } 
         else
         {
          push(m,*j);
          j++;
         }
        }
        //外层等于^^^
        
        //外层等于,,,
      else if(m->data[m->top]==',')
        {
        int m1=5;
        switch(*j)
        {
        case 'R':n=0;break;
        case 'S':n=1;break;
        case 'T':n=2;break;
        case 'a':n=3;break;
        case '^':n=4;break;
        case ',':n=5;break;
        case '(':n=6;break;
        case ')':n=7;break;
        case '$':n=8;break;
        }
        if(b[m1][n]=='>')
        {
        cout<<"这不是一个句子"; 
             break;
        }
        else if(b[m1][n]==' ')
         {
             cout<<"这不是一个句子"; 
             break;
         } 
         else
         {
          push(m,*j);
          j++;
         }
        }
        //外层等于,,,
        
        //外层等于(((
      else if(m->data[m->top]=='(')
        {
        int m1=6;
        switch(*j)
        {
        case 'R':n=0;break;
        case 'S':n=1;break;
        case 'T':n=2;break;
        case 'a':n=3;break;
        case '^':n=4;break;
        case ',':n=5;break;
        case '(':n=6;break;
        case ')':n=7;break;
        case '$':n=8;break;
        }
        if(b[m1][n]=='>')
        {
        cout<<"这不是一个句子"; 
             break;
        }
        else if(b[m1][n]==' ')
         {
             cout<<"这不是一个句子"; 
             break;
         } 
         else
         {
          push(m,*j);
          j++;
         }
        }
        //外层等于(((
        
        //外层等于)))
      else if(m->data[m->top]==')')
        {
        int m1=7;
        switch(*j)
        {
        case 'R':n=0;break;
        case 'S':n=1;break;
        case 'T':n=2;break;
        case 'a':n=3;break;
        case '^':n=4;break;
        case ',':n=5;break;
        case '(':n=6;break;
        case ')':n=7;break;
        case '$':n=8;break;
        }
        if(b[m1][n]=='>')
        {
           cout<<"这不是一个句子"; 
             break;
        }
        else if(b[m1][n]==' ')
         {
             cout<<"这不是一个句子"; 
             break;
         } 
         else
         {
          push(m,*j);
          j++;
         }
        }
        //外层等于)))
         
    //外层$$$ 
    else if(m->data[m->top]=='$')
    {
    push(m,*j);
          j++; 
    } 
    // 外层$$$   
      }
       return 0; 
    }

    更多相关内容
  • 自底向上分析方法,也称移进-归约分析法。 实现思想: 对输入符号串自左向右进行扫描,并将输入符逐个移入一个栈中,边移入边分析,一旦栈顶符号串...5.2 简单优先分析法 5.3 算符优先分析法 ...

    自底向上分析方法,也称移进-归约分析法。

    实现思想:

    • 对输入符号串自左向右进行扫描,并将输入符逐个移入一个栈中,边移入边分析,一旦栈顶符号串形成某个句型的句柄时,就用该产生式的左部非终结符代替相应右部的文法符号串,这称为归约
    • 重复这一过程,直到栈中只剩文法的开始符号时,则分析成功,也就确认输入串是文法的句子。
      在这里插入图片描述
      在这里插入图片描述

    5.1 自底向上优先分析法概述

    在这里插入图片描述

    5.2 简单优先分析法

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    5.3 算符优先分析法

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 简单优先分析的基本思想是对一个文法按照一定的原则求出该文法所有符号之间的优先关系,按照这种关系确定规约过程中的句柄。算符优先分析的基本思想是只规定算符之间的优先关系,在规约过程中只要找到可规约串就规约...

    概述

    • 简单优先分析的基本思想是对一个文法按照一定的原则求出该文法所有符号之间的优先关系,按照这种关系确定规约过程中的句柄。算符优先分析的基本思想是只规定算符之间的优先关系,在规约过程中只要找到可规约串就规约。

    简单优先分析

        • 1 :优先关系定义

        (1):若X优先级等于Y, 当且仅当G中含有产生式规则A->.... XY..... 。
        (2):若X优先级小于Y,当且仅当G中含有产生式规则A->....XB....,且B是Y的短
            语。
        (3):若X优先级大于Y,当且仅当G中含有产生式规则A->...BD....,且B是X的短
            语,D是Y的短语。
        • 2:简单优先分析的操作步骤

         1: 将输入符号串依次逐个压入符号栈中,直到遇到栈顶符号的优先级大于下一个待输入符号的优先级。
         2: 栈顶当前符号为句柄尾,由此向左在栈中找到句柄的头符号。  3: 将句柄产生式和文法右部产生式匹配,若找到,进行替换,若找不到,则出错。
         4: 重复上述步骤,直至栈中只剩下文法的开始符号为止。

    算符优先分析法

    • 算符优先只分析终结符之间的优先级,且文法必须满足两个相邻的非终结符之间必有一个终结符,FIRSTVT代表第一个终结符,LASTVT代表最后一个终结符。
    • 实例分析
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述
    • 最左素短语
      定义:句型至少包含一个终结符,并且自身外不包含其他素短语,最左边的素短语陈给最左素短语。其实寻找最左边的终结字符或者两个非终结字符夹着一个终结字符的形式,看下面的例子。
      在这里插入图片描述
    展开全文
  • (编译原理)简单优先分析方法

    千次阅读 2019-07-13 10:59:18
    #include<stdio.h> int find(int a,int b) //优先关系表 { int table[6][6] = { 1, -1, -1, -1, 1, 1, 1, 1, -1, -1, 1, 1, 1, 1...
    #include<stdio.h>
     
    int find(int a,int b)   //优先关系表
    {
        int table[6][6] = {
                           1, -1, -1, -1, 1, 1,
                           1,  1, -1, -1, 1, 1,
                           1,  1,  2,  2, 1, 1,
                          -1,- 1, -1, -1, 0, 2,
                           1,  1,  2,  2, 1, 1,
                          -1, -1,- 1, -1, 2, 0
                          };
     
      return table[a-1][b-1];
     
    }
     
     
    int in_vt(char c)    //可以根据返回的数值去优先关系表里面查找优先关系
    {                    //还可以判断是否是非终结符,不是非终结符返回0
       int n;
     
       switch(c)
       {
           case '+': n = 1; break;
           case '*': n = 2; break;
           case 'i': n = 3; break;
           case '(': n = 4; break;
           case ')': n = 5; break;
           case '#': n = 6; break;
           default : n = 0;
       }
     
       return n;
     
    }
     
     
     
     
    int judge(char *p,int k,char *psc)
    {
     
            if(k == 1 && p[k] == '#' && (*psc == '+' || *psc == '*'))
            {
                    printf("\n运算符前面没有操作数!\n");
                    return 0;
            }
            if((*psc == '+' || *psc == '*') && (*(psc + 1) == '+' || *(psc + 1) == '*'))
            {
                    printf("\n运算符号相邻!\n");
                    return 0;
            }
            if(*psc == '#' && (*(psc - 1) == '+' || *(psc - 1) == '*'))
            {
                    printf("\n运算符后面没有操作数!\n");
                    return 0;
            }
            return 1;
    }
     
     
     
    int main()
    {
       int  k;                   //栈顶指针
       char s[30] = {'\0'};      //分析栈
       char *ss;
       char in_c[50] = {'\0'};   //输入串
       char *psc;                //指向当前输入符号
       int  j;
       char q;
       int  flag;
       int  n;
     
    while(1)
    {
     
       printf("\n************************************\n");
       printf("请输入要归约的字符串(以‘#’结束):");
       scanf("%s",in_c);
     
       n = 1;          //记录步骤
       k = 1;
       s[k] = '#';
       s[k+1] = '\0';    //初始化
       ss = s + 1;       //指向栈底
       psc = in_c;
     
     
       printf("\n步骤\t栈内字符\t\t优先关系\t当前符号\t剩余输入串\t\t\t移进或归约\n");
       while(1)
       {
              if(judge(s,k,psc) == 0)
              {
                      printf("\n出错!\n");
                      break;
              }
     
              if(in_vt(s[k]))
                  j = k;
              else
                  j = k - 1;
     
              flag = find(in_vt(s[j]),in_vt(*psc));
              if(flag == 1)  //如果s[j] > 当前输入字符
              {
                   do
                   {
                       q = s[j];
                       if(in_vt(s[j-1]))
                            j--;
                       else
                            j = j - 2;
                   }while(find(in_vt(s[j]),in_vt(q)) != -1);
     
                   printf("(%d)\t%-24s>\t\t%c\t\t%-32s归约\n",n++,ss,*psc,psc+1);
                   k = j + 1;
                   s[k] = 'N';
                   s[k+1] = '\0';
                   continue;
              }
              else if(flag == -1)
                   {
                       printf("(%d)\t%-24s<\t\t%c\t\t",n++,ss,*psc);
                       k++;
                       s[k] = *psc;
                       s[k+1] = '\0';
                       psc++;
                       printf("%-32s移进\n",psc);
                       continue;
                   }
                   else if(flag == 0)
                        {
                              if(s[j] == '#')
                              {
                                   printf("(%d)\t%-24s=\t\t#\t\t\t\t\t\t接受\n",n,ss);
                                   printf("\n归约成功!\n");
                                   break;
                              }
                              else
                              {
                                   printf("(%d)\t%-24s=\t\t%c\t\t",n++,ss,*psc);
                                   k++;
                                   s[k] = *psc;
                                   s[k+1] = '\0';
                                   psc++;
                                   printf("%-32s移进\n",psc);
                                   continue;
                              }
                         }
                         else
                         {
                              printf("(%d)\t%-24s无\t\t%c\t\t%-32s\\\n",n++,ss,*psc,psc+1);
                              printf("\n错误!\n");
                              break;
                         }
    
       }
     
    }
    
     return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 编译原理上机实验-简单优先分析—C#[收集].pdf
  • 简单优先分析法 1.基本概念 通过语法树来理解这三个概念更加简单: 文法G1[S]: S→AB A→bB A→Aa B→a B→Sb 语法树 短语:若S=*=&gt;αAδ且A=+=&gt;β,则称β是相对于非终结符A的句型αβδ...
  • 简单优先分析算法

    2013-04-09 22:37:20
    简单优先分析算法实现,一种很弱的语法分析
  • 编译简单优先分析

    千次阅读 2016-12-11 14:37:45
    是编写一个简单优先关系算法,用于识别文法的句子,或句型; 输入 输入句子或句型 输出 判断句子或句型是否符合文法G[S]: 如果符合文法输出 accept 否则输出
  • 实现算符优先文法分析程序;完成对以下表达式文法的分析程序。 G[E]: E->E+T E->T T->T*F T->F F->(E) F->i
  • 简单优先分析文法的基本思想是对一个文法按一定的原则求出该文法所有符号包括终结符和非终结符之间的优先关系,按照这种关系确定规约过程中的句柄,它的规约过程实际上是规范规约。在算法实现过程中,主要使用visual...
  • 用算符优先分析方法设计一个分析解释程序,对输入的赋值语句、输出语句、清除语句进行词法分析、语法分析、表达式求值并存储于指定变量中;若存在错误,提示错误相关信息。
  • (Python实现,注释详细)直接输入:3+4*5,一般的...(1)第一阶段,运用算符优先分析算法完成计算器中对算术表达式的语法分析; (2)第二阶段,设计属性文法,改造第一阶段的程序,完成算术表达式的计算和相关的输出。
  • 原理:简单优先分析算法 语言:Java若需要查看算符优先算法,请进入主页查看https://blog.csdn.net/qq_24065713/article/details/71375421 MainMethod.java     public class MainMethod { public Str.....
  • 算符优先分析文法是一种工具,在编译的过程中,隶属于语法分析环节,却又与中间代码的生成息息相关,编译可以分为五个阶段:词法分析、语法分析、语义分析(中间代码的生成)、代码优化、目标代码生成。语法分析是指...
  • 2.1.4 简单优先分析法的操作步骤 6 2.2 需要完成的功能 7 2.2.1 判定输入的文法是否是简单优先文法 7 2.2.2 构造文法的简单优先关系矩阵 7 2.3 分析器的构造 7 第三章 逻辑设计 9 3.1系统的组织与基本工作流程 9 3.2...
  • 艏编译原理 编译原理 主讲:温璞 责任教师:蒋慧平 湖南户播电视大学 艏编译原理 第六讲 简单优先和算符 优先分析方法 2 湖南户播电视大学 本讲主要内容 艏编译原理 简单优先文法及其分析算法 算符优先文法及其分析...
  • 例子:该例子使用的是简单优先分析法 这种方式的问题,只有在有树图的情况下才好判断句柄,也就是难以寻找句柄,对于电脑来说,不容易实现,且耗费时间多 相邻文法符号之间的优先关系: 句柄寻找: 句柄的概念:...
  • 输入任意文法,输出优先矩阵初始状态,通过矩阵转置,相乘等的输出,构造简单优先矩阵.
  • 自下而上的分析法——算符优先分析

    万次阅读 多人点赞 2018-05-13 19:19:42
     算符优先分析法(Operator Precedence Parse)是仿效四则运算的计算过程而构造的一种语法分析方法。算符优先分析法的关键是比较两个相继出现的终结符的优先级而决定应采取的动作。  优点:简单,有效,适合表达式...
  • 刚做完的。简单优先文法的判定以及分析器的构造。代码可以用,但觉得不够完美,像是没有句子分析的过程。
  • 算符优先分析法的简单实现

    千次阅读 2018-05-11 19:05:50
    算符优先分析法即是一种针对算符优先文法的分析方法。 二.如果一个文法的任一产生式的右部都不存在两个相邻的非终结符,则称这个文法为算符文法(OG)。 三.假定文法G是一个不含e的算符文法,a,b∈Vt,P,Q,R∈Vn,...
  • 目录一、自下而上语法分析概述二、自下而上的分析算法1、 简单优先分析优先关系2、算符优先分析 一、自下而上语法分析概述 自下而上语法分析试图将一个字符串反向规约至开始符号。 自下而上语法分析比自上而下语法...
  • 算符优先分析法 1.基本概念 算符文法(OG):文法G中没有形如A=&gt;···BC···的产生式,其中B、C为非终结符,则G为算符文法(operator grammar)。 也就是说产生式的右部不能出现两个非终结符相邻,就...
  • 本次设计的存储结构简单易懂,且适合新手,目前实现了FirstVt集,LastVt以及算符优先分析表的构造,主要还是利用从各自的构造思想入手。 算符优先分析法是一种自底向上的语法分析方法。在算符文法中,任何一个规则...
  • 基于算符优先分析方法的表达式语法分析器:了解用算符优先法对表达进行语法分析的方法,掌握自顶向下的预测语法分析程序的手工构造方法。1、从键盘输入表达式,利用算符优先法求出其值,如输入表达式有错,则给出...
  • ⑴ 选择算符优先分析方法; ⑵ 选择对各种常见程序语言都用的语法结构,如赋值语句或表达式或控制流语句等作为分析对象,并且与所选语法分析方法要比较贴切。 实验内容及要求 (1)根据给定文法,先求出FirstVt和...
  • 算符优先分析程序&对着注释理解代码

    千次阅读 多人点赞 2020-05-29 09:50:26
    文章目录一 实验目的和要求二 实验内容三 实验过程3.1什么是算符文法?...5.理解算符优先分析算法,能够使用某种高级语言实现一个算符优先分析程序。 二 实验内容 编写一个算符优先分析程序,能实现以下功能
  • 编译原理 语法分析 简单优先 参考清华大学出版社
  • 算符优先分析程序(NCWU慎用) ** 1.实验要求 ⑴ 选择算符优先分析方法; ⑵ 选择对各种常见程序语言都用的语法结构,如赋值语句或表达式或控制流语句等作为分析对象,并且与所选语法分析方法要比较贴切。 ⑶ 实验...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 237,112
精华内容 94,844
关键字:

简单优先分析