void CLuaArguments::ReadTable ( lua_State* luaVM, int iIndexBegin, std::map < const void*, CLuaArguments* > * pKnownTables )
{
bool bKnownTablesCreated = false;
if ( !pKnownTables )
{
pKnownTables = new std::map < const void*, CLuaArguments* > ();
bKnownTablesCreated = true;
}
pKnownTables->insert ( std::make_pair ( lua_topointer(luaVM, iIndexBegin), this ) );
// Delete the previous arguments if any
DeleteArguments ();
lua_pushnil(luaVM); /* first key */
if ( iIndexBegin < 0 )
iIndexBegin--;
while (lua_next(luaVM, iIndexBegin) != 0) {
/* uses 'key' (at index -2) and 'value' (at index -1) */
CLuaArgument* pArgument = new CLuaArgument ( luaVM, -2, pKnownTables );
m_Arguments.push_back ( pArgument ); // push the key first
pArgument = new CLuaArgument ( luaVM, -1, pKnownTables );
m_Arguments.push_back ( pArgument ); // then the value
/* removes 'value'; keeps 'key' for next iteration */
lua_pop(luaVM, 1);
}
if ( bKnownTablesCreated )
delete pKnownTables;
}
void CLuaArguments::CopyRecursive ( const CLuaArguments& Arguments, std::map < CLuaArguments*, CLuaArguments* > * pKnownTables )
{
// Clear our previous list if any
DeleteArguments ();
bool bKnownTablesCreated = false;
if ( !pKnownTables )
{
pKnownTables = new std::map < CLuaArguments*, CLuaArguments* > ();
bKnownTablesCreated = true;
}
pKnownTables->insert ( std::make_pair ( (CLuaArguments *)&Arguments, (CLuaArguments *)this ) );
// Copy all the arguments
vector < CLuaArgument* > ::const_iterator iter = Arguments.m_Arguments.begin ();
for ( ; iter != Arguments.m_Arguments.end (); iter++ )
{
CLuaArgument* pArgument = new CLuaArgument ( **iter, pKnownTables );
m_Arguments.push_back ( pArgument );
}
if ( bKnownTablesCreated )
delete pKnownTables;
}
void CLuaArguments::ReadArguments ( lua_State* luaVM, unsigned int uiIndexBegin )
{
// Delete the previous arguments if any
DeleteArguments ();
// Start reading arguments until there are none left
while ( lua_type ( luaVM, uiIndexBegin ) != LUA_TNONE )
{
// Create an argument, let it read out the argument and add it to our vector
CLuaArgument* pArgument = new CLuaArgument ( luaVM, uiIndexBegin++ );
m_Arguments.push_back ( pArgument );
}
}
const CLuaArguments& CLuaArguments::operator = ( const CLuaArguments& Arguments )
{
// Clear our previous list if any
DeleteArguments ();
// Copy all the arguments
vector < CLuaArgument* > ::const_iterator iter = Arguments.m_Arguments.begin ();
for ( ; iter != Arguments.m_Arguments.end (); iter++ )
{
CLuaArgument* pArgument = new CLuaArgument ( **iter );
m_Arguments.push_back ( pArgument );
}
// Return the given reference allowing for chaining
return Arguments;
}
void CLuaArguments::ReadArguments ( lua_State* luaVM, signed int uiIndexBegin )
{
// Delete the previous arguments if any
DeleteArguments ();
std::map < const void*, CLuaArguments* > knownTables;
// Start reading arguments until there are none left
while ( lua_type ( luaVM, uiIndexBegin ) != LUA_TNONE )
{
// Create an argument, let it read out the argument and add it to our vector
CLuaArgument* pArgument = new CLuaArgument ( luaVM, uiIndexBegin++, &knownTables );
m_Arguments.push_back ( pArgument );
knownTables.clear ();
}
}
//
// ParseArguments
//
// Creates var items from command line arguments
//
void CmdParse::ParseArguments(void *context, Bool rawVar, Bool rawData)
{
U32 argCount = 0;
VarPathIdent argPath;
VarPathIdent argOffsetPath;
VNode *node;
// Reset argument count
argCount = 0;
// Delete the current scope if it exists (may exit this function via exception)
DeleteArguments();
// Store command name in first argument
MakeArgName(CmdParse::StackLevel(), argPath, argCount);
VarSys::CreateString(argPath.str, tBuf.lastToken, VarSys::DEFAULT);
MakeArgOffset(CmdParse::StackLevel(), argOffsetPath, argCount++);
VarSys::CreateInteger(argOffsetPath.str, 0);
if (rawData)
{
// Store rest of command line in second argument
MakeArgName(CmdParse::StackLevel(), argPath, argCount);
VarSys::CreateString(argPath.str, tBuf.CurrentStr());
MakeArgOffset(CmdParse::StackLevel(), argOffsetPath, argCount++);
VarSys::CreateInteger(argOffsetPath.str, argCount);
// Finished parsing
while (tBuf.NextToken() != TR_EOF) {}
}
else
{
Bool done = FALSE;
// Parse all arguments
while (!done)
{
// Save the position of this argument
U32 argPos = tBuf.CurrentPos();
// Generate argument name
MakeArgName(CmdParse::StackLevel(), argPath, argCount);
// Generate argument index name
MakeArgOffset(CmdParse::StackLevel(), argOffsetPath, argCount);
// Parse the VNode data
if ((node = StdParse::ParseAtomicVNode(&tBuf)) != NULL)
{
// Create the offset var
VarSys::CreateInteger(argOffsetPath.str, argPos);
switch (node->aType)
{
case VNode::AT_INTEGER:
VarSys::CreateInteger(argPath.str, node->GetInteger());
break;
case VNode::AT_FPOINT:
VarSys::CreateFloat(argPath.str, node->GetFPoint());
break;
case VNode::AT_STRING:
VarSys::CreateString(argPath.str, node->GetString());
break;
default:
ERR_FATAL(("Invalid node type!"));
}
// Successfully made an arg
argCount++;
// Delete the temporary VNode
delete node;
}
else
{
// Examine what we've got
switch (tBuf.PeekToken())
{
case TR_OK :
{
VarSys::VarItem *varItem;
// Create the offset var
VarSys::CreateInteger(argOffsetPath.str, argPos);
// Accept the identifier
tBuf.AcceptIdent();
// Are we in raw var mode or is this argument a var item
if (!rawVar && (varItem = VarSys::FindVarItem(tBuf.lastToken, context)) != NULL)
{
switch(varItem->type)
{
// Able to copy these types
case VarSys::VI_STRING:
case VarSys::VI_INTEGER:
case VarSys::VI_FPOINT:
VarSys::CopyVarItem(argPath.str, varItem);
break;
// Invalid item type
default:
{
// Convert single token into a string argument
VarSys::CreateString(argPath.str, tBuf.lastToken);
}
}
}
else
{
// Convert single token into a string argument
VarSys::CreateString(argPath.str, tBuf.lastToken);
}
// Successfully made an arg
argCount++;
break;
}
case TR_PUN:
switch (*tBuf.peekToken)
{
// Continue to next argument
case ',':
tBuf.AcceptPunct();
continue;
// We're finished
case ';':
done = TRUE;
break;
// Ignore brackets
case '(':
case ')':
tBuf.AcceptPunct();
continue;
default :
tBuf.TokenError("Unexpected punctuation '%c'", *tBuf.peekToken);
break;
}
case TR_EOF:
done = TRUE;
break;
default:
ERR_FATAL(("Missing case"));
break;
}
}
}
}
// Create argCount item (only created when successful)
MakeArgCount(CmdParse::StackLevel(), argPath);
VarSys::CreateInteger(argPath.str, argCount);
}
