CommandParserInterface.cpp

Go to the documentation of this file.

#include "CommandParserInterface.h"
#include "TransportInterface.h"
#include <string.h>
#include "RakAssert.h"
#include <stdio.h>
#if defined(_XBOX) || defined(X360)
                            
#elif defined(_WIN32)
// IP_DONTFRAGMENT is different between winsock 1 and winsock 2.  Therefore, Winsock2.h must be linked againt Ws2_32.lib
// winsock.h must be linked against WSock32.lib.  If these two are mixed up the flag won't work correctly
#include <winsock2.h>
#else
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif

#include "LinuxStrings.h"

#ifdef _MSC_VER
#pragma warning( push )
#endif

const unsigned char CommandParserInterface::VARIABLE_NUMBER_OF_PARAMETERS=255;

int RegisteredCommandComp( const char* const & key, const RegisteredCommand &data )
{
    return _stricmp(key,data.command);
}

CommandParserInterface::CommandParserInterface() {}
CommandParserInterface::~CommandParserInterface() {}

void CommandParserInterface::ParseConsoleString(char *str, const char delineator, unsigned char delineatorToggle, unsigned *numParameters, char **parameterList, unsigned parameterListLength)
{
    unsigned strIndex, parameterListIndex;
    unsigned strLen;
    bool replaceDelineator=true;

    strLen = (unsigned) strlen(str);

    // Replace every instance of delineator, \n, \r with 0
    for (strIndex=0; strIndex < strLen; strIndex++)
    {
        if (str[strIndex]==delineator && replaceDelineator)
            str[strIndex]=0;

        if (str[strIndex]=='\n' || str[strIndex]=='\r')
            str[strIndex]=0;

        if (str[strIndex]==delineatorToggle)
        {
            str[strIndex]=0;
            replaceDelineator=!replaceDelineator;
        }
    }

    // Fill up parameterList starting at each non-0
    for (strIndex=0, parameterListIndex=0; strIndex < strLen; )
    {
        if (str[strIndex]!=0)
        {
            parameterList[parameterListIndex]=str+strIndex;
            parameterListIndex++;
            RakAssert(parameterListIndex < parameterListLength);
            if (parameterListIndex >= parameterListLength)
                break;

            strIndex++;
            while (str[strIndex]!=0 && strIndex < strLen)
                strIndex++;
        }
        else
            strIndex++;
    }

    parameterList[parameterListIndex]=0;
    *numParameters=parameterListIndex;
}
void CommandParserInterface::SendCommandList(TransportInterface *transport, SystemAddress systemAddress)
{
    unsigned i;
    if (commandList.Size())
    {
        for (i=0; i < commandList.Size(); i++)
        {
            transport->Send(systemAddress, "%s", commandList[i].command);
            if (i < commandList.Size()-1)
                transport->Send(systemAddress, ", ");
        }
        transport->Send(systemAddress, "\r\n");
    }
    else
        transport->Send(systemAddress, "No registered commands\r\n");
}
void CommandParserInterface::RegisterCommand(unsigned char parameterCount, const char *command, const char *commandHelp)
{
    RegisteredCommand rc;
    rc.command=command;
    rc.commandHelp=commandHelp;
    rc.parameterCount=parameterCount;
    commandList.Insert( command, rc, true, __FILE__, __LINE__);
}
bool CommandParserInterface::GetRegisteredCommand(const char *command, RegisteredCommand *rc)
{
    bool objectExists;
    unsigned index;
    index=commandList.GetIndexFromKey(command, &objectExists);
    if (objectExists)
        *rc=commandList[index];
    return objectExists;
}
void CommandParserInterface::OnTransportChange(TransportInterface *transport)
{
    (void) transport;
}
void CommandParserInterface::OnNewIncomingConnection(SystemAddress systemAddress, TransportInterface *transport)
{
    (void) systemAddress;
    (void) transport;
}
void CommandParserInterface::OnConnectionLost(SystemAddress systemAddress, TransportInterface *transport)
{
    (void) systemAddress;
    (void) transport;
}
void CommandParserInterface::ReturnResult(bool res, const char *command,TransportInterface *transport, SystemAddress systemAddress)
{
    if (res)
        transport->Send(systemAddress, "%s returned true.\r\n", command);
    else
        transport->Send(systemAddress, "%s returned false.\r\n", command);
}
void CommandParserInterface::ReturnResult(int res, const char *command,TransportInterface *transport, SystemAddress systemAddress)
{
    transport->Send(systemAddress, "%s returned %i.\r\n", command, res);
}
void CommandParserInterface::ReturnResult(const char *command, TransportInterface *transport, SystemAddress systemAddress)
{
    transport->Send(systemAddress, "Successfully called %s.\r\n", command);
}
void CommandParserInterface::ReturnResult(char *res, const char *command, TransportInterface *transport, SystemAddress systemAddress)
{
    transport->Send(systemAddress, "%s returned %s.\r\n", command, res);
}
void CommandParserInterface::ReturnResult(SystemAddress res, const char *command, TransportInterface *transport, SystemAddress systemAddress)
{
#if !defined(_XBOX) && !defined(_X360)
    in_addr in;
    in.s_addr = systemAddress.binaryAddress;
    inet_ntoa( in );
    transport->Send(systemAddress, "%s returned %s %i:%i\r\n", command,inet_ntoa( in ),res.binaryAddress, res.port);
#else
    transport->Send(systemAddress, "%s returned %i:%i\r\n", command,res.binaryAddress, res.port);
#endif
}
SystemAddress CommandParserInterface::IntegersToSystemAddress(int binaryAddress, int port)
{
    SystemAddress systemAddress;
    systemAddress.binaryAddress=binaryAddress;
    systemAddress.port=(unsigned short)port;
    return systemAddress;
}

#ifdef _MSC_VER
#pragma warning( pop )
#endif