Добавил:

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

Вуз:

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

Предмет:

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

Файл:

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

.pdf

Скачиваний:

Добавлен:

12.02.2015

Размер:

497.5 Кб

Скачать

☆

<<< < Предыдущая 1 23 / 83 4 5 6 7 8 > Следующая >>>

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

_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________

return szText;

}

int TLexem::getLenText()

{

return strlen(szText);

}

void TLexem::setType(int _iType)

{

iType = _iType;

}

int TLexem::getType()

{

return iType;

}

void TLexem::setIval(int _iValue)

{

iValue = _iValue;

}

int TLexem::getIval()

{

return iValue;

}

void TLexem::setDval(double _dValue)

{

dValue = _dValue;

}

double TLexem::getDval()

{

return dValue;

}

void TLexem::setNumStr(unsigned int _iNumStr)

{

iNumStr = _iNumStr;

}

unsigned int TLexem::getNumStr()

{

return iNumStr;

}

void TLexem::setPosStr(unsigned int _iPosStr)

{

iPosStr = _iPosStr;

}

unsigned int TLexem::getPosStr()

{

return iPosStr;

}

void TLexem::setPos(unsigned int _iPos)

{

iPos = _iPos;

}

unsigned int TLexem::getPos()

{

return iPos;

}

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

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

Листинг 31. Класс TLexemList (файл TLexemList.h)

#ifndef TLexemListH #define TLexemListH

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

#include "TLexem.h" //---------------------------------------------------------------------------

class TLexemList

{

private:

TLexem** pList;

int	iCount;
int	iMax;
public:

TLexemList();

~TLexemList();

int	add(TLexem* _pLexem); // возвращает порядковый номер лексемы
void	set(int _iNum, TLexem* _pLexem);
void	get(int _iNum, TLexem** _pLexem);
TLexem* take(int _iNum);
int	getCount();
int	getType(int _iNum);
const char* getText(int _iNum);
int	getLenText(int _iNum);
int	clear(int _iNum); // очистка (удаление) элемента списка
void	sort();

};

#endif

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

TLexemList.cpp)

#pragma hdrstop #include "TLexemList.h" #include <string.h>

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

TLexemList::TLexemList()

{
pList	= 0;
iCount	= 0;
iMax	= 10;

}

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

TLexemList::~TLexemList()

{
if (pList != 0)	{
for (int i=0; i<iCount; i++) {
TLexem* ptr = pList[i];
if (ptr != 0)	delete ptr;
ptr = 0;
pList[i] = 0;

}

delete[] pList;

}

pList = 0;

}

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

int TLexemList::add(TLexem *_pLexem)

{

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

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

if (pList == 0) {

pList = new TLexem*[iMax];

}

if (pList != 0) {

if (iCount == iMax) { iMax += 10;

TLexem** pNewList = new TLexem*[iMax]; for (int i=0; i<iCount; i++) {

pNewList[i] = pList[i]; pList[i] = 0;

}

delete[] pList; pList = pNewList; pNewList = 0;

}

if (iCount < iMax) { pList[iCount++] = _pLexem;

}

return iCount;

}

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

void TLexemList::get(int _iNum, TLexem **_pLexem)

{

if (pList != 0) {

if (iCount >= _iNum) { *_pLexem = pList[_iNum];

}

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

TLexem* TLexemList::take(int _iNum)

{

TLexem *pLexem = 0; if (pList != 0) {

if (iCount >= _iNum) { pLexem = pList[_iNum]; pList[_iNum] = 0;

}

return pLexem;

}

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

void TLexemList::set(int _iNum, TLexem *_pLexem)

{

if (pList != 0) {

if (iCount >= _iNum) { TLexem *ptr = pList[_iNum]; if (ptr != 0)

delete ptr; pList[_iNum] = _pLexem;

}

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

int TLexemList::getCount()

{

return iCount;

}

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

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

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

int TLexemList::getType(int _iNum)

{

int iType = -1; if (pList != 0) {

if (iCount >= _iNum) {

iType = pList[_iNum]->getType();

}

return iType;

}

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

const char* TLexemList::getText(int _iNum)

{

const char* cText = 0; if (pList != 0) {

if (iCount >= _iNum) {

cText = pList[_iNum]->getText();

}

return cText;

}

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

int TLexemList::getLenText(int _iNum)

{

int iLen = 0;

if (pList != 0) {

if (iCount >= _iNum) {

iLen = ((TLexem*)(pList[_iNum]))->getLenText();

}

return iLen;

}

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

int TLexemList::clear(int _iNum)

{

int iRet = -1; if (pList != 0) {

if (iCount >= _iNum) {

TLexem *pLexem = pList[_iNum]; if (pLexem != 0) {

delete pLexem; iRet = 0;

}

pLexem = 0; pList[_iNum] = 0;

}

return iRet;

}

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

void TLexemList::sort()

{

int iCount = getCount(); if (iCount > 1) {

TLexem** pNewList = new TLexem*[iMax]; int iNumMin = 0;

TLexem *pMin = 0; int iLenMin = 0; char *szTextMin = 0; TLexem *pCur = 0;

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

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

int iLenCur = 0; char *szTextCur = 0; int iLen = 0;

int iSorted = 0;

while (iSorted < iCount) {

for (int i=iNumMin; i<iCount; i++) { // выборка первого непустого pMin = take(i);

if (pMin != 0) { iNumMin = i;

iLenMin = pMin->getLenText(); szTextMin = new char[iLenMin+1]; strcpy(szTextMin,pMin->getText()); break;

}

if (pMin != 0) { // в списке хотя бы один элемент есть pCur = 0;

for (int i=iNumMin+1; i<iCount; i++) { iLenCur = getLenText(i);

if (iLenCur > 0) {

szTextCur = new char[iLenCur+1]; strcpy(szTextCur,getText(i));

if (iLenMin > iLenCur) iLen = iLenCur;

else

iLen = iLenMin; int iEqCount = 0; char c = 0;

for (int j=0; j<iLen; j++) {

c = szTextMin[j] - szTextCur[j]; if (c == 0) {

iEqCount++;

continue;

}

if (c > 0) { // новый меньше меньшего - переставить! if (iEqCount == j) {

pCur = take(i); set(i,pMin);

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

szTextMin = szTextCur; szTextCur = 0; iLenMin = iLenCur; pMin = pCur;

pCur = 0; break;

}

if (c < 0) { // новый больше меньшего - выход из цикла? break;

}

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

szTextCur = 0; iLenCur = 0;

}

if (pMin != 0) { pNewList[iSorted++] = pMin;

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

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

pMin = 0;

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

szTextMin = 0; iLenMin = 0;

}

else break;

}

delete[] pList; pList = pNewList; pNewList = 0;

}

Листинг 33. Класс TIdent (файл TIdent.h)

#ifndef TIdentH #define TIdentH #include "TLexem.h"

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

class TIdent: public TLexem

{

private:

public:

TIdent(); TIdent(TIdent* _pIdent);

TIdent(char* _szText, int _iType, int _iValue, double _dValue, unsigned int _iNumStr, unsigned int _iPosStr, unsigned int _iPos);

~TIdent();

};

#endif

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

TIdent.cpp)

#pragma hdrstop #include "TIdent.h" #include <string.h>

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

TIdent::TIdent() : TLexem()

{

}

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

TIdent::TIdent(TIdent* _pIdent) : TLexem(_pIdent)

{

}

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

TIdent::TIdent(char* _szText, int _iType, int _iValue, double _dValue, unsigned int _iNumStr, unsigned int _iPosStr, unsigned int _iPos) :

TLexem( _szText, _iType, _iValue, _dValue, _iNumStr, _iPosStr, _iPos)

{

}

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

TIdent::~TIdent()

{

}

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

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

Листинг 35. Класс TIdentList (файл TIdentList.h)

#ifndef TIdentListH #define TIdentListH #include "TIdent.h"

#include "TLexemList.h" //---------------------------------------------------------------------------

class TIdentList : public TLexemList

{

private:

public:

TIdentList();

~TIdentList();

int addIdent(TIdent* _pIdent); // возвращает порядковый номер идентификатора int getNum(TIdent *_pIdent); // возвращает порядковый номер идентификатора

};

#endif

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

TIdentList.cpp)

#pragma hdrstop #include "TIdentList.h" #include <string.h>

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

TIdentList::TIdentList() : TLexemList()

{

}

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

TIdentList::~TIdentList()

{

}

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

int TIdentList::addIdent(TIdent *_pIdent)

{

int iNumIdent = -1;

iNumIdent = getNum(_pIdent); if (iNumIdent < 0) {

iNumIdent = add((TLexem*)_pIdent) - 1; sort();

iNumIdent = getNum(_pIdent);

}

return iNumIdent;

}

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

int TIdentList::getNum(TIdent *_pIdent)

{

int iNumIdent = -1;

int iCount = getCount(); if (iCount > 0) {

TLexem *pLexem = 0; int iLenLexem = 0;

int iLenIdent = _pIdent->getLenText(); char *szTextIdent = new char[iLenIdent+1]; strcpy(szTextIdent,_pIdent->getText()); char *szTextLexem = 0;

bool isEqu = true;

for (int i=0; i<iCount; i++) { pLexem = 0;

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

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

get(i, &pLexem); if (pLexem != 0) {

iLenLexem = pLexem->getLenText(); if (iLenLexem == iLenIdent) {

szTextLexem = new char[iLenLexem+1]; strcpy(szTextLexem,pLexem->getText()); isEqu = true;

for (int j=0; j<iLenIdent; j++) {

if (szTextLexem[j] != szTextIdent[j]) { isEqu = false;

break;

}

if (isEqu) { iNumIdent = i; break;

}

if (iNumIdent >= 0) break;

}

pLexem = 0;

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

szTextIdent = 0;

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

szTextLexem = 0;

}

return iNumIdent;

}

Листинг 37. Фрагмент основной программы лексического анализатора входного языка (файл kaLex.cpp)

#pragma hdrstop #include <vcl.h> #include <stdlib.h> #include <string.h> #include "kaLex.h" #include "TLexem.h"

#include "..\util\charToAny.h" #pragma package(smart_init) #include "typeLexem.h"

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

enum kaPos {// список состояний конечного автомата

kaPosTask,	// <задача>
kaPosSize,	// <размерность>
kaPosValueSize,	// <значение размерности>
kaPosMatrixA,	// <матрица А>

kaPosElemMatrixA, // <элементы матрицы А> kaPosRowElemMatrixA, // <все элементы матрицы А> kaPosOneElemMatrixA, // <элемент матрицы А> kaPosFractionElemMatrixA, // <дробь элемента матрицы А>

kaPosX0,	// <x0>
kaPosRowElemX0,	// <все элементы x0>
kaPosElemX0,	// <элемент x0>
kaPosFractionElemX0,	// <дробь элемента x0>
kaPosT0,	// <t0>

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

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

kaPosValueT0,		// <значение t0>
kaPosFractionValueT0,		// <дробь значения t0>
kaPosTk,	// <tk>
kaPosValueTk,		// <значение tk>
kaPosFractionValueTk,		// <дробь значения tk>
kaPosH,	// <h>
kaPosValueH,		// <значение h>
kaPosFractionValueH,		// <дробь значения h>
kaPosEndTask01,		// <остаток задачи 1>
kaPosEndTask02,		// <остаток задачи 2>
kaPosEndTask03,		// <остаток задачи 3>
kaPosEndTask04,		// <остаток задачи 4>
kaPosEndTask05,		// <остаток задачи 5>
kaPosEndTask06,		// <остаток задачи 6>
kaPosEndTask07,		// <остаток задачи 7>
kaPosEndTask08,		// <остаток задачи 8>
kaPosEndTask09,		// <остаток задачи 9>
kaPosEndTask10,		// <остаток задачи 10>
kaPosEndTask11,		// <остаток задачи 11>
kaPosEndTask12,		// <остаток задачи 12>
kaPosEndTask13,		// <остаток задачи 13>
kaPosEndTask14,		// <остаток задачи 14>
kaPosSuccess		// <Успех>

}; //---------------------------------------------------------------------------

enum kaTerm { // список терминальных символов конечного автомата

kaTerm_Space=' ',		// символ " " (пробел)
kaTerm_n='n',	// символ "n"
kaTerm_A='A',	// символ A
kaTerm_x='x',	// символ x
kaTerm_t='t', // символ t
kaTerm_k='k',	// символ k
kaTerm_h='h',	// символ h
kaTerm_0='0',	// символ 0
kaTerm_1='1',	// символ 1
kaTerm_2='2',	// символ 2
kaTerm_3='3',	// символ 3
kaTerm_4='4',	// символ 4
kaTerm_5='5',	// символ 5
kaTerm_6='6',	// символ 6
kaTerm_7='7',	// символ 7
kaTerm_8='8',	// символ 8
kaTerm_9='9',	// символ 9
kaTerm_Point		= '.', // символ "."
kaTerm_Plus		= '+',	// символ "+"
kaTerm_Minus		= '-',	// символ "-"
kaTerm_OpenQuadBracket			= '[',	// символ "["
kaTerm_CloseQuadBracket = ']',				// символ "]"
kaTerm_Semicolon		= ';',	// символ "["
kaTerm_Comma		= ',',	// символ ","
kaTerm_Equal		= '=',	// символ "="
kaTerm_NewR		= '\r',	// символ "\r"
kaTerm_NewN		= '\n'	// символ "\n"
};

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

int makeLexemList(char* szText, TLexemList **pLexemList, TIdentList **pIdentList, bool* _Terminated)

{ // формирование списка лексем текстового представления постановки задачи if (*pLexemList != NULL)

delete *pLexemList;

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

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

*pLexemList = new TLexemList(); // список лексем if (*pIdentList != NULL)

delete *pIdentList;
*pIdentList = new TIdentList();		// список идентификаторов
int kaCurPos = 0;	// текущее состояние анализатора (конечного автомата)
int iCurPosText = 0;	// текущая позиция в исходном тексте
int iLenText = strlen(szText);		// длина исходного текста
char szCurLex[256];	// текущая лексема
szCurLex[0] = '\0';
int iLenCurLex = 0;	// длина текущей лексемы
int iNumStrCurLex = 1;	// НОМЕР строки в исходном тексте, в которой начинается лексема
int iPosStrCurLex = 1;	// позиция в строке исходного текста, с которой начинается лексема

int iPosCurLex = 1; // позиция от начала исходного текста, с которой начинается лексема int iTypeCurLex = 0; // тип текущей лексемы

	//	1	- имя
	// 2		- разделитель ";"
	//	3	- вещественное число
	//	4	- целое число
	//	5	- знак операции присваивания "="
	//	6	- скобка "["
	//	7	- скобка "]"
char c;	// текущий символ

int iRet = -1; // код возврата

while (!(*_Terminated) && (iCurPosText <= iLenText)) {

//цикл пока не закончился входной текст,

//либо не будет прерван процесс, если используется поток команд (нить) c = szText[iCurPosText];

switch (kaCurPos) {

case kaPosTask:	// [КА] = <задача>
kaLexTask(&kaCurPos, &iCurPosText, szText, szCurLex, &iLenCurLex,				c,
&iNumStrCurLex, &iPosStrCurLex, &iPosCurLex, &iTypeCurLex,
pLexemList, pIdentList);			break;
case kaPosSize:	// текущее [КА] = <размерность>
kaLexSize(&kaCurPos, &iCurPosText, szText, szCurLex, &iLenCurLex,				c,
&iNumStrCurLex, &iPosStrCurLex, &iPosCurLex, &iTypeCurLex,
pLexemList, pIdentList);			break;
case kaPosValueSize:		// [КА] = <значение размерности>
kaLexValueSize(&kaCurPos, &iCurPosText, szText, szCurLex, &iLenCurLex, c,
&iNumStrCurLex, &iPosStrCurLex, &iPosCurLex, &iTypeCurLex,
pLexemList, pIdentList);			break;
case kaPosEndTask01:		// [КА] = <остаток задачи1>
kaLexEndTask01(&kaCurPos, &iCurPosText, szText, szCurLex, &iLenCurLex, c,
&iNumStrCurLex, &iPosStrCurLex, &iPosCurLex, &iTypeCurLex,
pLexemList, pIdentList);			break;
… // и т.д. для всех состояний конечного автомата (КА)
case kaPosSuccess:		// [КА] = <Успех>
iRet = 0;

iCurPosText = iLenText +1; break;

default:

{

iCurPosText++;

break;

};

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

iNumStrCurLex+1,1,iPosCurLex+1); (*pLexemList)->add(pLexem);

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

<<< < Предыдущая 1 23 / 83 4 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