//=============================================================================
// Copyright (C) 2002 Radical Entertainment Ltd.  All rights reserved.
//
// File:        console.cpp
//
// Description: 
//
// History:     + Created -- Darwin Chau
//
//=============================================================================

//========================================
// System Includes
//========================================
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
// Radcore
#include <radDebug.hpp>
#include <raddebugwatch.hpp>
#include <radFile.hpp>
// Pure3D
#include <p3d/utility.hpp>


//========================================
// Project Includes
//========================================
#include <console/console.h>

#include <console/fbstricmp.h>
#include <main/commandlineoptions.h>
#include <memory/srrmemory.h>
#include <memory/memorypool.h>
#include <loading/loadingmanager.h>

#ifdef RAD_DEBUG
#include <raddebugconsole.hpp>
#include <console/debugconsolecallback.h>
#endif

//******************************************************************************
//
// Global Data, Local Data, Local Classes
//
//******************************************************************************

#define PROFILE_PARSER 0

const char* gErrFileName = 0;
unsigned int gErrLineNum = ~0;

//---------------------------------------------------------------------------//

// Static pointer to instance of singleton.
Console* Console::spInstance = 0;

static char gConsoleEntry[Console::MAX_STRING_LENGTH];

//log message buffers needed so the async writes to the log file don't bog
static char* gConsoleMsgBuffer[2] = {0};
static char* gConsoleMsgBufferPtr = 0;
static int gConsoleBufferIndex = 0;

#ifdef RAD_GAMECUBE
FBMemoryPool Console::FunctionTableEntry::sMemoryPool( sizeof(Console::FunctionTableEntry), Console::MAX_FUNCTIONS, GMA_GC_VMM );
FBMemoryPool Console::AliasTableEntry::sMemoryPool( sizeof(Console::AliasTableEntry), Console::MAX_ALIASES, GMA_GC_VMM );
#else
FBMemoryPool Console::FunctionTableEntry::sMemoryPool( sizeof(Console::FunctionTableEntry), Console::MAX_FUNCTIONS, GMA_PERSISTENT );
FBMemoryPool Console::AliasTableEntry::sMemoryPool( sizeof(Console::AliasTableEntry), Console::MAX_ALIASES, GMA_PERSISTENT );
#endif

//=============================================================================
// static bool cConsoleTrue
//=============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//=============================================================================
static bool cConsoleTrue( int argc, char** argv )
{
    argc;
    argv;
    return( true );
}

static bool cConsoleFalse( int argc, char** argv )
{
    argc;
    argv;
    return( false );
}

static void cConsoleExit(int argc, char **argv)
{
    argc;
    argv;
    //does nothing, but the parser will terminate executing a script
}

static void cConsoleExec(int argc, char **argv)
{
    GetConsole()->ExecuteScriptSync(argv[1], true);
}

static void cConsoleSetLogMode(int argc, char **argv)
{
    argc;
    if (! smStricmp(argv[1], "on"))
        GetConsole()->SetConsoleLogMode(Console::LOGMODE_ON);
    else if (! smStricmp(argv[1], "append"))
        GetConsole()->SetConsoleLogMode(Console::LOGMODE_APPEND);
    else
        GetConsole()->SetConsoleLogMode(Console::LOGMODE_OFF);
}

static void cConsoleFlushLog(int argc, char **argv)
{
    GetConsole()->FlushConsoleLogFile();
}

static void cConsoleEcho(int argc, char **argv)
{
    if (argc == 3)
        GetConsole()->Printf(atoi(argv[1]), argv[2]);
    else
        GetConsole()->Printf(argv[1]);
}

static void cConsoleError(int argc, char **argv)
{
    GetConsole()->Errorf(argv[1]);
}

static void cConsoleListFunctions(int argc, char **argv)
{
    argc;
    argv;
    GetConsole()->ListConsoleFunctions();
}

static void cConsoleListenChannel(int argc, char **argv)
{
    argc;
    GetConsole()->ConsoleListenChannel(atoi(argv[1]));
}

static void cConsoleBlockChannel(int argc, char **argv)
{
    argc;
    GetConsole()->ConsoleBlockChannel(atoi(argv[1]));
}

static void cConsoleAlias(int argc, char **argv)
{
    GetConsole()->AddAlias(argv[1], argv[2], argc - 3, &argv[3]);
}

static void cWatcherExecConsoleCommand(void *)
{
    GetConsole()->Printf("==> %s", gConsoleEntry);
    GetConsole()->Evaluate(gConsoleEntry, "CMDLine");
}


//******************************************************************************
//
// Public Member Functions
//
//******************************************************************************

//==============================================================================
// Console::CreateInstance
//==============================================================================
//
// Description: Creates the Console.
//
// Parameters:  None.
//
// Return:      Pointer to the Console.
//
// Constraints: This is a singleton so only one instance is allowed.
//
//==============================================================================
Console* Console::CreateInstance()
{
MEMTRACK_PUSH_GROUP( "Console" );
    rTuneAssert( spInstance == 0 );

    #ifdef RAD_GAMECUBE
        HeapMgr()->PushHeap( GMA_GC_VMM );
    #else
        HeapMgr()->PushHeap( GMA_PERSISTENT );
    #endif

    spInstance = new Console;
    rTuneAssert( spInstance );

    #ifdef RAD_GAMECUBE
        HeapMgr()->PopHeap( GMA_GC_VMM );
    #else
        HeapMgr()->PopHeap( GMA_PERSISTENT );
    #endif
   
    Console::Initialize();
MEMTRACK_POP_GROUP( "Console" );

    return spInstance;
}


//==============================================================================
// Console::GetInstance
//==============================================================================
//
// Description: - Access point for the Console singleton.  
//
// Parameters:  None.
//
// Return:      Pointer to the Console.
//
// Constraints: This is a singleton so only one instance is allowed.
//
//==============================================================================
Console* Console::GetInstance()
{
    rTuneAssert( spInstance != 0 );
    
    return spInstance;
}


//==============================================================================
// Console::DestroyInstance
//==============================================================================
//
// Description: Destroy the Console.
//
// Parameters:  None.
//
// Return:      None.
//
//==============================================================================
void Console::DestroyInstance()
{
    rTuneAssert( spInstance != 0 );

    delete spInstance;
    spInstance = 0;
}


//==============================================================================
// Console::Initialize
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
bool Console::Initialize()
{
//the console doesn't use remote drive in the release build
#ifdef RAD_DEBUG
MEMTRACK_PUSH_GROUP( "Console Initialize" );

    if( !CommandLineOptions::Get( CLO_FIREWIRE ) )
    {
        //initialize the console log buffers
        gConsoleMsgBuffer[0] = new(GMA_DEBUG) char[MAX_STRING_LENGTH * MAX_BUFFERS];
        gConsoleMsgBuffer[1] = new(GMA_DEBUG) char[MAX_STRING_LENGTH * MAX_BUFFERS];
        gConsoleMsgBufferPtr = gConsoleMsgBuffer[0];
        gConsoleBufferIndex = 0;

        //add a function to allow the program to generate a console.log file
        GetConsole()->AddFunction("ifTrue", cConsoleTrue, "ifTrue() { } //returns true", 0, 0);
        GetConsole()->AddFunction("ifFalse", cConsoleFalse, "ifFalse() { } //returns false", 0, 0);
        GetConsole()->AddFunction("Exit", cConsoleExit, "Exit(msg);", 1, 1);
        GetConsole()->AddFunction("ConsoleExec", cConsoleExec, "ConsoleExec(file);", 1, 1);
        GetConsole()->AddFunction("ConsoleSetLogMode", cConsoleSetLogMode, "ConsoleSetLogMode(off/on/append);", 1, 1);
        GetConsole()->AddFunction("ConsoleFlushLog", cConsoleFlushLog, "ConsoleFlushLog();", 0, 0);
        GetConsole()->AddFunction("Echo", cConsoleEcho, "Echo([channel, ] msg);", 1, 2);
        GetConsole()->AddFunction("Error", cConsoleError, "Error(msg);", 1, 1);
        GetConsole()->AddFunction("ConsoleListFunctions", cConsoleListFunctions, "ConsoleListFunctions();", 0, 0);
        GetConsole()->AddFunction("ConsoleListenChannel", cConsoleListenChannel, "ConsoleListenChannel(-1 or [0 .. 31]);", 1, 1);
        GetConsole()->AddFunction("ConsoleBlockChannel", cConsoleBlockChannel, "ConsoleBlockChannel(-1 or [0 .. 31]);", 1, 1);
        GetConsole()->AddFunction("Alias", cConsoleAlias, "Alias(aliasName, functionName, arg1, arg2, \"%1\", arg3, \"%2\", etc...);", 2, MAX_ARGS);

        //add the console entry string and it's update function
        radDbgWatchAddString(gConsoleEntry, sizeof(gConsoleEntry), "Console command", "\\", cWatcherExecConsoleCommand);

        //add the debugconsole window as well...
        radDebugConsoleCreate(&(spInstance->mDebugConsole), GMA_DEBUG);

        if (spInstance->mDebugConsole)
        {
            //set the title and background color
            spInstance->mDebugConsole->SetTitle( "Fish Bulb Console" );
            spInstance->mDebugConsole->SetBackgroundColor(RGB( 0, 0, 0x188 ));  
            spInstance->mDebugConsole->Clear();

            spInstance->mDebugConsole->SetCursorPosition(0, 0);
            spInstance->mDebugConsole->SetTextColor(RGB(0xFF, 0xFF,0xFF));

            spInstance->mDebugConsoleCallback = new(GMA_DEBUG) DebugConsoleCallback();
            spInstance->mDebugConsole->SetKeyboardInputCallback(spInstance->mDebugConsoleCallback);
            spInstance->mDebugConsole->SetPointerInputCallback(spInstance->mDebugConsoleCallback);

            //initialize the debug console line number
            spInstance->mDebugConsoleLine = 0;
        }
    }
MEMTRACK_POP_GROUP( "Console Initialize" );
#endif

    return (true);
}


//==============================================================================
// Console::Console
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
Console::Console()
:
mpCallback( 0 )
{
    // Initialize the tables
    int i = 0;
    for( i = 0; i < MAX_FUNCTIONS; ++i )
    {
        mFunctionTable[i] = 0;
    }

    for( i = 0; i < MAX_ALIASES; ++i )
    {
        mAliasTable[i] = 0;
    }

    mFunctionCount = 0;
    mAliasCount = 0;


    //create the argv array
    #ifdef RAD_GAMECUBE
        HeapMgr()->PushHeap( GMA_GC_VMM );
    #else
        HeapMgr()->PushHeap( GMA_PERSISTENT );
    #endif

    mArgv = new char*[MAX_ARGS];
    mPrevArgv = new char*[MAX_ARGS];
    
    for( i = 0; i < MAX_ARGS; ++i )
    {
        mArgv[i] = new char[MAX_ARG_LENGTH];
        mPrevArgv[i] = new char[MAX_ARG_LENGTH];
    }

    #ifdef RAD_GAMECUBE
        HeapMgr()->PopHeap( GMA_GC_VMM );
    #else
        HeapMgr()->PopHeap( GMA_PERSISTENT );
    #endif
    //set the log file mode
    mLogFile = 0;
    mLogMode = LOGMODE_OFF;

    //initialize the console listen channels to everything
    mChannelMask = ~0;

#ifdef RAD_DEBUG
    //initialize the radcore debugconsole members
    mDebugConsole = 0;
#endif
}



//==============================================================================
// Console::~Console
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
Console::~Console()
{
    //clean up the console
    if( spInstance )
    {
#ifdef RAD_DEBUG
        if( spInstance->mDebugConsole )
        {
            spInstance->mDebugConsole->Release();
            delete spInstance->mDebugConsoleCallback;
        }
#endif

        if( spInstance->mLogFile )
            spInstance->mLogFile->WaitForCompletion();
    }

    //clean up after the watcher
#ifdef RAD_DEBUG
    delete [] gConsoleMsgBuffer[0];
    delete [] gConsoleMsgBuffer[1];
    radDbgWatchDelete(gConsoleEntry);
#endif
    
    int i = 0;

    //delete the tables
    for( i = 0; i < mFunctionCount; ++i )
    {
        if (mFunctionTable[i])
        {
            delete mFunctionTable[i];
        }
        
    }

    for( i = 0; i < MAX_ALIASES; ++i )
    {
        if( mAliasTable[i] )
        {
            delete mAliasTable[i];
        }
        
    }


    //delete the argv array
    for( i = 0; i < MAX_ARGS; ++i )
    {
        delete [] mArgv[i];
        delete [] mPrevArgv[i];
    }
        
    delete [] mArgv;
    delete [] mPrevArgv;


    //close the logfile
    if( mLogFile )
    {
        FlushLogFile();
        mLogFile->Release();
    }
}


//==============================================================================
// Console::SetConsoleLogMode
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
bool Console::SetConsoleLogMode(int logMode)
{
#ifndef RAD_DEBUG
    return (false);
#else
    //make sure we have a console
    if (!spInstance)
        return (false);

    return (spInstance->SetLogMode(logMode));
#endif
}

bool Console::SetLogMode(int logMode)
{
    //no work to do if we're not actually changing the mode
    if (logMode == mLogMode)
        return (true);

    switch (logMode)
    {
        case LOGMODE_OFF:
            if (mLogFile)
            {
                mLogFile->WaitForCompletion();
                mLogFile->Release();
                mLogFile = 0;
            }
            mLogMode = logMode;
            return (true);

        case LOGMODE_ON:
            if (!mLogFile)
            {
                char fullPath[256];
// RM                sprintf(fullPath, "%sconsole.log", ResourceManager::GetInstance()->GetRemoteDriveName());
                ::radFileOpen(&mLogFile, fullPath, true, CreateAlways, NormalPriority, 0, RADMEMORY_ALLOC_TEMP);
                if (mLogFile)
                {
                    const char *msg = "\r\n******** CONSOLE LOG OPENED ********\r\n";
                    mLogFile->WaitForCompletion();
                    mLogFile->WriteAsync(msg, strlen(msg)); 
                    mLogFile->WaitForCompletion();
                    mLogMode = logMode;
                    return (true);
                }
                else
                {
                    mLogMode = LOGMODE_OFF;
                    return (false);
                }
            }
            return (true);

        case LOGMODE_APPEND:
            if (!mLogFile)
            {
                char fullPath[256];
// RM               sprintf(fullPath, "%sconsole.log", ResourceManager::GetInstance()->GetRemoteDriveName());
                ::radFileOpen(&mLogFile, fullPath, true, OpenAlways, NormalPriority, 0, RADMEMORY_ALLOC_TEMP);
                if (mLogFile)
                {
                    const char *msg = "\r\n******** CONSOLE LOG OPENED ********\r\n";
                    mLogFile->WaitForCompletion();
                    int fileSize = mLogFile->GetSize();
                    mLogFile->SetPositionAsync(fileSize);
                    mLogFile->WaitForCompletion();
                    mLogFile->WriteAsync(msg, strlen(msg)); 
                    mLogFile->WaitForCompletion();
                    mLogMode = logMode;
                    return (true);
                }
                else
                {
                    mLogMode = LOGMODE_OFF;
                    return (false);
                }
            }
            return (true);
    }

    // Set Error Condition, to remove compiler warning.
    return (false);
}


//==============================================================================
// Console::Printf
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::Printf(char *fmt, ...)
{
#ifdef RAD_DEBUG
    //make sure we have a console
    if (!spInstance)
        return;

    char message[MAX_STRING_LENGTH];
    va_list args;
    int i = 0;
    va_start(args, fmt);
    i = vsprintf(message, fmt, args);
    va_end(args);

    // do some tune printf for designers
    rTunePrintf( message );

    //record the message to the console log file
    spInstance->LogMessage(0, message);
#endif
}

//for now, it does the same as Printf()...  should also echo
//to an error page in the DebugInfo stuff Chakib is working on!
void Console::Errorf(char *fmt, ...)
{
#ifdef RAD_DEBUG
    //make sure we have a console
    if (!spInstance)
        return;

    char message[MAX_STRING_LENGTH];
    va_list args;
    int i = 0;
    va_start(args, fmt);
    i = vsprintf(message, fmt, args);
    va_end(args);

    //record the message to the console log file
    spInstance->LogMessage(0, message, true);
#endif
}

void Console::Printf(int channel, char *fmt, ...)
{
#ifdef RAD_DEBUG
    //make sure we have a console
    if (!spInstance)
        return;

    char message[MAX_STRING_LENGTH];

    //prefix the message with the channel number
    sprintf(message, "ch%d ", channel);
    char *msgPtr;
    if (channel >= 10)
        msgPtr = &message[5];
    else
        msgPtr = &message[4];

    va_list args;
    int i = 0;
    va_start(args, fmt);
    i = vsprintf(msgPtr, fmt, args);
    va_end(args);

    // do some tune printf for designers
    rTunePrintf( message );

    //record the message to the console log file
    spInstance->LogMessage(channel, message);
#endif
}


//==============================================================================
// Console::AssertFatal
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::AssertFatal(char *fmt, ...)
{
    char msgFmt[512];
    sprintf(msgFmt, "File: %s, line: %d  %s", gErrFileName, gErrLineNum, fmt);
    char message[MAX_STRING_LENGTH];
    va_list args;
    int i = 0;
    va_start(args, fmt);
    i = vsprintf(message, msgFmt, args);
    va_end(args);

    //record the message to the console log file
    this->LogMessage(0, message, true);

    //flush the log file in case we're about to crash
    this->FlushLogFile();

    //pop the assert
    rTuneAssertMsg( 0, message );
}


//==============================================================================
// Console::AssertWarn
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::AssertWarn(char *fmt, ...)
{
    char msgFmt[512];
    sprintf(msgFmt, "File: %s, line: %d  %s", gErrFileName, gErrLineNum, fmt);
    char message[MAX_STRING_LENGTH];
    va_list args;
    int i = 0;
    va_start(args, fmt);
    i = vsprintf(message, msgFmt, args);
    va_end(args);

    //record the message to the console log file
    spInstance->LogMessage(0, message, true);

    //flush the log file in case we're about to crash
    spInstance->FlushLogFile();

    //assert warn using the p3d versions
    rDebugWarningFail_Implementation(message, gErrFileName, gErrLineNum);
}


//==============================================================================
// Console::LogMessage
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::LogMessage(int channel, char* msg, bool warning)
{
    //see if we're listening to this channel
    int listenChannel = channel;
    if (channel < 0 || channel > 31)
        listenChannel = 0;
    if (! (mChannelMask & (1 << listenChannel)))
        return;

    //append an '\r\n' to the end of every message
    char logMessage[512];
    if (strchr(msg, '\n'))
        strcpy(logMessage, msg);
    else
        sprintf(logMessage, "%s\r\n", msg);

    //print the message to the console
    p3d::printf(logMessage);

#ifdef RAD_DEBUG
    //print the message out the the radcore debug console as well...
    AddDebugConsoleLine(logMessage, warning);
#endif

    //write the msg out to the console.log (buffered)
    if (mLogMode == LOGMODE_ON || mLogMode == LOGMODE_APPEND)
    {
        //see if there's enough room in the buffer to store the string
        int bytesUsed = int(gConsoleMsgBufferPtr) - int(gConsoleMsgBuffer[gConsoleBufferIndex]);
        int bytesLeft = (MAX_STRING_LENGTH * MAX_BUFFERS) - bytesUsed;
        int strLength = strlen(logMessage);

        //if we don't have space, wait for file completion, then start using the next buffer
        if (bytesUsed > 0 && bytesLeft < strLength)
        {
            mLogFile->WaitForCompletion();
            mLogFile->WriteAsync(gConsoleMsgBuffer[gConsoleBufferIndex], bytesUsed);
            gConsoleBufferIndex = 1 - gConsoleBufferIndex;
            gConsoleMsgBufferPtr = gConsoleMsgBuffer[gConsoleBufferIndex];
        }

        //copy the string into the static console msg buffer
        strcpy(gConsoleMsgBufferPtr, logMessage);

        //increment the console msg buffer
        gConsoleMsgBufferPtr += strLength;
    }
}


//==============================================================================
// Console::FlushConsoleLogFile
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::FlushConsoleLogFile()
{
    //flush the log file in case we're about to crash
    spInstance->FlushLogFile();
}


//==============================================================================
// Console::FlushLogFile
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::FlushLogFile()
{
    if (mLogMode == LOGMODE_ON || mLogMode == LOGMODE_APPEND)
    {
        //see if there's enough room in the buffer to store the string
        int bytesUsed = int(gConsoleMsgBufferPtr) - int(gConsoleMsgBuffer[gConsoleBufferIndex]);

        //if there is info waiting in the buffer to be written out...
        if (bytesUsed > 0)
            mLogFile->WriteAsync(gConsoleMsgBuffer[gConsoleBufferIndex], bytesUsed);

        //wait for the File server to complete
        mLogFile->WaitForCompletion();

        //reset the buffer vars
        gConsoleBufferIndex = 0;
        gConsoleMsgBufferPtr = gConsoleMsgBuffer[0];
    }
}

#ifdef RAD_DEBUG
//debug console methods


//==============================================================================
// char* FormatDebugConsoleString
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================

const unsigned char MAX_STRING_LEN = 128;

static const char* FormatDebugConsoleString(const char *text, bool consoleEntry)
{
    static char formatString[MAX_STRING_LEN + 1];

    //copy the first 80 characters of the text
    if (consoleEntry)
    {
        formatString[0] = '=';
        formatString[1] = '>';
        strncpy(&formatString[2], text, MAX_STRING_LEN - 2);
    }
    else
        strncpy(formatString, text, MAX_STRING_LEN);

    //make sure there are no \r\n's in the string
    char *eolChar = strchr(formatString, '\r');
    if (eolChar)
        *eolChar = '\0';
    eolChar = strchr(formatString, '\n');
    if (eolChar)
        *eolChar = '\0';

    //pad the string with spaces
    formatString[MAX_STRING_LEN] = '\0';
    int strlength = strlen(formatString);
    if (strlength < MAX_STRING_LEN)
        memset(&formatString[strlength], ' ', MAX_STRING_LEN - strlength);
    formatString[MAX_STRING_LEN] = '\0';

    //return the formatted string
    return(formatString);
}


//==============================================================================
// Console::AddDebugConsoleLine
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::AddDebugConsoleLine(const char *text, bool warning)
{
    //make sure we have a debugconsole
    if (! mDebugConsole)
        return;

    //create the string to send to the debug console
    const char *formatString = FormatDebugConsoleString(text, false);
    if (warning)
        mDebugConsole->SetTextColor(RGB(0xFF, 0, 0));
    else
        mDebugConsole->SetTextColor(RGB(0xFF, 0xFF, 0xFF));
    mDebugConsole->TextOutAt(formatString, 0, mDebugConsoleLine++);

    //create the console entry string
    int cursorPosition;
    const char *consoleEntry = mDebugConsoleCallback->GetConsoleEntry(&cursorPosition);
    SetDebugConsoleEntry(consoleEntry, cursorPosition);
}


//==============================================================================
// Console::SetDebugConsoleEntry
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::SetDebugConsoleEntry(const char *text, int cursorPosition)
{
    const char *formatString = FormatDebugConsoleString(text, true);

    //update the consoleEntry
    mDebugConsole->SetTextColor(RGB(0xFF, 0xFF, 0xFF));
    mDebugConsole->TextOutAt(formatString, 0, mDebugConsoleLine);

    //update the cursor position
    spInstance->mDebugConsole->SetCursorPosition(cursorPosition + 2, mDebugConsoleLine);
}

#endif


//==============================================================================
// Console::ConsoleListenChannel
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::ConsoleListenChannel(int channel)
{
    //make sure we have a console
    if (!spInstance)
        return;

    if (channel <= -2 || channel > 31)
    {
        Printf("Console error - invalid channel: %d.  Specify -1 for all channels, or 0 to 31", channel);
        return;
    }

    spInstance->ListenChannel(channel);
}


//==============================================================================
// Console::ConsoleBlockChannel
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::ConsoleBlockChannel(int channel)
{
    //make sure we have a console
    if (!spInstance)
        return;

    if (channel <= -2 || channel > 31)
    {
        Printf("Console error - invalid channel: %d.  Specify -1 for all channels, or 0 to 31", channel);
        return;
    }

    spInstance->BlockChannel(channel);
}


//==============================================================================
// Console::ListenChannel
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::ListenChannel(int channel)
{
    //validate params
    if (channel <= -2 || channel > 31)
        return;

    if (channel == -1)
        mChannelMask = 0xffffffff;
    else
        mChannelMask |= (1 << channel);
}


//==============================================================================
// Console::BlockChannel
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::BlockChannel(int channel)
{
    //validate params
    if (channel <= -2 || channel > 31)
        return;

    //note:  can't block channel 0
    if (channel == -1)
        mChannelMask = (1 << 0);
    else
        mChannelMask &= ~(1 << channel);
}


//==============================================================================
// Console::ListConsoleFunctions
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::ListConsoleFunctions()
{
    if (!spInstance)
        return;

    spInstance->ListFunctions();
}


//==============================================================================
// Console::ListFunctions
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::ListFunctions()
{
    //for (int i = 0; i < mFunctionCount; i++)
        //Printf(mFunctionTable[i]->help.GetText());
}


//==============================================================================
// Console::AddFunction
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
bool Console::AddFunction
(
    const char* name,
    CONSOLE_FUNCTION funcPtr,
    const char* helpString,
    int minArgs,
    int maxArgs
)
{
    //make sure we've initialized the global console
    if (!spInstance)
    {
        rDebugString("Error - Console::AddFunction():  Console::Initialize() hasn't been called yet.");
        return (false);
    }

    return (spInstance->AddFunc(name, funcPtr, 0, helpString, minArgs, maxArgs));
}


//==============================================================================
// Console::AddFunction
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
bool Console::AddFunction
(
    const char* name,
    CONSOLE_BOOL_FUNCTION funcPtr,
    const char* helpString,
    int minArgs,
    int maxArgs
)
{
    //make sure we've initialized the global console
    if (!spInstance)
    {
        rDebugString("Error - Console::AddFunction():  Console::Initialize() hasn't been called yet.");
        return (false);
    }

    return (spInstance->AddFunc(name, 0, funcPtr, helpString, minArgs, maxArgs));
}



//==============================================================================
// Console::AddFunc
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
bool Console::AddFunc
(
    const char* name,           
    CONSOLE_FUNCTION funcPtr,
    CONSOLE_BOOL_FUNCTION boolFuncPtr,
    const char* helpString,
    int minArgs,
    int maxArgs
)
{
    //validate the input
    if (!name || !name[0] || strlen(name) >= MAX_STRING_LENGTH)
    {
        rDebugString("Error - Console::AddFunction():  invalid function name specified.\n");
        return (false);
    }
    if (!helpString || strlen(helpString) >= MAX_STRING_LENGTH)
    {
        rDebugString("Error - Console::AddFunction():  invalid help string specified.\n");
        return (false);
    }
    if (!funcPtr && !boolFuncPtr)
    {
        rDebugString("Error - Console::AddFunction():  no CONSOLE_FUNCTION specified.\n");
        return (false);
    }
    if (minArgs < 0)
    {
        rDebugString("Error - Console::AddFunction():  invalid minArgs specified.\n");
        return (false);
    }
    if (maxArgs < minArgs || maxArgs > MAX_ARGS)
    {
        rDebugString("Error - Console::AddFunction():  invalid maxArgs specified.\n");
        return (false);
    }

    //make sure we have room for one more
    if( mFunctionCount >= MAX_FUNCTIONS )
    {
        rDebugString("Error - Console::AddFunction():  Maximum number of functions has been reached.\n");
        return (false);
    }
    
#ifdef RAD_GAMECUBE
    HeapMgr()->PushHeap( GMA_GC_VMM );
#else
    HeapMgr()->PushHeap( GMA_PERSISTENT );
#endif
   
    //create the new function
    FunctionTableEntry* newFunction;
    if( funcPtr )
    {
        newFunction = new FunctionTableEntry(name, funcPtr, helpString, minArgs, maxArgs);
    }
    else
    {
        newFunction = new FunctionTableEntry(name, boolFuncPtr, helpString, minArgs, maxArgs);
    }

    //add the function to the table
    mFunctionTable[mFunctionCount] = newFunction;
    mFunctionLookup[radMakeCaseInsensitiveKey32(name)] = mFunctionCount;

    //increment the function count
    mFunctionCount++;

#ifdef RAD_GAMECUBE
    HeapMgr()->PopHeap( GMA_GC_VMM );
#else
    HeapMgr()->PopHeap( GMA_PERSISTENT );
#endif

    // return success condition
    return (true);
}


//==============================================================================
// Console::AddAlias
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
bool Console::AddAlias
(
    const char* name, 
    const char* functionName, 
    int argc, 
    char** argv
)
{
    //make sure we've initialized the global console
    if (!spInstance)
    {
        rDebugString("Error - Console::AddFunction():  Console::Initialize() hasn't been called yet.");
        return (false);
    }

    return (spInstance->AddFunctionAlias(name, functionName, argc, argv));
}


//==============================================================================
// Console::AddFunctionAlias
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
bool Console::AddFunctionAlias
(
    const char* name, 
    const char* functionName, 
    int argc, 
    char** argv 
)
{
    //validate the input
    if (!name || !name[0] || strlen(name) >= MAX_STRING_LENGTH)
    {
        rDebugString("Error - Console::AddFunctionAlias():  invalid function name specified.\n");
        return (false);
    }

    //make sure we have room for one more
    if (mAliasCount >= MAX_FUNCTIONS)
    {
        rDebugString("Error - Console::AddFunctionAlias():  Maximum number of alias' has been reached.\n");
        return (false);
    }
    
#ifdef RAD_GAMECUBE
    HeapMgr()->PushHeap( GMA_GC_VMM );
#else
    HeapMgr()->PushHeap( GMA_PERSISTENT );
#endif

    //create the new alias
    AliasTableEntry* newAlias = new AliasTableEntry(name, functionName, argc, argv);

    //insert the new alias into the table alphabetically
    int index = 0;
    while (index < mAliasCount)
    {
        if (smStricmp(mAliasTable[index]->name, name) > 0)
            break;

        index++;
    }

    //the new alias should be inserted at position "index", shift everything else down by one
    for (int i = mAliasCount; i > index; i--)
        mAliasTable[i] = mAliasTable[i - 1];

    //add the alias to the table
    mAliasTable[index] = newAlias;

    //increment the alias count
    mAliasCount++;

#ifdef RAD_GAMECUBE
    HeapMgr()->PopHeap( GMA_GC_VMM );
#else
    HeapMgr()->PopHeap( GMA_PERSISTENT );
#endif

    // return success condition
    return (true);
}


//==============================================================================
// Console::TabCompleteFunction
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
const tNameInsensitive& Console::TabCompleteFunction
(
    const char* tabString, 
    const char* curFunction
)
{
    static tNameInsensitive error( "ERROR" );
    //make sure we've initialized the global console
    if (!spInstance)
    {
        rDebugString("Error - Console::TabCompleteFunction():  Console::Initialize() hasn't been called yet.");
        return error;
    }

    return (spInstance->TabComplete(tabString, curFunction));
}


//==============================================================================
// Console::TabComplete
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
const tNameInsensitive& Console::TabComplete
(
    const char* tabString, 
    const char* curFunction
)
{
    int i;
    static tNameInsensitive error( "ERROR" );
    //sanity check
    if (! tabString || ! tabString[0])
    {
        rAssert( false );
        return error;
    }

    //find the first function beginning with the tabString
    //note - functions are stored alphabetically...
    int firstFunctionIndex = -1;
    for (i = 0; i < mFunctionCount; i++)
    {
        if (! smStrincmp(tabString, mFunctionTable[i]->name.GetText(), strlen(tabString)))
        {
            firstFunctionIndex = i;
            break;
        }
    }

    //if no function was found, return 0
    if (firstFunctionIndex < 0)
    {
        rAssert( false );
        return error;
    }

    //if there's no current function, return the first function we found
    if (! curFunction || ! curFunction[0])
        return (mFunctionTable[firstFunctionIndex]->name);

    //if the current function doesn't contain the tabString, ???
    if (smStrincmp(tabString, curFunction, strlen(tabString)))
        return (mFunctionTable[firstFunctionIndex]->name);
        
    //search for the next function that contains the tabstring, but follows the curFunction
    int curFunctionIndex = -1;
    for (i = firstFunctionIndex; i < mFunctionCount; i++)
    {
        if ( mFunctionTable[i]->name == curFunction )
        {
            curFunctionIndex = i;
            break;
        }
    } 

    //if no current function was found, return the first function
    if (curFunctionIndex < 0 || curFunctionIndex == mFunctionCount - 1)
        return (mFunctionTable[firstFunctionIndex]->name);

    //see if the next function also contains the tabString
    if (! smStrincmp(tabString, mFunctionTable[curFunctionIndex + 1]->name.GetText(), strlen(tabString)))
        return (mFunctionTable[curFunctionIndex + 1]->name);

    //otherwise, return the first function found again
    else
        return (mFunctionTable[firstFunctionIndex]->name);
}

//---------------------------------------------------------------------------//

static const char* gWhiteSpace = " \t\r\n";
static const char* gEndOfToken = " \t\r\n,();[]{}+/*!@#$%^&:\"<>?'`~";

char *Console::SkipWhiteSpace(const char *string)
{
    //this function should never be called with an invalid string
    char *temp = const_cast<char*>(string);
    while (true)
    {
        //break on an end of string character
        if (*temp == '\0')
            break;

        //break when a non-white space character is found
        char *found = strchr(gWhiteSpace, *temp);
        if (! found)
            break;

        //see if we found an eol char
        if (*found == '\n')
            mLineNumber++;

        //check the next character
        temp++;
    }
    
    return (temp);
}


//==============================================================================
// Console::FoundComment
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
bool Console::FoundComment(char** stringPtr)
{
    char *tokenPtr = *stringPtr;
    if (*tokenPtr == '/')
    {
        tokenPtr++;

        //see if we've found a line comment
        if (*tokenPtr == '/')
        {
            while (*tokenPtr != '\r' && *tokenPtr != '\n' && *tokenPtr != '\0')
                tokenPtr++;

            //increment the line count
            if (*tokenPtr == '\n')
                mLineNumber++;

            //now we've hit the end of the line or file
            *stringPtr = tokenPtr;
            return (true);
        }

        //else see if we've found a block comment
        else if (*tokenPtr == '*')
        {
            //here we search for the end of the block:  */
            while (true)
            {
                tokenPtr++;
                while (*tokenPtr != '*' && *tokenPtr != '\0')
                {
                    //increment the line count
                    if (*tokenPtr == '\n')
                        mLineNumber++;

                    tokenPtr++;
                }

                //see if we've found the end of the file
                if (*tokenPtr == '\0')
                {
                    *stringPtr = tokenPtr;
                    return (true);
                }
                
                //else see if we've found the end of the comment block
                else
                {
                    tokenPtr++;
                    if (*tokenPtr == '/')
                    {
                        tokenPtr++;
                        *stringPtr = tokenPtr;
                        return (true);
                    }
                }
            }
        }

        //else no comment found
        else
            return (false);
    }

    //else no commment found
    else
        return (false);
}


//==============================================================================
// Console::FindTokenEnd
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
char* Console::FindTokenEnd( const char* string )
{
    //this function should never be called with an invalid string
    char *temp = const_cast<char*>(string);
    bool finished = false;
    while (true)
    {
        //break on an end of string character
        if (*temp == '\0')
            break;

        //break on an end of token character
        char *found = strchr(gEndOfToken, *temp);
        if (found)
        {
            //see if we found an eol char
            if (*found == '\n')
                mLineNumber++;

            break;
        }

        //neither was found, check the next character
        temp++;
    }
    
    return (temp);
}


//==============================================================================
// Console::ReadToken
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
bool Console::ReadToken(char **stringPtr, const char *requiredToken)
{
    //validate parameters
    if (! stringPtr || ! *stringPtr || !requiredToken)
        return (false);

    //read the next token
    char tempBuffer[MAX_STRING_LENGTH];
    char *token = GetNextToken(stringPtr, tempBuffer);

    //if we don't have a token, or it doesn't match what we're looking for, return false
    if (! token || smStricmp(token, requiredToken))
        return (false);

    //everything is ok, return true
    return (true);
}


//==============================================================================
// Console::GetNextToken
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
char* Console::GetNextToken(char **stringPtr, char *tokenBuffer)
{
    //validate parameters
    if (! stringPtr || ! *stringPtr || !tokenBuffer)
        return (0);

    char *tokenPtr = *stringPtr;
    char *tokenEnd = 0;

    //skip comments and white space until we reach the beginning of a valid token
    while (true)
    {
        tokenPtr = SkipWhiteSpace(tokenPtr);
        if (! FoundComment(&tokenPtr))
            break;
    }

    //if the next character is a '\0', no more tokens
    if (*tokenPtr == '\0')
        return (0);

    //if the token is enclosed in quotes, search for the end quote
    if (*tokenPtr == '\"')
    {
        tokenEnd = tokenPtr + 1;
        while (true)
        {
            tokenEnd = strchr(tokenEnd, '\"');
            if (! tokenEnd)
                return (0);

            //make sure the previous character isn't a '\\'
            if (*(tokenEnd - 1) == '\\')
                tokenEnd++;

            //otherwise, we've found our matching quotes
            else
                break;
        }

        //now we've got our string enclosed with quotes, copy it the contents to the tokenBuffer
        int strLength = (tokenEnd - tokenPtr) - 1;
        strncpy(tokenBuffer, tokenPtr + 1, strLength);
        tokenBuffer[strLength] = '\0';

        //update the next position in the string
        *stringPtr = tokenEnd + 1;
        return (tokenBuffer);
    }

    //else find the end of the token
    else
    {
        tokenEnd = FindTokenEnd(tokenPtr);

        //if 0 was returned, the token ends on a '\0'
        if (! tokenEnd)
        {
            //copy the token to the tokenBuffer
            strcpy(tokenBuffer, tokenPtr);

            //update the next position in the string
            *stringPtr = &tokenPtr[strlen(tokenPtr)];
            return (tokenBuffer);
        }

        //if the tokenEnd == the tokenPtr, the token is either a '\0', or one of the token end chars
        else if (tokenEnd == tokenPtr)
        {
            //copy the character into the tokenBuffer
            tokenBuffer[0] = *tokenPtr;
            tokenBuffer[1] = '\0';

            //update the next position in the string
            *stringPtr = tokenEnd + 1;
            return (tokenBuffer);
        } 

        else
        {
            //copy the token into the tokenBuffer
            int strLength = tokenEnd - tokenPtr;
            strncpy(tokenBuffer, tokenPtr, strLength);
            tokenBuffer[strLength] = '\0';

            //update the next position in the string
            *stringPtr = tokenEnd;
            return (tokenBuffer);
        }
    }
}


//==============================================================================
// Console::Evaluate
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
bool Console::Evaluate( const char* string, const char* fileName )
{
    rTuneAssert( string != 0 );

#if PROFILE_PARSER
    float curTime = 0.0f, elapsedTime = 0.0f, totalTime = 0.0f;
#endif

    // make sure we have a real string
    if( !string[0] )
    {
        return( false );
    }

    // intialize the file name line number
    strcpy( mFileName, fileName );
    mLineNumber = 1;

    // setup the string ptr
    char* stringPtr = const_cast<char*>(string);

    // process the string until it's finished
    int readEndBracketLevel = 0;
    bool negateCondition = false;
    
    do 
    {

#if !PROFILE_PARSER
//      Sound::daSoundManagerService( );
#endif

        // first, get the function name
        char* token = this->GetNextToken( &stringPtr, mArgv[0] );

        // if no function name found, we're finished
        if( !token )
        {
            if( readEndBracketLevel > 0 )
            {
                this->Printf( "ConERR file %s line %d - expecting '}'.", mFileName, mLineNumber );
                rTuneAssert( 0 );
                return( false );
            }
            break;
        }

        // it's possible we might read an end bracket - skip past it...
        while( !smStricmp(token, "}") )
        {
            if( readEndBracketLevel <= 0 )
            {
                this->Printf( "ConERR file %s line %d - unexpected '}' found.", mFileName, mLineNumber );
                rTuneAssert( 0 );
                return( false );
            }

            // otherwise, set the bool, and read the next token
            readEndBracketLevel--;
            token = GetNextToken( &stringPtr, mArgv[0] );

            // if no function name found, we're finished
            if( !token )
            {
                if( readEndBracketLevel > 0 )
                {
                    this->Printf("ConERR file %s line %d - expecting '}'.", mFileName, mLineNumber);
                    rTuneAssert( 0 );
                    return( false );
                }
                else
                {
                    return( true );
                }
                
            }
        }
        mArgc = 1;

        // see if we read a "!" symbol before a conditional function call...
        if( !strcmp( token, "!") )
        {
            // set the bool
            negateCondition = true;

            //read the next token (should be function name)
            token = GetNextToken(&stringPtr, mArgv[0]);

            if (! token)
            {
                Printf("ConERR file %s line %d - unexpected '!'.", mFileName, mLineNumber);
                rTuneAssert( 0 );
                return (false);
            }
        }

        //mArgv[0] currently contains the function name
        //next token should be an '('
        if (! ReadToken(&stringPtr, "("))
        {
            Printf("ConERR file %s line %d - unable to process function %s.  Expecting '('", mFileName, mLineNumber, mArgv[0]);
            rTuneAssert( 0 );
            return (false);
        }

        //some bools to ensure proper syntax
        bool canReadBrace = true;
        bool mustReadComma = false;
        do
        {
            //make sure we haven't run out of arguments
            if (mArgc >= MAX_ARGS)
            {
                Printf("ConERR file %s line %d - unable to process function %s.  Too many args.", mFileName, mLineNumber, mArgv[0]);
                rTuneAssert( 0 );
                return (false);
            }

            //get the next argument
            token = GetNextToken(&stringPtr, mArgv[mArgc]);
            if (! token)
            {
                Printf("ConERR file %s line %d - unable to process function %s.  Expecting ')'", mFileName, mLineNumber, mArgv[0]);
                rTuneAssert( 0 );
                return (false);
            }

            //if we've read a ')', the next token should be a ';' and we've found our function
            if (! smStricmp(token, ")"))
            {
                //make sure we can read a ')'
                if (! canReadBrace)
                {
                    Printf("ConERR file %s line %d - unable to process function %s.  Extra ',' found.", mFileName, mLineNumber, mArgv[0]);
                    rTuneAssert( 0 );
                    return (false);
                }

                //our function and it's arguments is complete
                break;
            }
            
            //else the next token is an argument or a comma
            else
            {
                if (mustReadComma)
                {
                    if (smStricmp(token, ","))
                    {
                        Printf("ConERR file %s line %d - unable to process function %s.  Args must be separated by a ','", mFileName, mLineNumber, mArgv[0]);
                        rTuneAssert( 0 );
                        return (false);
                    }

                    //else we read our comma in correctly
                    else
                    {
                        mustReadComma = false;
                        canReadBrace = false;
                    }
                }

                //otherwise the next token is a valid argument
                else
                {
                    mArgc++;
                    mustReadComma = true;
                    canReadBrace = true;
                }
            }

        } while (true);

        //at this point, the array mArgv should contain the function name and all the arg strings
        //search the table looking for the matching function
        //first, search the alias table...
        int i;
        for (i = 0; i < mAliasCount; i++)
        {
            if (! smStricmp(mAliasTable[i]->name, mArgv[0]))
            {
                //copy the original set of args

                int mPrevArgc = mArgc;
                int j;
                for( j = 0; j < mPrevArgc; ++j )
                {
                    strcpy( mPrevArgv[j], mArgv[j] );
                }


                //replace the function name
                AliasTableEntry *alias = mAliasTable[i];
                strcpy(mArgv[0], alias->functionName);

                //do the argument substitution
                bool argcSet = false;
                for (j = 0; j < alias->argc; j++)
                {
                    //see if the variable is a substitution (%1, %2, etc...)
                    if (alias->argv[j][0] == '%')
                    {
                        //copy the given argment in
                        int index = alias->argv[j][1] - '0';

                        if( index < mPrevArgc )
                        {
                            strcpy( mArgv[j + 1], mPrevArgv[index] );
                        }
                        //once we get to an argument which has not been provided
                        //the substitutions are complete...
                        else
                        {
                            //set the argc
                            mArgc = j + 1;
                            argcSet = true;
                            break;
                        }
                    }
                    
                    //else use the alias's argument
                    else
                    {
                        strcpy(mArgv[j + 1], alias->argv[j]);
                    }
                }

                //if we used the entire set of args from the alias, set the argc count
                if (! argcSet)
                    mArgc = alias->argc + 1;

                break;
            }
        }

        //now the mArgc and mArgv vars are set, and any alias substitutions have been done
        //search for the function
        bool isConditional = false;
        bool conditionalResult = false;
        bool found = false;

        std::map<radKey32, int>::const_iterator lookup;
        lookup = mFunctionLookup.find(radMakeCaseInsensitiveKey32(mArgv[0]));
        
        {
            if( lookup != mFunctionLookup.end() )
            {
                i = lookup->second;
                rTuneAssert( mFunctionTable[i]->name == mArgv[0] );  // make sure there wasn't a hash collision

                //call the function
                found = true;

                //now make sure the argument count is correct
                if ((mArgc - 1) >= mFunctionTable[i]->minArgs && (mArgc - 1) <= mFunctionTable[i]->maxArgs)
                {
                    //conditional function call
                    if (mFunctionTable[i]->isConditional)
                    {
                        //make sure we read the opening brace '{'
                        if (! ReadToken(&stringPtr, "{"))
                        {
                            Printf("ConERR file %s line %d - unable to process function %s.  Expecting '{'", mFileName, mLineNumber, mArgv[0]);
                            rTuneAssert( 0 );
                            return (false);
                        }

                        isConditional = true;
                        readEndBracketLevel++;
                        conditionalResult = (mFunctionTable[i]->functionPointer.boolReturn)(mArgc, (char**)mArgv);
                        if (negateCondition)
                            conditionalResult = (! conditionalResult);
                        negateCondition = false;
                    }
                    //non conditional function call
                    else
                    {
                        //make sure we're not trying to negate a non-conditional function
                        if (negateCondition)
                        {
                            Printf("ConERR file %s line %d - trying to negate non-conditional function %s.", mFileName, mLineNumber, mArgv[0]);
                            rTuneAssert( 0 );
                            return (false);
                        }
                        //make sure the function call ends with a ';'
                        if (! ReadToken(&stringPtr, ";"))
                        {
                            Printf("ConERR file %s line %d - unable to process function %s.  Expecting ';'", mFileName, mLineNumber, mArgv[0]);
                            rTuneAssert( 0 );
                            return (false);
                        }

                        isConditional = false;
                        negateCondition = false;

                        (mFunctionTable[i]->functionPointer.voidReturn)(mArgc, (char**)mArgv);

                        //see if the function was "exit"
                        if (! smStricmp(mArgv[0], "exit"))
                        {
                            //print out any exit messages
                            if (mArgc >= 2)
                                GetConsole()->Printf(mArgv[1]);

                            //terminate evaluating...
                            return (true);
                        }
                    }
                }

                //else print out the help string, but continue processing the string
                else
                {
                    Printf("ConERR file %s line %d - invalid arg list for function: %s()", mFileName, mLineNumber, mArgv[0]);
                    //Printf(mFunctionTable[i]->help);

                    rTuneAssert( 0 );

                    //even though the function couldn't be called, still need to read in
                    //either the ';' or the '{ ... }'
                    if (mFunctionTable[i]->isConditional)
                    {
                        //make sure we read the opening brace '{'
                        if (! ReadToken(&stringPtr, "{"))
                        {
                            Printf("ConERR file %s line %d - unable to process function %s.  Expecting '{'", mFileName, mLineNumber, mArgv[0]);
                            rTuneAssert( 0 );
                            return (false);
                        }

                        int balanceBrackets = readEndBracketLevel;
                        readEndBracketLevel++;

                        //skip past everything until we find the closing bracket
                        while (readEndBracketLevel > balanceBrackets)
                        {
                            char *token = GetNextToken(&stringPtr, mArgv[0]);
                            if (! token)
                            {
                                Printf("ConERR file %s line %d - end bracket for function %s not found.", mFileName, mLineNumber, mArgv[0]);
                                rTuneAssert( 0 );
                                return (false);
                            }

                            //see if we read another '{'
                            else if (! smStricmp(token, "{"))
                                readEndBracketLevel++;

                            else if (! smStricmp(token, "}"))
                                readEndBracketLevel--;
                        }
                    }
                    else
                    {
                        //make sure the function call ends with a ';'
                        if (! ReadToken(&stringPtr, ";"))
                        {
                            Printf("ConERR file %s line %d - unable to process function %s.  Expecting ';'", mFileName, mLineNumber, mArgv[0]);
                            rTuneAssert( 0 );
                            return (false);
                        }
                    }
                }
            }
        }

        //if we didn't find the function, print an error msg, but go on to the next...
        if (! found)
        {
            Printf("ConERR file %s line %d - console function not found: %s", mFileName, mLineNumber, mArgv[0]);
            rTuneAssert( 0 );

            //since the function couldn't be found, don't forget to skip past the ';'
            if (! ReadToken(&stringPtr, ";"))
            {
                Printf("ConERR file %s line %d - unable to process function %s.  Expecting ';'", mFileName, mLineNumber, mArgv[0]);
                rTuneAssert( 0 );
                return (false);
            }
        }

        //if the function is conditional, and the result is false
        //skip past until we find the closing brace...
        if (isConditional && ! conditionalResult)
        {
            //skip past everything until we find the closing bracket
            while (true)
            {
                char *token = GetNextToken(&stringPtr, mArgv[0]);
                if (! token)
                {
                    Printf("ConERR file %s line %d - end bracket for function %s not found.", mFileName, mLineNumber, mArgv[0]);
                    rTuneAssert( 0 );
                    return (false);
                }

                else if (! smStricmp(token, "}"))
                {
                    readEndBracketLevel--;
                    break;
                }
            }
        }

    } while (true);

#if PROFILE_PARSER
GetConsole()->Printf("DEBUG total time spent calling functions: %.3f", totalTime);
#endif

    return (true);
}



//==============================================================================
// Console::ExecuteScriptSync
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::ExecuteScriptSync( const char* filename, bool reload )
{
#if PROFILE_PARSER
float curTime = GameManager::GetRealTime();
GetConsole()->Printf("Console loading script file %s\n", filename);
#endif

    GetLoadingManager()->LoadSync( FILEHANDLER_CONSOLE, filename );
}


//==============================================================================
// 
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
bool Console::atob( const char* value )
{
    if( atoi(value) != 0 || !smStricmp(value, "true") )
    {
        return( true );
    }
    else
    {
        return( false );
    }
}


//==============================================================================
// Console::ExecuteScript
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::ExecuteScript
( 
    const char* filename, 
    Console::ExecuteScriptCallback* pCallback, 
    void* pUserData, 
    bool reload
)
{
    rTuneAssert( filename != 0 );
    rTuneAssert( pCallback != 0 );
    
    mpCallback = pCallback;
    GetLoadingManager()->AddRequest( FILEHANDLER_CONSOLE, filename, HeapMgr()->GetCurrentHeap(), this, pUserData );
}

//==============================================================================
// Console::OnProcessRequestsComplete
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
void Console::OnProcessRequestsComplete( void* pUserData )
{
    mpCallback->OnExecuteScriptComplete( pUserData );    
}


//******************************************************************************
//
// Private Member Functions
//
//******************************************************************************

//==============================================================================
// FunctionTableEntry::FunctionTableEntry
//==============================================================================
//
// Description: 
//
// Parameters:  
//
// Return:      
//
//==============================================================================
Console::FunctionTableEntry::FunctionTableEntry
( 
    const char* in_name, 
    CONSOLE_FUNCTION in_func, 
    const char* in_help, 
    int in_minArgs, 
    int in_maxArgs 
)
    :
    minArgs( in_minArgs ),
    maxArgs( in_maxArgs ),
    isConditional( false )
{
    rTuneAssert( in_func != 0 );
    rTuneAssert( strlen( in_name ) < MAX_FUNCTION_NAME );
    rTuneWarningMsg( strlen( in_help ) < MAX_HELP_LENGTH, "Help text too long.  Text has been truncated.\n" );

    functionPointer.voidReturn = in_func;
    name = in_name;
    help = in_help;
};


//==============================================================================
// FunctionTableEntry::FunctionTableEntry
//==============================================================================
//
// Description: Constructor.
//
// Parameters:  
//
// Return:      N/A.
//
//==============================================================================
Console::FunctionTableEntry::FunctionTableEntry
(
    const char* in_name,
    CONSOLE_BOOL_FUNCTION in_func,
    const char* in_help, 
    int in_minArgs, 
    int in_maxArgs 
)
    :
    minArgs( in_minArgs ),
    maxArgs( in_maxArgs ),
    isConditional( true )
{
    rTuneAssert( in_func != 0 );
    rTuneAssert( strlen( in_name ) < MAX_FUNCTION_NAME );
    rTuneAssert( strlen( in_help ) < MAX_HELP_LENGTH );

    functionPointer.boolReturn = in_func;
    name = in_name;
    help = in_help;
}


//==============================================================================
// AliasTableEntry::AliasTableEntry
//==============================================================================
//
// Description: Constructor.
//
// Parameters:  
//
// Return:      N/A.
//
//==============================================================================
Console::AliasTableEntry::AliasTableEntry
( 
    const char* srcName, 
    const char* funcName, 
    int srcArgc, 
    char** srcArgv 
)
{
    rTuneAssert( strlen( srcName ) < MAX_ALIAS_NAME );
    rTuneAssert( strlen( funcName ) < MAX_FUNCTION_NAME );
    rTuneAssert( srcArgc < MAX_ARGS );

    strcpy( name, srcName );
    strcpy( functionName, funcName );

    argc = srcArgc;

    int i;
    for( i = 0; i < argc; ++i )
    {
        rTuneAssert( strlen( srcArgv[i]) < MAX_ARG_LENGTH );
        strcpy(argv[i], srcArgv[i]);
    }
}