LL(1)分析法_C++實現

原創 Robin_just 2020-02-21 13:04

Code by C++

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
/*******************************************/

int count=0;              /*分解的產生式的個數*/
int number;               /*所有終結符和非終結符的總數*/
char start;               /*開始符號*/
char termin[50];          /*終結符號*/
char non_ter[50];         /*非終結符號*/
char v[50];               /*所有符號*/
char left[50];            /*左部*/
char right[50][50];       /*右部*/
char first[50][50],follow[50][50];       /*各產生式右部的FIRST和左部的FOLLOW集合*/
char first1[50][50];      /*所有單個符號的FIRST集合*/
char select[50][50];      /*各單個產生式的SELECT集合*/
char f[50],F[50];         /*記錄各符號的FIRST和FOLLOW是否已求過*/
char empty[20];           /*記錄可直接推出^的符號*/
char TEMP[50];            /*求FOLLOW時存放某一符號串的FIRST集合*/
int validity=1;           /*表示輸入文法是否有效*/
int ll=1;                 /*表示輸入文法是否爲LL(1)文法*/
int M[20][20];            /*分析表*/
char choose;              /*用戶輸入時使用*/
char empt[20];            /*求_emp()時使用*/
char fo[20];              /*求FOLLOW集合時使用*/

/*******************************************
 判斷一個字符是否在指定字符串中
********************************************/
int in(char c,char *p)
{
    int i;
    if(strlen(p)==0)
        return(0);
    for(i=0;;i++)
    {   
        if(p[i]==c)
            return(1);       /*若在，返回1*/
        if(i==strlen(p))
            return(0);       /*若不在，返回0*/
    }
}
/*******************************************
 得到一個不是非終結符的符號
********************************************/
char c()
{
    char c='A';
    while(in(c,non_ter)==1)
        c++;
    return(c);
}
/*******************************************
 分解含有左遞歸的產生式
********************************************/
void recur(char *point)
{                     /*完整的產生式在point[]中*/
    int j,m=0,n=3,k;
    char temp[20],ch;
    ch=c();           /*得到一個非終結符*/
    k=strlen(non_ter);
    non_ter[k]=ch;
    non_ter[k+1]='\0';
    for(j=0;j<=strlen(point)-1;j++)
    {   
        if(point[n]==point[0])
        {                          /*如果‘|’後的首符號和左部相同*/
            for(j=n+1;j<=strlen(point)-1;j++)
            {
                while(point[j]!='|'&&point[j]!='\0')
                    temp[m++]=point[j++];
                left[count]=ch;
                memcpy(right[count],temp,m);
                right[count][m]=ch;
                right[count][m+1]='\0';
                m=0;
                count++;
                if(point[j]=='|')
                {
                    n=j+1;
                    break;
                }
            }
        }
        else
        {                          /*如果‘|’後的首符號和左部不同*/
            left[count]=ch;
            right[count][0]='^';
            right[count][1]='\0';
            count++;
            for(j=n;j<=strlen(point)-1;j++)
            {
                if(point[j]!='|')
                    temp[m++]=point[j];
                else
                {
                    left[count]=point[0];
                    memcpy(right[count],temp,m);
                    right[count][m]=ch;
                    right[count][m+1]='\0';
                    printf(" count=%d ",count);
                    m=0;
                    count++;
                }
            }
            left[count]=point[0];
            memcpy(right[count],temp,m);
            right[count][m]=ch;
            right[count][m+1]='\0';
            count++;
            m=0;
        }
    }
}
/*******************************************
 分解不含有左遞歸的產生式
********************************************/
void non_re(char *point)
{
    int m=0,j;
    char temp[20];
    for(j=3;j<=strlen(point)-1;j++)
    {
        if(point[j]!='|')
            temp[m++]=point[j];
        else
        {
            left[count]=point[0];
            memcpy(right[count],temp,m);
            right[count][m]='\0';
            m=0;
            count++;
        }
    }
    left[count]=point[0];
    memcpy(right[count],temp,m);
    right[count][m]='\0';
    count++;
    m=0;
}
/*******************************************
 讀入一個文法
********************************************/
char grammer(char *t,char *n,char *left,char right[50][50])
{
    char vn[50],vt[50];
    char s;
    char p[50][50];
    int i,j,k;
    printf("\n請輸入文法的非終結符號串：");
    scanf("%s",vn);
    getchar();
    i=strlen(vn);
    memcpy(n,vn,i);
    n[i]='\0';
    printf("請輸入文法的終結符號串：");
    scanf("%s",vt);
    getchar();
    i=strlen(vt);
    memcpy(t,vt,i);
    t[i]='\0';
    printf("請輸入文法的開始符號：");
    scanf("%c",&s);
    getchar();
    printf("請輸入文法產生式的條數：");
    scanf("%d",&i);
    getchar();
    for(j=1;j<=i;j++)
    {
        printf("請輸入文法的第%d條（共%d條）產生式：",j,i);
        scanf("%s",p[j-1]);
        getchar();
    }
    for(j=0;j<=i-1;j++)
        if(p[j][1]!='-'||p[j][2]!='>')
        {   printf("\ninput error!");
            validity=0;
            return('\0');
        }            /*檢測輸入錯誤*/
   for(k=0;k<=i-1;k++)
   {                        /*分解輸入的各產生式*/
        if(p[k][3]==p[k][0])
            recur(p[k]);
        else
            non_re(p[k]);
    }
    return(s);
}
/*******************************************
 將單個符號或符號串併入另一符號串
********************************************/
void merge(char *d,char *s,int type)
{                 /*d是目標符號串，s是源串，type＝1，源串中的‘ ^ ’一併併入目串；
                   type＝2，源串中的‘ ^ ’不併入目串*/
    int i,j;
    for(i=0;i<=strlen(s)-1;i++)
    {
        if(type==2&&s[i]=='^')
            ;
        else
        {
            for(j=0;;j++)
            {
                if(j<strlen(d)&&s[i]==d[j])
                   break;
                if(j==strlen(d))
                {
                    d[j]=s[i];
                    d[j+1]='\0';
                    break;
                }
            }
        }
    }
}
/*******************************************
 求所有能直接推出^的符號
********************************************/
void emp(char c)
{                   /*即求所有由‘ ^ ’推出的符號*/
    char temp[10];
    int i;
    for(i=0;i<=count-1;i++)
    {
        if(right[i][0]==c&&strlen(right[i])==1)
        {
            temp[0]=left[i];
            temp[1]='\0';
            merge(empty,temp,1);
            emp(left[i]);
        }
    }
}
/*******************************************
 求某一符號能否推出‘ ^ ’
********************************************/
int _emp(char c)
{                  /*若能推出，返回1；否則，返回0*/
    int i,j,k,result=1,mark=0;
    char temp[20];
    temp[0]=c;
    temp[1]='\0';
    merge(empt,temp,1);
    if(in(c,empty)==1)
        return(1);
    for(i=0;;i++)
    {
        if(i==count)
            return(0);
        if(left[i]==c)         /*找一個左部爲c的產生式*/
        {
            j=strlen(right[i]);    /*j爲右部的長度*/
            if(j==1&&in(right[i][0],empty)==1)
                return(1);
            else if(j==1&&in(right[i][0],termin)==1)
                return(0);
            else 
            {
                for(k=0;k<=j-1;k++)
                    if(in(right[i][k],empt)==1)
                        mark=1;
                if(mark==1)
                    continue;
                else
                {
                    for(k=0;k<=j-1;k++)
                    {
                        result*=_emp(right[i][k]);
                        temp[0]=right[i][k];
                        temp[1]='\0';
                        merge(empt,temp,1);
                    }
                }
            }
            if(result==0&&i<count)
                continue;
            else if(result==1&&i<count)
                return(1);
        }
    }
}
/*******************************************
 判斷讀入的文法是否正確
********************************************/
int judge()
{
    int i,j;
    for(i=0;i<=count-1;i++)
    {
        if(in(left[i],non_ter)==0)
        {                    /*若左部不在非終結符中，報錯*/
            printf("\nerror1!");
            validity=0;
            return(0);
        }
        for(j=0;j<=strlen(right[i])-1;j++)
        {
            if(in(right[i][j],non_ter)==0&&in(right[i][j],termin)==0&&right[i][j]!='^')
            {               /*若右部某一符號不在非終結符、終結符中且不爲‘ ^ ’，報錯*/
                printf("\nerror2!");
                validity=0;
                return(0);
            }
        }
    }
    return(1);
}
/*******************************************
 求單個符號的FIRST
********************************************/
void first2(int i)
{                     /*i爲符號在所有輸入符號中的序號*/
    char c,temp[20];
    int j,k,m;
    c=v[i];
    char ch='^';
    emp(ch);
    if(in(c,termin)==1)       /*若爲終結符*/
    {
        first1[i][0]=c;
        first1[i][1]='\0';
    }   
    else if(in(c,non_ter)==1)       /*若爲非終結符*/
    {
        for(j=0;j<=count-1;j++)
        {
            if(left[j]==c)
            {
                if(in(right[j][0],termin)==1||right[j][0]=='^')
                {
                    temp[0]=right[j][0];
                    temp[1]='\0';
                    merge(first1[i],temp,1);
                }
                else if(in(right[j][0],non_ter)==1)
                {
                    if(right[j][0]==c)
                        continue;
                    for(k=0;;k++)
                        if(v[k]==right[j][0])
                            break;
                    if(f[k]=='0')
                    {   
                        first2(k);
                        f[k]='1';
                    }
                    merge(first1[i],first1[k],2);
                    for(k=0;k<=strlen(right[j])-1;k++)
                    {
                        empt[0]='\0';
                        if(_emp(right[j][k])==1&&k<strlen(right[j])-1)
                        {
                            for(m=0;;m++)
                                if(v[m]==right[j][k+1])
                                    break;
                            if(f[m]=='0')
                            {
                                first2(m);
                                f[m]='1';
                            }
                            merge(first1[i],first1[m],2);
                        }
                        else if(_emp(right[j][k])==1&&k==strlen(right[j])-1)
                        {
                            temp[0]='^';
                            temp[1]='\0';
                            merge(first1[i],temp,1);
                        }
                        else 
                            break;
                    }
                }
            }
        }
    }
    f[i]='1';
}
/*******************************************
 求各產生式右部的FIRST
********************************************/
void FIRST(int i,char *p)
{
    int length;
    int j,k,m;
    char temp[20];
    length=strlen(p);
    if(length==1)                  /*如果右部爲單個符號*/
    {
        if(p[0]=='^')
        {   
            if(i>=0)
            {
                first[i][0]='^';
                first[i][1]='\0';
            }
            else
            {
                TEMP[0]='^';
                TEMP[1]='\0';
            }
        }
        else
        {   
            for(j=0;;j++)
                if(v[j]==p[0])
                    break;
            if(i>=0)
            {
                memcpy(first[i],first1[j],strlen(first1[j]));
                first[i][strlen(first1[j])]='\0';
            }
            else
            {
                memcpy(TEMP,first1[j],strlen(first1[j]));
                TEMP[strlen(first1[j])]='\0';
            }
        }
    }
    else                      /*如果右部爲符號串*/
    {
        for(j=0;;j++)
            if(v[j]==p[0])
                break;
        if(i>=0)
            merge(first[i],first1[j],2);
        else
            merge(TEMP,first1[j],2);
        for(k=0;k<=length-1;k++)
        {
            empt[0]='\0';
            if(_emp(p[k])==1&&k<length-1)
            { 
                for(m=0;;m++)
                    if(v[m]==right[i][k+1])
                        break;
                if(i>=0)
                    merge(first[i],first1[m],2);
                else
                    merge(TEMP,first1[m],2);
            }
            else if(_emp(p[k])==1&&k==length-1)
            {

                temp[0]='^';
                temp[1]='\0';
                if(i>=0)
                    merge(first[i],temp,1);   
                else
                    merge(TEMP,temp,1);
            }
            else if(_emp(p[k])==0)
                break;
        }
    }
}
/*******************************************
 求各產生式左部的FOLLOW
********************************************/
void FOLLOW(int i)
{
    int j,k,m,n,result=1;
    char c,temp[20];
    c=non_ter[i];             /*c爲待求的非終結符*/
    temp[0]=c;
    temp[1]='\0';
    merge(fo,temp,1);
    if(c==start)
    {                         /*若爲開始符號*/
        temp[0]='#';
        temp[1]='\0';
        merge(follow[i],temp,1);
    }
    for(j=0;j<=count-1;j++)
    {
        if(in(c,right[j])==1)     /*找一個右部含有c的產生式*/
        {
            for(k=0;;k++)
                if(right[j][k]==c)
                    break;       /*k爲c在該產生式右部的序號*/
            for(m=0;;m++)
                if(v[m]==left[j])
                    break;        /*m爲產生式左部非終結符在所有符號中的序號*/
            if(k==strlen(right[j])-1)
            {              /*如果c在產生式右部的最後*/
                if(in(v[m],fo)==1)
                {
                    merge(follow[i],follow[m],1);
                    continue;
                }
                if(F[m]=='0')
                {
                    FOLLOW(m);
                    F[m]='1';
                }
                merge(follow[i],follow[m],1);
            }
            else 
            {              /*如果c不在產生式右部的最後*/
                for(n=k+1;n<=strlen(right[j])-1;n++)
                {   
                    empt[0]='\0';
                    result*=_emp(right[j][n]);
                }
                if(result==1)
                {         /*如果右部c後面的符號串能推出^*/
                    if(in(v[m],fo)==1)
                    {           /*避免循環遞歸*/
                        merge(follow[i],follow[m],1);
                        continue;
                    }
                    if(F[m]=='0')
                    {
                        FOLLOW(m);
                        F[m]='1';
                    }
                    merge(follow[i],follow[m],1);
                }
                for(n=k+1;n<=strlen(right[j])-1;n++)
                    temp[n-k-1]=right[j][n];       
                temp[strlen(right[j])-k-1]='\0';
                FIRST(-1,temp);
                merge(follow[i],TEMP,2);
            }
        }
    }
    F[i]='1';
}

/*******************************************
 判斷讀入文法是否爲一個LL(1)文法
********************************************/
int ll1()
{
    int i,j,length,result=1;
    char temp[50];
    for(j=0;j<=49;j++)
    {                              /*初始化*/
        first[j][0]='\0';
        follow[j][0]='\0';
        first1[j][0]='\0';
        select[j][0]='\0';
        TEMP[j]='\0';
        temp[j]='\0';
        f[j]='0';
        F[j]='0';
    }
    for(j=0;j<=strlen(v)-1;j++)
        first2(j);                /*求單個符號的FIRST集合*/
    printf("\nfirst1:");
    for(j=0;j<=strlen(v)-1;j++)
        printf("%c:%s  ",v[j],first1[j]);
    printf("\nempty:%s",empty);
    printf("\n:::\n_emp:");
    for(j=0;j<=strlen(v)-1;j++)
        printf("%d  ",_emp(v[j]));
    for(i=0;i<=count-1;i++)
        FIRST(i,right[i]);          /*求FIRST*/
    printf("\n");
    for(j=0;j<=strlen(non_ter)-1;j++)
    {                               /*求FOLLOW*/
        if(fo[j]==0)
        {
            fo[0]='\0';
            FOLLOW(j);
        }
    }
    printf("\nfirst:");
    for(i=0;i<=count-1;i++)
        printf("%s ",first[i]);
    printf("\nfollow:");
    for(i=0;i<=strlen(non_ter)-1;i++)
        printf("%s ",follow[i]);
    for(i=0;i<=count-1;i++)
    {                          /*求每一產生式的SELECT集合*/
        memcpy(select[i],first[i],strlen(first[i]));
        select[i][strlen(first[i])]='\0';
        for(j=0;j<=strlen(right[i])-1;j++)
            result*=_emp(right[i][j]);
        if(strlen(right[i])==1&&right[i][0]=='^')
            result=1;
        if(result==1)
        {   
            for(j=0;;j++)
                if(v[j]==left[i])
                    break;
            merge(select[i],follow[j],1);
        }
    }
    printf("\nselect:");
    for(i=0;i<=count-1;i++)
        printf("%s ",select[i]);
    memcpy(temp,select[0],strlen(select[0]));
    temp[strlen(select[0])]='\0';
    for(i=1;i<=count-1;i++)
    {                 /*判斷輸入文法是否爲LL(1)文法*/
        length=strlen(temp);
        if(left[i]==left[i-1])
        {
            merge(temp,select[i],1);
            if(strlen(temp)<length+strlen(select[i]))
                return(0);
        }
        else
        {
            temp[0]='\0';
            memcpy(temp,select[i],strlen(select[i]));
            temp[strlen(select[i])]='\0';
        }
    }
    return(1);
}

/*******************************************
 構造分析表M
********************************************/
void MM()
{
    int i,j,k,m;
    for(i=0;i<=19;i++)
        for(j=0;j<=19;j++)
            M[i][j]=-1;
    i=strlen(termin);
    termin[i]='#';     /*將#加入終結符數組*/
    termin[i+1]='\0';
    for(i=0;i<=count-1;i++)
    {
        for(m=0;;m++)
            if(non_ter[m]==left[i])
                break;      /*m爲產生式左部非終結符的序號*/
        for(j=0;j<=strlen(select[i])-1;j++)
        {
            if(in(select[i][j],termin)==1)
            {
                for(k=0;;k++)
                    if(termin[k]==select[i][j])
                        break;        /*k爲產生式右部終結符的序號*/
                M[m][k]=i;
            }
        }
    }
}

/*******************************************
 總控算法
********************************************/
void syntax()
{
    int i,j,k,m,n,p,q;
    char ch;
    char S[50],str[50];
    printf("請輸入該文法的句型：");
    scanf("%s",str);
    getchar();
    i=strlen(str);
    str[i]='#';
    str[i+1]='\0';
    S[0]='#';
    S[1]=start;
    S[2]='\0';
    j=0;
    ch=str[j];
    while(1)
    {
        if(in(S[strlen(S)-1],termin)==1)
        {
            if(S[strlen(S)-1]!=ch)
            {
                printf("\n該符號串不是文法的句型！");
                return;
            }
            else if(S[strlen(S)-1]=='#')
            {
                printf("\n該符號串是文法的句型.");
                return;
            }
            else
            {
                S[strlen(S)-1]='\0';
                j++;
                ch=str[j];
            }
        }
        else 
        {   
            for(i=0;;i++)
                if(non_ter[i]==S[strlen(S)-1])
                    break;
            for(k=0;;k++)
            {   
                if(termin[k]==ch)
                    break;
                if(k==strlen(termin))
                {
                    printf("\n詞法錯誤！");
                    return;
                }
            }
            if(M[i][k]==-1)
            {
                printf("\n語法錯誤！");
                return;
            }
            else
            {
                m=M[i][k];
                if(right[m][0]=='^')
                    S[strlen(S)-1]='\0';
                else
                {
                    p=strlen(S)-1;
                    q=p;
                    for(n=strlen(right[m])-1;n>=0;n--)
                        S[p++]=right[m][n];
                    S[q+strlen(right[m])]='\0';
                }
            }
        }
        printf("\nS:%s str:",S);
        for(p=j;p<=strlen(str)-1;p++)
            printf("%c",str[p]);
        printf(" ");
    }
}

/*******************************************
 一個用戶調用函數
********************************************/
void menu()
{
    syntax();
    printf("\n是否繼續？(y or n):");
    scanf("%c",&choose);
    getchar();
    while(choose=='y')
        { 
            menu();
        }
}


/*******************************************
 主函數
********************************************/
int main()
{
    int i,j;
    start=grammer(termin,non_ter,left,right);               /*讀入一個文法*/
    printf("count=%d",count);
    printf("\nstart:%c",start);
    strcpy(v,non_ter);
    strcat(v,termin);
    printf("\nv:%s",v);
    printf("\nnon_ter:%s",non_ter);
    printf("\ntermin:%s",termin);
    printf("\nright:");
    for(i=0;i<=count-1;i++)
        printf("%s   ",right[i]); 
    printf("\nleft:");
    for(i=0;i<=count-1;i++)
        printf("%c   ",left[i]);            
    if(validity==1)
       validity=judge();
    printf("\nvalidity=%d",validity);
    if(validity==1)
    {
        printf("\n文法有效");
        ll=ll1();
        printf("\nll=%d",ll);
        if(ll==0)
            printf("\n該文法不是一個LL1文法！");
        else
        {
            MM();
            printf("\n");
            for(i=0;i<=19;i++)
                for(j=0;j<=19;j++)
                    if(M[i][j]>=0)
                        printf("M[%d][%d]=%d ",i,j,M[i][j]);
            printf("\n");
            menu();
        }
    }

    return 0;
}

截圖

這裏寫圖片描述

這裏寫圖片描述

Robin_just
發佈了161 篇原創文章 · 獲贊 49 · 訪問量 15萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

一些compile筆記

///////////////////////compile第九章note////////////////////// 程序源代碼多用樹狀結構，因爲源代碼都是上下文無關文法； 而經過編譯器翻譯後形成的目標代碼，由於包含了語義，

Robin_just 2020-07-02 16:09:48

LL(1)分析法(簡單版)_C++實現

代碼 #include<iostream> #include <stdio.h> #include<stdlib.h> #include<string.h> using namespace std; char A[20]

Robin_just 2020-07-02 16:09:48

逆波蘭表達式的產生及計算

JAVA Code RPN_Operation.java package test3; public class RPN_Operation { private char[] expChar = new char[10

Robin_just 2020-07-02 16:09:48

GCC gcov 代碼覆蓋工具的簡單使用

LU_ZHAO 2020-02-27 00:16:07

GCC -fprofile-arcs -ftest-coverage編譯選項

LU_ZHAO 2020-02-27 00:15:57

Linux C/C++產生覆蓋率

LU_ZHAO 2020-02-27 00:15:57

GCC 優化選項 -O -O0 -O1 -O2 -O3 -Os 簡單介紹

LU_ZHAO 2020-02-27 00:15:57

gdb調試命令

spark_csdn 2020-02-23 16:18:03

makefile之 “@” “-”

_cloud 2020-02-22 11:32:35

alsa-lib 交叉編譯以及聲卡驅動測試

wiwa 2020-02-22 07:55:31

靜態庫和動態庫的區別

shaoyizhe2006 2020-02-22 05:43:35

解決Clock skew detected.

shaoyizhe2006 2020-02-22 05:43:35

android gradle依賴：implementation 和compile的區別

卖药郎-徐 2020-02-22 01:12:54

C語言 強符號與弱符號

LU_ZHAO 2020-02-20 18:04:35

java中\r與\n的區別 （主要是在windows中DOS命令下）

\r ： return 到當前行的最左邊。 \n： newline 向下移動一行，並不移動左右。 歷史： 回車”（Carriage Return）和“換行”（Line Feed）這兩個概念的來歷和區別。 在計算機還沒有出現之 前，有一

是夜色太荒芜 2020-07-04 02:05:34