LuaState class Reference

00438                                                              : indentLevel) * INDENT_SIZE;
00439     IndentFile(file, indentSpaces);
00440     
00441     // If the object has a name, write it out.
00442     if (name)
00443         file.Print("%s = ", name);
00444 
00445     // If the object's value is a number, write it as a number.
00446     if (value.IsNumber())
00447         file.Print("%.16g", value.GetNumber());
00448 
00449     // Or if the object's value is a string, write it as a quoted string.
00450     else if (value.IsString())
00451     {
00452         luaI_addquotedbinary(file, m_state, value.GetString(), value.StrLen());
00453     }
00454 
00455     // Or if the object's value is a string, write it as a quoted string.
00456     else if (value.IsUString())
00457     {
00458         luaI_addquotedwidebinary(file, m_state, value.GetUString(), value.StrLen());
00459     }
00460 
00461     // Otherwise, see if the object's value is a table.
00462     else if (value.IsTable())
00463     {
00464         // Write the table header.
00465         if (indentLevel != -1)
00466         {
00467             if (indentLevel < maxIndentLevel)
00468             {
00469                 file.Print("\n");
00470                 IndentFile(file, indentSpaces);
00471             }
00472             if (writeTablePointers)
00473                 file.Print("{ --%8x\n", lua_topointer(m_state, value));
00474             else
00475                 file.Print("{");
00476             if (indentLevel < maxIndentLevel)
00477             {
00478                 file.Print("\n");
00479             }
00480         }
00481 
00482         // Rename, just for ease of reading.
00483         LuaObject table = value;
00484 
00485         // upperIndex is the upper index value of a sequential numerical array
00486         // items.
00487         int upperIndex = 1;
00488         bool wroteSemi = false;
00489         bool hasSequential = false;
00490 
00491         // Block to search for array items.
00492         {
00493             // Pop the stack state when done.
00494             LuaAutoBlock block(*this);
00495 
00496             // Grab index 1 and index 2 of the table.
00497             LuaObject value1 = table.GetByIndex(1);
00498             LuaObject value2 = table.GetByIndex(2);
00499 
00500             // If they both exist, then there is a sequential list.
00501             if (!value1.IsNil()  &&  !value2.IsNil())
00502             {
00503                 // Cycle through the list.
00504                 bool firstSequential = true;
00505                 for (; ; ++upperIndex)
00506                 {
00507                     // Restore the stack state each iteration.
00508                     LuaAutoBlock block(*this);
00509 
00510                     // Try retrieving the table entry at upperIndex.
00511                     LuaObject value = table.GetByIndex(upperIndex);
00512 
00513                     // If it doesn't exist, then exit the loop.
00514                     if (value.IsNil())
00515                         break;
00516 
00517                     // Only add the comma and return if not on the first item.
00518                     if (!firstSequential  &&  indentLevel != -1)
00519                     {
00520                         file.Print(",");
00521                         if (indentLevel < maxIndentLevel)
00522                         {
00523                             file.Print("\n");
00524                         }
00525                     }
00526                     
00527                     // Write the object as an unnamed entry.
00528                     WriteLuaObject(file, NULL, value, indentLevel + 1, writeAll, alphabetical, writeTablePointers, maxIndentLevel);
00529 
00530                     // We've definitely passed the first item now.
00531                     firstSequential = false;
00532                 }
00533             }
00534         }
00535 
00536         // Did we find any sequential table values?
00537         if (upperIndex > 1)
00538         {
00539             hasSequential = true;
00540         }
00541         
00542         if (alphabetical)
00543         {
00544             std::list<std::string> keyNames;
00545 
00546             // Cycle through the table.
00547             int i;
00548             PushNil();
00549             while ((i = Next(table)) != 0)
00550             {
00551                 char keyName[255];
00552 
00553                 // Retrieve the table entry's key and value.
00554                 LuaObject key(this, GetTop() - 1);
00555 
00556                 // Is the key a number?
00557                 if (key.IsNumber())
00558                 {
00559                     // Yes, were there sequential array items in this table?
00560                     if (hasSequential)
00561                     {
00562                         // Is the array item's key an integer?
00563                         float realNum = key.GetNumber();
00564                         int intNum = (int)realNum;
00565                         if (realNum == (float)intNum)
00566                         {
00567                             // Yes.  Is it between 1 and upperIndex?
00568                             if (intNum >= 1  &&  intNum < upperIndex)
00569                             {
00570                                 // We already wrote it as part of the sequential
00571                                 // list.
00572                                 Pop();
00573                                 continue;
00574                             }
00575                         }
00576                     }
00577 
00578                     // Build the table entry name for the number.
00579                     sprintf(keyName, "[%.16g]", key.GetNumber());
00580                 }
00581                 else
00582                 {
00583                     // Build the table entry name for the string key name.
00584                     const char* ptr = key.GetString();
00585                     bool isAlphaNumeric = true;
00586                     while (*ptr)
00587                     {
00588                         if (!isalnum(*ptr)  &&  *ptr != '_')
00589                         {
00590                             isAlphaNumeric = false;
00591                             break;
00592                         }
00593                         ptr++;
00594                     }
00595                     if (isAlphaNumeric)
00596                         strcpy(keyName, key.GetString());
00597                     else
00598                         sprintf(keyName, "[\"%s\"]", key.GetString());
00599                 }
00600 
00601                 keyNames.push_back(keyName);
00602 
00603                 // Go to the next item.
00604                 Pop();
00605             }
00606 
00607             keyNames.sort();
00608 
00609             if (keyNames.size() > 0)
00610             {
00611                 // If we wrote a sequential list, the value we're about to write
00612                 // is not nil, and we haven't written the semicolon to separate
00613                 // the sequential table entries from the keyed table entries...
00614                 if (hasSequential  &&  indentLevel != -1)
00615                 {
00616                     // Then add a comma (for good measure) and the semicolon.
00617                     file.Print(", ;");
00618                     if (indentLevel < maxIndentLevel)
00619                     {
00620                         file.Print("\n");
00621                     }
00622                     wroteSemi = true;
00623                 }
00624             }
00625 
00626             for(std::list<std::string>::iterator it = keyNames.begin(); it != keyNames.end(); ++it)
00627             {
00628                 LuaAutoBlock autoBlock(*this);
00629                 const std::string& keyFullName = (*it);
00630 
00631                 LuaObject value = table;        // Temp
00632                 if (keyFullName[0] == '[')
00633                 {
00634                     if (keyFullName[1] == '"')
00635                     {
00636                         std::string keyName = keyFullName.substr(2, keyFullName.size() - 4);
00637                         value = table.GetByName(keyName.c_str());
00638                     }
00639                     else
00640                     {
00641                         std::string keyName = keyFullName.substr(1, keyFullName.size() - 2);
00642                         int number = atoi(keyName.c_str());
00643                         value = table.GetByIndex(number);
00644                     }
00645                 }
00646                 else
00647                 {
00648                     value = table.GetByName(keyFullName.c_str());
00649                 }
00650 
00651                 // Write the table entry.
00652                 bool ret = WriteLuaObject(file, keyFullName.c_str(), value, indentLevel + 1, writeAll, alphabetical, writeTablePointers, maxIndentLevel);
00653 
00654                 // Add a comma after the table entry.
00655                 if (indentLevel != -1  &&  ret)
00656                 {
00657                     file.Print(",");
00658                     if (indentLevel < maxIndentLevel)
00659                     {
00660                         file.Print("\n");
00661                     }
00662                 }
00663             }
00664         }
00665         else
00666         {
00667             // Cycle through the table.
00668             int i;
00669             PushNil();
00670             while ((i = Next(table)) != 0)
00671             {
00672                 char keyName[255];
00673 
00674                 // Retrieve the table entry's key and value.
00675                 LuaObject key(this, GetTop() - 1);
00676                 LuaObject value(this, GetTop());
00677 
00678                 // Is the key a number?
00679                 if (key.IsNumber())
00680                 {
00681                     // Yes, were there sequential array items in this table?
00682                     if (hasSequential)
00683                     {
00684                         // Is the array item's key an integer?
00685                         float realNum = key.GetNumber();
00686                         int intNum = (int)realNum;
00687                         if (realNum == (float)intNum)
00688                         {
00689                             // Yes.  Is it between 1 and upperIndex?
00690                             if (intNum >= 1  &&  intNum < upperIndex)
00691                             {
00692                                 // We already wrote it as part of the sequential
00693                                 // list.
00694                                 Pop();
00695                                 continue;
00696                             }
00697                         }
00698                     }
00699 
00700                     // Build the table entry name for the number.
00701                     sprintf(keyName, "[%.16g]", key.GetNumber());
00702                 }
00703                 else
00704                 {
00705                     // Build the table entry name for the string key name.
00706                     const char* ptr = key.GetString();
00707                     bool isAlphaNumeric = true;
00708                     while (*ptr)
00709                     {
00710                         if (!isalnum(*ptr)  &&  *ptr != '_')
00711                         {
00712                             isAlphaNumeric = false;
00713                             break;
00714                         }
00715                         ptr++;
00716                     }
00717                     if (isAlphaNumeric)
00718                         strcpy(keyName, key.GetString());
00719                     else
00720                         sprintf(keyName, "[\"%s\"]", key.GetString());
00721                 }
00722 
00723                 // If we wrote a sequential list, the value we're about to write
00724                 // is not nil, and we haven't written the semicolon to separate
00725                 // the sequential table entries from the keyed table entries...
00726                 if (hasSequential  &&  !value.IsNil()  &&  !wroteSemi)
00727                 {
00728                     // Then add a comma (for good measure) and the semicolon.
00729                     if (indentLevel != -1)
00730                     {
00731                         file.Print(", ;");
00732                         if (indentLevel < maxIndentLevel)
00733                         {
00734                             file.Print("\n");
00735                         }
00736                     }
00737                     wroteSemi = true;
00738                 }
00739 
00740                 // Write the table entry.
00741                 bool ret = WriteLuaObject(file, keyName, value, indentLevel + 1, writeAll, alphabetical, writeTablePointers, maxIndentLevel);
00742 
00743                 // Add a comma after the table entry.
00744                 if (ret  &&  indentLevel != -1)
00745                 {
00746                     file.Print(",");
00747                     if (indentLevel < maxIndentLevel)
00748                     {
00749                         file.Print("\n");
00750                     }
00751                 }
00752 
00753                 // Go to the next item.
00754                 Pop();
00755             }
00756         }
00757 
00758         // If we wrote a sequential list and haven't written a semicolon, then
00759         // there were no keyed table entries.  Just write the final comma.
00760         if (hasSequential  &&  !wroteSemi  &&  indentLevel != -1)
00761         {
00762             file.Print(",");
00763             if (indentLevel < maxIndentLevel)
00764             {
00765                 file.Print("\n");
00766             }
00767         }
00768         
00769         // Indent, with the intent of closing up the table.
00770         IndentFile(file, indentSpaces);
00771 
00772         // If the indentation level is 0, then we're at the root position.
00773         if (indentLevel == 0)
00774         {
00775             // Add a couple extra returns for readability's sake.
00776             file.Print("}");
00777             if (indentLevel < maxIndentLevel)
00778             {
00779                 file.Print("\n\n", file);
00780             }
00781         }
00782         else if (indentLevel > 0)
00783         {
00784             // Close the table.  The comma is written when WriteObject()
00785             // returns from the recursive call.
00786             file.Print("}");
00787         }
00788     }
00789 
00790     // If the indentation level is at the root, then add a return to separate
00791     // the lines.
00792     if (indentLevel == 0)
00793     {
00794         if (indentLevel < maxIndentLevel)
00795         {
00796             file.Print("\n");
00797         }
00798     }
00799 
00800     return true;
00801 }
00802 
00803 
00807 void LuaState::WriteLuaGlobalsFile(const char* filename, bool writeAll,
00808                                    bool alphabetical, bool writeTablePointers,
00809                                    unsigned int maxIndentLevel)
00810 {
00811     // For safety, just in case we leave something behind on the script stack.
00812     LuaAutoBlock block(*this);
00813 
00814     WriteLuaFile(filename, NULL, GetGlobals(), -1, writeAll, alphabetical,
00815             writeTablePointers, maxIndentLevel);
00816 }
00817 
00818 
00822 void LuaState::WriteLuaFile(const char* filename, const char* name, LuaObject value,
00823                          int indentLevel, bool writeAll, bool alphabetical,
00824                          bool writeTablePointers, unsigned int maxIndentLevel)
00825 {
00826     // Open the text file to write the script state to.
00827     LuaStateOutFile file;
00828     file.Open(filename);
00829

Public Types
enum	{ NOREF = LUA_NOREF }
enum	{ REFNIL = LUA_REFNIL }
Public Methods
	LuaState (lua_State *state)
	~LuaState ()
LuaObject	GetMethods (int index)
LuaObject	GetDefaultMethods (int type)
void	SetMethods (int index)
int	GetTop ()
void	SetTop (int index)
void	PushValue (int index)
void	PushValue (LuaObject object)
void	RemoveStack (int index)
void	InsertStack (int index)
int	StackSpace ()
const lua_char *	Type (int index)
int	IsNumber (int index)
int	IsString (int index)
int	IsUString (int index)
int	IsCFunction (int index)
bool	IsFunction (int index)
bool	IsTable (int index)
bool	IsUserData (int index)
bool	IsNil (int index)
bool	IsNull (int index)
bool	IsPointer (int index) const
int	Tag (int index)
int	RawTag (int index)
int	Equal (int index1, int index2)
int	LessThan (int index1, int index2)
lua_Number	ToNumber (int index)
int	ToInteger (int index)
const lua_char *	ToString (int index)
const wchar_t *	ToUString (int index)
size_t	StrLen (int index)
lua_CFunction	ToCFunction (int index)
void *	ToUserData (int index)
const void *	ToPointer (int index)
const void *	ToLuaPointer (int index)
void	PushBool (bool value)
void	PushNil ()
void	PushNumber (double n)
void	PushLString (const char *s, size_t len)
void	PushString (const char *s)
void	PushLUString (const wchar_t *s, size_t len)
void	PushUString (const wchar_t *s)
void	PushCClosure (lua_CFunction fn, int n)
void	PushCClosure (LuaStateCFunction fn, int n)
void	PushPointer (const void *p)
LuaObject	GetGlobal (const char *name)
void	GetTable (int index)
void	RawGet (int index)
void	RawGetI (int index, int n)
LuaObject	GetGlobals ()
void	GetTagMethod (int tag, const char *event)
LuaObject	GetRef (int ref)
LuaObject	NewTable (int size=0)
void	GetRegistry ()
void	GetWeakRegistry ()
void	SetGlobal (const char *name)
void	SetTable (int index)
void	RawSet (int index)
void	RawSetI (int index, int n)
void	SetGlobals ()
void	SetTagMethod (int tag, const char *event)
int	Ref (int lock)
int	Call (int nargs, int nresults)
void	RawCall (int nargs, int nresults)
int	LoadFile (const lua_char *filename)
int	DoFile (const char *filename)
int	DoString (const char *str)
int	LoadBuffer (const lua_char buff, size_t size, const lua_char name)
int	DoBuffer (const char buff, size_t size, const char name)
int	GetGCThreshold ()
int	GetGCCount ()
void	SetGCThreshold (int newthreshold)
int	NewType (const lua_char *name, int basictype)
int	CopyTagMethods (int tagto, int tagfrom)
void	SetTag (int tag)
int	Name2Tag (const lua_char *name)
const lua_char *	Tag2Name (int tag)
void	Error (const lua_char *errorStr)
void	Unref (int ref)
int	Next (int index)
int	GetN (int index)
void	Concat (int n)
void	PushUserData (void *u)
void *	NewUserData (size_t size)
void	NewUserDataBox (void *u)
void	SetWeakMode (int mode)
int	GetWeakMode (int index)
void	Pop ()
void	Pop (int amount)
void	Register (const char *funcName, lua_CFunction function)
void	Register (const char *funcName, LuaStateCFunction function)
void	Unregister (const char *funcName)
void	Register (const LuaFunctionList *functionList)
void	Unregister (const LuaFunctionList *functionList)
void	PushCFunction (lua_CFunction f)
void	PushCFunction (LuaStateCFunction f)
int	CloneTag (int t)
void	CollectGarbage ()
void	SetNilGCMethod (LuaStateCFunction f)
int	ConfigGetInteger (const char section, const char entry, int defaultValue=0)
float	ConfigGetReal (const char section, const char entry, double defaultValue=0.0)
const char *	ConfigGetString (const char section, const char entry, const char *defaultValue="")
void	ConfigSetInteger (const char section, const char entry, int value)
void	ConfigSetReal (const char section, const char entry, double value)
void	ConfigSetString (const char section, const char entry, const char *value)
void	WriteLuaGlobalsFile (const char *filename, bool writeAll=false, bool alphabetical=false, bool writeTablePointers=false, unsigned int maxIndentLevel=0xffffffff)
void	WriteLuaFile (const char filename, const char name, LuaObject value, int indentLevel, bool writeAll=false, bool alphabetical=false, bool writeTablePointers=false, unsigned int maxIndentLevel=0xffffffff)
bool	WriteLuaObject (LuaStateOutFile &file, const char *name, LuaObject value, int indentLevel, bool writeAll=false, bool alphabetical=false, bool writeTablePointers=false, unsigned int maxIndentLevel=0xffffffff)
bool	WriteLuaObject (FILE file, const char name, LuaObject value, int indentLevel, bool writeAll=false, bool alphabetical=false, bool writeTablePointers=false, unsigned int maxIndentLevel=0xffffffff)
	operator lua_State * ()
Public Attributes
lua_State *	m_state
Protected Methods
	LuaState ()

LuaState Class Reference

Public Types

Public Methods

Public Attributes

Protected Methods

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation