main.~cpp

ll1文法分析器

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "main.h"
#include "AnalysisTable.h"
#include "AnalysisSentence.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
int count=0;
int ll=1;
int validity=1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{   open=false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button5Click(TObject *Sender)
{
Application->Terminate();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button3Click(TObject *Sender)
{
int answer;
answer=Application->MessageBox("是否真的清除文法","请确认",4);
if(answer==6)
{
Memo1->Clear();
Memo2->Clear();
Memo3->Clear();
Edit1->Clear();
Form2->Memo1->Clear();
Form3->Memo1->Clear();
open=false;
}
else
{ }
}
//---------------------------------------------------------------------------


void __fastcall TForm1::Button1Click(TObject *Sender)
{    Memo1->Lines->Clear();
     Memo2->Lines->Clear();
     Memo3->Lines->Clear();
     for(int b=0;b<50;b++)
     {non_ter[b]=NULL;
      termin[b]=NULL;left[b]=NULL;
      for(int b=0;b<50;b++)
          right[c][b]=NULL;
      }




OpenDialog1->Filter="文本文档(*.txt)|*.TXT";
if(OpenDialog1->Execute())
{Memo3->Lines->LoadFromFile(OpenDialog1->FileName);
 open=true;
}

ISVT(termin,non_ter);




}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button4Click(TObject *Sender)
{
Form1->SaveDialog1->Filter="文本文档(*.txt)|*.TXT";
if(Form1->SaveDialog1->Execute())
{Form1->Memo3->Lines->SaveToFile(Form1->SaveDialog1->FileName);}
}
//-----------------------------识别终结与非终结符--------------------------------
void __fastcall TForm1::ISVT(char *termin,char *non_ter)
{  int line=0; int ivt=0;int invt=0; int temp;
   //for(int b=0;b<=50;b++)non_ter[b]=NULL;
  for(line=0;line<Memo3->Lines->Count;line++)
  {  char *buffer;    int bufnum=0;
   buffer=new char[Memo3->Lines->Strings[line].Length()+1];
   strcpy(buffer,Memo3->Lines->Strings[line].c_str());
  //char buf=buffer[0];
    for( bufnum=0;bufnum<Memo3->Lines->Strings[line].Length();bufnum++)
     {
      if(buffer[bufnum]>='A'&&buffer[bufnum]<='Z'&&IsInNVT(buffer[bufnum],invt+1))
        {non_ter[invt++]=buffer[bufnum];}
      else
      {temp=Isright(line);
      if(bufnum>temp&&buffer[bufnum]!=' '&&!(buffer[bufnum]>='A'&&buffer[bufnum]<='Z')&&SameVT(buffer[bufnum],ivt))
         {
          termin[ivt]=buffer[bufnum];ivt++;
     }
     /* else
         buf=buffer[bufnum];*/
          }}
    }
      for(int nvtnum=0;nvtnum<=ivt;nvtnum++)
      {  Memo1->Lines->Add(non_ter[nvtnum]);}
      starter=non_ter[0];
      Edit1->Text=starter;

      for(int vtnum=0;vtnum<=invt;vtnum++)
         Memo2->Lines->Add(termin[vtnum]);

}
//--------------------------------------------------
bool __fastcall TForm1::IsInNVT(char buf,int nvtnum)
{   for(int j=0;j<nvtnum;j++)
       if(non_ter[j]==buf)
         return false;
       return true;
       }

bool _fastcall TForm1::SameVT(char buf,int vtnum)
{

      for(int j=0;j<vtnum;j++)
          if(termin[j]==buf)

            return false;
            return true;

 }
//---------------------------------------------------------------------------
int __fastcall TForm1::Isright(int line)
{  char* buffer;
   buffer=new char[Memo3->Lines->Strings[line].Length()+1];
   strcpy(buffer,Memo3->Lines->Strings[line].c_str());
   for(int bufnum=0;bufnum<Memo3->Lines->Strings[line].Length();bufnum++)
   if(buffer[bufnum]=='-'&&buffer[bufnum+1]=='>')
    return bufnum+1;
}
//---------------------------识别终结与非终结符-----------------------------------------------


//----------------------------分析表生成函数---------------------------------------------
  /*******************************************
 判断一个字符是否在指定字符串中
********************************************/
int __fastcall TForm1::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 __fastcall TForm1::c()
{
 char c='A';
    while(in(c,non_ter)==1)
  c++;
 return(c);
}
/*******************************************
 分解含有左递归的产生式
********************************************/
void __fastcall TForm1::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 __fastcall TForm1::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 __fastcall TForm1::grammer(char *t,char *n,char *left,char right[50][50])
{
 char vn[50],vt[50];
 char s;
 
 int i,j,k;int num1=0,num2=0;

    while(strlen(n)>=num1)
    {vn[num1]=n[num1];num1++;}
    i=strlen(vn);
    memcpy(n,vn,i);
 n[i]='\0';
/* printf("请输入文法的终结符号串：");
    scanf("%s",vt);
 getchar();
    i=strlen(vt);*/
    while(strlen(t)>=num2)
    {vt[num2]=t[num2];num2++;}
    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();
 }    */
   i=Memo3->Lines->Count;
   for(j=0;j<=i;j++)
   {char* bufp;
    bufp=new char[Memo3->Lines->Strings[j].Length()];
     strcpy(bufp,Memo3->Lines->Strings[j].c_str());
        for(int n=0;n<=Memo3->Lines->Strings[j].Length();n++)
        {p[j][n]=bufp[n];}   }
        Form2->Memo1->Lines->Add("产生式：");
            for(j=0;j<i;j++)
    Form2->Memo1->Lines->Add(p[j]);


   for(j=0;j<=i-1;j++)
  if(p[j][1]!='-'||p[j][2]!='>')
  {

    ShowMessage("输入错误!");
      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 __fastcall TForm1::merge(char *d,char *s,int type)
 {   int i,j;                     /*d是目标符号串，s是源串，type＝1，源串中的‘@’一并并入目串；
                type＝2，源串中的‘ @ ’不并入目串*/
 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 __fastcall TForm1::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 __fastcall TForm1::_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 __fastcall TForm1::judge()
{  

    int i,j;
 for(i=0;i<=count-1;i++)
 {
  if(in(left[i],non_ter)==0)
  {                   // 若左部不在非终结符中，报错
   ShowMessage("左部无效符号!");
   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]!='@')
   {               /*若右部某一符号不在非终结符、终结符中且不为‘ @ ’，报错*/
    ShowMessage("右部无效符号");
    validity=0;
    return(0);
   }
  }
 }
 return(1);
}
/*******************************************
 求单个符号的FIRST
********************************************/
void __fastcall TForm1::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;
     }
    }