Главная страница

курсовая 2. 1 Постановка задачи 4 2 Формальная модель задачи 5


Скачать 0.89 Mb.
Название1 Постановка задачи 4 2 Формальная модель задачи 5
Дата27.11.2021
Размер0.89 Mb.
Формат файлаdoc
Имя файлакурсовая 2.doc
ТипРеферат
#283891
страница4 из 4
1   2   3   4

nid(0);

//---------------функция преобразует таблицу идентификаторов к расшир. виду--

void ident_to ()

{

int i;

Identificator a;

a.type="";

a.zn.m=0;

a.zn.p=0;

for (i=0;i
{

a.id=ident[i];

nid.push(a);

}

}

//=================================3.2 && 3.3================================

//-------------------------стек----------------------------------------------

array stack (0); //стек для хранения номеров лексем

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

AnsiString typelec(int n)

{

AnsiString strlec(int nomerlec);

if (lec[n].t==3 && NUM[lec[n].n-1].p==0 && (NUM[lec[n].n-1].m==1 || NUM[lec[n].n-1].m==0)) return "boolean";

else if (lec[n].t==3 && NUM[lec[n].n-1].p>=0) return "integer";

else if (lec[n].t==3) return "real";

else if (strlec(n)=="true"||strlec(n)=="false") return "boolean";

else if (lec[n].t==4 && nid[lec[n].n-1].id!="")

return nid[lec[n].n-1].type;

else return "err";

}

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

AnsiString typeoper(AnsiString fir,AnsiString sec)

{

AnsiString strlec(int nomerlec);

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

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 poliz (0); //массив для хранения полиза программы

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

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

{

ogran.push("!");

ogran.push("!F");

ogran.push("R");

ogran.push("W");

}

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

array 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
return n;}

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

int re(int n)

{

if (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
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
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;//в выражениях ошибка

return 0;}

}

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

int verS(int beg,int fin)

{

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

int t1,t2,t3,i,j,z;

TL x; int p0,p1,p2;

beg=e(beg);

fin=re(fin);

for (i=beg;i<=fin && !(strlec(i)==":"||(strlec(i)=="13" && strlec(i-1)!=";" && strlec(i-1)!="13")) ;i++);

//|||||||||||||if||||||||||||||||||||||||

if (strlec(beg)=="if")

{

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

int fl=0;

for (j=beg+1;j<=fin && !(strlec(j)=="else" && fl==0);j++)

if(strlec(j)=="if") fl++; else if (strlec(j)=="else") fl--;

if (i>fin) return 16;//нет then

else if (j then

else if (j<=fin) {

t1=verE(beg+1,i-1);

if(t1) return t1;

if (stack.pop()!="boolean") return 18;

p1=poliz.gsize();

x.t=0; x.n=0; poliz.push(x);

x.t=2; x.n=ogran.find("!F"); poliz.push(x);

t2=verS(i+1,j-1);

if(t2) return t2;

p2=poliz.gsize();

x.t=0; x.n=0; poliz.push(x);

x.t=2; x.n=ogran.find("!"); poliz.push(x);

x.t=0; x.n=poliz.gsize(); poliz[p1]=x;

t3=verS(j+1,fin);

if(t3) return t3;

x.t=0; x.n=poliz.gsize(); poliz[p2]=x;

return 0;}

else if (j>fin){t1=verE(beg+1,i-1);

if(t1) return t1;

if (stack.pop()!="boolean") return 18;

p1=poliz.gsize();

x.t=0; x.n=0; poliz.push(x);

x.t=2; x.n=ogran.find("!F"); poliz.push(x);

t2=verS(i+1,fin);

if(t2) return t2;

x.t=0; x.n=poliz.gsize(); poliz[p1]=x;

return 0;}

}

//|||||||||||||while|||||||||||||||||||||

else if (strlec(beg)=="while")

{

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

if (i>fin) return 19;//нет do

else if (i==fin) return 20;//зацикливание

else {

p0=poliz.gsize();

t1=verE(beg+1,i-1);

if(t1) return t1;

if (stack.pop()!="boolean") return 18;

p1=poliz.gsize();

x.t=0; x.n=0; poliz.push(x);

x.t=2; x.n=ogran.find("!F"); poliz.push(x);

t2=verS(i+1,fin);

if(t2) return t2;

x.t=0; x.n=p0; poliz.push(x);

x.t=2; x.n=ogran.find("!"); poliz.push(x);

x.t=0; x.n=poliz.gsize(); poliz[p1]=x;

return 0;}

}

else if (strlec(beg)=="for")

{

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

for (z=beg;z<=fin && strlec(z)!="do";z++);
if (strlec(beg+2)!="ass") return 21;//нет ass

else if (j>fin) return 22;//нет to

else if (z>fin) return 23;//нет do

else if (lec[beg+1].t==4 && strlec(beg+2)=="ass" )

{

t1=verS(beg+1,j-1); //присватвание

if(t1) return t1;

p0=poliz.gsize(); //заточка под while

x.t=4; x.n=lec[beg+1].n-1; poliz.push(x);

t2=verE(j+1,z-1);

if(t2) return t2;

if(oper_ass(nid[lec[beg+1].n-1].type,stack.pop())) stack.erase(); else return 24;

x.t=2; x.n=ogran.find("<="); poliz.push(x);

p1=poliz.gsize();

x.t=0; x.n=0; poliz.push(x);

x.t=2; x.n=ogran.find("!F"); poliz.push(x);

t3=verS(z+1,fin);

if(t3) return t3;

x.t=5; x.n=lec[beg+1].n-1; poliz.push(x);//i

x.t=4; x.n=lec[beg+1].n-1; poliz.push(x);//i

x.t=1; x.n=slova.find("true"); poliz.push(x);//1

x.t=2; x.n=ogran.find("+"); poliz.push(x);//+

x.t=1; x.n=slova.find("ass"); poliz.push(x);//ass

x.t=0; x.n=p0; poliz.push(x);

x.t=2; x.n=ogran.find("!"); poliz.push(x);

x.t=0; x.n=poliz.gsize(); poliz[p1]=x;

return 0;}

else return 100; //ошибка for

}

//|||||||||||распознавание блока|||||||||||||||||

else if (i
t2=verS(i+1,fin);

if(t1) return t1;

else if(t2) return t2;

else return 0;}

//|||||||||||read and write||||||||||||||

else if (strlec(beg)=="write")

{if (strlec(beg+1)!="(" || strlec(fin)!=")") return 25;

else return verE2(beg+2,fin-1);}

else if (strlec(beg)=="read")

{if (strlec(beg+1)!="(" || strlec(fin)!=")") return 26;

else {

for (i=beg+3;i<=fin-1; i+=2) if(strlec(i)!=",") return 6;

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

return verI1(beg+2,fin-1);

}

}

//||||||||||||||ass||||||||||||||||||||||

else if (lec[beg].t==4 && strlec(beg+1)=="ass")

{if(typelec(beg)=="") return 12;/*пер не об*/

x.t=5; x.n=lec[beg].n-1; poliz.push(x);

t1=verE(beg+2,fin);

if (t1) return t1;

if(oper_ass(nid[lec[beg].n-1].type,stack.pop())) stack.erase(); else return 24;

x.t=1; x.n=slova.find("ass"); poliz.push(x); return 0;}

else return 27;}

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

int verS1(int beg,int fin){

int t1,t2;

int i;

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

beg=e(beg);

while(strlec(fin)=="13") fin--;

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

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

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

t2=verS1(i+1,fin);

if(t1) return t1;

else if(t2) return t2;

else return 0;}}

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

int verP()

{

int tek=e(0),save,q;

while (strlec(tek)!="program" && tek
if (strlec(tek)!="program") return 1;

tek=e(tek+1);

if(strlec(tek)!="var") return 2;

tek=e(tek+1);

save=tek;

while (strlec(save)!="begin"&&save
if(save!=lec.gsize()) {save--; while(strlec(save)=="13") save--;

q=verD1(tek,save);}

else return 3;

if(q) return q;

tek=save;

while (strlec(save)!="begin"&&save
while (strlec(tek)!="end"&&tek
if(tek!=lec.gsize())

q=verS1(save+1,tek-1);

else return 4;

if(q) return q;

tek=e(tek+1);

if(strlec(tek)!=".") return 5;

TL x;

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

return 0;}

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

int SinAnalize()

{

int t=verP();

switch (t){

case 0: errt(""); break;

case 1: errt("ERROR 1: отсутствует program"); break;

case 2: errt("ERROR 2: отсутствует var"); break;

case 3: errt("ERROR 3: отсутствует begin"); break;

case 4: errt("ERROR 4: отсутствует end"); break;

case 5: errt("ERROR 5: отсутствует ."); break;

case 6: errt("ERROR 6: не корректные идентификаторы"); break;

case 7: errt("ERROR 7: описание не верно"); break;

case 8: errt("ERROR 8: нет типа в описании"); break;

case 9: errt("ERROR 9: нет : в описании"); break;

case 10: errt("ERROR 10:повтор в описании"); break;

case 11: errt("ERROR 11:отсутствует ; в описании"); break;

case 12: errt("ERROR 12:идентификатор не обьявлен"); break;

case 13: errt("ERROR 13:множитель не верен"); break;

case 14: errt("ERROR 14:не совместимые типы операндов "); break;

case 15: errt("ERROR 15:ошибка выражений "); break;

case 16: errt("ERROR 16:нет then"); break;

case 17: errt("ERROR 17:then<-->else"); break;

case 18: errt("ERROR 18:условие if или while не bool"); break;

case 19: errt("ERROR 19:нет do для while"); break;

case 20: errt("ERROR 20:зацикливание while(нет оператора)"); break;

case 21: errt("ERROR 21:нет ass в for"); break;

case 22: errt("ERROR 22:нет to в for"); break;

case 23: errt("ERROR 23:нет do в for"); break;

case 24: errt("ERROR 24:не совпадение типов присваивания"); break;

case 25: errt("ERROR 25:нет '(' или ')' в write "); break;

case 26: errt("ERROR 26:нет '(' или ')' в read"); break;

case 27: errt("ERROR 27:оператор не верен"); break;

case 28: errt("ERROR 28:баланс скобок нарушен"); break;

case 100: errt("ERROR 100:отсутствие числа,идентификатора и т.д"); break;

default: errt("ERROR: ошибка компилятора"); break;};

return t;}

//========================================================

AnsiString FILE_NAME;

//====================КНОПКА ОТКРЫТЬ======================

void __fastcall TForm1::Button2Click(TObject *Sender)

{

TOpenDialog* dlg=new TOpenDialog(this);

if(dlg->Execute()){

Memo2->Clear();

FILE_NAME=dlg->FileName;

ifstream is(FILE_NAME.c_str(),ios::in);

char t[100];

while(is.getline(t,100,'\n'))

Memo2->Lines->Add(t);

}

}

//====================КНОПКА АНАЛИЗ=======================

void __fastcall TForm1::Button1Click(TObject *Sender)

{

text.erase(); chisla.erase(); ident.erase(); NUM.erase(); S.erase();

lec.erase(); nid.erase(); stack.erase(); poliz.erase();

finstr; nomersymbol=0;

Memo1->Clear(); Memo3->Clear();

for (int i=0;iLines->Text.Length();i++)

if (Memo2->Lines->Text[i+1]!='\r') text.push(Memo2->Lines->Text[i+1]);

ifstream ts("1.txt",ios::in);

ifstream to("2.txt",ios::in);

char t[100];

while(ts.getline(t,100,'\n')) slova.push(t);

while(to.getline(t,100,'\n')) ogran.push(t);

LAnalize();

ident_to();

tab_to_poliz();

if(!SinAnalize()) {AnsiString strpoliz="";

for(int i=0;i

switch (poliz[i].t)

{

case 0: {strpoliz+="#";strpoliz+=poliz[i].n;} break;

case 1: {strpoliz+=slova[poliz[i].n];} break;

case 2: {strpoliz+=ogran[poliz[i].n];} break;

case 3: {strpoliz+=chisla[poliz[i].n];} break;

case 4: {strpoliz+=ident[poliz[i].n];} break;

case 5: {strpoliz+=ident[poliz[i].n];} break;

}strpoliz+=">";}

errt(strpoliz);}}

//====================КНОПКА СОХРАНИТЬ=======================

void __fastcall TForm1::Button4Click(TObject *Sender)

{

if (FILE_NAME=="")

{

TSaveDialog* dlg=new TSaveDialog(this);

if(dlg->Execute()){

FILE_NAME=dlg->FileName;

Memo2->Lines->SaveToFile(FILE_NAME);} }

else Memo2->Lines->SaveToFile(FILE_NAME);

}

//====================КНОПКА START============================

void __fastcall TForm1::Button5Click(TObject *Sender)

{

long mant (double x,int &p);

ST.erase();

strB x,y;

for(int i=0;i

{

case 0: {

x.m=poliz[i].n; x.p=0;

ST.push(x);

} break;

case 1: {

if(slova[poliz[i].n]=="ass")

{ x=ST.pop();

y=ST.pop();

nid[y.m].zn=x;}

else if (slova[poliz[i].n]=="or")

{ x=ST.pop();

y=ST.pop();

if (x.p==0 && y.p==0 && (x.m || y.m)) {x.m=1; ST.push(x);}

else {x.m=0; ST.push(x);}}

else if (slova[poliz[i].n]=="and")

{ x=ST.pop();

y=ST.pop();

if (x.p==0 && y.p==0 && (x.m && y.m)) {x.m=1; ST.push(x);}

else {x.m=0; ST.push(x);}}

else if (slova[poliz[i].n]=="not")

{ x=ST.pop();

if (x.p==0 && x.m==1) x.m=0;

else x.m=1;

ST.push(x);}

else if (slova[poliz[i].n]=="true")

{ x.m=1;

x.p=0;

ST.push(x);}

else if (slova[poliz[i].n]=="false")

{ x.m=0;

x.p=0;

ST.push(x);}

} break;

case 2: {

if (ogran[poliz[i].n]=="<>")

{ x=ST.pop();

y=ST.pop();

if ((x.m==y.m && x.p==y.p) || (x.m==0&&y.m==0&&x.p!=y.p)) {x.m=0;x.p=0;ST.push(x);}

else {x.m=1; x.p=0; ST.push(x);}}

else if (ogran[poliz[i].n]=="=")

{ x=ST.pop();

y=ST.pop();

if ((x.m==y.m && x.p==y.p) || (x.m==0&&y.m==0&&x.p!=y.p)) {x.m=1;x.p=0;ST.push(x);}

else {x.m=0; x.p=0; ST.push(x);}}

else if (ogran[poliz[i].n]=="<=")

{ y=ST.pop();

x=ST.pop();

if (x.p
else if (x.m<=y.m && x.p==y.p) {x.m=1;x.p=0;ST.push(x);}

else {x.m=0; x.p=0; ST.push(x);}}

else if (ogran[poliz[i].n]==">=")

{ y=ST.pop();

x=ST.pop();

if (x.p>y.p) {x.m=1;x.p=0;ST.push(x);}

else if (x.m>=y.m && x.p==y.p) {x.m=1;x.p=0;ST.push(x);}

else {x.m=0; x.p=0; ST.push(x);}}

else if (ogran[poliz[i].n]==">")

{ y=ST.pop();

x=ST.pop();

if (x.p>y.p) {x.m=1;x.p=0;ST.push(x);}

else if (x.m>y.m && x.p==y.p) {x.m=1;x.p=0;ST.push(x);}

else {x.m=0; x.p=0; ST.push(x);}}

else if (ogran[poliz[i].n]=="<")

{ y=ST.pop();

x=ST.pop();

if (x.p
else if (x.m
else {x.m=0; x.p=0; ST.push(x);}}

else if (ogran[poliz[i].n]=="+")

{ y=ST.pop();

x=ST.pop();

if (x.p>y.p) for(;y.p!=x.p;x.p--) x.m*=10;

if (x.p
x.m+=y.m;

if (x.m==0) x.p=0;

ST.push(x);}

else if (ogran[poliz[i].n]=="-")

{ y=ST.pop();

x=ST.pop();

if (x.p>y.p) for(;y.p!=x.p;x.p--) x.m*=10;

if (x.p
x.m-=y.m;

if (x.m==0) x.p=0;

ST.push(x); }

else if (ogran[poliz[i].n]=="*")

{ y=ST.pop();

x=ST.pop();

x.p+=y.p;

x.m*=y.m;

if (x.m==0) x.p=0;

ST.push(x); }

else if (ogran[poliz[i].n]=="/")

{ y=ST.pop();

x=ST.pop();

if (y.m==0) {errt("ERROR 29:деление на ноль"); return ;}

x.p-=y.p;

double q1=x.m,q2=y.m;

q1/=q2;

x.m=mant(q1,x.p);

ST.push(x);}

else if (ogran[poliz[i].n]=="!")

{ y=ST.pop();

i=y.m-1; }

else if (ogran[poliz[i].n]=="!F")

{ x=ST.pop();

y=ST.pop();

if (y.m==0) i=x.m-1;}

else if (ogran[poliz[i].n]=="R")

{ y=ST.pop();

void INP(int nomer);

INP(y.m);}

else if (ogran[poliz[i].n]=="W")

{ y=ST.pop();

void OUTP(strB x);

OUTP(y);

}

} break;

case 3: {

ST.push(NUM[poliz[i].n]);

} break;

case 4: {

ST.push(nid[poliz[i].n].zn);

} break;

case 5: {

x.m=poliz[i].n;

x.p=0;

ST.push(x);

} break;

}

}

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

void INP(int nomer)

{

long mant (double x,int &p);

AnsiString value="";

while (value=="") value=InputBox("Введите:"+nid[nomer].type,nid[nomer].id,"");

if (nid[nomer].type=="boolean")

{

if (value=="true") {nid[nomer].zn.m=1;nid[nomer].zn.p=0;}

if (value=="false") {nid[nomer].zn.m=0;nid[nomer].zn.p=0;}

if (value=="1") {nid[nomer].zn.m=1;nid[nomer].zn.p=0;}

if (value=="0") {nid[nomer].zn.m=0;nid[nomer].zn.p=0;}

}

else if (nid[nomer].type=="integer"){nid[nomer].zn.m=value.ToInt();

nid[nomer].zn.p=0;}

else {double x=value.ToDouble();

nid[nomer].zn.m= mant(x,nid[nomer].zn.p);}

}

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

void OUTP(strB x)

{

AnsiString a=">>";

if (x.p==0 &&(x.m==0 || x.m==1))

{

if (x.m==1) a+="true";

else a+="false";

}

else if (x.p==0) a+=x.m;

else {a+=x.m; a+="E"; a+=x.p;}

Form1->Memo4->Lines->Add(a);

}

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

long mant (double x,int &p)

{

while (fabs(x)>=1) {x/=10; p++;}

int i; double c;

for (i=0;i<9 && modf(x,&c)!=0;i++) {x*=10; p--;}

return floor(x+0.1);

}
//////////////////////////UNIT ARRAY//////////////////////////////////////////
#include

#include

template class array

{

D *p;

int size;

//+++++++++++++++++++++++++++++

public:

array(int n=10)

{size=n;

p=new D[size];

}

//+++++++++++++++++++++++++++++

array (const D a[],int n)

{

size=n;

p=new D [size];

for(int i=0;i
}

//+++++++++++++++++++++++++++++

array() {delete [] p;}

//+++++++++++++++++++++++++++++

D & operator [] (int i)

{

if(i<0||i>=size)

{

cout<<"\nincorrect index array";

getch();

exit(0);

}

return p[i];

}

//+++++++++++++++++++++++++++++

int gsize(){return size;}

//+++++++++++++++++++++++++++++

void resize(int n)

{

int i;

D *temp=new D[n];

if (n<=size)

for (i=0;i
temp[i]=p[i];

else

{for (i=0;i
temp[i]=p[i];

// for (i=size;i
// temp[i]=D;

}

delete []p;

p=temp;

size=n;

}

//+++++++++++++++++++++++++++++

void push(D z)

{

resize(size+1);

p[size-1]=z;

}

//+++++++++++++++++++++++++++++

D pop()

{

D temp;

if(size<1) return temp;

temp=p[size-1];

resize(size-1);

return temp;

}

//+++++++++++++++++++++++++++++

void erase() {if (size) resize(0);}

//+++++++++++++++++++++++++++++

int find(D elem)

{

for (int i=0;i
return -1;

}

//+++++++++++++++++++++++++++++

};




Лист


1   2   3   4


написать администратору сайта