Добавил:

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

Вуз:

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

Предмет:

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

Файл:

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

.pdf

Скачиваний:

Добавлен:

12.02.2015

Размер:

497.5 Кб

Скачать

☆

<<< < Предыдущая 1 2 34 / 84 5 6 7 8 > Следующая >>>

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

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

pLexem = 0; if (iRet == 0)

iRet = (*pLexemList)->getCount(); return iRet;

}

Листинг 38. Функции, эмулирующие работу конечного автомата лексического анализатора в состояниях <задача>, <размерность>, <значение размерности>, <остаток задачи1> (файл kaLex.cpp):

int kaLexTask(int* kaCurPos,		int* iCurPosText, char* szText,
char* szCurLex,		int* iLenCurLex, char cCurChar,
int* iNumStrCurLex, int* iPosStrCurLex,
int* iPosCurLex,		int* iTypeCurLex,
TLexemList* pLexemList, TIdentList* pIdentList)
{
int iRet = -1;
switch (cCurChar)	{
case kaTerm_n:	// символ "n"
{

*iTypeCurLex = 1; // - идентификатор *iPosCurLex = (*iCurPosText)++; *iLenCurLex = 0; szCurLex[(*iLenCurLex)++] = cCurChar; szCurLex[*iLenCurLex] = '\0';

TLexem* pLexem = new TLexem( // новая лексема szCurLex,*iTypeCurLex,0,0.0, *iNumStrCurLex,(*iPosStrCurLex)++,*iPosCurLex);

pLexemList->add(pLexem); pLexem = 0;

TIdent *pIdent = new TIdent( // новый идентификатор szCurLex,*iTypeCurLex,0,0.0, *iNumStrCurLex,(*iPosStrCurLex)++,*iPosCurLex);

int iNumIdent = pIdentList->addIdent(pIdent); pIdent = 0;

szCurLex[0] = '\0'; *iLenCurLex = 0; *iTypeCurLex = 0; *iPosCurLex = *iCurPosText;

*kaCurPos = kaPosSize; // следующее состояние КА = <размерность> iRet = 1;

break;

};

}; return iRet;

}

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

int kaLexSize(int* kaCurPos, int* iCurPosText, char* szText,

char* szCurLex,	int* iLenCurLex, char cCurChar,
int* iNumStrCurLex, int* iPosStrCurLex,
int* iPosCurLex,	int* iTypeCurLex,
TLexemList* pLexemList, TIdentList* pIdentList)
{
int iRet = -1;
switch (cCurChar) {
case kaTerm_Equal:	// символ "="
{

*iTypeCurLex = 5;

*iPosCurLex = (*iCurPosText)++; *iLenCurLex = 0; szCurLex[(*iLenCurLex)++] = cCurChar;

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

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

szCurLex[*iLenCurLex] = '\0';

TLexem *pLexem = new TLexem( // новая лексема szCurLex,*iTypeCurLex,0,0.0, *iNumStrCurLex,(*iPosStrCurLex)++,*iPosCurLex);

pLexemList->add(pLexem); pLexem = 0;

szCurLex[0] = '\0'; *iLenCurLex = 0; *iTypeCurLex = 0; *iPosCurLex = *iCurPosText;

*kaCurPos = kaPosValueSize; // следующее состояние КА = <значение размерности> iRet = 1;

break;

};

}; return iRet;

}

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

int kaLexValueSize(int* kaCurPos, int* iCurPosText, char* szText,

char* szCurLex,	int* iLenCurLex, char cCurChar,
int* iNumStrCurLex, int* iPosStrCurLex,
int* iPosCurLex,	int* iTypeCurLex,
TLexemList* pLexemList, TIdentList* pIdentList)
{
int iRet = -1;
switch (cCurChar) {
case kaTerm_0:	// символ "0"
case kaTerm_1:	// символ "1"
case kaTerm_2:	// символ "2"
case kaTerm_3:	// символ "3"
case kaTerm_4:	// символ "4"
case kaTerm_5:	// символ "5"
case kaTerm_6:	// символ "6"
case kaTerm_7:	// символ "7"
case kaTerm_8:	// символ "8"
case kaTerm_9:	// символ "9"
{

*iLenCurLex = 0; szCurLex[(*iLenCurLex)++] = cCurChar;

szCurLex[*iLenCurLex] = '\0';
(*iCurPosText)++;
break;
};
case kaTerm_Semicolon:	// символ ";"
{
if (*iLenCurLex > 0) {
*iTypeCurLex = 4;
int iVal = atoi(szCurLex);

TLexem* pLexem = new TLexem( // новая лексема - значение размерности szCurLex,*iTypeCurLex,iVal,0.0, *iNumStrCurLex,(*iPosStrCurLex)++,*iPosCurLex);

pLexemList->add(pLexem); pLexem = 0;

}

*iPosCurLex = (*iCurPosText)++; *iLenCurLex = 0; szCurLex[(*iLenCurLex)++] = cCurChar; szCurLex[*iLenCurLex] = '\0'; *iTypeCurLex = 2;

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

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

TLexem *pLexem = new TLexem( // новая лексема szCurLex,*iTypeCurLex,0,0.0, *iNumStrCurLex,(*iPosStrCurLex)++,*iPosCurLex);

pLexemList->add(pLexem);
pLexem = 0;
szCurLex[0] = '\0';
*iLenCurLex = 0;
*iTypeCurLex = 0;
iPosCurLex = iCurPosText;
*kaCurPos = kaPosEndTask01; // следующее [КА] = <остаток задачи1>
break;
};
case kaTerm_Equal:	// символ "="

{

*iTypeCurLex = 5;

*iPosCurLex = (*iCurPosText)++; *iLenCurLex = 0; szCurLex[(*iLenCurLex)++] = cCurChar; szCurLex[*iLenCurLex] = '\0';

TLexem* pLexem = new TLexem( // новая лексема szCurLex,*iTypeCurLex,0,0.0, *iNumStrCurLex,*iPosStrCurLex++,*iPosCurLex);

pLexemList->add(pLexem); pLexem = 0;

szCurLex[0] = '\0'; *iLenCurLex = 0; *iTypeCurLex = 0; *iPosCurLex = *iCurPosText;

*kaCurPos = kaPosValueSize; // следующее состояние КА = <значение размерности> iRet = 1;

break;

};

}; return iRet;

}

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

int kaLexEndTask01(int* kaCurPos, int* iCurPosText, char* szText,

char* szCurLex,	int* iLenCurLex, char cCurChar,
int* iNumStrCurLex, int* iPosStrCurLex,
int* iPosCurLex,	int* iTypeCurLex,
TLexemList* pLexemList, TIdentList* pIdentList)
{
int iRet = -1;
switch (cCurChar) {
case kaTerm_A:	// символ "A"
{

*iTypeCurLex = 1;

*iPosCurLex = (*iCurPosText)++; *iLenCurLex = 0; szCurLex[(*iLenCurLex)++] = cCurChar; szCurLex[*iLenCurLex] = '\0';

TLexem *pLexem = new TLexem( // новая лексема szCurLex,*iTypeCurLex,0,0.0, *iNumStrCurLex,*iPosStrCurLex++,*iPosCurLex);

pLexemList->add(pLexem); pLexem = 0;

TIdent* pIdent = new TIdent( // новый идентификатор szCurLex,*iTypeCurLex,0,0.0, *iNumStrCurLex,(*iPosStrCurLex)++,*iPosCurLex);

pIdentList->addIdent(pIdent);

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

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

pIdent = 0; szCurLex[0] = '\0'; *iLenCurLex = 0; *iTypeCurLex = 0;

*iPosCurLex = *iCurPosText;

*kaCurPos = kaPosMatrixA; // следующее [КА] = <матрица А>

iRet = 1;
break;
};
case kaTerm_NewR:	// символ "\r"
{

(*iCurPosText)++;

cCurChar = szText[*iCurPosText];

switch (cCurChar) {
case kaTerm_NewN:	// символ "\n"
(*iCurPosText)++;
(*iNumStrCurLex)++;
*iPosStrCurLex = 1;
iRet = 1;
break;

};

break;

};

case kaTerm_NewN: // символ "\n"

{

(*iCurPosText)++;

(*iNumStrCurLex)++; *iPosStrCurLex = 1; iRet = 1;

break;

};

}; return iRet;

}

Листинг 39. Заголовочный файл класса TTranslationThread

(файл TTranslationThread.h)

#ifndef TTranslationThreadH #define TTranslationThreadH

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

#include <Classes.hpp> #include <ComCtrls.hpp>

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

#include "TLexemList.h" #include "TIdentList.h" #include "..\classDll\TTask.h"

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

class TTranslationThread : public TThread

{

private:

TProgressBar *fPrBar; char* szText;

void __fastcall DoStep();

void __fastcall DoVisualStep(); void __fastcall DoVisualSyntStep();

void	translateTask();
char	*cProtocol;
protected:

void __fastcall Execute();

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

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

public:

__fastcall TTranslationThread(TProgressBar *_PrBar,

	char* szText, char *_cProtocol);
TLexemList	**ppLexemList;
TIdentList	**ppIdentList;
TTask	**ppTask;
};
#endif

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

TTranslationThread.cpp)

#include <vcl.h> #pragma hdrstop

#include "TTranslationThread.h" #include "kaLex.h"

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

__fastcall TTranslationThread::TTranslationThread(TProgressBar *_PrBar,

	char	*_szText,
	char	*_cProtocol)
: TThread(true)
{
fPrBar	= _PrBar;
int iLenText = strlen(_szText);
szText = new char[iLenText + 1];
strcpy(szText,_szText);
cProtocol	= _cProtocol;
ppLexemList = NULL;
ppIdentList	= NULL;
FreeOnTerminate = true;
Priority = tpLowest;

}

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

void __fastcall TTranslationThread::Execute()

{

DoStep();

}

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

void __fastcall TTranslationThread::DoStep()

{

try {

if (!Terminated) { translateTask();

}
}
__finally {
fPrBar	= NULL;
if (szText != NULL)
delete[] szText;
szText	= NULL;

ppLexemList = NULL; ppIdentList = NULL;

}

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

void __fastcall TTranslationThread::DoVisualStep()

{

if (fPrBar != NULL) fPrBar->StepIt();

}

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

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

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

void __fastcall TTranslationThread::DoVisualSyntStep()

{

if (fPrBar != NULL) fPrBar->StepIt();

}

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

void TTranslationThread::translateTask()

{

int iRet;

int iLexemCount; if (!Terminated) {

iLexemCount = makeLexemList(szText, ppLexemList, ppIdentList, &Terminated); Synchronize(DoVisualStep);

}

Листинг 41. Исходный код функции кнопки "Старт" трансляции постановки задачи (файл TFormTaskSolve.cpp)

void __fastcall TFormTaskSolve::StartTranslationBitBtnClick( TObject *Sender)

{

StartTranslationBitBtn->Visible = false; StopTranslationBitBtn->Visible = true; ContinueTranslationBitBtn->Visible = false; CancelTranslationBitBtn->Visible = true; RunProgressBar->Visible = true; RunProgressBar->Position = 0; RunProgressBar->Brush->Color = clRed; RunProgressBar->Repaint(); startTranslationTime = GetTickCount();

String s = setTextTask(); // формирование текстового представления постановки задачи

RunProgressBar->StepIt(); viewTextTask(); RunProgressBar->StepIt(); cProtocol[0] = '\0';

if (pTranslationThread == NULL) {

pTranslationThread = new TTranslationThread(RunProgressBar, s.c_str(), cProtocol); pTranslationThread->OnTerminate = TranslationThreadDone; pTranslationThread->ppLexemList = &pLexemList;

pTranslationThread->ppIdentList = &pIdentList; pTranslationThread->ppTask = &tsk; pTranslationThread->Resume(); StopTranslationBitBtn->Visible = true; CancelTranslationBitBtn->Visible = true;

}

Листинг 42. Исходный код функции кнопки "Стоп" трансляции постановки задачи (файл TFormTaskSolve.cpp)

void __fastcall TFormTaskSolve::StopTranslationBitBtnClick(TObject *Sender)

{

if (pTranslationThread != NULL) { pTranslationThread->Suspend(); StopTranslationBitBtn->Visible = false; ContinueTranslationBitBtn->Visible = true; CancelTranslationBitBtn->Visible = false;

}

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

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

Листинг 43. Исходный код функции кнопки "Продолжить" трансляции постановки задачи (файл TFormTaskSolve.cpp)

void __fastcall TFormTaskSolve::ContinueTranslationBitBtnClick(TObject *Sender)

{

if (pTranslationThread != NULL) {

if (pTranslationThread->Suspended) { pTranslationThread->Resume(); StopTranslationBitBtn->Visible = true; CancelTranslationBitBtn->Visible = true; ContinueTranslationBitBtn->Visible = false;

}

Листинг 44. Исходный код функции кнопки "Прекратить" трансляции постановки задачи (файл TFormTaskSolve.cpp)

void __fastcall TFormTaskSolve::CancelTranslationBitBtnClick(TObject *Sender)

{

if (pTranslationThread != NULL) { pTranslationThread->Terminate(); StopTranslationBitBtn->Visible = false; ContinueTranslationBitBtn->Visible = false; CancelTranslationBitBtn->Visible = false; StartTranslationBitBtn->Visible = true;

}

Листинг 45. Исходный код функции, вызываемой по окончании работы нити транслятора (файл TFormTaskSolve.cpp)

void __fastcall TFormTaskSolve::TranslationThreadDone(TObject *Sender)

{

StopTranslationBitBtn->Visible = false; ContinueTranslationBitBtn->Visible = false; CancelTranslationBitBtn->Visible = false; StartTranslationBitBtn->Visible = true; pTranslationThread = NULL; viewLexem();

viewIdent(); TranslationTabSheet->TabVisible = true; endTranslationTime = GetTickCount();

int iTranslationTime = endTranslationTime - startTranslationTime; TranslationTimeEdit->Text = iTranslationTime; // отображение времени решения в мсек RunProgressBar->Visible = false;

}

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

TSyntSymbol.h)

#ifndef TSyntSymbolH
#define TSyntSymbolH
#include "TLexem.h"
//---------------------------------------------------------------------------
class TSyntSymbol {
private:
int	iTypeSyntSymbol; // 0 - нетерминальный,		1 - терминальный
int	iNumRule;	// номер правила, формирующего нетерминальный символ, иначе = 0

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

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

int	iNumSyntSymbol;		// порядковый номер нетерминального символа, иначе = 0
char*	szLeftRule;	// левая часть правила грамматики
char*	szFillRightRule;		// заполненная правая часть правила грамматики
char*	szLeftBnfRule;		// левая часть правила грамматики в форме Бэкуса-Наура
char*	szRightBnfRule;		// правая часть правила грамматики в форме Бэкуса-Наура
char*	szBnfRule;	// правило в форме Бэкуса-Наура
TLexem* pLexem;			// лексема (для терминальных символов)
int	iSubItemCount;		// кол-во составных частей в соответствии с правилом грамматики
void*	pSyntSymbolSubList; // тип ТSyntSymbolSubList - список составных частей public:

TSyntSymbol();

TSyntSymbol(int _iNumRule, int _iNumSyntSymbol, char* _cLeftRule, char* _cRightRule, char* _cBnfRule); // нетерминальный символ

TSyntSymbol(TLexem* _pLexem);			// терминальный символ
~TSyntSymbol();
int	getNumRule();
void	setNumRule(int _iNumRule);
void	setNumSyntSymbol(int _iNumSyntSymbol);
int	getNumSyntSymbol();
int	getLexemType();
int	getType();
const char*		getText();
const char*		getLexemText();
int	getLexemIval();
double		getLexemDval();
const char*		setRightRule(char* _cRightRule);
const char*		getRightRule();
const char*		setLeftRule(const char* _cLeftRule);
const char*		getLeftRule();
const char*		setBnfRule(const char* _cBnfRule);
const char*		getBnfRule();
const char*		setLeftBnfRule(const char* _cLeftBnfRule);
const char*		getLeftBnfRule();
const char*		setRightBnfRule(const char* _cRightBnfRule);
const char*		getRightBnfRule();
void*	getItemsList();
int	getSubItemsCount();
void	addSubItem(TSyntSymbol *_pSyntSymbol);
void	addTopSubItem(TSyntSymbol *_pSyntSymbol);
void	takeTopSubItem(TSyntSymbol **_pSyntSymbol);
void	getSubItem(int _iNum, TSyntSymbol **_pSyntSymbol);
int	deleteSubItem(int _iNum);		//
int	getTypeSubItem(int _iNum); //
double		takeTopSubItemLexemDval();
};
#endif

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

TSyntSymbol.cpp)

#pragma hdrstop

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

#include <stdlib.h> //---------------------------------------------------------------------------

TSyntSymbol::TSyntSymbol() { iTypeSyntSymbol = 0; iNumRule = 0; iNumSyntSymbol = 0;

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

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

szLeftRule	= 0;
szFillRightRule = 0;
szLeftBnfRule	= 0;
szRightBnfRule = 0;
szBnfRule	= 0;
pLexem	= 0;
iSubItemCount = 0;
pSyntSymbolSubList = 0;
}

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

TSyntSymbol::TSyntSymbol(int _iNumRule, int _iNumSyntSymbol, char* _cLeftRule, char* _cRightRule, char* _cBnfRule) {

iTypeSyntSymbol = 0; iNumRule = _iNumRule;

iNumSyntSymbol = _iNumSyntSymbol; szFillRightRule = 0;

int iLen = strlen(_cRightRule); szFillRightRule = new char[iLen+1]; strcpy(szFillRightRule,_cRightRule); iLen = strlen(_cLeftRule); szLeftRule = new char[iLen+1]; strcpy(szLeftRule,_cLeftRule);

iLen = strlen(_cBnfRule); szBnfRule = new char[iLen+1]; strcpy(szBnfRule,_cBnfRule);

szLeftBnfRule		= 0;
szRightBnfRule		= 0;
pLexem	= 0;
iSubItemCount		= 0;

pSyntSymbolSubList = 0;

}

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

TSyntSymbol::TSyntSymbol(TLexem *_pLexem) { iTypeSyntSymbol = 1;

iNumRule	= 0;
iNumSyntSymbol = 0;
szLeftRule	= 0;
szFillRightRule = 0;
szLeftBnfRule	= 0;
szRightBnfRule = 0;
szBnfRule	= 0;
pLexem	= new TLexem(_pLexem);
iSubItemCount = 0;
pSyntSymbolSubList = 0;
}
//---------------------------------------------------------------------------

TSyntSymbol::~TSyntSymbol() { if (szFillRightRule != 0)

delete[] szFillRightRule; szFillRightRule = 0;

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

szLeftRule = 0;

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

szLeftBnfRule = NULL;

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

szRightBnfRule = NULL; if (szBnfRule != 0)

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

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

delete[] szBnfRule; szBnfRule = 0;

if (pLexem != 0) delete pLexem;

pLexem = 0;

if (pSyntSymbolSubList != 0) {

TSyntSymbolList* ptr = (TSyntSymbolList*)pSyntSymbolSubList; delete ptr;

ptr = 0;

}

pSyntSymbolSubList = 0;

}

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

int TSyntSymbol::getNumRule() { return iNumRule;

}

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

void TSyntSymbol::setNumRule(int _iNumRule) { if (_iNumRule > 0)

iNumRule = _iNumRule;

}

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

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

iNumSyntSymbol = _iNumSyntSymbol;

}

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

int TSyntSymbol::getNumSyntSymbol() { return iNumSyntSymbol;

}

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

int TSyntSymbol::getLexemType() { int iType = -1;

if (pLexem != 0)

iType = pLexem->getType(); return iType;

}

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

int TSyntSymbol::getType() { int iType = -1;

if (iTypeSyntSymbol == 0)

iType = iNumSyntSymbol + 7; // тип символа - нетерминальный else

if (pLexem != 0)

iType = pLexem->getType();

return iType;

}

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

const char* TSyntSymbol::getText() { const char *cText = 0;

if (iTypeSyntSymbol == 0)

cText = szLeftBnfRule; // тип символа - нетерминальный else

if (pLexem != 0)

cText = pLexem->getText(); return cText;

}

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

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

<<< < Предыдущая 1 2 34 / 84 5 6 7 8 > Следующая >>>

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

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