Файл: Отчет Л.р.4 ШАВРОВА.docx

Сделать презентацию

Скачать файл (1,42Мб)

Заказать решение

ВУЗ: Не указан

Категория: Не указан

Дисциплина: Не указана

Добавлен: 18.04.2025

Просмотров: 404

Скачиваний: 0

ВНИМАНИЕ! Если данный файл нарушает Ваши авторские права, то обязательно сообщите нам.

СОДЕРЖАНИЕ

Национальный исследовательский университет «Московский энергетический институт» Институт автоматики и вычислительной техники Кафедра математического моделирования

Оглавление

Void Prints(rez &r)

Void __fastcall tForm1::BitBtn1Click(tObject *Sender)

LeksBlok.H

Void Strcpy(char mas[], int n, char *txt, int m);

Void LeksichBlok(Ident &I, char *txt);

LeksBlok.Cpp

Void LeksichBlok(Ident &I, char *txt)

Sintaksis.H

Void Sint(Ident &I, rez &r);

Sintaksis.Cpp

Void Sint(Ident &I, rez &r)

Interpretator.H

Void Inter(Ident &I, rez &r);

Interpretator.Cpp

Void Inter(Ident &I, rez &r)

Data.Cpp

Ident::Ident()

Void Ident::Delete(elem el)

Stack_mass.H

case C_INT: case C_IDENTIF: //#8

St.push(-1);

St.push(T_E_SPIS);

St.push(St.Size() - 2);

St.push(T_T);

break;

default:

throw ErrInvChain();

}

break;

case T_E_SPIS: //#9

if (el.clas == C_RAZDEL)

switch(el.name[0])

{

case '+' :

ptr = St.pop();

el.clas = C_NOV;

R.Data.push(el);

St.push(R.Data.Size() - 1);

St.push(T_E_SPIS);

St.push(R.Data.Size() - 1);

St.push(-1);

St.push(ptr);

St.push(K_SLOJ);

St.push(St.Size() - 3);

St.push(T_T);

++i;

break;

case ';' : //#10

ptr = St.pop();

St[St.pop()] = ptr;

break;

default:

throw ErrInvChain();

}

break;

case T_T:

switch(el.clas) //#11

{

case C_INT: case C_IDENTIF:

St.push(-1);

St.push(T_T_SPIS);

St.push(St.Size() - 2);

St.push(T_F);

break;

default:

throw ErrInvChain();

}

break;

case T_T_SPIS:

if (el.clas == C_RAZDEL) //#12

switch(el.name[0])

{

case '*' :

ptr = St.pop();

el.clas = C_NOV;

R.Data.push(el);

St.push(R.Data.Size() - 1);

St.push(T_T_SPIS);

St.push(R.Data.Size() - 1);

St.push(-1);

St.push(ptr);

St.push(K_UMNOJ);

St.push(St.Size() - 3);

St.push(T_F);

++i;

break;

case '+' : case ';' : //#13

ptr = St.pop();

St[St.pop()] = ptr;

break;

default:

throw ErrInvChain();

}

break;

case T_F:

switch(el.clas) //#14

{

case C_INT: case C_IDENTIF:

St.push(-1);

St.push(T_F_SPIS);

St.push(St.Size() - 2);

St.push(T_P);

break;

default:

throw ErrInvChain();

}

break;

case T_F_SPIS:

if (el.clas == C_RAZDEL)

switch(el.name[0])

{

case '^': //#15

ptr = St.pop();

el.clas = C_NOV;

R.Data.push(el);

St.push(R.Data.Size() - 1);

St.push(T_F_SPIS);

St.push(R.Data.Size() - 1);

St.push(-1);

St.push(ptr);

St.push(K_V_STEP);

St.push(St.Size() - 3);

St.push(T_P);

++i;

break;

case '*' : case '+' : case ';' : //#16

ptr = St.pop();

St[St.pop()] = ptr;

break;

default :

throw ErrInvChain();

}

break;

case T_P:

switch(el.clas)

{

case C_INT: case C_IDENTIF: //#17//#18

//проверка на вхождения

for (ptr = 0; ptr < R.Data.Size(); ++ptr)

if ((R.Data[ptr].clas == C_IDENTIF || R.Data[ptr].clas == C_INT) && !strcmp(R.Data[ptr].name, el.name))

break;

if (ptr == R.Data.Size())

R.Data.push(el);

St[St.pop()] = ptr;

++i;

break;

default :

throw ErrInvChain();

}

break;

case T_OPER_IF:

if (el.clas == C_KEY_WORD && el.name[0] == 'i') //#19

{

R.Label.push(-1);

St.push(R.Label.Size() - 1);

St.push(T_ELSE_PART);

St.push(T_OPER);

St.push(KS_THEN);

St.push(R.Label.Size() - 1);

St.push(-1);

St.push(K_PEREHOD_0);

St.push(St.Size() - 2);

St.push(T_LOG_VIR);

++i;

}

else

throw ErrInvChain();

break;

case T_ELSE_PART:

if (el.clas == C_KEY_WORD && el.name[0] == 'e') //#20

{

ptr = St.pop();

R.Label.push(-1);

St.push(R.Label.Size() - 1);

St.push(K_METKA);

St.push(T_OPER);

St.push(ptr);

St.push(K_METKA);

St.push(R.Label.Size() - 1);

St.push(K_PEREHOD_BEZ_USL);

++i;

break;

}

if (el.clas == C_IDENTIF || //#21

el.clas == C_KEY_WORD && el.name[0] == 'i' ||

el.clas == C_KEY_WORD && el.name[0] == 'w' ||

el.clas == C_RAZDEL && el.name[0] == -74)

{

St.push(K_METKA);

break;

}

throw ErrInvChain();

case T_OPER_CYCLE: //#22

if (el.clas == C_KEY_WORD && el.name[0] == 'w')

{

St.push(KS_END_WHILE);

R.Label.push(-1);

St.push(R.Label.Size() - 1);

St.push(K_METKA);

R.Label.push(-1);

St.push(R.Label.Size() - 1);

St.push(K_PEREHOD_BEZ_USL);

St.push(T_SOVOK_OPER);

St.push(R.Label.Size() - 2);

St.push(-1);

St.push(K_PEREHOD_SRAVN);

St.push(St.Size() - 2);

St.push(T_LOG_VIR);

St.push(R.Label.Size() - 1);

St.push(K_METKA);

++i;

}

else

throw ErrInvChain();

break;

case T_LOG_VIR: //#23

if (el.clas == C_RAZDEL)

{

ptr = St.pop();

St.push(S_SK_RIGHT);

St.push(ptr);

St.push(-1);

St.push(T_LOG_SPIS);

St.push(St.Size() - 2);

St.push(T_P);

++i;

break;

}

throw ErrInvChain();

case T_LOG_SPIS: //#24 //#25

if (el.clas == C_RAZDEL && (el.name[0] == '#' || el.name[0] == '='))

{

ptr = St.pop();

el.clas = C_NOV;

R.Data.push(el);

St[St.pop()] = R.Data.Size() - 1;

St.push(R.Data.Size() - 1);

St.push(-1);

St.push(ptr);

if (el.name[0] == '=')

St.push(K_RAVNO);

if (el.name[0] == '#')

St.push(K_NE_RAVNO);

St.push(St.Size() - 3);

St.push(T_P);

++i;

}

else

throw ErrInvChain();

break;

case S_T_Z:

if (el.clas == C_RAZDEL && el.name[0] == ';')

++i;

else

throw ErrInvChain();

break;

case S_SK_RIGHT:

if (el.clas == C_RAZDEL && el.name[0] == ')' )

++i;

else

throw ErrInvChain();

break;

case KS_THEN: case KS_END_WHILE:

if (el.clas == C_KEY_WORD && (el.name[0] == 't' || el.name[0] == 'e'))

++i;

else

throw ErrInvChain();

break;

//Команды

case K_PRISV:

R.Command.push(K_PRISV);

for (int ptr = 0; ptr < 2; ++ptr)

R.Command.push(St.pop());

break;

case K_SLOJ:

R.Command.push(K_SLOJ);

for (int i = 0; i < 3; ++i)

R.Command.push(St.pop());

break;

case K_UMNOJ:

R.Command.push(K_UMNOJ);

for (int i = 0; i < 3; ++i)

R.Command.push(St.pop());

break;

case K_V_STEP:

R.Command.push(K_V_STEP);

for (int i = 0; i < 3; ++i)

R.Command.push(St.pop());

break;

case K_PEREHOD_0:

R.Command.push(K_PEREHOD_0);

for (int i = 0; i < 2; ++i)

R.Command.push(St.pop());

break;

case K_PEREHOD_BEZ_USL:

R.Command.push(K_PEREHOD_BEZ_USL);

R.Command.push(St.pop());

break;

case K_PEREHOD_SRAVN:

R.Command.push(K_PEREHOD_SRAVN);

for (int i = 0; i < 2; ++i)

R.Command.push(St.pop());

break;

case K_RAVNO:

R.Command.push(K_RAVNO);

for (int i = 0; i < 3; ++i)

R.Command.push(St.pop());

break;

case K_NE_RAVNO:

R.Command.push(K_NE_RAVNO);

for (int i = 0; i < 3; ++i)

R.Command.push(St.pop());

break;

case K_METKA:

R.Label[St.pop()] = R.Command.Size();

break;

default:

throw ErrSearch();

}

#pragma package(smart_init)

Interpretator.H

#ifndef InterpretatorH

#define InterpretatorH

#include "DataBase.h"

Void Inter(Ident &I, rez &r);

#endif

Interpretator.Cpp

#pragma hdrstop

#include "Interpretator.h"

#include "Stack_mass.h"

#include "LeksBlok.h"

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

int pow (int x, int y) // x^y

{

if (y < 0) throw ErrInvChain(); //Отрицательная степень

int rezult = 1;

for (int i = 0; i < y; ++i)

rezult *= x;

return rezult;

}

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

Void Inter(Ident &I, rez &r)

{

int size = R.Command.Size();

for (int i = 0; i < size; )

{

int el = R.Command[i];

switch (el)

{

case K_PRISV:

R.Data[R.Command[i + 1]].value = R.Data[R.Command[i + 2]].value;

i += 3;

break;

case K_SLOJ:

R.Data[R.Command[i + 3]].value = R.Data[R.Command[i + 2]].value + R.Data[R.Command[i + 1]].value;

i += 4;

break;

case K_UMNOJ:

R.Data[R.Command[i + 3]].value = R.Data[R.Command[i + 2]].value * R.Data[R.Command[i + 1]].value;

i += 4;

break;

case K_V_STEP:

R.Data[R.Command[i + 3]].value = pow(R.Data[R.Command[i + 1]].value, R.Data[R.Command[i + 2]].value);

i += 4;

break;

case K_PEREHOD_0:

if (R.Data[R.Command[i + 1]].value)

i += 3;

else

i = R.Label[R.Command[i + 2]];

break;

case K_PEREHOD_BEZ_USL:

i = R.Label[R.Command[i + 1]];

break;

case K_PEREHOD_SRAVN:

if (R.Data[R.Command[i + 1]].value)

i += 3;

else

i = R.Label[R.Command[i + 2]];

break;

case K_RAVNO:

R.Data[R.Command[i + 3]].value = (R.Data[R.Command[i + 2]].value == R.Data[R.Command[i + 1]].value);

i += 4;

break;

case K_NE_RAVNO:

R.Data[R.Command[i + 3]].value = (R.Data[R.Command[i + 2]].value != R.Data[R.Command[i + 1]].value);

i += 4;

break;

}

#pragma package(smart_init)

Data.h

#ifndef DataBaseH

#define DataBaseH

#define MAX_CHAR 25

#include "Stack_mass.h"

struct elem

{

int clas; //класс

int value; //значение (для идентификаторов и констант)

char name[MAX_CHAR]; //имя

int link; //ссылка

elem() //конструктор

{

clas = -1;

value = 0;

name[0] = '\0';

link = -1;

}

};

struct rez

{

Stack<elem> Data; //Область данных

Stack<int> Label; //Массив меток

Stack<int> Command; //Массив комманд

};

class ErrOverFlow {}; //ошибка переполнения массива mas

class ErrIdent {}; //буква сразу после цифры

class ErrSimb {}; //символ, отсутствующий в данной грамматике

class ErrSearch {}; //не найден искомый символ

Смотрите также файлы

отчет 1 лаба.doc

ответы политология.docx

Ответы На Защиту К Лабам 2, 6.doc

Ответы на вопросы ТП 25-34.docx

Ответы на вопросы Волчковой (1).docx

Файл: Отчет Л.р.4 ШАВРОВА.docx

Interpretator.H

Void Inter(Ident &I, rez &r);

Interpretator.Cpp

Void Inter(Ident &I, rez &r)

Смотрите также файлы

Информация

Списки файлов

Дополнительно