grammar.cpp

用VC实现的词法分析器

#include "StdAfx.h"
#include "grammar.h"

void Grammar::Node::Destroy()
{
	if (!bDtor)
	{
		for (std::list<Edge>::iterator _Iter = Transitions.begin(); _Iter != Transitions.end(); ++_Iter)
			(*_Iter).Next->Destroy();
		bDtor = true;
	}
}

void Grammar::Dump(FILE * stream, bool sub, int nIndent)
{
	for (int i = 0; i < nIndent; i++)
		fputc(' ', stream);
	fputs("{Grammar}\n", stream);

	Root->Dump(stream, true, 1);;
}

void Grammar::Node::Dump(FILE * stream, bool sub, int nIndent)
{
	for (int i = 0; i < nIndent; i++)
		fputc(' ', stream);
	fprintf(stream, "[%s]\n", ObjectTypeName(Result));

	for (std::list<Edge>::iterator _Iter = Transitions.begin(); _Iter != Transitions.end(); ++_Iter)
	{
		for (int i = 0; i < nIndent+1; i++)
			fputc(' ', stream);
		fprintf(stream, "->%s\n", ObjectTypeName((*_Iter).Type));
		(*_Iter).Next->Dump(stream, true, nIndent+2);
	}
}

int Grammar::AddRule(Grammar::Rule * rule)
{

	ObjectType * pStep = rule->Steps;
	if (rule->Result == Null)
	{
		LastError = "Grammar rule cannot result in \"Null\".";
		return -1;
	}
	if (*pStep == Null)
	{
		LastError = "Grammar rule cannot have 0 steps.";
		return -1;
	}

	Node * pNode = Root, * pNew;

	bool bCreate;

	while(*pStep != Null)
	{
		bCreate = true;
		for (std::list<Edge>::iterator _Iter = pNode->Transitions.begin(); _Iter != pNode->Transitions.end(); ++_Iter)
		{
			if ((*_Iter).Type == *pStep)
			{
				pNode = (*_Iter).Next;
				bCreate = false;
				++pStep;
				break;
			}
		}
		if (bCreate) break;
	}

	// Recursive creation
	while(*pStep != Null)
	{
		pNew = new Node;
		pNode->Transitions.push_back(Edge(pNew, *pStep));
		pNode = pNew;
		++pStep;
	}

	if (pNode->Result != Null)
	{
		LastError = "Similar rule already exists.";
		return -1;
	}

	pNode->Result = rule->Result;
	return 0;
}

void Grammar::Begin(void)
{
	Iterator = Root;
}

Grammar::Result Grammar::Next(ObjectType type)
{
	Edge * pEdge;

	for (std::list<Edge>::iterator _Iter = Iterator->Transitions.begin(); _Iter != Iterator->Transitions.end(); ++_Iter)
	{
		pEdge = &*_Iter;
		if (pEdge->Type == type)
		{
			Iterator = pEdge->Next;
			return Result::Continue;
		}
	}

	// Not found in edges

	if (Iterator->Result == Null)
		return Result::NotFound;

	return Result::Found;
}

ObjectType Grammar::GetResult(void)
{
	return Iterator->Result;
}