Добавил:

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

Вуз:

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

Предмет:

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

Файл:

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

.pdf

Скачиваний:

Добавлен:

12.02.2015

Размер:

497.5 Кб

Скачать

☆

<<< < Предыдущая 1 2 3 4 5 67 / 87 8 > Следующая >>>

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

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

int iSyntTypeTopStack = -1; int iSyntTypeCurLexem = -1; int iNumName = 0;

if (iNumLexem < pLexemList->getCount()) { iTypeCurLexem = pLexemList->getType(iNumLexem);

if (iTypeCurLexem == TYPE_LEXEM_NAME) { // входная лексема - "идентификатор" s = pLexemList->getText(iNumLexem);

int iIdentCount = pIdentList->getCount(); String sName;

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

iNumName = i; break;

}

iSyntTypeCurLexem = iTypeCurLexem + iNumName -1;

}

else { // входная лексема НЕ "идентификатор" if (iTypeCurLexem == TYPE_LEXEM_END)

iSyntTypeCurLexem = 24; else

iSyntTypeCurLexem = iTypeCurLexem + iIdentCount - 2;

}

int iTypeTopSyntSymbolStack = pSyntSymbolStack->getTypeTopSymbol();

if (iTypeTopSyntSymbolStack == TYPE_LEXEM_START) { // в вершине стека "начало цепочки" iTypeCurLexem = pLexemList->getType(iNumLexem);

if (iTypeCurLexem == TYPE_LEXEM_END) { iRet = 0;

}

else

iSyntTypeTopStack = TYPE_LEXEM_START;

}

else {

if (iTypeTopSyntSymbolStack == TYPE_LEXEM_NAME) { // в вершине стека "идентификатор" s = pSyntSymbolStack->getTextTopSymbol();

int iIdentCount = pIdentList->getCount(); String sName;

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

iNumName = i; break;

}

iSyntTypeTopStack = iTypeTopSyntSymbolStack + iNumName;

}

else { // в вершине стека НЕ "идентификатор"

if (iTypeTopSyntSymbolStack == TYPE_LEXEM_END) { // в вершине стека "конец цепочки" *cRule = 'q';

iRet = 0;

}

iSyntTypeTopStack = iTypeTopSyntSymbolStack + iIdentCount - 1;

}

int iPosRelation = iSyntTypeTopStack*SIZE_GRAM_MATRIX + iSyntTypeCurLexem; *cRule = gramMatrix[iPosRelation];

}

else { // входная цепочка исчерпана

*cRule = 'q';

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

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

iRet = 0;

}

return iRet;

}

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

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

{

int iRet = 1;

int iIdentCount = pIdentList->getCount(); String s;

int iTypeCurLexem1 = -1; int iTypeCurLexem2 = -1;

int iSyntTypeCurLexem1 = -1; int iSyntTypeCurLexem2 = -1; int iNumName = 0;

iTypeCurLexem1 = _pSyntSymbol1->getLexemType();

if (iTypeCurLexem1 == TYPE_LEXEM_NAME) { // входная лексема1 - "идентификатор" s = _pSyntSymbol1->getLexemText();

int iIdentCount = pIdentList->getCount(); String sName;

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

iNumName = i; break;

}

iSyntTypeCurLexem1 = iTypeCurLexem1 + iNumName;

}

else { // входная лексема1 НЕ "идентификатор" iSyntTypeCurLexem1 = iTypeCurLexem1 + iIdentCount - 1;

}

iTypeCurLexem2 = _pSyntSymbol2->getLexemType();

if (iTypeCurLexem2 == TYPE_LEXEM_NAME) { // входная лексема1 - "идентификатор" s = _pSyntSymbol2->getLexemText();

int iIdentCount = pIdentList->getCount(); String sName;

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

iNumName = i; break;

}

iSyntTypeCurLexem2 = iTypeCurLexem2 + iNumName -1;

}

else { // входная лексема1 НЕ "идентификатор" iSyntTypeCurLexem2 = iTypeCurLexem2 + iIdentCount - 2;

}

int iPosRelation = iSyntTypeCurLexem1*SIZE_GRAM_MATRIX + iSyntTypeCurLexem2; *cRule = gramMatrix[iPosRelation];

return iRet;

}

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

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

Листинг 59. Исходный код заголовочного файла модуля генерации выходного представления транслятора постановки задачи (файл kaGenOut.h)

#ifndef kaGenOutH #define kaGenOutH

#include "TSyntSymbolList.h" #include "..\classDll\TTask.h"

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

int makeOutText(TSyntSymbolList *_pSyntSymbolList, TTask **_tsk); //---------------------------------------------------------------------------

#endif

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

#include <vcl.h> #pragma hdrstop

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

#include "kaGenOut.h" #include "TSyntSymbol.h"

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

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

int makeOutText(TSyntSymbolList *_pSyntSymbolList, TTask **_tsk)

{

int iRet = -1; TTask *tsk = *_tsk; if (tsk == NULL)

{

tsk = new TTask(); *_tsk = tsk;

}

int iType = 0;

int iSubCount = 0; int n = 0;

double d = 0.0;

if (_pSyntSymbolList != 0)

{

int iSyntSymbolCount = _pSyntSymbolList->getSyntSymbolCount(); if (iSyntSymbolCount == 1)

{

String s;

TSyntSymbol *pSyntSymbol = 0; _pSyntSymbolList->getLastSyntSymbol(&pSyntSymbol);

// проверка - символ - начальный символ грамматики Z = <задача> s = pSyntSymbol->getLeftBnfRule();

if (s.AnsiCompare("<задача>") == 0)

{

//это начальный символ грамматики Z = <задача>

//теперь достать список составных частей

int iSubSymbolCount = pSyntSymbol->getSubItemsCount(); TSyntSymbol *pSubSyntSymbol = 0;

while (iSubSymbolCount > 0)

{

pSyntSymbol->getSubItem(0,&pSubSyntSymbol); // это <массивыCразмерностью> ?

s = pSubSyntSymbol->getLeftBnfRule();

if (s.AnsiCompare("<массивыCразмерностью>") == 0)

{

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

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

int iSub2SymbolCount = pSubSyntSymbol->getSubItemsCount(); TSyntSymbol *pSub2SyntSymbol = 0;

while (iSub2SymbolCount > 0)

{

pSubSyntSymbol->getSubItem(0,&pSub2SyntSymbol); s = pSub2SyntSymbol->getLeftBnfRule();

if (s.AnsiCompare("<размерность>") == 0)

{

int iSub3SymbolCount = pSub2SyntSymbol->getSubItemsCount(); TSyntSymbol *pSub3SyntSymbol = 0;

while (iSub3SymbolCount > 0)

{

pSub2SyntSymbol->getSubItem(0,&pSub3SyntSymbol); int iType = pSub3SyntSymbol->getType();

if (iType == 4)

{// <целое число>

n = pSub3SyntSymbol->getLexemIval(); tsk->setSizeX(n); pSub2SyntSymbol->deleteSubItem(0);

}

else pSub2SyntSymbol->deleteSubItem(0);

iSub3SymbolCount = pSub2SyntSymbol->getSubItemsCount();

}

pSub3SyntSymbol = 0;

}

if (s.AnsiCompare("<массивы>") == 0)

{

int iSub3SymbolCount = pSub2SyntSymbol->getSubItemsCount(); TSyntSymbol *pSub3SyntSymbol = 0;

while (iSub3SymbolCount > 0)

{

pSub2SyntSymbol->getSubItem(0,&pSub3SyntSymbol); s = pSub3SyntSymbol->getLeftBnfRule();

if (s.AnsiCompare("<матрицаА>") == 0)

{

int iSub4SymbolCount = pSub3SyntSymbol->getSubItemsCount(); TSyntSymbol *pSub4SyntSymbol = 0;

while (iSub4SymbolCount > 0)

{

pSub3SyntSymbol->getSubItem(0,&pSub4SyntSymbol); s = pSub4SyntSymbol->getLeftBnfRule();

if (s.AnsiCompare("<матрица>") == 0)

{

int iSub5SymbolCount = pSub4SyntSymbol->getSubItemsCount(); TSyntSymbol *pSub5SyntSymbol = 0;

while (iSub5SymbolCount > 0)

{

pSub4SyntSymbol->getSubItem(0,&pSub5SyntSymbol); s = pSub5SyntSymbol->getLeftBnfRule();

if (s.AnsiCompare("<строкиМатрицы>") == 0)

{

for (int iRow=0; iRow<n; iRow++)

{

for (int iCol=0; iCol<n; iCol++)

{

d = pSub5SyntSymbol->takeTopSubItemLexemDval(); tsk->setElemA(iRow,iCol,d);

}

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

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

}

iType = pSub5SyntSymbol->getNumSyntSymbol(); if (iType > 0)

{ // >0 - нетерминальный

iSubCount = pSub5SyntSymbol->getSubItemsCount(); if (iSubCount == 0) {

pSub4SyntSymbol->deleteSubItem(0);

}

else pSub4SyntSymbol->deleteSubItem(0);

iSub5SymbolCount = pSub4SyntSymbol->getSubItemsCount();

}

pSub5SyntSymbol = 0;

}

iType = pSub4SyntSymbol->getNumSyntSymbol(); if (iType > 0)

{ // >0 - нетерминальный

iSubCount = pSub4SyntSymbol->getSubItemsCount(); if (iSubCount == 0) {

pSub3SyntSymbol->deleteSubItem(0);

}

else pSub3SyntSymbol->deleteSubItem(0);

iSub4SymbolCount = pSub3SyntSymbol->getSubItemsCount();

}

pSub4SyntSymbol = 0;

}

if (s.AnsiCompare("<векторX0>") == 0)

{

int iSub4SymbolCount = pSub3SyntSymbol->getSubItemsCount(); TSyntSymbol *pSub4SyntSymbol = 0;

while (iSub4SymbolCount > 0)

{

pSub3SyntSymbol->getSubItem(0,&pSub4SyntSymbol); s = pSub4SyntSymbol->getLeftBnfRule();

if (s.AnsiCompare("<матрица>") == 0)

{

int iSub5SymbolCount = pSub4SyntSymbol->getSubItemsCount(); TSyntSymbol *pSub5SyntSymbol = 0;

while (iSub5SymbolCount > 0)

{

pSub4SyntSymbol->getSubItem(0,&pSub5SyntSymbol); s = pSub5SyntSymbol->getLeftBnfRule();

if (s.AnsiCompare("<строкиМатрицы>") == 0)

{

for (int iRow=0; iRow<n; iRow++)

{

d = pSub5SyntSymbol->takeTopSubItemLexemDval(); tsk->setElemX0(iRow,d);

}

iType = pSub5SyntSymbol->getNumSyntSymbol(); if (iType > 0)

{ // >0 - нетерминальный

iSubCount = pSub5SyntSymbol->getSubItemsCount(); if (iSubCount == 0) {

pSub4SyntSymbol->deleteSubItem(0);

}

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

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

}

else pSub4SyntSymbol->deleteSubItem(0);

iSub5SymbolCount = pSub4SyntSymbol->getSubItemsCount();

}

pSub5SyntSymbol = 0;

}

iType = pSub4SyntSymbol->getNumSyntSymbol(); if (iType > 0)

{ // >0 - нетерминальный

iSubCount = pSub4SyntSymbol->getSubItemsCount(); if (iSubCount == 0) {

pSub3SyntSymbol->deleteSubItem(0);

}

else pSub3SyntSymbol->deleteSubItem(0);

iSub4SymbolCount = pSub3SyntSymbol->getSubItemsCount();

}

pSub4SyntSymbol = 0;

}

iType = pSub3SyntSymbol->getNumSyntSymbol(); if (iType > 0)

{ // >0 - нетерминальный

iSubCount = pSub3SyntSymbol->getSubItemsCount(); if (iSubCount == 0) {

pSub2SyntSymbol->deleteSubItem(0);

}

else pSub2SyntSymbol->deleteSubItem(0);

iSub3SymbolCount = pSub2SyntSymbol->getSubItemsCount();

}

pSub3SyntSymbol = 0;

}

iType = pSub2SyntSymbol->getNumSyntSymbol(); if (iType > 0)

{ // >0 - нетерминальный

iSubCount = pSub2SyntSymbol->getSubItemsCount(); if (iSubCount == 0) {

pSubSyntSymbol->deleteSubItem(0);

}

else pSubSyntSymbol->deleteSubItem(0);

iSub2SymbolCount = pSubSyntSymbol->getSubItemsCount();

}

pSub2SyntSymbol = 0;

}

if (s.AnsiCompare("<началоАнализа>") == 0)

{

int iSub3SymbolCount = pSubSyntSymbol->getSubItemsCount(); TSyntSymbol *pSub3SyntSymbol = 0;

while (iSub3SymbolCount > 0)

{

pSubSyntSymbol->getSubItem(0,&pSub3SyntSymbol); int iType = pSub3SyntSymbol->getType();

if (iType == 3)

{// <вещественноеЧисло>

d = pSub3SyntSymbol->getLexemDval();

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

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

tsk->setT0(d); pSubSyntSymbol->deleteSubItem(0);

}

else pSubSyntSymbol->deleteSubItem(0);

iSub3SymbolCount = pSubSyntSymbol->getSubItemsCount();

}

pSub3SyntSymbol = 0;

}

if (s.AnsiCompare("<конецАнализа>") == 0)

{

int iSub3SymbolCount = pSubSyntSymbol->getSubItemsCount(); TSyntSymbol *pSub3SyntSymbol = 0;

while (iSub3SymbolCount > 0)

{

pSubSyntSymbol->getSubItem(0,&pSub3SyntSymbol); int iType = pSub3SyntSymbol->getType();

if (iType == 3)

{// <вещественноеЧисло>

d = pSub3SyntSymbol->getLexemDval(); tsk->setTk(d); pSubSyntSymbol->deleteSubItem(0);

}

else pSubSyntSymbol->deleteSubItem(0);

iSub3SymbolCount = pSubSyntSymbol->getSubItemsCount();

}

pSub3SyntSymbol = 0;

}

if (s.AnsiCompare("<шаг>") == 0)

{

int iSub3SymbolCount = pSubSyntSymbol->getSubItemsCount(); TSyntSymbol *pSub3SyntSymbol = 0;

while (iSub3SymbolCount > 0)

{

pSubSyntSymbol->getSubItem(0,&pSub3SyntSymbol); int iType = pSub3SyntSymbol->getType();

if (iType == 3)

{// <вещественноеЧисло>

d = pSub3SyntSymbol->getLexemDval();

tsk->setH(d); pSubSyntSymbol->deleteSubItem(0);

}

else pSubSyntSymbol->deleteSubItem(0);

iSub3SymbolCount = pSubSyntSymbol->getSubItemsCount();

}

pSub3SyntSymbol = 0;

}

iType = pSubSyntSymbol->getNumSyntSymbol(); if (iType > 0)

{ // >0 - нетерминальный

iSubCount = pSubSyntSymbol->getSubItemsCount(); if (iSubCount == 0) {

pSyntSymbol->deleteSubItem(0);

}

else pSyntSymbol->deleteSubItem(0);

iSubSymbolCount = pSyntSymbol->getSubItemsCount();

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

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

}

pSubSyntSymbol = 0;

}

pSyntSymbol = 0;

}

*_tsk = tsk; tsk = NULL; return iRet;

}

Листинг 61. Модифицированный заголовочный файл класса

TTranslationThread (файл TTranslationThread.h)

#ifndef TTranslationThreadH #define TTranslationThreadH

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

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

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

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

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

class TTranslationThread : public TThread

{

private:

TProgressBar *fPrBar; TTreeView *fSyntTreeView; char* szText;

void __fastcall DoStep();

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

void	addToTreeNode(TTreeNode* pParentNode, TSyntSymbol *pSyntSymbol);
void	translateTask();
char	*cProtocol;
protected:

void __fastcall Execute(); public:

__fastcall TTranslationThread(TProgressBar *_PrBar, TTreeView *_SyntTreeView,

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

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

TTranslationThread.cpp)

#include <vcl.h> #pragma hdrstop

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

#include "kaSynt.h" #include "kaGenOut.h"

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

#pragma package(smart_init)

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

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

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

__fastcall TTranslationThread::TTranslationThread(TProgressBar *_PrBar,

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

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

void __fastcall TTranslationThread::Execute()

{

DoStep();

}

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

void __fastcall TTranslationThread::DoStep()

{
try {
if (!Terminated)		{
translateTask();
}
}
__finally {
fPrBar	= NULL;
fSyntTreeView		= NULL;
if (szText != NULL)
delete[] szText;
szText	= NULL;

ppLexemList = NULL; ppIdentList = NULL; ppSyntSymbolList = NULL;

}

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

void __fastcall TTranslationThread::DoVisualStep()

{

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

}

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

void __fastcall TTranslationThread::DoVisualSyntStep()

{

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

if (fSyntTreeView != NULL) { fSyntTreeView->Items->Clear(); int TreeViewIndex = 0; TTreeNodes* pItems = 0;

if (*ppSyntSymbolList != 0) { pItems = fSyntTreeView->Items;

int iSyntSymbolCount = (*ppSyntSymbolList)->getSyntSymbolCount();

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

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

int iSubItemCount = 0; TSyntSymbol *pSyntSymbol = 0; TSyntSymbol *pSubSyntSymbol = 0;

for (int i=0; i<iSyntSymbolCount; i++) { (*ppSyntSymbolList)->getSyntSymbol(i,&pSyntSymbol); fSyntTreeView->Items->Add(NULL,pSyntSymbol->getText()); iSubItemCount = pSyntSymbol->getSubItemsCount();

for (int j=0; j<iSubItemCount; j++) { pSyntSymbol->getSubItem(j,&pSubSyntSymbol); addToTreeNode(pItems->Item[i], pSubSyntSymbol); pSubSyntSymbol = 0;

}

pSyntSymbol = 0;

}

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

void TTranslationThread::addToTreeNode(TTreeNode* pParentNode, TSyntSymbol *pSyntSymbol)

{

if (pSyntSymbol != NULL) {

if (fSyntTreeView != NULL) { TSyntSymbol *pSubSyntSymbol = 0;

fSyntTreeView->Items->AddChild(pParentNode,pSyntSymbol->getText()); int iSubItemCount = pSyntSymbol->getSubItemsCount();

for (int j=0; j<iSubItemCount; j++) { pSyntSymbol->getSubItem(j,&pSubSyntSymbol); if (pSubSyntSymbol != NULL)

addToTreeNode(pParentNode->GetLastChild(), pSubSyntSymbol); pSubSyntSymbol = 0;

}

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

void TTranslationThread::translateTask()

{

int iRet;

int iLexemCount; if (!Terminated) {

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

}

if (!Terminated) {

iRet = makeSyntSymbolList(*ppLexemList, *ppIdentList, ppSyntSymbolList, cProtocol, &Terminated);

Synchronize(DoVisualSyntStep);

}

if (!Terminated) {

iRet = makeOutText(*ppSyntSymbolList,ppTask); Synchronize(DoVisualStep);

}

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

<<< < Предыдущая 1 2 3 4 5 67 / 87 8 > Следующая >>>

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

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