Добавил:

Upload Опубликованный материал нарушает ваши авторские права? Сообщите нам.

Вуз:

Саратовский Государственный Технический Университет им. Ю.А. Гагарина

Предмет:

Системное программирование

Файл:

Системное программирование / SSW_kw_Appendix

.pdf

Скачиваний:

Добавлен:

12.02.2015

Размер:

497.5 Кб

Скачать

☆

<<< < Предыдущая 1 2 3 4 56 / 86 7 8 > Следующая >>>

Создание распределенной системы решения задач

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

char*	szRightBnfRule; // правая часть правила грамматики в форме Бэкуса-Наура
char*	szBnfRule; // правило в форме Бэкуса-Наура
public:

TSyntRule();

TSyntRule(int _iNumRule, int _iNumSyntSymbol, char* _cLeftRule, char* _cRightRule,

	char* _cLeftBnfRule, char* _cRightBnfRule);
~TSyntRule();
int	getNumRule();
void	setNumSyntSymbol(int _iNumSyntSymbol);
int	getNumSyntSymbol();
const char* getLeftRule();

const char* getRightRule(); const char* getLeftBnfRule(); const char* getRightBnfRule(); const char* getBnfRule();

};

#endif

Листинг 54. Файл реализации класса TSyntRule (файл

TSyntRule.cpp)

#pragma hdrstop

#pragma package(smart_init) #include "TSyntRule.h" #include <string.h>

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

TSyntRule::TSyntRule() {

iNumRule	= 0;
iNumSyntSymbol = 0;
szLeftRule	= 0;
szRightRule	= 0;
szLeftBnfRule	= 0;
szRightBnfRule	= 0;
szBnfRule	= 0;
}

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

TSyntRule::TSyntRule(int _iNumRule, int _iNumSyntSymbol, char* _cLeftRule, char* _cRightRule,

char* _cLeftBnfRule, char* _cRightBnfRule)

{

iNumRule = _iNumRule; iNumSyntSymbol = _iNumSyntSymbol; int iLen = strlen(_cLeftRule); szLeftRule = new char[iLen+1]; strcpy(szLeftRule,_cLeftRule);

iLen = strlen(_cRightRule); szRightRule = new char[iLen+1]; strcpy(szRightRule,_cRightRule); int iLeftLen = strlen(_cLeftBnfRule);

szLeftBnfRule = new char[iLeftLen+1]; strcpy(szLeftBnfRule,_cLeftBnfRule); int iRightLen = strlen(_cRightBnfRule);

szRightBnfRule = new char[iRightLen+1]; strcpy(szRightBnfRule,_cRightBnfRule);

szBnfRule = new char[iLeftLen + 3 + iRightLen + 1]; strcpy(szBnfRule,_cLeftBnfRule); strcat(szBnfRule,"::="); strcat(szBnfRule,_cRightBnfRule);

}

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

TSyntRule::~TSyntRule() {

Методические указания к выполнению курсовой работы

Системное программное обеспечение

if (szLeftRule != NULL) delete[] szLeftRule;

szLeftRule = NULL;

if (szRightRule != NULL) delete[] szRightRule;

szRightRule = NULL;

if (szLeftBnfRule != NULL) delete[] szLeftBnfRule;

szLeftBnfRule = NULL;

if (szRightBnfRule != NULL) delete[] szRightBnfRule;

szRightBnfRule = NULL; if (szBnfRule != NULL)

delete[] szBnfRule; szBnfRule = NULL;

}

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

int TSyntRule::getNumRule() { return iNumRule;

}

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

void TSyntRule::setNumSyntSymbol(int _iNumSyntSymbol) { if (_iNumSyntSymbol > 0)

iNumSyntSymbol = _iNumSyntSymbol;

}

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

int TSyntRule::getNumSyntSymbol() { return iNumSyntSymbol;

}

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

const char* TSyntRule::getLeftRule() { return szLeftRule;

}

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

const char* TSyntRule::getRightRule() { return szRightRule;

}

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

const char* TSyntRule::getLeftBnfRule() { return szLeftBnfRule;

}

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

const char* TSyntRule::getRightBnfRule() { return szRightBnfRule;

}

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

const char* TSyntRule::getBnfRule() { return szBnfRule;

}

Листинг 55. Заголовочный файл класса TSyntRuleList (файл

TSyntRuleList.h)

#ifndef TSyntRuleListH #define TSyntRuleListH #include "TSyntRule.h"

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

class TSyntRuleList

{

private:

TSyntRule** pSyntRuleList;

52	М.Ф.Степанов

Создание распределенной системы решения задач

int	iSyntRuleCount;
int	iSyntRuleMax;
public:
	TSyntRuleList();
	~TSyntRuleList();
	int	addSyntRule(TSyntRule* _pSyntRule); // возвращает порядковый номер лексемы
	void	getSyntRule(int _iNum, TSyntRule** _pSyntRule);
	const char* getLeftRule(int _iNum);
};	int	getSyntRuleCount();
};
#endif
	Листинг 56. Файл реализации класса TSyntRuleList (файл

TSyntRuleList.cpp)

#pragma hdrstop

#pragma package(smart_init) #include "TSyntRuleList.h"

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

TSyntRuleList::TSyntRuleList()

{

pSyntRuleList	= 0;
iSyntRuleCount	= 0;
iSyntRuleMax	= 10;
}
//---------------------------------------------------------------------------

TSyntRuleList::~TSyntRuleList()

{

if (pSyntRuleList != 0) {

for (int i=0; i<iSyntRuleCount; i++) { TSyntRule* ptr = pSyntRuleList[i]; if (ptr != 0)

delete ptr; ptr = 0;

pSyntRuleList[i] = 0;

}

delete[] pSyntRuleList;

}

pSyntRuleList = 0;

}

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

int TSyntRuleList::addSyntRule(TSyntRule* _pSyntRule)

{

if (pSyntRuleList == 0) {

pSyntRuleList = new TSyntRule*[iSyntRuleMax];

}

if (pSyntRuleList != 0) {

if (iSyntRuleCount == iSyntRuleMax) { iSyntRuleMax += 10;

TSyntRule** pList = new TSyntRule*[iSyntRuleMax]; for (int i=0; i<iSyntRuleCount; i++) {

pList[i] = pSyntRuleList[i]; pSyntRuleList[i] = 0;

}

delete[] pSyntRuleList; pSyntRuleList = pList; pList = 0;

}

if (iSyntRuleCount < iSyntRuleMax) { pSyntRuleList[iSyntRuleCount++] = _pSyntRule;

}

Методические указания к выполнению курсовой работы

Системное программное обеспечение

}

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

void TSyntRuleList::getSyntRule(int _iNum, TSyntRule** _pSyntRule)

{

if (pSyntRuleList != 0) {

if (iSyntRuleCount > _iNum) { *_pSyntRule = pSyntRuleList[_iNum];

}

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

const char* TSyntRuleList::getLeftRule(int _iNum)

{

const char *psz = 0;

if (pSyntRuleList != 0) {

if (iSyntRuleCount > _iNum) {

TSyntRule *pSyntRule = pSyntRuleList[_iNum]; if (pSyntRule != 0)

psz = pSyntRule->getLeftRule();

}

return psz;

}

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

int TSyntRuleList::getSyntRuleCount()

{

return iSyntRuleCount;

}

Листинг 57. Заголовочный файл основного модуля синтаксического анализатора (файл kaSynt.h)

#ifndef kaSyntH #define kaSyntH #include "TLexemList.h" #include "TIdentList.h"

#include "TSyntSymbolList.h" #include "TSyntSymbolStack.h"

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

extern "C" int makeSyntSymbolList(TLexemList *pLexemList, TIdentList *pIdentList, TSyntSymbolList **pSyntSymbolList,

char *_cProtocol, bool* _Terminated);

int getRelationStackToLexem(int iNumLexem, TLexemList *pLexemList, TSyntSymbolStack *pSyntSymbolStack, TIdentList *pIdentList, char* cRule);

int getRelationSyntSymbolToSyntSymbol(TSyntSymbol *_pSyntSymbol1, TSyntSymbol *_pSyntSymbol2, TIdentList *pIdentList, char* cRule);

#endif

Листинг 58. Исходный код основного модуля синтаксического анализатора (файл kaSynt.cpp)

#include <vcl.h> #pragma hdrstop

#pragma package(smart_init) //---------------------------------------------------------------------------

#include "kaSynt.h" #include "TSyntRuleList.h" #include "typeLexem.h"

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

// матрица предшествования SIZE_GRAM_MATRIX х SIZE_GRAM_MATRIX

54	М.Ф.Степанов

Создание распределенной системы решения задач

char gramMatrix[] =

// A

t0 tk x0 ;

','

вч цч =

','

[

]

кц

// кц

{' ','

','<',' ','

',' ','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','=',

// нц

' ','

','

',' ','

','

','=','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// A

' ','

','

',' ','

','

','=','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// h

' ','

','

',' ','

',' ','=','

','=','=','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// n

' ','

','

',' ','

','

','=','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// t0

' ','

','

',' ','

','

','=','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// tk

' ','

','

',' ','

','

','=','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// x0

'>','=','

','>','=','>','=','>','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','>',

// ;

' ','

','

',' ','

',' ','>','>','

','

','>',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// вч

' ','

','

',' ','

',' ','=','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// цч

' ','

','

',' ','

',' ','=','=','=','

','=',' ',' ',' ',' ',' ',' ',' ',' ',' ','=',' ',' ',' ',' ',

// =

' ','

','

',' ','

','=','

','

','=',' ',' ',' ',' ',' ',' ',' ',' ',' ','=',' ',' ',' ',

// [

' ','

','

',' ','

',' ','>','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// ]

' ','

','

',' ','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','<',

// Z

' ','

','

','=','

',' ','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// R

' ','

','

','>','

',' ','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// D

'=','

','

',' ','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// r

' ','

','

',' ','

',' ','=','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// B

' ','

','

',' ','

',' ','=','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// E

' ','

','

',' ','

',' ','=','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ','>',

// H

' ','

','

',' ','

','=','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// S

' ','

','

',' ','

',' ','=','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// M

' ','

','

',' ','

',' ','=','=','

','

','=',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// C

' ','

','

',' ','

',' ','=','=','

','

','>',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',

// c

' ','

','

','>','

',' ','

','

',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};

// X

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

int makeSyntSymbolList(TLexemList *pLexemList, TIdentList *pIdentList, TSyntSymbolList **_pSyntSymbolList,

char *_cProtocol, bool* _Terminated)

{// формирование списка синтаксических символов int iRet = -1;

bool bDoWork = true; if (pLexemList != 0) {

TSyntRuleList *pSyntRuleList = new TSyntRuleList(); TSyntRule *pSyntRule = 0;

pSyntRule = new TSyntRule(1,1,"Z","RB2E2H2","<задача>","<массивыCразмерностью><началоАнализа>;<ко нецАнализа>;<шаг>;");

pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(2,4,"r","1n542","<размерность>","n=<целоеЧисло>;"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(3,5,"B","1t053","<началоАнализа>","t0=<вещественноеЧисло>"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(4,6,"E","1tk53","<конецАнализа>","tk=<вещественноеЧисло>"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(5,7,"H","1h53","<шаг>","h=<вещественноеЧисло>"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(6,8,"S","1A5M2","<матрицаА>","A=<матрица>;"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(7,12,"X","1x05M2","<векторX0>","x0=<матрица>;"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(8,10,"C","Cc2","<строкиМатрицы>","<строкиМатрицы><строкаМатрицы>;");

pSyntRuleList->addSyntRule(pSyntRule); pSyntRule = new

TSyntRule(9,10,"C","CCc","<строкиМатрицы>","<строкиМатрицы><строкиМатрицы><строка Матрицы>");

pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(10,9,"M","6C7","<матрица>","[<строкиМатрицы>]"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(11,9,"M","6c7","<матрица>","[<строкаМатрицы>]"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(12,10,"C","CC","<строкиМатрицы>","<строкиМатрицы><строкиМатрицы>");

pSyntRuleList->addSyntRule(pSyntRule); pSyntRule = new

TSyntRule(13,10,"C","Cc","<строкиМатрицы>","<строкиМатрицы><строкаМатрицы>");

Методические указания к выполнению курсовой работы

Системное программное обеспечение

pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(14,10,"C","c2","<строкиМатрицы>","<строкаМатрицы>;"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(15,11,"c","c3","<строкаМатрицы>","<строкаМатрицы><вещественноеЧисло>");

pSyntRuleList->addSyntRule(pSyntRule); pSyntRule = new

TSyntRule(16,2,"R","rD","<массивыCразмерностью>","<размерность><массивы>"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(17,3,"D","SX","<массивы>","<матрицаА><векторX0>"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(18,11,"c","3","<строкаМатрицы>","<вещественноеЧисло>"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = new TSyntRule(20,10,"C","c","<строкиМатрицы>","<строкаМатрицы>"); pSyntRuleList->addSyntRule(pSyntRule);

pSyntRule = 0;

int iRuleCount = pSyntRuleList->getSyntRuleCount(); TSyntSymbolList *pSyntSymbolList = *_pSyntSymbolList; if (pSyntSymbolList != 0)

delete pSyntSymbolList;

pSyntSymbolList = new TSyntSymbolList(); // новый пустой список синтаксических символов *_pSyntSymbolList = pSyntSymbolList;

String sInStr;

String sStack; String sRuleList; String sProtocol; String s;

TSyntSymbol *pSyntSymbol = 0;

TSyntSymbolStack *pSyntSymbolStack = new TSyntSymbolStack(); // стек синт. символов

TLexem *pLexem = new TLexem( // новая лексема - "начало входной цепочки" - тип = "0" "_",0,0,0.0, 0,0,0);

pSyntSymbolStack->Push(pLexem); pLexem = 0;

int iLexemCount = pLexemList->getCount(); int iNumLexem = 0;

int iStep = 0;

while (bDoWork & (!*_Terminated) & (iNumLexem < iLexemCount)) { pLexemList->get(iNumLexem++,&pLexem);

int iTypeLexem = pLexem->getType(); s = iTypeLexem; s = s.Trim();

if (iTypeLexem == 1) {

s += pLexem->getText();

}

sInStr += s;

}

sStack = "";

int iCountSymbolStack = pSyntSymbolStack->getElemCount(); for (int i=iCountSymbolStack-1; i>=0; i--) {

pSyntSymbol = pSyntSymbolStack->getSymbol(i); int iRule = pSyntSymbol->getNumRule();

if (iRule > 0) {

s = pSyntSymbol->getLeftRule();

}

else {

int iType = pSyntSymbol->getLexemType(); s = iType;

if (iType <= 1)

s += pSyntSymbol->getLexemText();

}

sStack += s;

56	М.Ф.Степанов

Создание распределенной системы решения задач

}

s = iStep;

sProtocol += "\r\n шаг анализа = "; sProtocol += s;

sProtocol += "\r\nцепочка = '"; sProtocol += sInStr; sProtocol += "'";

sProtocol += "\r\nстек = '"; sProtocol += sStack; sProtocol += "'"; iNumLexem = 0;

char cRule = '\0'; int iNumName = 0; int iPosRelation = 0;

int iSyntTypeCurLexem = 0; int iSyntTypeTopStack = 0;

TSyntSymbol *pNewSyntSymbol = new TSyntSymbol();

while (bDoWork & (!*_Terminated) & (iNumLexem < iLexemCount)) { // собственно разбор s = ++iStep;

sProtocol += "\r\n шаг анализа = "; sProtocol += s;

iRet = getRelationStackToLexem(iNumLexem, pLexemList, pSyntSymbolStack, pIdentList, &cRule);

if (iRet == 0) { // разбор входной цепочки завершен ?

int iCountSymbolStack = pSyntSymbolStack->getElemCount(); if (iCountSymbolStack == 2) {

pSyntSymbol = pSyntSymbolStack->takeTop(); // д.б. символ "Z" - начальный символ грамматики

int iRule = pSyntSymbol->getNumRule(); if (iRule > 0) {

int iType = pSyntSymbol->getNumRule();

if (iType == 1) { // это начальный символ грамматики "Z"

sProtocol += "\r\n ==> в вершине стека символ начальный символ грамматики 'Z' \r\n

===> разбор завершен - цепочка допущена"; pSyntSymbolList->addSyntSymbol(pSyntSymbol);

}

else { // ошибка: в стеке не символ "Z" - начальный символ грамматики

sProtocol += "\r\n ==> в середине стека НЕ начальный символ грамматики 'Z' \r\n ===>

ОШИБКА - цепочка НЕ допущена";

}

else { // ошибка: в стеке терминальный символ, а не символ "Z" - начальный символ sProtocol += "\r\n ==> в вершине стека терминальный символ, а НЕ начальный символ

грамматики 'Z' \r\n ===> ОШИБКА - цепочка НЕ допущена";

}

bDoWork = false;

}

if (bDoWork & (!*_Terminated)) { switch (cRule) {

case '>': {// свертка

sProtocol += "\t ==> свёртка:"; String sRightTileRule;

int iRightTileRuleSymbolCount = 0; int iNumCurLexem = 1;

TSyntSymbol *pCurSyntSymbolStack = 0; TSyntSymbol *pNextSyntSymbolStack = 0; int iNextSyntSymbolStackType = -1;

int iNextSyntSymbolStackRuleNum = -1;

int iStackSyntSymbolCount = pSyntSymbolStack->getElemCount();

Методические указания к выполнению курсовой работы

Системное программное обеспечение

bool bDoWorkWithStack = true;

while (iRightTileRuleSymbolCount < MAXLEN_RIGHT_TILE_RULE) { pNextSyntSymbolStack = pSyntSymbolStack->getTop();

if (pNextSyntSymbolStack != 0) {

iNextSyntSymbolStackRuleNum = pNextSyntSymbolStack->getNumRule();

if (iNextSyntSymbolStackRuleNum > 0) { // очередной символ - занести в правило sRightTileRule = pNextSyntSymbolStack->getLeftRule() + sRightTileRule; pNewSyntSymbol->addTopSubItem(pNextSyntSymbolStack); pNextSyntSymbolStack = pSyntSymbolStack->takeTop(); iRightTileRuleSymbolCount++;

}

else { // очередной символ - терминальный

if (pCurSyntSymbolStack == 0) { // сделать выбранный символ текущим pCurSyntSymbolStack = pSyntSymbolStack->takeTop(); pNewSyntSymbol->addTopSubItem(pCurSyntSymbolStack); iNextSyntSymbolStackType = pNextSyntSymbolStack->getLexemType(); s = iNextSyntSymbolStackType;

if (iNextSyntSymbolStackType == TYPE_LEXEM_NAME) // символ - идентификатор s += pNextSyntSymbolStack->getLexemText(); // добавим текст символа

sRightTileRule = s + sRightTileRule; // занести тип выбранного символа в правило iRightTileRuleSymbolCount++;

}

else { // текущий символ не пуст char cRuleSymb = ' ';

int iRet = getRelationSyntSymbolToSyntSymbol(pNextSyntSymbolStack, pCurSyntSymbolStack, pIdentList, &cRuleSymb);

if (cRuleSymb == '=') { // сделать выбранный символ текущим pCurSyntSymbolStack = pSyntSymbolStack->takeTop(); pNewSyntSymbol->addTopSubItem(pCurSyntSymbolStack); iNextSyntSymbolStackType = pNextSyntSymbolStack->getLexemType(); s = iNextSyntSymbolStackType;

if (iNextSyntSymbolStackType == TYPE_LEXEM_NAME) // символ - идентификатор s += pNextSyntSymbolStack->getLexemText(); // добавим текст символа

sRightTileRule = s + sRightTileRule; // занести тип выбранного символа в правило iRightTileRuleSymbolCount++;

}

else

iRightTileRuleSymbolCount = MAXLEN_RIGHT_TILE_RULE; // выход из цикла

};

}

iStackSyntSymbolCount = pSyntSymbolStack->getElemCount(); if (iStackSyntSymbolCount == 0)

iRightTileRuleSymbolCount = MAXLEN_RIGHT_TILE_RULE; // выход из цикла

}

// если выбран хотя бы один символ из стека, то ищем правило с построенной правой частью bool isRuleFound = false;

while (!sRightTileRule.IsEmpty()) {

for (int iRuleNum = 0; iRuleNum < iRuleCount; iRuleNum++) { pSyntRuleList->getSyntRule(iRuleNum,&pSyntRule);

if (pSyntRule != 0) {

s = pSyntRule->getRightRule();

if (sRightTileRule.AnsiCompare(s) == 0) { // правило найдено isRuleFound = true;

s = "\r\n Применено правило с правой частью = '"; s += sRightTileRule;

s += "'"; sProtocol += s;

// создаем нетерминальный символ для правила и добавляем его в стек pNewSyntSymbol->setNumRule(pSyntRule->getNumRule());

58	М.Ф.Степанов

Создание распределенной системы решения задач

pNewSyntSymbol->setNumSyntSymbol(pSyntRule->getNumSyntSymbol()); pNewSyntSymbol->setLeftRule(pSyntRule->getLeftRule()); pNewSyntSymbol->setRightRule(sRightTileRule.c_str()); pNewSyntSymbol->setLeftBnfRule(pSyntRule->getLeftBnfRule()); pNewSyntSymbol->setRightBnfRule(pSyntRule->getRightBnfRule()); pNewSyntSymbol->setBnfRule(pSyntRule->getBnfRule()); pCurSyntSymbolStack = 0;

pSyntSymbolStack->Push(pNewSyntSymbol); pNewSyntSymbol = new TSyntSymbol(); sRightTileRule = "";

if (!sRuleList.IsEmpty()) sRuleList += ",";

sRuleList += pSyntRule->getNumRule(); bDoWorkWithStack = false; // выход из цикла break;

}

if (!isRuleFound) { // возврат

s = sRightTileRule.SubString(1,1); if (s.AnsiCompare("1") == 0) {

int iLen = 0;

bool doCompare = true; while (doCompare) {

s = sRightTileRule.SubString(2,++iLen); int iIdentCount = pIdentList->getCount(); String sName;

for (int i=0; i<iIdentCount; i++) { sName = pIdentList->getText(i); if (s.AnsiCompare(sName) == 0) {

doCompare = false; break;

}

sRightTileRule = sRightTileRule.SubString(2+iLen,sRightTileRule.Length()-1-iLen);

}

else

sRightTileRule = sRightTileRule.SubString(2,sRightTileRule.Length()-1); pNewSyntSymbol->takeTopSubItem(&pNextSyntSymbolStack); pSyntSymbolStack->Push(pNextSyntSymbolStack);

}

if (!isRuleFound) {

s = "\r\n Ошибка: НЕТ подходящего правила для свертки!"; sProtocol += s;

bDoWork = false;

}

pCurSyntSymbolStack = 0; pNextSyntSymbolStack = 0; break;

}; case '<':

case '=':{ // сдвиг (перенос)

sProtocol += "\t ==> сдвиг (перенос):"; TLexem *pLexem = 0; pLexemList->get(iNumLexem++,&pLexem); pSyntSymbolStack->Push(pLexem); break;}

default: // ошибка

Методические указания к выполнению курсовой работы

Системное программное обеспечение

bDoWork = false;

sProtocol += "\r\n ==> Ошибка: недопустимое следование символов."; break;

}

int iNum = iNumLexem; sInStr = "";

while (iNum < iLexemCount) { pLexemList->get(iNum++,&pLexem); int iTypeLexem = pLexem->getType(); s = iTypeLexem; s = s.Trim();

if (iTypeLexem == 1) {

s += pLexem->getText();

}

sInStr += s;

}

sStack = "";

int iCountSymbolStack = pSyntSymbolStack->getElemCount(); for (int i=iCountSymbolStack-1; i>=0; i--) {

pSyntSymbol = pSyntSymbolStack->getSymbol(i); int iRule = pSyntSymbol->getNumRule();

if (iRule > 0) {

s = pSyntSymbol->getLeftRule();

}

else {

int iType = pSyntSymbol->getLexemType(); s = iType;

if (iType <= 1)

s += pSyntSymbol->getLexemText();

}

sStack += s;

}

sProtocol += "\r\nцепочка = '"; sProtocol += sInStr; sProtocol += "'";

sProtocol += "\r\nстек = '"; sProtocol += sStack; sProtocol += "'";

sProtocol += "\r\nправила = '"; sProtocol += sRuleList; sProtocol += "'";

}

pNewSyntSymbol = 0; if (_cProtocol != NULL)

strcpy(_cProtocol,sProtocol.c_str()); pSyntSymbol = 0;

if (pSyntSymbolStack != 0) delete pSyntSymbolStack;

pSyntSymbolStack = 0;

}

return iRet;

}

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

int getRelationStackToLexem(int iNumLexem, TLexemList *pLexemList, TSyntSymbolStack *pSyntSymbolStack, TIdentList *pIdentList, char* cRule)

{

int iRet = 1; String s;

int iIdentCount = pIdentList->getCount(); int iTypeCurLexem = -1;

60	М.Ф.Степанов

<<< < Предыдущая 1 2 3 4 56 / 86 7 8 > Следующая >>>

Соседние файлы в папке Системное программирование

#
12.02.20151.01 Mб26SSW_kw.pdf
#
12.02.2015497.5 Кб22SSW_kw_Appendix.pdf
#
12.02.201533.28 Кб21Задание к кр мое.doc