---

LuaState.cpp

Go to the documentation of this file.

// This source file is part of the LuaState (Lua Wrapper) source distribution
// and is Copyright 2000-2001 by Joshua C. Jensen (jjensen@workspacewhiz.com).
// The latest version may be obtained from http://www.workspacewhiz.com/.
//
// The code presented in this file may be freely used and modified for all
// non-commercial and commercial purposes.
#include "LuaState.h"
#ifdef WIN32
#include <windows.h>
#undef GetObject
#endif WIN32
#pragma warning(disable: 4786)
#include <list>
#include <string>
#include <algorithm>
#include <stdio.h>
#include <string.h>
#include "LuaStateFunctions.h"
#pragma warning(disable: 4786)

//-----------------------------------------------------------------------------
extern "C"
{
#include "lualib.h"
}

static int LS_LOG(LuaState state)
{
    LuaObject obj(state, 1);
#ifdef WIN32
    OutputDebugStringA(obj.GetString());
    OutputDebugStringA("\n");
#else
    printf("%s\n", obj.GetString());
#endif
    return 0;
}


static int LS_WriteLuaObject(LuaState state)
{
    FILE* stdioFile = (FILE *)LuaObject(state, 1).GetUserData();
    LuaObject nameObj(state, 2);
    LuaObject valueObj(state, 3);
    LuaObject indentLevelObj(state, 4);
    LuaObject writeAllObj(state, 5);
    LuaObject alphabeticalObj(state, 6);
    LuaObject maxIndentLevelObj(state, 7);
    bool writeAll = !writeAllObj.IsNil()  &&  writeAllObj.GetInteger() != 0;
    bool alphabetical = !alphabeticalObj.IsNil()  &&  alphabeticalObj.GetInteger() != 0;
    int maxIndentLevel = maxIndentLevelObj.IsNumber() ? maxIndentLevelObj.GetInteger() : 0xFFFFFFFF;

    LuaStateOutFile file;
    file.Assign(stdioFile);
    state.WriteLuaObject(file, nameObj.GetString(), valueObj, indentLevelObj.GetInteger(), writeAll, alphabetical, false, maxIndentLevel);

    return 0;
}


static int LS_WriteLuaFile(LuaState state)
{
    LPCSTR fileName = state.ToString(1);
    FILE* file = fopen(fileName, "wt");
    if (!file)
    {
        state.PushBool(false);
        return 1;
    }
    LuaObject nameObj(state, 2);
    LuaObject valueObj(state, 3);
    LuaObject indentLevelObj(state, 4);
    LuaObject writeAllObj(state, 5);
    LuaObject alphabeticalObj(state, 6);
    LuaObject maxIndentLevelObj(state, 7);
    bool writeAll = !writeAllObj.IsNil()  &&  writeAllObj.GetInteger() != 0;
    bool alphabetical = !alphabeticalObj.IsNil()  &&  alphabeticalObj.GetInteger() != 0;
    int maxIndentLevel = maxIndentLevelObj.IsNumber() ? maxIndentLevelObj.GetInteger() : 0xFFFFFFFF;

    LuaStateOutFile stdFile;
    stdFile.Assign(file);
    state.WriteLuaObject(stdFile, nameObj.GetString(), valueObj,
            indentLevelObj.GetInteger(), writeAll, alphabetical, false, maxIndentLevel);
    fclose(file);

    state.PushBool(true);
    return 1;
}


static int LS_WriteLuaGlobalsFile(LuaState state)
{
    LPCSTR fileName = state.ToString(1);
    LuaObject writeAllObj(state, 2);
    LuaObject alphabeticalObj(state, 3);
    LuaObject maxIndentLevelObj(state, 4);
    bool writeAll = !writeAllObj.IsNil()  &&  writeAllObj.GetInteger() != 0;
    bool alphabetical = !alphabeticalObj.IsNil()  &&  alphabeticalObj.GetInteger() != 0;
    int maxIndentLevel = maxIndentLevelObj.IsNumber() ? maxIndentLevelObj.GetInteger() : 0xFFFFFFFF;

    state.WriteLuaGlobalsFile(fileName, writeAll, alphabetical, false, maxIndentLevel);

    state.PushBool(true);
    return 1;
}


static void FatalError()
{
    throw -1;
}


static void LSLock(void* data)
{
    CRITICAL_SECTION* cs = (CRITICAL_SECTION*)data;
    ::EnterCriticalSection(cs);
}


static void LSUnlock(void* data)
{
    CRITICAL_SECTION* cs = (CRITICAL_SECTION*)data;
    ::LeaveCriticalSection(cs);
}


LuaStateOwner::LuaStateOwner(bool initStandardLibrary, DWORD stackSize, bool multithreaded)
{
    m_state = lua_open(stackSize);

    if (multithreaded)
    {
        // What about clean up?
        CRITICAL_SECTION* cs = new CRITICAL_SECTION;
        ::InitializeCriticalSection(cs);
        lua_setlockfunctions(m_state, LSLock, LSUnlock, cs);
    }
    
    Init(initStandardLibrary, stackSize);
}


LuaStateOwner::LuaStateOwner(LuaState& script, bool initStandardLibrary, DWORD stackSize)
{
    m_state = lua_newthread(script, stackSize);
    Init(initStandardLibrary, stackSize);
}


extern "C" int lua_dumplibopen (lua_State *L);

void LuaStateOwner::Init(bool initStandardLibrary, DWORD stackSize)
{
    // Register some basic functions with Lua.
    if (initStandardLibrary)
    {
        lua_baselibopen(m_state);
        lua_iolibopen(m_state);
        lua_strlibopen(m_state);
        lua_mathlibopen(m_state);
        lua_dblibopen(m_state);
        lua_dumplibopen(m_state);

        ScriptFunctionsRegister(m_state);

        Register("WriteLuaObject", LS_WriteLuaObject);
        Register("WriteLuaFile", LS_WriteLuaFile);
        Register("WriteLuaGlobalsFile", LS_WriteLuaGlobalsFile);
    }

    Register("LOG", LS_LOG);
    Register("_ALERT", LS_LOG);

    lua_setfatalerrorfunction(m_state, FatalError);
}


int LuaState::ConfigGetInteger(const char* section, const char* entry,
                             int defaultValue)
{
    return static_cast<int>(ConfigGetReal(section, entry, defaultValue));
}


float LuaState::ConfigGetReal(const char* section, const char* entry,
                            double defaultValue)
{
    LuaAutoBlock block(*this);

    LuaObject obj = GetGlobal(section);
    if (obj.IsNil())
        return (float)defaultValue;
    obj = obj.GetByName(entry);
    if (obj.IsNumber())
        return obj.GetNumber();
    return (float)defaultValue;
}


const char* LuaState::ConfigGetString(const char* section, const char* entry,
                                    const char* defaultValue)
{
    LuaAutoBlock block(*this);

    LuaObject obj = GetGlobal(section);
    if (obj.IsNil())
        return defaultValue;
    obj = obj.GetByName(entry);
    if (obj.IsString())
        return obj.GetString();
    return defaultValue;
}


void LuaState::ConfigSetInteger(const char* section, const char* entry, int value)
{
    LuaAutoBlock block(*this);

    // section.entry = value
    // Difficult in code.  Do it this way.
    LuaObject sectionTable = GetGlobal(section);

    // If the global table isn't there, then create it.
    if (sectionTable.IsNil())
    {
        sectionTable = GetGlobals().CreateTable(section);
    }

    sectionTable.SetNumber(entry, value);
}


void LuaState::ConfigSetReal(const char* section, const char* entry, double value)
{
    LuaAutoBlock block(*this);

    // section.entry = value
    // Difficult in code.  Do it this way.
    LuaObject sectionTable = GetGlobal(section);

    // If the global table isn't there, then create it.
    if (sectionTable.IsNil())
    {
        sectionTable = GetGlobals().CreateTable(section);
    }

    sectionTable.SetNumber(entry, value);
}


void LuaState::ConfigSetString(const char* section, const char* entry, const char* value)
{
    LuaAutoBlock block(*this);

    // section.entry = value
    // Difficult in code.  Do it this way.
    LuaObject sectionTable = GetGlobal(section);

    // If the global table isn't there, then create it.
    if (sectionTable.IsNil())
    {
        sectionTable = GetGlobals().CreateTable(section);
    }

    sectionTable.SetString(entry, value);
}


static void IndentFile(LuaStateOutFile& file, unsigned int indentLevel)
{
    // Write out indentation.
    char spaces[500];
    for (unsigned int i = 0; i < indentLevel; ++i)
        spaces[i] = '\t';
    spaces[i] = 0;
    file.Print(spaces);
}

bool LuaState::WriteLuaObject(FILE* stdioFile, const char* name, LuaObject value,
                             int indentLevel, bool writeAll, bool alphabetical,
                             bool writeTablePointers, unsigned int maxIndentLevel)
{
    LuaStateOutFile file;
    file.Assign(stdioFile);
    WriteLuaObject(file, name, value, indentLevel, writeAll, alphabetical,
            writeTablePointers, maxIndentLevel);
    return false;
}   


static void luaI_addquotedbinary (LuaStateOutFile& file, lua_State *L, const char* s, int l)
{
    file.Print("%c", l_c('"'));
    while (l--)
    {
        switch (*s)
        {
            case l_c('"'):  case l_c('\\'):
                file.Print("\\%c", *s);
                break;
            case l_c('\a'):     file.Print("\\a");      break;
            case l_c('\b'):     file.Print("\\b");      break;
            case l_c('\f'):     file.Print("\\f");      break;
            case l_c('\n'):     file.Print("\\n");      break;
            case l_c('\r'):     file.Print("\\r");      break;
            case l_c('\t'):     file.Print("\\t");      break;
            case l_c('\v'):     file.Print("\\v");      break;
            default:
                if (isprint((BYTE)*s))
                    file.Print("%c", *s);
                else
                {
                    file.Print("\\%03d", (BYTE)*s);
                }
        }
        s++;
    }
    file.Print("%c", l_c('"'));
}


static void luaI_addquotedwidebinary (LuaStateOutFile& file, lua_State *L, const wchar_t* s, int l)
{
    file.Print("L\"");
    while (l--)
    {
        switch (*s)
        {
            case l_uc('"'):
            case l_uc('\\'):
                file.Print("\\%c", *s);
                break;
            case l_uc('\a'):        file.Print("\\a");      break;
            case l_uc('\b'):        file.Print("\\b");      break;
            case l_uc('\f'):        file.Print("\\f");      break;
            case l_uc('\n'):        file.Print("\\n");      break;
            case l_uc('\r'):        file.Print("\\r");      break;
            case l_uc('\t'):        file.Print("\\t");      break;
            case l_uc('\v'):        file.Print("\\v");      break;
            default:
                if (*s < 256  &&  isprint((BYTE)*s))
                {
                    file.Print("%c", *s);
                }
                else
                {
                    file.Print("\\x%04x", (DWORD)*s);
                }
        }
        s++;
    }
    file.Print("\"");
}


bool LuaState::WriteLuaObject(LuaStateOutFile& file, const char* name, LuaObject value,
                         int indentLevel, bool writeAll, bool alphabetical,
                         bool writeTablePointers, unsigned int maxIndentLevel)
{
    LuaState script = value;
    
    // If there is nothing in the variable, then don't write it.
    if (value.IsNil())
        return false;

    // If the variable is user data or a function, then don't write it.
    if (value.IsUserData()  ||  value.IsFunction()  ||  value.IsCFunction())
    {
        if (writeAll  &&  name)
        {
            if (value.IsUserData())
                file.Print("-- %s = '!!!USERDATA!!!'\n", name);
            else if (value.IsFunction())
            {
                lua_Debug ar;
                PushValue(value);
                lua_getinfo(m_state, ">S", &ar);
//              printf("%d\n", ar.linedefined);
                file.Print("-- %s = '!!!FUNCTION!!! %s %d'\n", name, ar.source, ar.linedefined);
            }
            else
                file.Print("-- %s = '!!!CFUNCTION!!!'\n", name);
            return true;
        }
        return false;
    }

    // Indent the line the number of spaces for the current indentation level.
    const unsigned int INDENT_SIZE = 1;
    const unsigned int indentSpaces = (indentLevel == -1 ? 0 : indentLevel) * INDENT_SIZE;
    IndentFile(file, indentSpaces);
    
    // If the object has a name, write it out.
    if (name)
        file.Print("%s = ", name);

    // If the object's value is a number, write it as a number.
    if (value.IsNumber())
        file.Print("%.16g", value.GetNumber());

    // Or if the object's value is a string, write it as a quoted string.
    else if (value.IsString())
    {
        luaI_addquotedbinary(file, m_state, value.GetString(), value.StrLen());
    }

    // Or if the object's value is a string, write it as a quoted string.
    else if (value.IsUString())
    {
        luaI_addquotedwidebinary(file, m_state, value.GetUString(), value.StrLen());
    }

    // Otherwise, see if the object's value is a table.
    else if (value.IsTable())
    {
        // Write the table header.
        if (indentLevel != -1)
        {
            if (indentLevel < maxIndentLevel)
            {
                file.Print("\n");
                IndentFile(file, indentSpaces);
            }
            if (writeTablePointers)
                file.Print("{ --%8x\n", lua_topointer(m_state, value));
            else
                file.Print("{");
            if (indentLevel < maxIndentLevel)
            {
                file.Print("\n");
            }
        }

        // Rename, just for ease of reading.
        LuaObject table = value;

        // upperIndex is the upper index value of a sequential numerical array
        // items.
        int upperIndex = 1;
        bool wroteSemi = false;
        bool hasSequential = false;

        // Block to search for array items.
        {
            // Pop the stack state when done.
            LuaAutoBlock block(*this);

            // Grab index 1 and index 2 of the table.
            LuaObject value1 = table.GetByIndex(1);
            LuaObject value2 = table.GetByIndex(2);

            // If they both exist, then there is a sequential list.
            if (!value1.IsNil()  &&  !value2.IsNil())
            {
                // Cycle through the list.
                bool firstSequential = true;
                for (; ; ++upperIndex)
                {
                    // Restore the stack state each iteration.
                    LuaAutoBlock block(*this);

                    // Try retrieving the table entry at upperIndex.
                    LuaObject value = table.GetByIndex(upperIndex);

                    // If it doesn't exist, then exit the loop.
                    if (value.IsNil())
                        break;

                    // Only add the comma and return if not on the first item.
                    if (!firstSequential  &&  indentLevel != -1)
                    {
                        file.Print(",");
                        if (indentLevel < maxIndentLevel)
                        {
                            file.Print("\n");
                        }
                    }
                    
                    // Write the object as an unnamed entry.
                    WriteLuaObject(file, NULL, value, indentLevel + 1, writeAll, alphabetical, writeTablePointers, maxIndentLevel);

                    // We've definitely passed the first item now.
                    firstSequential = false;
                }
            }
        }

        // Did we find any sequential table values?
        if (upperIndex > 1)
        {
            hasSequential = true;
        }
        
        if (alphabetical)
        {
            std::list<std::string> keyNames;

            // Cycle through the table.
            int i;
            PushNil();
            while ((i = Next(table)) != 0)
            {
                char keyName[255];

                // Retrieve the table entry's key and value.
                LuaObject key(this, GetTop() - 1);

                // Is the key a number?
                if (key.IsNumber())
                {
                    // Yes, were there sequential array items in this table?
                    if (hasSequential)
                    {
                        // Is the array item's key an integer?
                        float realNum = key.GetNumber();
                        int intNum = (int)realNum;
                        if (realNum == (float)intNum)
                        {
                            // Yes.  Is it between 1 and upperIndex?
                            if (intNum >= 1  &&  intNum < upperIndex)
                            {
                                // We already wrote it as part of the sequential
                                // list.
                                Pop();
                                continue;
                            }
                        }
                    }

                    // Build the table entry name for the number.
                    sprintf(keyName, "[%.16g]", key.GetNumber());
                }
                else
                {
                    // Build the table entry name for the string key name.
                    const char* ptr = key.GetString();
                    bool isAlphaNumeric = true;
                    while (*ptr)
                    {
                        if (!isalnum(*ptr)  &&  *ptr != '_')
                        {
                            isAlphaNumeric = false;
                            break;
                        }
                        ptr++;
                    }
                    if (isAlphaNumeric)
                        strcpy(keyName, key.GetString());
                    else
                        sprintf(keyName, "[\"%s\"]", key.GetString());
                }

                keyNames.push_back(keyName);

                // Go to the next item.
                Pop();
            }

            keyNames.sort();

            if (keyNames.size() > 0)
            {
                // If we wrote a sequential list, the value we're about to write
                // is not nil, and we haven't written the semicolon to separate
                // the sequential table entries from the keyed table entries...
                if (hasSequential  &&  indentLevel != -1)
                {
                    // Then add a comma (for good measure) and the semicolon.
                    file.Print(", ;");
                    if (indentLevel < maxIndentLevel)
                    {
                        file.Print("\n");
                    }
                    wroteSemi = true;
                }
            }

            for(std::list<std::string>::iterator it = keyNames.begin(); it != keyNames.end(); ++it)
            {
                LuaAutoBlock autoBlock(*this);
                const std::string& keyFullName = (*it);

                LuaObject value = table;        // Temp
                if (keyFullName[0] == '[')
                {
                    if (keyFullName[1] == '"')
                    {
                        std::string keyName = keyFullName.substr(2, keyFullName.size() - 4);
                        value = table.GetByName(keyName.c_str());
                    }
                    else
                    {
                        std::string keyName = keyFullName.substr(1, keyFullName.size() - 2);
                        int number = atoi(keyName.c_str());
                        value = table.GetByIndex(number);
                    }
                }
                else
                {
                    value = table.GetByName(keyFullName.c_str());
                }

                // Write the table entry.
                bool ret = WriteLuaObject(file, keyFullName.c_str(), value, indentLevel + 1, writeAll, alphabetical, writeTablePointers, maxIndentLevel);

                // Add a comma after the table entry.
                if (indentLevel != -1  &&  ret)
                {
                    file.Print(",");
                    if (indentLevel < maxIndentLevel)
                    {
                        file.Print("\n");
                    }
                }
            }
        }
        else
        {
            // Cycle through the table.
            int i;
            PushNil();
            while ((i = Next(table)) != 0)
            {
                char keyName[255];

                // Retrieve the table entry's key and value.
                LuaObject key(this, GetTop() - 1);
                LuaObject value(this, GetTop());

                // Is the key a number?
                if (key.IsNumber())
                {
                    // Yes, were there sequential array items in this table?
                    if (hasSequential)
                    {
                        // Is the array item's key an integer?
                        float realNum = key.GetNumber();
                        int intNum = (int)realNum;
                        if (realNum == (float)intNum)
                        {
                            // Yes.  Is it between 1 and upperIndex?
                            if (intNum >= 1  &&  intNum < upperIndex)
                            {
                                // We already wrote it as part of the sequential
                                // list.
                                Pop();
                                continue;
                            }
                        }
                    }

                    // Build the table entry name for the number.
                    sprintf(keyName, "[%.16g]", key.GetNumber());
                }
                else
                {
                    // Build the table entry name for the string key name.
                    const char* ptr = key.GetString();
                    bool isAlphaNumeric = true;
                    while (*ptr)
                    {
                        if (!isalnum(*ptr)  &&  *ptr != '_')
                        {
                            isAlphaNumeric = false;
                            break;
                        }
                        ptr++;
                    }
                    if (isAlphaNumeric)
                        strcpy(keyName, key.GetString());
                    else
                        sprintf(keyName, "[\"%s\"]", key.GetString());
                }

                // If we wrote a sequential list, the value we're about to write
                // is not nil, and we haven't written the semicolon to separate
                // the sequential table entries from the keyed table entries...
                if (hasSequential  &&  !value.IsNil()  &&  !wroteSemi)
                {
                    // Then add a comma (for good measure) and the semicolon.
                    if (indentLevel != -1)
                    {
                        file.Print(", ;");
                        if (indentLevel < maxIndentLevel)
                        {
                            file.Print("\n");
                        }
                    }
                    wroteSemi = true;
                }

                // Write the table entry.
                bool ret = WriteLuaObject(file, keyName, value, indentLevel + 1, writeAll, alphabetical, writeTablePointers, maxIndentLevel);

                // Add a comma after the table entry.
                if (ret  &&  indentLevel != -1)
                {
                    file.Print(",");
                    if (indentLevel < maxIndentLevel)
                    {
                        file.Print("\n");
                    }
                }

                // Go to the next item.
                Pop();
            }
        }

        // If we wrote a sequential list and haven't written a semicolon, then
        // there were no keyed table entries.  Just write the final comma.
        if (hasSequential  &&  !wroteSemi  &&  indentLevel != -1)
        {
            file.Print(",");
            if (indentLevel < maxIndentLevel)
            {
                file.Print("\n");
            }
        }
        
        // Indent, with the intent of closing up the table.
        IndentFile(file, indentSpaces);

        // If the indentation level is 0, then we're at the root position.
        if (indentLevel == 0)
        {
            // Add a couple extra returns for readability's sake.
            file.Print("}");
            if (indentLevel < maxIndentLevel)
            {
                file.Print("\n\n", file);
            }
        }
        else if (indentLevel > 0)
        {
            // Close the table.  The comma is written when WriteObject()
            // returns from the recursive call.
            file.Print("}");
        }
    }

    // If the indentation level is at the root, then add a return to separate
    // the lines.
    if (indentLevel == 0)
    {
        if (indentLevel < maxIndentLevel)
        {
            file.Print("\n");
        }
    }

    return true;
}


void LuaState::WriteLuaGlobalsFile(const char* filename, bool writeAll,
                                   bool alphabetical, bool writeTablePointers,
                                   unsigned int maxIndentLevel)
{
    // For safety, just in case we leave something behind on the script stack.
    LuaAutoBlock block(*this);

    WriteLuaFile(filename, NULL, GetGlobals(), -1, writeAll, alphabetical,
            writeTablePointers, maxIndentLevel);
}


void LuaState::WriteLuaFile(const char* filename, const char* name, LuaObject value,
                         int indentLevel, bool writeAll, bool alphabetical,
                         bool writeTablePointers, unsigned int maxIndentLevel)
{
    // Open the text file to write the script state to.
    LuaStateOutFile file;
    file.Open(filename);

    // For safety, just in case we leave something behind on the script stack.
    LuaAutoBlock block(*this);

    // Run through all the globals.
    WriteLuaObject(file, name, value, indentLevel, writeAll, alphabetical,
            writeTablePointers, maxIndentLevel);
}

---