【编译原理】LL(1)分析法:C/C++实现

这篇具有很好参考价值的文章主要介绍了【编译原理】LL(1)分析法:C/C++实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

ll(1)文法c语言实现,# 【编译原理】,c语言,c++,开发语言,汇编,算法,数据结构 🌈个人主页:Sarapines Programmer
🔥 系列专栏:《编译原理奇遇记》
🔖墨香寄清辞:空谷幽篁风动,梦中仙鹤月明。 辗转千秋豪情在,乘风翱翔志不移。

ll(1)文法c语言实现,# 【编译原理】,c语言,c++,开发语言,汇编,算法,数据结构

目录结构


1. 编译原理之LL(1)分析法概念

1.1 编译原理

1.2 LL(1)分析法

2. LL(1)分析法

2.1 实验目的

2.2 实验要求

2.3 实验内容

2.3.1 实验解决代码

2.3.2 运行结果

2.3.3 详细代码分析

2.3.3.1 init()函数

2.3.3.2 analyse()函数

2.4 实验心得

3. 致各位


1. 编译原理之LL(1)分析法概念

1.1 编译原理

编译原理是计算机科学领域的一个重要分支,它研究如何将高级编程语言的源代码转化成计算机能够执行的机器代码或中间代码的过程。编译原理涵盖了编译器的设计和实现,其中编译器是一种将源代码翻译成目标代码的软件工具。编译器的主要任务包括语法分析、词法分析、语义分析、优化和代码生成等环节。

1.2 LL(1)分析法

LL(1)分析法是一种常用的自顶向下的语法分析方法,用于分析和解释编程语言或其他形式的文本。LL(1)代表"Left-to-Right, Leftmost derivation, 1 symbol lookahead",这表示了分析器的工作方式和限制条件,通常用于编程语言的语法分析,编写编译器或解释器。主要步骤包括构建LL(1)文法、构建LL(1)分析表和使用递归下降分析或预测分析器等算法来分析输入文本。

🔥 资源获取:关注文末公众号回复  LL(1)分析法源码

🔥 相关博文:编译原理之逆波兰式的产生及计算:C/C++实现(附源码+详解!)


2. LL(1)分析法

2.1 实验目的

(1)加深对预测分析LL(1)分析法的理解;

(2)根据某一文法编制调试LL(1)分析程序,以便对任意输入的符号串分析。


2.2 实验要求

实验规定对下列文法,用LL(1)分析法对任意输入的符号串进行分析,具体文法如下:

(1)E::=TG

(2)G::=+TG

(3)G::=ε

(4)T::=FS

(5)S::=*FS

(6)S::=ε

(7)F::=(E)

(8)F::=i

若输入串为

i+i*i#

则输出:

ll(1)文法c语言实现,# 【编译原理】,c语言,c++,开发语言,汇编,算法,数据结构​​

LL(1)的分析表:

   i

   +

   *

  (

    )

   #

    说    明

 E

   e

   e

Select(E→TG)={(,i}

 G

g

g1

g1

Select (G→+TG)={+}

Select (G→є)={#,)}

 T

   t

 t

Select (T→FS)={(,i}

 S

s1

   s

  s1

  s1

Select (S→*FS)={*}Select (S→є)={#,) +}

 F

  f1

   F

Select (F→(E))={(}

Select (F→i)={i}

参考代码(不完整):

do/*读入分析串*/
{
    scanf("%c",&ch);
    if ((ch!='i') &&(ch!='+') &&(ch!='*')&&(ch!='(')&&(ch!=')')&&(ch!='#'))
    {
        printf("输入串中有非法字符\n");
        exit(1);
    }
    B[j]=ch;
    j++;
}while(ch!='#');

l=j;/*分析串长度*/
ch=B[0];/*当前分析字符*/
A[top]='#'; A[++top]='E';/*'#','E'进栈*/
printf("步骤\t\t分析栈 \t\t剩余字符 \t\t所用产生式 \n");
do
{
    x=A[top--];/*x为当前栈顶字符*/
    printf("%d",k++);
    printf("\t\t");
}   

for(j=0;j<=5;j++)/*判断是否为终结符*/
    if(x==v1[j])
    {   
        flag=1;
        break;
    }
    if(flag==1)/*如果是终结符*/
    {
        if(x=='#')
        {
            finish=1;/*结束标记*/
            printf("acc!\n");/*接受 */
            getchar();
            getchar();
            exit(1);
        }
        if(x==ch)
        {
            print();
            print1();
            printf("%c匹配\n",ch);
            ch=B[++b];/*下一个输入字符*/
            flag=0;/*恢复标记*/
        }
        else/*出错处理*/
        {
            print();
            print1();
            printf("%c出错\n",ch);/*输出出错终结符*/
            exit(1);  
        }
    }
    else/*非终结符处理*/
    {
        for(j=0;j<=4;j++)
            if(x==v2[j])
            {
                m=j;/*行号*/
                break;
            }
        for(j=0;j<=5;j++)
            if(ch==v1[j])
            {
                n=j;/*列号*/
                break;
            }
        cha=C[m][n];
        if(cha.origin!='N')/*判断是否为空*/
        {
            print();
            print1();
            printf("%c->",cha.origin);/*输出产生式*/
            for(j=0;j<cha.length;j++)
                printf("%c",cha.array[j]);
            printf("\n");
            for(j=(cha.length-1);j>=0;j--)/*产生式逆序入栈*/
                A[++top]=cha.array[j];
            if(A[top]=='^')/*为空则不进栈*/
                top--;
        }
    }
}

void print()/*输出分析栈 */
{
    int a;/*指针*/
    for(a=0;a<=top+1;a++)
        printf("%c",A[a]);
    printf("\t\t");
}

void print1()/*输出剩余串*/
{
    int j;
    for(j=0;j<b;j++)/*输出对齐符*/
        printf(" ");
    for(j=b;j<=l;j++)
        printf("%c",B[j]);
    printf("\t\t\t");
}

// 主程序中的各变量定义
char A[20];/*分析栈*/
char B[20];/*剩余串*/
char v1[20]={'i','+','*','(',')','#'};/*终结符 */
char v2[20]={'E','G','T','S','F'};/*非终结符 */

int j=0,b=0,top=0,l;/*L为输入串长度 */
typedef struct type/*产生式类型定义 */
{
    char origin;/*大写字符 */
    char array[5];/*产生式右边字符 */
    int length;/*字符个数 */
}type;

type e,t,g,g1,s,s1,f,f1;/*结构体变量 */
type C[10][10];/*预测分析表 */

/*把文法产生式赋值结构体*/
e.origin='E';
strcpy(e.array,"TG");
t.origin='T';
strcpy(t.array,"FS");
g.origin='G';
strcpy(g.array,"+TG");
g1.origin='G';
g1.array[0]='^';
s.origin='S';
strcpy(s.array,"*FS");
s1.origin='S';
s1.array[0]='^';
f.origin='F';
strcpy(f.array,"(E)");
f1.origin='F';
f1.array[0]='i';

for(m=0;m<=4;m++)/*初始化分析表*/
    for(n=0;n<=5;n++)
        C[m][n].origin='N';/*全部赋为空*/
/*填充分析表*/
C[0][0]=e;C[0][3]=e;
C[1][1]=g;C[1][4]=g1;C[1][5]=g1;
C[2][0]=t;C[2][3]=t;
C[3][1]=s1;C[3][2]=s;C[3][4]=C[3][5]=s1;
C[4][0]=f1;C[4][3]=f;

2.3 实验内容

2.3.1 实验解决代码

根据参考代码修改如下:

do/*读入分析串*/
{
    scanf("%c",&ch);
    if ((ch!='i') &&(ch!='+') &&(ch!='*')&&(ch!='(')&&(ch!=')')&&(ch!='#'))
    {
        printf("输入串中有非法字符\n");
        exit(1);
    }
    B[j]=ch;
    j++;
}while(ch!='#');
l=j;/*分析串长度*/
ch=B[0];/*当前分析字符*/
A[top]='#'; A[++top]='E';/*'#','E'进栈*/
printf("步骤\t\t分析栈 \t\t剩余字符 \t\t所用产生式 \n");
do
{
    x=A[top--];/*x为当前栈顶字符*/
    printf("%d",k++);
    printf("\t\t");
}

for(j=0;j<=5;j++)/*判断是否为终结符*/
    if(x==v1[j])
    {   
        flag=1;
        break;
    }
    if(flag==1)/*如果是终结符*/
    {
        if(x=='#')
        {
            finish=1;/*结束标记*/
            printf("acc!\n");/*接受 */
            getchar();
            getchar();
            exit(1);
        }
        if(x==ch)
        {
            print();
            print1();
            printf("%c匹配\n",ch);
            ch=B[++b];/*下一个输入字符*/
            flag=0;/*恢复标记*/
        }
        else/*出错处理*/
        {
            print();
            print1();
            printf("%c出错\n",ch);/*输出出错终结符*/
            exit(1);
        }
    }
    else/*非绂
        for(j=0;j<=4;j++)
            if(x==v2[j])
            {
                m=j;/*行号*/
                break;
            }
        for(j=0;j<=5;j++)
            if(ch==v1[j])
            {
                n=j;/*列号*/
                break;
            }
        cha=C[m][n];
        if(cha.origin!='N')/*判断是否为空*/
        {
            print();
            print1();
            printf("%c->",cha.origin);/*输出产生式*/
            for(j=0;j<cha.length;j++)
                printf("%c",cha.array[j]);
            printf("\n");
            for(j=(cha.length-1);j>=0;j--)/*产生式逆序入栈*/
                A[++top]=cha.array[j];
            if(A[top]=='^')/*为空则不进栈*/
                top--;
        }
    }
}

void print()/*输出分析栈 */
{
    int a;/*指针*/
    for(a=0;a<=top+1;a++)
        printf("%c",A[a]);
    printf("\t\t");
}

void print1()/*输出剩余串*/
{
    int j;
    for(j=0;j<b;j++)/*输出对齐符*/
        printf(" ");
    for(j=b;j<=l;j++)
        printf("%c",B[j]);
    printf("\t\t\t");
}

// 主程序中的各变量定义
char A[20];/*分析栈*/
char B[20];/*剩余串*/
char v1[20]={'i','+','*','(',')','#'};/*终结符 */
char v2[20]={'E','G','T','S','F'};/*非绂
int j=0,b=0,top=0,l;/*L为输入串长度 */
typedef struct type/*产生式类型定义 */
{
    char origin;/*大写字符 */
    char array[5];/*产生式右边字符 */
    int length;/*字符个数 */
}type;

type e,t,g,g1,s,s1,f,f1;/*结构体变量 */
type C[10][10];/*预测分析表 */

/*把文法产生式赋值结构体*/
e.origin='E';
strcpy(e.array,"TG");
t.origin='T';
strcpy(t.array,"FS");
g.origin='G';
strcpy(g.array,"+TG");
g1.origin='G';
g1.array[0]='^';
s.origin='S';
strcpy(s.array,"*FS");
s1.origin='S';
s1.array[0]='^';
f.origin='F';
strcpy(f.array,"(E)");
f1.origin='F';
f1.array[0]='i';

for(m=0;m<=4;m++)/*初始化分析表*/
    for(n=0;n<=5;n++)
        C[m][n].origin='N';/*全部赋为空*/
/*填充分析表*/
C[0][0]=e;C[0][3]=e;
C[1][1]=g;C[1][4]=g1;C[1][5]=g1;
C[2][0]=t;C[2][3]=t;
C[3][1]=s1;C[3][2]=s;C[3][4]=C[3][5]=s1;
C[4][0]=f1;C[4][3]=f;

2.3.2 运行结果

输入正确的测试用例

i+i*i

ll(1)文法c语言实现,# 【编译原理】,c语言,c++,开发语言,汇编,算法,数据结构​​

输入错误的测试用例

一>i+i

ll(1)文法c语言实现,# 【编译原理】,c语言,c++,开发语言,汇编,算法,数据结构​​

输入错误的测试用例二

i+i*i)

ll(1)文法c语言实现,# 【编译原理】,c语言,c++,开发语言,汇编,算法,数据结构​​

输入错误的测试用例三

i**i

ll(1)文法c语言实现,# 【编译原理】,c语言,c++,开发语言,汇编,算法,数据结构​​


2.3.3 详细代码分析

1.首先,在程序的开头包含了 <stdio.h> 和 <string.h> 这两个头文件,用于提供输入输出和字符串处理的功能。

2.定义了宏 number_zjfu 和 unnumber_zjfu 分别表示终结符和非终结符的个数。

3.声明了全局变量和结构体

 stack1 和 stack2 是字符数组,分别表示分析栈和剩余串。

  1. terminal_array 是一个字符数组,存储终结符。
  2. non_terminal_array 是一个字符数组,存储非终结符。
  3. struct Production 是一个结构体类型,表示产生式,包括产生式的起始符号、右边的字符数组和字符个数。

 e、t、g、g1、s、s1、f、f1 是 struct Production 类型的结构体变量,表示相应的产生式。

  1. analyseTable 是一个二维数组,存储预测分析表的内容。

4.定义辅助变量:

  1. frist 表示输入串的指针,初始值为 0。
  2. last 表示分析栈的指针,初始值为 0。
  3. length_of_string 表示输入串的长度。
  4. userF 和 stacktop 分别表示当前处理的输入串中的字符和栈顶的字符。
  5. statue 用于表示分析状态,初始值为 0。
  6. proce 用于记录分析步骤的序号,初始值为 1。

5.定义了一系列函数的原型,包括 init()、analyse()、printStack()、printRemainString() 和 input_string()。

6.main() 函数是程序的主函数。

    1. 在 main() 函数中首先调用 init() 函数进行初始化。
    2. 接下来通过 input_string() 函数获取用户输入的串,并进行合法性判断。
    3. 将结束符号 # 和开始符号 E 分别入栈。
    4. 进入一个循环,在循环中调用 analyse() 函数进行分析,直到 statue 变量的值变为 1 表示分析完成。
    5. 分析完成后,程序结束并返回 1。

7.input_string() 函数用于获取用户输入的串。

  1. 首先打印提示信息,要求用户输入终结符。
  2. 使用 getchar() 函数逐个读取用户输入的字符,并将其存储到 stack2 数组中。
  3. 判断输入的字符是否合法,如果不是终结符则输出错误信息并返回 false。
  4. 将结束符号 # 加入到 stack2 数组中,并将输入串的
  5. 长度保存到 length_of_string 变量中,并返回 true 表示输入串合法。

8.init() 函数用于初始化产生式和预测分析表。

  1. 初始化了各个产生式的起始符号、右边字符数组和字符个数。
  2. 初始化了预测分析表 analyseTable,将非终结符对应的产生式填入表中。

9.analyse() 函数用于执行分析操作。

  1. 获取栈顶字符 stacktop 和输入串第一个字符 userF。
  2. 判断栈顶字符是否为终结符,如果是则进行终结符匹配操作。
  3. 如果栈顶字符为 #,且输入串字符也为 #,表示输入串已经全部匹配完成,打印当前分析栈和剩余串,并输出 "acc!" 表示分析成功,将 statue 设置为 1 表示分析完成。
  4. 如果栈顶字符和输入串字符相等,则进行匹配操作,将指针 frist 向后移动一位,将指针 last 向前移动一位,并将终结符标志 logo 设为 0。
  5. 如果栈顶字符和输入串字符不相等,表示匹配失败,将 statue 设置为 2 表示错误状态,打印当前分析栈和剩余串,并输出 "error" 表示错误。
  6. 如果栈顶字符不是终结符,进行查表操作。
  7. 首先根据栈顶字符找到对应的行号 row。
  8. 然后根据输入串字符找到对应的列号 column。
  9. 根据行号和列号在预测分析表 analyseTable 中找到对应的产生式 cha。
  10. 如果产生式不为空(即 cha.origin 不为 'N'),表示可以继续分析。
  11. 打印当前分析栈和剩余串。
  12. 输出产生式的左边字符 cha.origin 和右边字符数组 cha.array。
  13. 将栈顶字符出栈,根据产生式逆序将字符入栈。
  14. 如果产生式右边的第一个字符为 '^',则将其出栈。
  15. 如果产生式为空(即 cha.origin 为 'N'),表示无对应的产生式,说明输入串不符合文法规则,将 statue 设置为 2 表示错误状态,打印当前分析栈和剩余串,并输出 "error" 表示错误。

10.printStack() 函数用于打印分析栈。

  1. 首先打印当前分析步骤的序号 proce。
  2. 然后遍历分析栈数组 stack1,将栈中的字符逐个输出。

11.printRemainString() 函数用于打印剩余串。

  1. 首先打印一定数量的空格以对齐输出。
  2. 遍历剩余串数组 stack2,从指针 frist 开始输出剩余的字符。

12.在 main() 函数中进行程序的主要逻辑。

  1. 首先进行初始化操作调用 init() 函数。
  2. 使用循环获取用户输入的分析串,直到输入合法的分析串为止,调用 input_string() 函数。
  3. 将结束符 # 和起始符号 E 分别压入分析栈数组 stack1 中。
  4. 使用循环进行分析操作,直到 statue 不为 0。
  5. 调用 analyse() 函数执行分析操作。
  6. 返回 1,表示程序执行完毕。

这段程序实现了基于LL(1)分析法的语法分析器。通过使用预测分析表和栈来进行自顶向下的语法分析,并且比较栈顶符号和输入串的符号,根据预测分析表中的产生式进行匹配和规约操作,直到分析完成或出现错误。在分析过程中,输出每一步的分析栈、剩余串和所使用的产生式。


2.3.3.1 init()函数
void init(){
    e.origin='E';
    strcpy(e.array,"TG");
    e.length = 2;

    t.origin='T';
    strcpy(t.array,"FS");
    t.length = 2;

    g.origin='G';
    strcpy(g.array,"+TG");
    g.length = 3;

    g1.origin='G';
    g1.array[0]='^';
    g1.length = 1;

    s.origin='S';
    strcpy(s.array,"*FS");
    s.length = 3;

    s1.origin='S';
    s1.array[0]='^';
    s1.length = 1;

    f.origin='F';
    strcpy(f.array,"(E)");
    f.length = 3;

    f1.origin='F';
    f1.array[0]='i';
    f1.length = 1;

    for(int m=0; m<unnumber_zjfu; m++) //初始化分析表
        for(int n=0; n<number_zjfu; n++)
            analyseTable[m][n].origin='N';

    analyseTable[0][0]=e;
    analyseTable[0][3]=e;
    analyseTable[1][1]=g;
    analyseTable[1][4]=g1;
    analyseTable[1][5]=g1;
    analyseTable[2][0]=t;
    analyseTable[2][3]=t;
    analyseTable[3][1]=s1;
    analyseTable[3][2]=s;
    analyseTable[3][4]=s1;
    analyseTable[3][5]=s1;
    analyseTable[4][0]=f1;
    analyseTable[4][3]=f;
}

分析如下:

这里的init() 函数用于初始化语法分析器中的产生式和预测分析表。通过定义了一系列的结构体变量来表示产生式,每个产生式包含三个属性:origin 表示产生式的起始符号,array 表示产生式右边的字符序列,length 表示产生式右边字符序列的长度。

然后,根据文法的产生式规则,为每个结构体变量赋值。具体赋值如下:

  1. e 产生式:起始符号为 E,右边字符序列为 "TG",长度为 2。
  2. t 产生式:起始符号为 T,右边字符序列为 "FS",长度为 2。
  3. g 产生式:起始符号为 G,右边字符序列为 "+TG",长度为 3。
  4. g1 产生式:起始符号为 G,右边字符序列为 "^",长度为 1。
  5. s 产生式:起始符号为 S,右边字符序列为 "*FS",长度为 3。
  6. s1 产生式:起始符号为 S,右边字符序列为 "^",长度为 1。
  7. f 产生式:起始符号为 F,右边字符序列为 "(E)",长度为 3。
  8. f1 产生式:起始符号为 F,右边字符序列为 "i",长度为 1。

接下来,通过双重循环初始化预测分析表 analyseTable。循环变量 m 遍历非终结符数组的索引,循环变量 n 遍历终结符数组的索引。每个表格项是一个产生式结构体。将所有表格项的 origin 属性设置为 'N',表示空,再根据预测分析表中的产生式规则,为表格项赋值。具体赋值如下:

  1. analyseTable[0][0] 赋值为 e 产生式。
  2. analyseTable[0][3] 赋值为 e 产生式。
  3. analyseTable[1][1] 赋值为 g 产生式。
  4. analyseTable[1][4] 和 analyseTable[1][5] 赋值为 g1 产生式。
  5. analyseTable[2][0] 赋值为 t 产生式。
  6. analyseTable[2][3] 赋值为 t 产生式。
  7. analyseTable[3][1] 赋值为 s1 产生式。
  8. analyseTable[3][2] 赋值为s产生式。
  9. analyseTable[3][4] 和 analyseTable[3][5] 赋值为 s1 产生式。
  10. analyseTable[4][0] 赋值为 f1 产生式。
  11. analyseTable[4][3] 赋值为 f 产生式。

这样预测分析表 analyseTable 中的每个表格项都被正确赋值,表示了语法分析中的产生式规则。


2.3.3.2 analyse()函数
void analyse(){
    stacktop = stack1[last]; //获取栈顶字符
    userF = stack2[frist]; //获取用户输入串第一个字符

    int logo = 0; //终结符标志

    for(int j=0; j<number_zjfu; j++){ /*判断是否为终结符*/
        if(stacktop==terminal_array[j]){
            logo=1;
            break;
        }
    }

    if(logo==1){ //如果是终结符
        if(stacktop=='#'&&userF=='#'){   //如果该终结符是#,说明输入串已经全部匹配完成。
            printStack();
            printRemainString();
            statue=1;
            printf("acc!\n");
            return ;
        }
        
        if(stacktop==userF){ //相等则匹配
            printStack();
            printRemainString();
            printf("%c匹配\n",userF);
            frist++;
            last--;
            logo = 0;
        }
        else{
            statue = 2;
            printStack();
            printRemainString();
            printf("error"); //输出产生式
            return;
        }
    }
    else{  //查表
        int row,column;
        for(int j=0; j<unnumber_zjfu; j++){
            if(stacktop==non_terminal_array[j]){
                row = j;  //行号 
                break;
            }
        }
        
        for(int j=0; j<=number_zjfu; j++){
            if(userF==terminal_array[j]){
                column = j;  //列号
                break;
            }
        }
        
        Production cha = analyseTable[row][column];
        if(cha.origin!='N'){ //如果对应的产生式不为空,说明可以继续分析
            printStack();
            printRemainString();
            printf("%c->",cha.origin); //输出产生式
            printf("%s\n",cha.array);
            
            //如果为非终结符,则栈顶的非终结符要去掉
            last--;
            
            for(int j=(cha.length-1); j>=0; j--){ /*产生式逆序入栈*/
                last++;
                stack1[last]=cha.array[j];
            }
            
            if(stack1[last]=='^'){
                last--;
            }
        }
        else{
            //如果对应的产生式为N,则报错。
            statue = 2; //状态为报错状态
            printStack();
            printRemainString();
            printf("error"); //输出产生式
        }
    }
    return ;
}

分析如下:

这里实现了语法分析的核心部分,即根据当前的栈顶符号和输入串的首字符进行分析和匹配。代码先通过以下语句获取栈顶字符和输入串的首字符:

stacktop = stack1[last]; //获取栈顶字符
userF = stack2[frist]; //获取用户输入串第一个字符

接着通过一个循环判断栈顶字符是否为终结符:

int logo = 0; //终结符标志
for(int j=0; j<number_zjfu; j++){  /*判断是否为终结符*/
    if(stacktop==terminal_array[j]){
        logo=1;
        break;
    }
}

如果栈顶字符是终结符,执行以下逻辑:

首先,检查栈顶字符是否为终止符号 #,同时输入串的首字符也是 #。如果是,说明输入串已经全部匹配完成,打印分析栈和剩余串,设置状态为1(acc),输出 "acc!",然后函数返回。

如果栈顶字符和输入串的首字符相等,说明匹配成功,打印分析栈和剩余串,输出当前匹配的终结符号,并更新分析栈和剩余串的指针,即 frist++ 和 last--,并将终结符标志 logo 设置为0,表示不是终结符。

如果栈顶字符和输入串的首字符不相等,说明匹配失败,将状态设置为2(error),打印分析栈和剩余串,输出 "error",然后函数返回。

如果栈顶字符不是终结符,执行以下逻辑:

首先通过循环找到栈顶字符所在的非终结符的行号 row。然后通过循环找到输入串的首字符所在的终结符的列号 column。接着从预测分析表 analyseTable 中获取对应的产生式 cha,根据行号和列号索引到对应的表格项。

如果对应的产生式不为空(即 origin 字段不为 'N'),说明可以继续分析。打印分析栈和剩余串,输出产生式的左部和右部,然后更新分析栈,将产生式的右部逆序入栈。如果对应的产生式为空(即 origin 字段为 'N'),说明发生错误。将状态设置为2(error),打印分析栈和剩余串,输出 "error"。

最后,函数返回,继续下一步的分析过程。


2.4 实验心得

通过本次实验,我实现了LL(1)分析法进行语法分析,并认识到LL(1)分析法利用预测分析表和栈来进行符号匹配和产生式的选择,从而推导出输入串的语法结构。

首先,我了解到LL(1)分析法的核心是构建预测分析表。预测分析表由非终结符和终结符构成,通过预测分析表我们可以根据当前的栈顶符号和输入串的首符号,快速确定应该选择的产生式,从而进行语法推导。在实验中,我通过定义非终结符和终结符的数组以及预测分析表的初始化,构建了一个完整的预测分析表。

其次,我认识到LL(1)分析法对文法的要求比较严格,文法必须满足LL(1)文法的条件。LL(1)文法要求每个非终结符的每个产生式的选择集与其他产生式的选择集没有交集,这样才能保证在分析过程中不会出现二义性和回溯。在实验中,我针对给定的文法,仔细检查了每个非终结符的产生式,并根据LL(1)文法的条件进行了调整和修改,确保文法满足LL(1)的要求。

在编写代码的过程中,我深入理解了LL(1)分析法的工作原理。通过构建函数analyse()的代码,我实现了循环的语法分析过程。在每次循环中,根据栈顶字符和输入串的首字符进行匹配,并根据预测分析表选择相应的产生式。通过不断地匹配和产生式的选择,逐步推导出输入串的语法结构。

通过实验,我对LL(1)分析法的应用有了更深刻的理解。我意识到LL(1)分析法在编译原理中的重要性,它可以帮助构建抽象语法树或生成中间代码。


3. 致各位

亦余心之所善兮 虽九死其犹未悔

ll(1)文法c语言实现,# 【编译原理】,c语言,c++,开发语言,汇编,算法,数据结构文章来源地址https://www.toymoban.com/news/detail-785989.html

到了这里,关于【编译原理】LL(1)分析法:C/C++实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 编译原理实验三:预测分析法语法分析器的设计

    ​ 根据文法编制预测分析法语法分析程序,以便对输入的符号串进行语法分析。通过编写预测分析法语法分析程序掌握预测分析法的基本原理、FIRST和FOLLOW集的计算、预测分析表的构造方法以及语法分析法主控程序的设计。 对于给定的上下文无关文法,编程完成以下功能:

    2024年02月05日
    浏览(52)
  • 【编译原理】【C语言】实验三:递归下降分析法

    C语言 实验环境:Visual Studio 2019 author:zoxiii   用高级语言实现递归下降分析程序。使用输入串i*(i+i),输出分析栈中所有内容,并给出分析结果。   自顶向下分析就是从文法的开始符触发并寻找出这样一个推导序列:推导出的句子恰好为输入符号串;或者说,能否从根节

    2023年04月21日
    浏览(39)
  • 编译原理之LL(1)语法分析实验(附完整C/C++代码与测试)

    先从键盘读入要分析的文法,由程序自动构造FIRST、FOLLOW 集以及SELECT集合,判断是否为LL (1)文法。 分析文法为G[E]: (0)E→ TE’   (1)E’→ +TE’ (2)E’→ε    (3)T→ FT’ (4)T’→ *FT’   (5)T’→ε     (6)F→ (E)    (7)F→a 若符合LL (1)文法,由程序自动构

    2024年02月04日
    浏览(45)
  • LL(1)语法分析设计原理与实现——以赋值语句为例

    一、实验目的 语法分析的设计方法和实现原理;LL(1)分析表的构造;LL(1)分析过程;LL(1)分析器 的构造; 二、实验内容 实现 LL(1)分析中控制程序(表驱动程序);完成以下描述赋值语句的 LL(1) 文法的 LL(1)分析过程。 G[S]:S→V=E E→TE′ E′→ATE′|ε T→FT′ T′→MFT′|ε F→

    2024年02月03日
    浏览(48)
  • 研究性学习专题 3_LL(1)语法分析设计原理与实现

    实现 LL(1)分析中控制程序(表驱动程序);完成以下描述赋值语句的 LL(1)文法的 LL(1)分析过程。重点 LL(1)分析方法和 LL(1)分析器的实现。G[S]: S→ V=E E→ TE’ E’→ ATE’ | e T→ FT’ T’→ MFT’ | E F→ (E) | i A→ + | - M→ * | / V→ i 设计说明:终结符号 i 为用户定义的简单变量,即

    2024年02月03日
    浏览(45)
  • 层次分析法原理及实例(AHP)

    层次分析法(AHP) 层次分析法(analytic hierarchy process) ,简称AHP,是指将与决策总是有关的元素分解成目标、准则、方案等层次,在此基础之上进行定性和定量分析的决策方法。该方法是美国运筹学家匹茨堡大学教授萨蒂于20世纪70年代初,在为美国国防部研究\\\"根据各个工业

    2024年02月08日
    浏览(44)
  • 【AHP层次分析法】原理+应用步骤+旅游目的地选择实例应用

    实现标准之间相对重要程度,并给出决策方案中每个标准的权重,利用权数求出各个方案的优劣次序。 1.建立层次结构模型 该层主要有三个方面: 目标层 准则层 领域层(各种解决问题的措施和方案) 这里选择了一个旅游问题的层次分析模型来直观的展示三个层的关系: 如

    2024年02月04日
    浏览(42)
  • 层次分析法(matlab实现)

           在决策理论中,层次分析法是一种以 数学 和 心理学 为基础,组织和分析复杂决策的结构化技术,它代表了一种 量化决策标准权重 的准确方法,通过成对比较,利用个别专家的经验来估计因素的相对大小        在很多情况下,我们对事物的评价,应该多维度的进

    2024年02月09日
    浏览(43)
  • LVGL源码分析(1):lv_ll链表的实现

    在LVGL中难免需要用到链表:group中的对象需要用链表来存储,这样可以切换对象的焦点;再比如LVGL内部的定时器,多个定时器也是用链表进行存储的。这篇文章就来分析一下LVGL中链表的源码。 对于链表来说,肯定有一个头指针和一个尾指针,在LVGL中,链表的数据结构如下:

    2024年02月13日
    浏览(53)
  • 【建模算法】层次分析法(Python实现)

    在很多情况下,我们对事物评价,应该要多维度评价。多维度评价之后我们要如何把它们合并成一个指标用于比较事物的好坏呢,这时候需要对各个指标赋权, 层次分析法就是用来赋权重的了。 这个方法主观性比较强,在数据集比较小,实在不好比较的时候可以用这个方法

    2024年01月22日
    浏览(42)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包