По теории языков программирования и методов трансляции Разработка компилятора модельного языка

else if (fir=="real" || sec=="real") return "real";

else if (fir=="integer" || sec=="integer") return "integer";

else if (fir=="boolean" || sec=="boolean") return "boolean";

else return "err";

}

//-------------------------возвращает  тип операции----------------------------

bool oper_ass(AnsiString fir,AnsiString sec)

{

AnsiString strlec(int nomerlec);

if (fir=="err" || sec=="err") return false;

else if (fir=="boolean" && sec!="boolean") return false;

else if (fir=="integer" && sec=="real") return false;

else return true;

}

//=================================4=========================================

array <TL> poliz (0);   //массив для хранения полиза программы

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

void tab_to_poliz()     //добавление новых ограничителей

{

ogran.push("!");

ogran.push("!F");

ogran.push("R");

ogran.push("W");

}

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

array <strB> ST (0);  //стек операндов

//=================================2=========================================

//------------текст в  окне синтаксического анализатора-----------------------

void errt(AnsiString TErr)  //ERROR TEXT

{Form1->Memo3->Lines->Add(TErr);}

//------------проверка  на правильность входа в вершину  дерева----------------

bool ISTRUE(int a,int b)

{

if (a>b) return true;

else return false;

}

//------------возращает  строку лексемы по номеру из  списка лексем------------

AnsiString strlec(int nomerlec)

{

if (nomerlec>=lec.gsize()||(lec[nomerlec].t<1&&lec[nomerlec].t>4)) return "";

switch (lec[nomerlec].t)

        {

        case 1:return slova[lec[nomerlec].n-1];

        case 2:return ogran[lec[nomerlec].n-1];

        case 3:return chisla[lec[nomerlec].n-1];

        case 4:return ident[lec[nomerlec].n-1];

        }

return "";

}

//-----------пропускает  перевод каретки с текущего  положения-----------------

int e(int n)

{

if (n<lec.gsize()) while (n<lec.gsize()&&strlec(n)=="13") n++;

return n;}

//-----пропускает  перевод каретки с текущего  положения в обратном направлении

int re(int n)

{

if (n<lec.gsize()) while (n>=0&&strlec(n)=="13") n--;

return n;}

//-----------проверяет  открытие - закрытие скобок для  блока лексем-----------

bool skobki(int a,int b,int c)

{

int i,t1=0,t2=0;

for(i=a;i<b;i++) if(strlec(i)=="(")t1++; else if(strlec(i)==")") t1--;

for(i=b+1;i<=c;i++) if(strlec(i)=="(")t2++; else if(strlec(i)==")") t2--;

if (t1==0 && t2==0) return true;

else return false;

} 

//-----------вершина  дерева распознавания идентификатора(ов)-----------------

int verI1(int beg,int fin)

{

if(ISTRUE(beg,fin)) return 100;

int t1,t2;

if (fin==beg && lec[beg].t==4) {if (nid[lec[beg].n-1].type!="")

                                   {TL x; x.t=5; x.n=lec[beg].n-1;

                                    poliz.push(x);

                                    x.t=2; x.n=ogran.find("R");

                                    poliz.push(x);}

                                return 0;}

else if((fin-beg)%2==0 && strlec(beg+1)==",")

        {t1=verI1(beg,beg);

         t2=verI1(beg+2,fin);

         if (t1) return t1;

         if (t2) return t2;}

else return 6;

} 

//-----------вершина дерева распознавания описания--------------------------

int verD(int beg,int fin)

{

int i;

if(ISTRUE(beg,fin)) return 100;

if ((fin-beg)<2) return 7; //не  верно описание

if(strlec(fin)!="boolean" && strlec(fin)!="integer" && strlec(fin)!="real") return 8; //нет типа в описании

if (strlec(fin-1)!=":")  return 9;//нет : в описании

i=verI1(beg,fin-2);

if (i==0) {

        for (i=beg;i<=fin-2; i+=2)   if(nid[lec[i].n-1].type=="") nid[lec[i].n-1].type=strlec(fin);

                                     else return 10; //повтор в описании

        return 0;

          }

else return i;

}

//-----------вершина  дерева распознавания описаний-------------------------

int verD1(int beg,int fin)

{

int t1,t2;

int i;

beg=e(beg); fin=re(fin);

if(ISTRUE(beg,fin)) return 0;

for (i=beg;i<=fin && strlec(i)!=";";i++);

if (i==fin) return verD(e(beg),fin-1);

else if (i>fin) return 11;//нет ;

else {t1=verD(e(beg),i-1);

      t2=verD1(e(i+1),re(fin));

      if(t1) return t1;

      else if(t2) return t2;

      else return 0;}

}

//-----------вершина  дерева распознавания множителя------------------------

int verF(int beg,int fin)

{

int verE(int beg,int fin);

int t1;

if(ISTRUE(beg,fin)) return 100;

if (strlec(beg)=="(" && strlec(fin)==")")  return verE(beg+1,fin-1);

else if (strlec(beg)=="not") {t1=verF(beg+1,fin);

                              if(stack.pop()=="boolean" && t1==0)

                                                         {stack.push("boolean");

                                                          TL x; x.t=1; x.n=slova.find("not");

                                                          poliz.push(x);

                                                          return 0;

                                                          }

                              else {stack.push("err"); return t1;}}

else if ((strlec(beg)=="true" || strlec(beg)=="false")&&beg==fin) {stack.push(typelec(beg));

                                                                   TL x; x.t=1; x.n=slova.find(strlec(beg));

                                                                   poliz.push(x);

                                                                   return 0;}

else if (beg==fin && lec[beg].t==3) {stack.push(typelec(beg));

                                     TL x; x.t=3; x.n=lec[beg].n-1;

                                     poliz.push(x);

                                     return 0;}

else if (beg==fin && lec[beg].t==4) if(typelec(beg)=="") return 12;/*пер не об*/

                                    else {stack.push(typelec(beg));

                                          TL x; x.t=4; x.n=lec[beg].n-1;

                                          poliz.push(x);

                                          return 0;}

else return 13;

}

//-----------вершина  дерева распознавания слагаемого-----------------------

int verT(int beg,int fin)

{

int t1,t2;

AnsiString st1,st2;

int i;

if(ISTRUE(beg,fin)) return 100;

for (i=beg;i<=fin && !((strlec(i)=="*" || strlec(i)=="/" || strlec(i)=="and")&&skobki(beg,i,fin));i++);

if (i>fin) return verF(beg,fin);

else {t1=verF(beg,i-1); t2=verT(i+1,fin);

      st1=stack.pop();

      st2=stack.pop();

      st1=typeoper(st1,st2);

      if(t1) return t1;

      if(t2) return t2;

      if (strlec(i)=="*" && st1!="err") {if(st1=="boolean") stack.push("integer");

                                         else stack.push(st1);}

      else if (strlec(i)=="and" && st1=="boolean") stack.push(st1);

      else if (strlec(i)=="/" && st1!="err") stack.push("real");

      else return 14;//не совпадение типов операндов

      TL x; if(strlec(i)!="and")x.t=2; else x.t=1; x.n=lec[i].n-1;

       poliz.push(x);

      return 0;}

}

//-----------вершина  дерева распознавания операнда------------------------

int verE1(int beg,int fin)

{

int t1,t2;

AnsiString st1,st2;

int i;

if(ISTRUE(beg,fin)) return 100;

for (i=fin;i>=beg && !((strlec(i)=="+" || strlec(i)=="-" || strlec(i)=="or")&&skobki(beg,i,fin));i--);

if (i<beg) return verT(beg,fin);

else {t1=verE1(beg,i-1);

      t2=verT(i+1,fin);

      st1=stack.pop();

      st2=stack.pop();

      st1=typeoper(st1,st2);

      if(t1) return t1;

      if(t2) return t2;

      if ((strlec(i)=="+"|| strlec(i)=="-") && st1!="err")

                                        {if(st1=="boolean") stack.push("integer");

                                         else stack.push(st1);}

      else if (strlec(i)=="or" && st1=="boolean") stack.push(st1);

      else return 14;//не совпадение типов

       TL x; if(strlec(i)!="or")x.t=2; else x.t=1; x.n=lec[i].n-1;

       poliz.push(x);

      return 0;}

}

//-----------вершина  дерева распознавания варажения------------------------

int verE(int beg,int fin)

{

int t1,t2;

int i;

stack.erase();

if(ISTRUE(beg,fin)) return 100;

for (i=beg;i<=fin && !((strlec(i)==">" || strlec(i)=="<" || strlec(i)=="=" || strlec(i)==">=" || strlec(i)=="<=" || strlec(i)=="<>")&&skobki(beg,i,fin));i++);

if (i>fin) {if (skobki(beg,beg-1,fin)) return verE1(beg,fin); else return 28;}

else {

      t1=verE1(beg,i-1);

      t2=verE1(i+1,fin);

      if(t1) return t1;

      else if(t2) return t2;

      else if(stack.pop()!="err" && stack.pop()!="err") stack.push("boolean"); else stack.push("err");}

       TL x; x.t=2; x.n=lec[i].n-1;

       poliz.push(x);

      return 0;

}

//-----------вершина  дерева распознавания варажений------------------------

int verE2(int beg,int fin)

{

int t1,t2,i;

if(ISTRUE(beg,fin)) return 100;

for (i=beg;i<=fin && strlec(i)!=",";i++);

if (i>fin) {t1=verE(beg,fin);

            TL x; x.t=2; x.n=ogran.find("W");

            poliz.push(x);

            return t1;}

else {t1=verE(beg,i-1);

      if(t1) return t1;

      TL x; x.t=2; x.n=ogran.find("W");

      poliz.push(x);

      if(stack.pop()!="err") stack.erase();    else return 15;//в выражениях ошибка

      t2=verE2(i+1,fin);

      if(t2) return t2;

      if(stack.pop()!="err") stack.erase();    else return 15;//в выражениях ошибка