contextdb.cpp

一个RPG术语查询器

#define ALLEGRO_STATICLINK
#include <allegro.h>
#ifdef _WIN32
#include <winalleg.h>
#endif


#include <iostream>
#include <fstream>
#include <string.h>

#include "context.h"
#include "types.h"
#include "entity.h"



char* TOKEN::AddToken(TOKEN *root, char *adddata,CONTEXTPROMPTFUNC bfunc, char *descriptor, int tvalue, int ttype)
{
	if(root==0 || adddata==0) return 0;
	TOKEN *working=root;
	while(1)
	{
		switch(strcmp(adddata,working->data))
		{
			case 0:
				return working->data;
				break;
			case -1:
				TOKEN *bleh = new TOKEN(adddata,bfunc,descriptor, tvalue, ttype);
				bleh->parent=working->parent;
				bleh->next=working;
				if(working->parent!=0)
				{
					working->parent->next=bleh;
					working->parent=bleh;
				}
				return bleh->data;
		}

		if(working->next==0)
		{
			working->next=new TOKEN(adddata,bfunc,descriptor, tvalue, ttype);
			working->next->parent=working;
			return working->next->data;
		}
		working=working->next;
	}
}


TOKEN* TOKEN::FindToken(TOKEN *root, char *name)
{
	if(root==0) return 0;
	TOKEN *working=root;
	while(1)
	{
		if(strcmp(name,working->data) == 0)
		{
			return working;
			
		}
		if(working->next==0)
		{
			return 0;
		}
		working=working->next;
	}
}


CONTEXTPROMPTFUNC TOKEN::FindFunction(TOKEN *root,char *identifier)
{
	if(root==0) return 0;
	TOKEN *working=root;
	while(1)
	{
		if(strcmp(identifier,working->data) == 0)
		{
			return working->bindfunction;
		}

		if(working->next==0)
		{
			return 0;
		}

		working=working->next;
	}
}


int TOKEN::SetToken(TOKEN *root, char *adddata, CONTEXTPROMPTFUNC bfunc, char *descriptor)
{
	if(root==0 || adddata==0 || descriptor==0) return -1;
	TOKEN *working=root;

	while(1)
	{
		if(strcmp(adddata,working->data) == 0)
		{
			std::cout << "Submitted changes to " << adddata << std::endl;
			working->bindfunction=bfunc;
			strcpy(working->operation,descriptor);
			return 1;
		}

		if(working->next==0)
		{
			return -1;
		}
		working=working->next;
	}
}
	
TOKEN::TOKEN(char *stringy, CONTEXTPROMPTFUNC userfunc, char *operation, int tvalue, int ttype)
{
	strcpy(TOKEN::operation,operation);
	parent=0;
	next=0;
	strcpy(data,stringy);
	bindfunction=userfunc;
	value=tvalue;
	type=ttype;
}
	
TOKEN::TOKEN()
{
	strcpy(operation,"UNDEFINED");
	parent=0;
	next=0;
	data[0]=0;
	bindfunction=0;
	value=0;
	type=0;
}
	
TOKEN::~TOKEN()
{
	if(next!=0) delete next;
}

CONTEXTPROMPTFUNC CONTEXTPROMPT::findfunc(char *dealy)
{
	if(dealy==0) return 0;
	return hash[dealy[0]]->FindFunction(hash[dealy[0]],dealy);
}
	
TOKEN* CONTEXTPROMPT::searchtoken(char *name)
{
	if(name==0) return 0;
	return hash[name[0]]->FindToken(hash[name[0]],name);
}

void CONTEXTPROMPT::setmaster(void *pmaster)
{
    master = pmaster;
}


		
int CONTEXTPROMPT::settoken(char *toadd,char *userfunction, char *descriptor)
{
	if(toadd==0 || descriptor==0 || userfunction==0)
	{
		std::cout << "INVALID DATE FOR SET" << std::endl;
		return -1;
	}
	
	CONTEXTPROMPTFUNC bleh = findfunc(userfunction);
	if(bleh==0)
	{
		std::cout << "Invalid Function" << std::endl;
		return -1;
	}
	return hash[toadd[0]]->SetToken(hash[toadd[0]],toadd,bleh,descriptor);
	std::cout << "Could not find a matching token" << std::endl;
	return -1;
}
	
void CONTEXTPROMPT::addtoken(char *toadd,CONTEXTPROMPTFUNC userfunction, char *descriptor, int tvalue, int ttype)
{
	if(toadd[0]!=0 && descriptor!=0)
	{
		hash[toadd[0]]->AddToken(hash[toadd[0]],toadd,userfunction,descriptor, tvalue, ttype);
	}
}
	
int CONTEXTPROMPT::query(char *input, char *output, int szoutput)
{
	parse(input);
	if(argc==0) return -1;
	else
	{
		CONTEXTPROMPTFUNC bleh = findfunc(argv[0]);
		if (bleh==0)
		{
			std::cout << "Bad Function" << std::endl;	
			return -1;
		}
		return bleh(argc,argv, (void *)this);
   }
}	
	
void CONTEXTPROMPT::parse(char *whole)
{
	argc=0;
	char *ripper=whole;
	
	if(ripper==0) return;
	char buffer[1024];
	int bufloc=0;
	int bufstate=STATEEMPTY;

	while(*ripper!=0)
	{
		switch(*ripper)
		{
			case ' ':

				switch(bufstate)
				{
					case STATEEMPTY:
						break;
					case STATEWORD:
						buffer[bufloc]=0;
							strcpy(argtoken[argc].text,buffer);
							argv[argc]=argtoken[argc].text;
							++argc;
							bufstate=STATEEMPTY;
							break;
						case STATEPHRASE:
							buffer[bufloc]=*ripper;
							++bufloc;
							break;
				}
				break;
			case 34:
				switch(bufstate)
				{
					case STATEEMPTY:
						bufstate=STATEPHRASE;
						bufloc=0;
						break;
					case STATEPHRASE:
						buffer[bufloc]=0;
						strcpy(argtoken[argc].text,buffer);
						argv[argc]=argtoken[argc].text;
						++argc;
						bufstate=STATEEMPTY;
						break;
					case STATEWORD:
						buffer[bufloc]=*ripper;
						++bufloc;
						break;
				}
				break;
			case 13:
			case 10:
			     break;
			default:
				switch(bufstate)
				{
					case STATEEMPTY:
						bufstate=STATEWORD;
						bufloc=0;
						buffer[bufloc]=*ripper;
						++bufloc;
						break;
					case STATEWORD:
					case STATEPHRASE:
						buffer[bufloc]=*ripper;
						++bufloc;
						break;
					
				}
				break;

		}
	
		++ripper;
	}

	if(bufstate==STATEWORD)
	{
		buffer[bufloc]=0;
		strcpy(argtoken[argc].text,buffer);
		argv[argc]=argtoken[argc].text;
		++argc;
	}
	
	if(bufstate==STATEPHRASE)
	{
		buffer[bufloc]=0;
		strcpy(argtoken[argc].text,buffer);
		argv[argc]=argtoken[argc].text;
		++argc;
	}
	
}



int CONTEXTPROMPT::save(char *xmlfile)
{
    std::ofstream xmlwrite;
    
    xmlwrite.open(xmlfile);
    if(xmlwrite)
    {
        xmlwrite << "<Context>" << std::endl << std::endl;
       	TOKEN *working;
        for(int printhash=0;printhash<256;++printhash)
        {
       		working=hash[printhash]->next;
       		while(working!=0)
			{
       			xmlwrite << " <Token name=" << (char)34 << working -> data << (char)34 << ">" << std::endl;
       			xmlwrite << "  <Description>" << working->operation << "</Description>" << std::endl;
       			xmlwrite << "  <Type>" << working->type << "</Type>" << std::endl;
       			xmlwrite << "  <Value>" << working->value << "</Value>" << std::endl;
                xmlwrite << "  <Functional>" << ((working->bindfunction!=NULL)?"Yes":"No") << "</Functional>" << std::endl;
                xmlwrite << " </Token>" << std::endl << std::endl;
      			working=working->next;
      			
      			
	      	}
        }		
        xmlwrite << "</Context>" << std::endl;
        xmlwrite.close();
    }
    else
    {
        return XML_FILENOTVALID;
    }
    return 0;
}

int CONTEXTPROMPT::load(char *xmlfile)
{


	return 0;
}






		
CONTEXTPROMPT::CONTEXTPROMPT()
{
	for(int fillhash=0;fillhash<256;++fillhash) hash[fillhash]=new TOKEN;
	argc=0;
	active=1;
	startupprompt((void *)this);
}


CONTEXTPROMPT::~CONTEXTPROMPT()
{
	for(int killhash=0;killhash<256;++killhash) delete hash[killhash];
}