giftcommand.cpp

Last change: 2008-02-03 This is the source code of KCeasy。

/*
This file is part of KCeasy (http://www.kceasy.com)
Copyright (C) 2002-2004 Markus Kern <[e-mail]>

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
*/
//---------------------------------------------------------------------------
#pragma hdrstop
#include "GiftCommand.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

namespace KCeasyEngine {

using std::pair;

TGiftCommand& TGiftCommand::GetNode(const string& Name)
{
    static TGiftCommand EmptyNode;
    Iterator itr = Nodes.find(Name);
    if(itr == Nodes.end())
        return EmptyNode;
    else
        return *itr;
}

TGiftCommand& TGiftCommand::GetNode(const char* Name)
{
    static TGiftCommand EmptyNode;
    Iterator itr = Nodes.find(Name);
    if(itr == Nodes.end())
        return EmptyNode;
    else
        return *itr;
}

TGiftCommand& TGiftCommand::AddNode(const TGiftCommand& NewNode)
{
    return (*Nodes.insert(multimap<string,TGiftCommand>::value_type(NewNode.Name,NewNode))).second;
}

bool TGiftCommand::RemoveNode(const string& Name)
{
    return (bool)Nodes.erase(Name);
}

bool TGiftCommand::RemoveNode(const char* Name)
{
    return (bool)Nodes.erase(string(Name));
}

void TGiftCommand::Clear()
{
    Name.clear();
    Value.clear();
    Nodes.clear();
}

bool TGiftCommand::Parse(char* Packet)
{
    Clear();
    return ParseRecursive(&Packet);
}

string TGiftCommand::Print(bool Root)
{
    string Packet("");
    Packet += Escape(Name);
//    if(Value != "") Packet += "(" + Escape(Value) + ")";
    Packet += "(" + Escape(Value) + ") ";

    if(!Root && Nodes.empty()) {
        return Packet;
    }

    // enum nodes
    if(!Root)
        Packet += "{ ";
    for(Iterator itr=Nodes.begin();itr!=Nodes.end();++itr)
        Packet += (*itr).Print(false);
    Packet += Root ? ";" : "}\r\n";

    return Packet;
}

// private

bool TGiftCommand::ParseRecursive(char **packet)
{
    TGiftCommand *Node = this;
    string Token;

	while(**packet) {
		switch (**packet) {
        case ' ':
        case '\t':
        case '\r':
        case '\n':
            (*packet)++;
            continue;

        case '(':
            for((*packet)++;**packet!=')' && **packet!=0;(*packet)++) {
                if(**packet == '\\') (*packet)++;
                Node->Value += **packet;
            }
            (*packet)++; // skip ')'
            continue;

        case '{':
            (*packet)++;
            if(Node->ParseRecursive(packet) == false)
                return false;
            continue;

        case '}':
        case ';':
            (*packet)++;
            return true;

        default:
            Token.clear();
            for(;!strchr(" \t\r\n({",**packet);(*packet)++) {
                if(**packet == '\\') (*packet)++;
                Token += **packet;
            }
            if(Name == "") // only "" on first call
                Node->Name = Token;
            else
                Node = &AddNode(TGiftCommand(Token,""));
            continue;
		}
	}
    return false;
}

string TGiftCommand::Escape(string& String)
{
    char* buf = new char[String.length()*2];
    char* dst = buf;

    for(const char *src=String.c_str();*src;src++,dst++) {
        if(*src == '(' || *src == ')' || *src == '[' || *src == ']' ||
           *src == '{' || *src == '}' || *src == ';' || *src == '\\')
        {
            *dst++ = '\\';
        }
        *dst = *src;
    }
    *dst = 0;
    string ret(buf);
    delete[] buf;
    return ret;
}

} // namespace KCeasyEngine