Системное программирование / SSW_kw_Appendix
.pdf
Создание распределенной системы решения задач
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
const char* TSyntSymbol::setRightRule(char* _cRightRule) { if (szFillRightRule != 0)
delete[] szFillRightRule;
int iLen = strlen(_cRightRule); szFillRightRule = new char[iLen+1]; strcpy(szFillRightRule,_cRightRule); return szFillRightRule;
}
//---------------------------------------------------------------------------
const char* TSyntSymbol::getRightRule() { return szFillRightRule;
}
//---------------------------------------------------------------------------
const char* TSyntSymbol::setLeftRule(const char* _cLeftRule) { if (szLeftRule != 0)
delete[] szLeftRule;
int iLen = strlen(_cLeftRule); szLeftRule = new char[iLen+1]; strcpy(szLeftRule,_cLeftRule); return szLeftRule;
}
//---------------------------------------------------------------------------
const char* TSyntSymbol::getLeftRule() { return szLeftRule;
}
//---------------------------------------------------------------------------
const char* TSyntSymbol::setBnfRule(const char* _cBnfRule) { if (szBnfRule != 0)
delete[] szBnfRule;
int iLen = strlen(_cBnfRule); szBnfRule = new char[iLen+1]; strcpy(szBnfRule,_cBnfRule); return szBnfRule;
}
//---------------------------------------------------------------------------
const char* TSyntSymbol::getBnfRule() { return szBnfRule;
}
//---------------------------------------------------------------------------
const char* TSyntSymbol::setLeftBnfRule(const char* _cLeftBnfRule) { if (szLeftBnfRule != 0)
delete[] szLeftBnfRule;
int iLen = strlen(_cLeftBnfRule); szLeftBnfRule = new char[iLen+1]; strcpy(szLeftBnfRule,_cLeftBnfRule); return szLeftBnfRule;
}
//---------------------------------------------------------------------------
const char* TSyntSymbol::getLeftBnfRule() { return szLeftBnfRule;
}
//---------------------------------------------------------------------------
const char* TSyntSymbol::setRightBnfRule(const char* _cRightBnfRule) { if (szRightBnfRule != 0)
delete[] szRightBnfRule;
int iLen = strlen(_cRightBnfRule); szRightBnfRule = new char[iLen+1]; strcpy(szRightBnfRule,_cRightBnfRule); return szRightBnfRule;
}
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Методические указания к выполнению курсовой работы |
41 |
Системное программное обеспечение
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
//---------------------------------------------------------------------------
const char* TSyntSymbol::getRightBnfRule() { return szRightBnfRule;
}
//---------------------------------------------------------------------------
const char* TSyntSymbol::getLexemText() { return pLexem->getText();
}
//---------------------------------------------------------------------------
int TSyntSymbol::getLexemIval() { int iRet = 0;
if (pLexem != 0)
iRet = pLexem->getIval(); return iRet;
}
//---------------------------------------------------------------------------
double TSyntSymbol::getLexemDval() { double dRet = 0.0;
if (pLexem != 0)
dRet = pLexem->getDval(); return dRet;
}
//---------------------------------------------------------------------------
void* TSyntSymbol::getItemsList() { return pSyntSymbolSubList;
}
//---------------------------------------------------------------------------
int TSyntSymbol::getSubItemsCount() {
TSyntSymbolList *ptr = (TSyntSymbolList*)pSyntSymbolSubList; if (ptr != 0) {
iSubItemCount = ptr->getSyntSymbolCount();
}
ptr = 0;
return iSubItemCount;
}
//---------------------------------------------------------------------------
void TSyntSymbol::addSubItem(TSyntSymbol *_pSyntSymbol) { TSyntSymbolList *ptr = 0;
if (pSyntSymbolSubList == 0) { ptr = new TSyntSymbolList(); pSyntSymbolSubList = (void*)ptr;
}
else {
ptr = (TSyntSymbolList*)pSyntSymbolSubList;
}
ptr->addSyntSymbol(_pSyntSymbol); iSubItemCount = ptr->getSyntSymbolCount();
ptr = 0;
}
//---------------------------------------------------------------------------
void TSyntSymbol::addTopSubItem(TSyntSymbol *_pSyntSymbol) { TSyntSymbolList *ptr = 0;
if (pSyntSymbolSubList == 0) { ptr = new TSyntSymbolList(); pSyntSymbolSubList = (void*)ptr;
}
else {
ptr = (TSyntSymbolList*)pSyntSymbolSubList;
}
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
42 |
М.Ф.Степанов |
Создание распределенной системы решения задач
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
ptr->addTopSyntSymbol(_pSyntSymbol); iSubItemCount = ptr->getSyntSymbolCount(); ptr = 0;
}
//---------------------------------------------------------------------------
void TSyntSymbol::takeTopSubItem(TSyntSymbol **_pSyntSymbol) { if (pSyntSymbolSubList != 0) {
TSyntSymbolList *ptr = (TSyntSymbolList*)pSyntSymbolSubList; if (ptr != 0) {
ptr->takeTopSyntSymbol(_pSyntSymbol);
}
iSubItemCount = ptr->getSyntSymbolCount(); ptr = 0;
}
}
//---------------------------------------------------------------------------
void TSyntSymbol::getSubItem(int _iNum, TSyntSymbol **_pSyntSymbol) { if (pSyntSymbolSubList != 0) {
TSyntSymbolList *ptr = (TSyntSymbolList*)pSyntSymbolSubList; if (ptr != 0) {
int iCount = ptr->getSyntSymbolCount(); if (iCount > _iNum)
ptr->getSyntSymbol(_iNum,_pSyntSymbol);
}
ptr = 0;
}
}
//---------------------------------------------------------------------------
int TSyntSymbol::deleteSubItem(int _iNum) { int iRet = -1;
if (pSyntSymbolSubList != 0) {
TSyntSymbolList *ptr = (TSyntSymbolList*)pSyntSymbolSubList; if (ptr != 0) {
int iCount = ptr->getSyntSymbolCount(); if (iCount > _iNum)
iRet = ptr->deleteItem(_iNum);
}
ptr = 0;
}
return iRet;
}
//---------------------------------------------------------------------------
int TSyntSymbol::getTypeSubItem(int _iNum) { int iRet = -1;
if (pSyntSymbolSubList != 0) {
TSyntSymbolList *ptr = (TSyntSymbolList*)pSyntSymbolSubList; if (ptr != 0) {
int iCount = ptr->getSyntSymbolCount(); if (iCount > _iNum)
iRet = ptr->getTypeSyntSymbol(_iNum);
}
ptr = 0;
}
return iRet;
}
//---------------------------------------------------------------------------
double TSyntSymbol::takeTopSubItemLexemDval() { double dRet = 0.0;
TSyntSymbol *pSyntSymbol = 0; if (pSyntSymbolSubList != 0) {
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Методические указания к выполнению курсовой работы |
43 |
Системное программное обеспечение
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
TSyntSymbolList *ptr = (TSyntSymbolList*)pSyntSymbolSubList; if (ptr != 0) {
ptr->getSyntSymbol(0,&pSyntSymbol); if (pSyntSymbol != 0) {
int iType = pSyntSymbol->getNumSyntSymbol(); if (iType > 0)
{ // >0 - нетерминальный
dRet = pSyntSymbol->takeTopSubItemLexemDval(); int iSubCount = pSyntSymbol->getSubItemsCount(); if (iSubCount == 1)
{
int iType = pSyntSymbol->getTypeSubItem(0);
if ((iType == 1) | (iType == 2) | (iType == 5) | (iType == 6) | (iType == 7))
{
pSyntSymbol->deleteSubItem(0); ptr->deleteItem(0);
}
}
if (iSubCount == 0)
{
ptr->deleteItem(0);
}
}
else
{ // 0 - терминальный
iType = pSyntSymbol->getLexemType(); if (iType == 3)
{
dRet = pSyntSymbol->getLexemDval(); ptr->deleteItem(0);
}
}
}
}
iSubItemCount = ptr->getSyntSymbolCount(); if (iSubItemCount == 0)
{
pSyntSymbolSubList = 0; delete ptr;
}
ptr = 0;
}
pSyntSymbol = 0; return dRet;
}
Листинг 49. Заголовочный файл класса TSyntSymbolList (файл
TSyntSymbolList.h)
#ifndef TSyntSymbolListH #define TSyntSymbolListH #include "TSyntSymbol.h"
//---------------------------------------------------------------------------
class TSyntSymbolList
{
private:
TSyntSymbol** pSyntSymbolList;
int |
iSyntSymbolCount; |
int |
iSyntSymbolMax; |
public: |
|
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
44 |
М.Ф.Степанов |
Создание распределенной системы решения задач
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
TSyntSymbolList();
~TSyntSymbolList();
int addSyntSymbol(TSyntSymbol* _pSyntSymbol); // возвращает номер символа
int addTopSyntSymbol(TSyntSymbol* _pSyntSymbol); // возвращает номер символа int takeTopSyntSymbol(TSyntSymbol **_pSyntSymbol);
void getSyntSymbol(int _iNum, TSyntSymbol** _pSyntSymbol); void getLastSyntSymbol(TSyntSymbol** _pSyntSymbol);
int getSyntSymbolCount();
int getTypeSyntSymbol(int _iNum); int getTypeLastSyntSymbol();
int deleteLastSyntSymbol(); int deleteItem(int _iNum); //
const char* getTextSyntSymbol(int _iNum); void Clear();
};
#endif
Листинг 50. Файл реализации класса TSyntSymbolList (файл
TSyntSymbolList.cpp)
//---------------------------------------------------------------------------
#pragma hdrstop
#pragma package(smart_init) //---------------------------------------------------------------------------
#include "TSyntSymbolList.h" //---------------------------------------------------------------------------
TSyntSymbolList::TSyntSymbolList()
{ |
|
pSyntSymbolList |
= 0; |
iSyntSymbolCount |
= 0; |
iSyntSymbolMax |
= 10; |
} |
|
//---------------------------------------------------------------------------
TSyntSymbolList::~TSyntSymbolList()
{
if (pSyntSymbolList != 0) {
for (int i=0; i<iSyntSymbolCount; i++) { TSyntSymbol* ptr = pSyntSymbolList[i]; if (ptr != 0)
delete ptr; ptr = 0;
pSyntSymbolList[i] = 0;
}
delete[] pSyntSymbolList;
}
pSyntSymbolList = 0;
}
//---------------------------------------------------------------------------
int TSyntSymbolList::addSyntSymbol(TSyntSymbol *_pSyntSymbol)
{
if (pSyntSymbolList == 0) {
pSyntSymbolList = new TSyntSymbol*[iSyntSymbolMax];
}
if (pSyntSymbolList != 0) {
if (iSyntSymbolCount == iSyntSymbolMax) { iSyntSymbolMax += 10;
TSyntSymbol** pList = new TSyntSymbol*[iSyntSymbolMax]; for (int i=0; i<iSyntSymbolCount; i++) {
pList[i] = pSyntSymbolList[i]; pSyntSymbolList[i] = 0;
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Методические указания к выполнению курсовой работы |
45 |
Системное программное обеспечение
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
}
delete[] pSyntSymbolList; pSyntSymbolList = pList; pList = 0;
}
if (iSyntSymbolCount < iSyntSymbolMax) { pSyntSymbolList[iSyntSymbolCount++] = _pSyntSymbol;
}
}
return iSyntSymbolCount;
}
//---------------------------------------------------------------------------
int TSyntSymbolList::addTopSyntSymbol(TSyntSymbol *_pSyntSymbol)
{
if (pSyntSymbolList == 0) {
pSyntSymbolList = new TSyntSymbol*[iSyntSymbolMax];
}
if (pSyntSymbolList != 0) {
if (iSyntSymbolCount == iSyntSymbolMax) iSyntSymbolMax += 10;
TSyntSymbol** pList = new TSyntSymbol*[iSyntSymbolMax]; pList[0] = _pSyntSymbol;
for (int i=0; i<iSyntSymbolCount; i++) { pList[i+1] = pSyntSymbolList[i]; pSyntSymbolList[i] = 0;
}
delete[] pSyntSymbolList; pSyntSymbolList = pList; pList = 0;
}
return ++iSyntSymbolCount;
}
//---------------------------------------------------------------------------
int TSyntSymbolList::takeTopSyntSymbol(TSyntSymbol **_pSyntSymbol)
{
if (pSyntSymbolList != 0) { if (_pSyntSymbol != 0) {
*_pSyntSymbol = pSyntSymbolList[0]; for (int i=0; i<iSyntSymbolCount-1; i++) {
pSyntSymbolList[i] = pSyntSymbolList[i+1];
}
pSyntSymbolList[--iSyntSymbolCount] = 0;
}
}
return iSyntSymbolCount;
}
//---------------------------------------------------------------------------
void TSyntSymbolList::getSyntSymbol(int _iNum, TSyntSymbol **_pSyntSymbol)
{
if (pSyntSymbolList != 0) {
if (iSyntSymbolCount > _iNum) { if (_pSyntSymbol != 0) {
*_pSyntSymbol = pSyntSymbolList[_iNum];
}
}
}
}
//---------------------------------------------------------------------------
void TSyntSymbolList::getLastSyntSymbol(TSyntSymbol **_pSyntSymbol)
{
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
46 |
М.Ф.Степанов |
Создание распределенной системы решения задач
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
if (pSyntSymbolList != 0) { if (iSyntSymbolCount > 0) {
if (_pSyntSymbol != 0) {
*_pSyntSymbol = pSyntSymbolList[iSyntSymbolCount - 1];
}
}
}
}
//---------------------------------------------------------------------------
int TSyntSymbolList::getSyntSymbolCount()
{
return iSyntSymbolCount;
}
//---------------------------------------------------------------------------
int TSyntSymbolList::getTypeSyntSymbol(int _iNum)
{
int iType = -1;
if (pSyntSymbolList != 0) {
if (iSyntSymbolCount > _iNum) {
iType = pSyntSymbolList[_iNum]->getLexemType();
}
}
return iType;
}
//---------------------------------------------------------------------------
int TSyntSymbolList::getTypeLastSyntSymbol()
{
int iType = -1;
if (pSyntSymbolList != 0) {
iType = pSyntSymbolList[iSyntSymbolCount - 1]->getType();
}
return iType;
}
//---------------------------------------------------------------------------
int TSyntSymbolList::deleteLastSyntSymbol()
{
int iRet = -1;
if (pSyntSymbolList != 0) { if (iSyntSymbolCount > 0) {
pSyntSymbolList[--iSyntSymbolCount] = 0; iRet = iSyntSymbolCount;
}
}
return iRet;
}
//---------------------------------------------------------------------------
int TSyntSymbolList::deleteItem(int _iNum)
{
int iRet = -1;
if (pSyntSymbolList != 0) { if (iSyntSymbolCount > 0) {
if (_iNum < iSyntSymbolCount) {
TSyntSymbol *pSyntSymbol = pSyntSymbolList[_iNum]; if (pSyntSymbol != 0)
delete pSyntSymbol; pSyntSymbol = 0;
for (int i=_iNum; i<iSyntSymbolCount-1; i++) { pSyntSymbolList[i] = pSyntSymbolList[i+1];
}
pSyntSymbolList[iSyntSymbolCount-1] = 0;
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Методические указания к выполнению курсовой работы |
47 |
Системное программное обеспечение
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
iRet = --iSyntSymbolCount;
}
}
}
return iRet;
}
//---------------------------------------------------------------------------
const char* TSyntSymbolList::getTextSyntSymbol(int _iNum)
{
const char* cText = 0;
if (pSyntSymbolList != 0) {
if (iSyntSymbolCount > _iNum) {
cText = pSyntSymbolList[_iNum]->getLexemText();
}
}
return cText;
}
//---------------------------------------------------------------------------
void TSyntSymbolList::Clear()
{
if (pSyntSymbolList != 0) {
for (int i=0; i<iSyntSymbolCount; i++) { TSyntSymbol* ptr = pSyntSymbolList[i]; if (ptr != 0)
delete ptr; ptr = 0;
pSyntSymbolList[i] = 0;
}
iSyntSymbolCount = 0;
}
}
Листинг 51. Заголовочный файл класса TSyntSymbolStack (файл
TSyntSymbolStack.h)
#ifndef TSyntSymbolStackH |
|
|||
#define TSyntSymbolStackH |
|
|||
#include "TSyntSymbol.h" |
|
|||
#include "TLexem.h" |
|
|
||
#include "TSyntSymbolList.h" |
|
|||
//--------------------------------------------------------------------------- |
|
|
|
|
class TSyntSymbolStack |
|
|
||
{ |
|
|
|
|
private: |
|
|
|
|
int iSyntSymbolTop; |
// номер элемента, находящегося в вершине стека |
|||
TSyntSymbolList* pSyntSymbolList; // список элементов стека |
||||
public: |
|
|
|
|
TSyntSymbolStack(); |
|
|
||
~TSyntSymbolStack(); |
|
|
||
int |
getElemCount(); |
// кол-во элементов в стеке |
||
void |
Clear(); |
// очистка стека |
||
TSyntSymbol* |
getSymbol(int _iNumSymbol); // выборка символа по номеру от вершины стека |
|||
TSyntSymbol* |
getTop(); |
// получить самый верхний символ в стеке |
||
TSyntSymbol* |
takeTop(); |
// выборка самого верхнего символа в стеке с удалением |
||
из стека |
|
|
|
|
TSyntSymbol* |
Push(TLexem* _pLexem); |
// погружение лексемы в стек |
TSyntSymbol* |
Push(TSyntSymbol *_pSyntSymbol); |
|
int |
getTypeTopSymbol(); |
// тип самого верхнего символа в стеке |
const char* getTextTopSymbol(); |
// текст самого верхнего символа в стеке |
|
};
#endif
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
48 |
М.Ф.Степанов |
Создание распределенной системы решения задач
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Листинг 52. Файл реализации класса TSyntSymbolStack (файл
TSyntSymbolStack.h)
#pragma hdrstop
#pragma package(smart_init) #include "TSyntSymbolStack.h"
//-------------------------------------------------------------------------
TSyntSymbolStack::TSyntSymbolStack()
{
iSyntSymbolTop = 0; pSyntSymbolList = 0;
}
//-------------------------------------------------------------------------
TSyntSymbolStack::~TSyntSymbolStack()
{
if (pSyntSymbolList != 0) delete pSyntSymbolList;
pSyntSymbolList = 0;
}
//-------------------------------------------------------------------------
void TSyntSymbolStack::Clear()
{
if (pSyntSymbolList != 0) pSyntSymbolList->Clear();
}
//-------------------------------------------------------------------------
TSyntSymbol* TSyntSymbolStack::getSymbol(int _iNumSymbol)
{
TSyntSymbol *pSyntSymbol = 0; if (pSyntSymbolList != 0) {
int iSymbolCount = pSyntSymbolList->getSyntSymbolCount();
if (iSymbolCount > _iNumSymbol) // если _iNumSymbol = 0 - то это вершина стека pSyntSymbolList->getSyntSymbol(iSymbolCount - _iNumSymbol - 1,&pSyntSymbol);
}
return pSyntSymbol;
}
//-------------------------------------------------------------------------
TSyntSymbol* TSyntSymbolStack::takeTop()
{
TSyntSymbol *pSyntSymbol = 0; if (pSyntSymbolList != 0) {
pSyntSymbolList->getLastSyntSymbol(&pSyntSymbol); iSyntSymbolTop = pSyntSymbolList->deleteLastSyntSymbol() - 1;
}
return pSyntSymbol;
}
//-------------------------------------------------------------------------
TSyntSymbol* TSyntSymbolStack::getTop()
{
TSyntSymbol *pSyntSymbol = 0; if (pSyntSymbolList != 0) {
pSyntSymbolList->getLastSyntSymbol(&pSyntSymbol);
}
return pSyntSymbol;
}
//-------------------------------------------------------------------------
TSyntSymbol* TSyntSymbolStack::Push(TLexem *_pLexem)
{
TSyntSymbol *pSyntSymbol = 0; if (pSyntSymbolList == 0) {
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
Методические указания к выполнению курсовой работы |
49 |
Системное программное обеспечение
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
pSyntSymbolList = new TSyntSymbolList();
}
if (pSyntSymbolList != 0) {
pSyntSymbol = new TSyntSymbol(_pLexem); pSyntSymbolList->addSyntSymbol(pSyntSymbol); iSyntSymbolTop = pSyntSymbolList->getSyntSymbolCount();
}
return pSyntSymbol;
}
//-------------------------------------------------------------------------
TSyntSymbol* TSyntSymbolStack::Push(TSyntSymbol *_pSyntSymbol)
{
if (pSyntSymbolList == 0) { pSyntSymbolList = new TSyntSymbolList();
}
if (pSyntSymbolList != 0) { pSyntSymbolList->addSyntSymbol(_pSyntSymbol); iSyntSymbolTop = pSyntSymbolList->getSyntSymbolCount();
}
return _pSyntSymbol;
}
//-------------------------------------------------------------------------
int TSyntSymbolStack::getElemCount()
{
if (pSyntSymbolList != 0) {
iSyntSymbolTop = pSyntSymbolList->getSyntSymbolCount();
}
return iSyntSymbolTop;
}
//-------------------------------------------------------------------------
int TSyntSymbolStack::getTypeTopSymbol()
{
int iType = -1;
if (pSyntSymbolList != 0) {
iType = pSyntSymbolList->getTypeLastSyntSymbol();
}
return iType;
}
//-------------------------------------------------------------------------
const char* TSyntSymbolStack::getTextTopSymbol()
{
const char* cText = 0;
if (pSyntSymbolList != 0) {
cText = pSyntSymbolList->getTextSyntSymbol(iSyntSymbolTop-1);
}
return cText;
}
Листинг 53. Заголовочный файл класса TSyntRule (файл
TSyntRule.h)
#ifndef TSyntRuleH |
|
||
#define TSyntRuleH |
|
||
//--------------------------------------------------------------------------- |
|
|
|
class TSyntRule { |
|
||
private: |
|
|
|
int |
iNumRule; // номер правила |
||
int |
iNumSyntSymbol; |
// порядковый номер нетерминального символа |
|
char* |
szLeftRule; |
// левая часть правила грамматики |
|
char* |
szRightRule; |
// правая часть правила грамматики |
|
char* |
szLeftBnfRule; |
// левая часть правила грамматики в форме Бэкуса-Наура |
|
_____________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________
50 |
М.Ф.Степанов |