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

Автор: Пользователь скрыл имя, 19 Мая 2012 в 17:24, курсовая работа

Краткое описание

Теория формальных языков, грамматик и автоматов составляет фундамент синтаксических методов. Основы этой теории были заложены Н. Хомским в 40–50-е годы XX столетия в связи с его лингвистическими работами, посвященными изучению естественных языков. Но уже в следующем десятилетии синтаксические методы нашли широкое практическое применение в области разработки и реализации языков программирования.

Оглавление

Введение 3
1 Постановка задачи 4
2 Формальная модель задачи 5
3 Структура программы………………………………………………….....16
3.1 Лексический анализатор 16
3.2 Синтаксический анализатор 18
3.3 Семантический анализатор 20
3.4 Генерация ПОЛИЗа программы 22
3.5 Интерпритация ПОЛИЗа программы 24
4 Структурная организация данных 31
4.1 Спецификация входной информации 31
4.2 Спецификация выходной информации 31
4.3 Спецификация процедур и функций 31
5 Разработка алгоритма решения задачи 32
5.1 Укрупненная схема алгоритма программного средства 32
5.2 Детальная разработка алгоритмов отдельных подзадач 33
6 Установка и эксплуатация программного средства 34
7 Работа с программным средством 35
Заключение 36
Список использованных источников 37
Приложение А – Текст программы 38

Файлы: 1 файл

отчет3.doc

— 910.50 Кб (Скачать)

                        {

                        for (int i=0;i<S.gsize();i++) mantisa+=S[i];

                        S.push(CH);

                        char **q=new char*;

                       CS2=V;

                        B.m=(long)strtol(mantisa.c_str(),q,16) ;

                        }

                 else  if (CH=='+'||CH=='-')

                        {S.push(CH);

                         int flag=0;

                         for (int j=0;j<S.gsize()-2;j++) if (!isdigit(S[j])) flag=1;

                         if (S[S.gsize()-2]!='E'&&S[S.gsize()-2]!='e') flag=1;

                         if (flag) {CS2=ERR; continue;}

                         for (int i=0;i<S.gsize()-2;i++) mantisa+=S[i];

                         B.m=mantisa.ToInt();

                         while(B.m%10==0) {B.m=B.m/10; B.p++;}

                         if (CH=='-')znak=false;

                         CS2=l5;}

                 else  if (ogran.find(CH)>=0 || CH=='\n' || CH==' ' || CH=='\t')

                        {int  Ne,flag=0;

                         for (Ne=0;Ne<S.gsize() && S[Ne]!='e' && S[Ne]!='E';Ne++);

                         if (Ne==S.gsize() || Ne==S.gsize()-1 || Ne==0) {CS2=ERR; continue;}

                        for (int j=0;j<Ne;j++) if (!isdigit(S[j])) flag=1;

                         for (int j=Ne+1;j<S.gsize();j++) if (!isdigit(S[j])) flag=1;

                         if (flag) {CS2=ERR; continue;}

                         for (int i=0;i<Ne;i++) mantisa+=S[i];

                         B.m=mantisa.ToInt();

                         while(B.m%10==0) {B.m=B.m/10; B.p++;}

                         mantisa="";

                         for (int i=Ne+1;i<S.gsize();i++) mantisa+=S[i];

                         B.p+=mantisa.ToInt();

                         retgc();

                         CS2=V;}

                   else CS2=ERR;

                } break;

        case l4:{

                gc();

                if(digit()) {B.p--; B.m=B.m*10+atoi(&CH); CS2=l2; S.push(CH);}

                else if (ogran.find(CH)>=0 || CH=='\n')

                        {CS2=V;

                         retgc();

                         }

                else CS2=ERR;

                } break;

        case l5:

                {

                gc();

                if(digit()) {CS2=l7; S.push(CH); por=atoi(&CH);}

                else if(CH=='+') {CS2=l6; S.push(CH);}

                else if (CH=='-') {znak=false; CS2=l6; S.push(CH);}

                else CS2=ERR;

                } break;

        case l6:

                {

                gc();

                if(digit()) {CS2=l7; S.push(CH); por=atoi(&CH);}

                else CS2=ERR;

                } break;

        case l7:

                {

                gc();

                if(digit()) {por=por*10+atoi(&CH); S.push(CH);}

                else if (ogran.find(CH)>=0 || CH=='\n') {if(znak) B.p+=por; else B.p-=por;

                                             CS2=V; retgc();}

                else CS2=ERR;

                } break; 

        case ERR:

                {

                 Form1->Memo1->Lines->Add("Ошибка вo втором автомате");

                 return 1;

                } break; 

        case V:

                {

                AnsiString a="",b=""; int i;

                for(int i=0;i<S.gsize();i++) a+=S[i];

                b+=B.m; b+=" "; b+=B.p;

                for (i=0;i<NUM.gsize() && (NUM[i].m!=B.m || NUM[i].p!=B.p);i++);

                if (NUM.gsize()==i) NUM.push(B);

                S.erase();

                for(int i=0;i<b.Length();i++) S.push(b[i+1]);

                int nomer=chisla.find(b);

                if (nomer>=0) outlec(3,nomer+1);

                else {

                     outlec(3,chisla.gsize()+1);

                     AddTab(3);}

                return 0;

                } break; 

        }

while (CS1!=lEND);

} 

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

void LAnalize()

{

CS1=lA;

do switch (CS1)

        {

        case lA:{

                S.erase();

                if(gc()) {CS1=lEND; continue;}

                if(digit()||CH=='.') CS1=lCHISLO ;

                else if (let()) CS1=lB;

                else CS1=lE;

                S.push(CH);

                break; }

        case lB:{

                gc();

                if(digit()||let()) S.push(CH);

                else {CS1=lC;

                      retgc();

                     };

                } break;

        case lC:{

                AnsiString slovo="";

                for (int i=0;i<S.gsize();i++) slovo+=S[i];

                int nomer=slova.find(slovo); int fl;

                if (slovo=="end") {outlec(1,nomer+1);

                                   fl=gc();

                                   if(CH=='.'&& fl==0)

                                              {S.erase();

                                               S.push('.');

                                               outlec(2,ogran.find(".")+1);

                                               CS1=lEND;}

                                   else CS1=lERR;

                                   }

                else if (nomer>=0)

                        {outlec(1,nomer+1);

                         CS1=lA;

                        }

                else CS1=lD;

                } break;

        case lD:{

                AnsiString id="";

                for (int i=0;i<S.gsize();i++)

                id+=S[i];

                int nomer=ident.find(id);

                if (nomer>=0)

                        {outlec(4,nomer+1);

                         CS1=lA;

                        }

                else {

                     outlec(4,ident.gsize()+1);

                     AddTab(4);

                     CS1=lA;

                     }

                } break;

        case lE:{

                AnsiString o=""; o+=CH;

                if (CH==' ' || CH=='\t') {CS1=lA; continue;}

                else if(CH=='>'||CH=='<')

                        {

                        gc();

                        if(CH=='>'||CH=='=')

                                {o+=CH;

                                 if(ogran.find(o)>=0) {S.push(CH); outlec(2,ogran.find(o)+1); CS1=lA;}

                                 else CS1=lERR;

                                }

                         else {  retgc();

                                 if(ogran.find(o)>=0) {outlec(2,ogran.find(o)+1);  CS1=lA;}

                                 else CS1=lERR;

                              }

                        }

                else if (CH=='{')

                                {

                                CS1=lERR;

                                while (CH!='}'&& gc()==0);

                                if(CH=='}') CS1=lA;

                                }

                else if (CH=='}'){CS1=lERR;}

                else    {if (CH=='\n') o="13";

                        if(ogran.find(o)>=0) {outlec(2,ogran.find(o)+1); CS1=lA;}

                        else {CS1=lERR;}}

                } break;

        case lCHISLO:

                {if(AnalizeChislo()) CS1=lEND;

                 else CS1=lA;} break;

        case lERR:

                {

                 CS1=lEND;

                 Form1->Memo1->Lines->Add("Ошибка в первом автомате");

                } break; 

        }

while (CS1!=lEND);

}

//=================================3.1=======================================

//---------------структура  для хранения расширенной таблицы  идентификаторов--

struct Identificator

{

AnsiString id;

AnsiString type;

strB zn;

};

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

array <Identificator> nid(0);

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

void ident_to ()

{

int i;

Identificator a;

a.type="";

a.zn.m=0;

a.zn.p=0;

for (i=0;i<ident.gsize();i++)

        {

         a.id=ident[i];

         nid.push(a);

        }

}

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

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

array <AnsiString> 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";

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