static
void ParseDeclarations()
{
TToken Token;
Dump("ParseDeclarations()\n");
Token = InputGetNext();
while(Token.Type != TK_SECTION)
{
if(Token.Type == TK_LEFT || Token.Type == TK_RIGHT || Token.Type == TK_NONASSOC)
ParsePrecedence(Token);
else if(Token.Type == TK_TOKEN)
ParseToken(Token);
else if(Token.Type == TK_OPERAND)
ParseOperand(Token);
else if(Token.Type == TK_TEST)
SkipTest(Token);
else if(Token.Type == TK_START)
ParseStart(Token);
else if(Token.Type == TK_CODE)
;/*???*/
else if(Token.Type == TK_EOF)
SyntaxError(ERROR_EOF_IN_PREC, Token,
"Unexpected EOF in declaration section.\n", Token.Type);
else
SyntaxError(ERROR_BAD_TOKEN_IN_DECL, Token,
"Unexpected token [%d] in declaration section.\n", Token.Type);
Token = InputGetNext();
}
#if 0
#endif
Dump("ParseDeclarations() returns\n");
}
bool CConsole::LineIsValid(const char *pStr)
{
if(!pStr || *pStr == 0)
return false;
do
{
CResult Result;
const char *pEnd = pStr;
const char *pNextPart = 0;
int InString = 0;
while(*pEnd)
{
if(*pEnd == '"')
InString ^= 1;
else if(*pEnd == '\\') // escape sequences
{
if(pEnd[1] == '"')
pEnd++;
}
else if(!InString)
{
if(*pEnd == ';') // command separator
{
pNextPart = pEnd+1;
break;
}
else if(*pEnd == '#') // comment, no need to do anything more
break;
}
pEnd++;
}
if(ParseStart(&Result, pStr, (pEnd-pStr) + 1) != 0)
return false;
CCommand *pCommand = FindCommand(Result.m_pCommand, m_FlagMask);
if(!pCommand || ParseArgs(&Result, pCommand->m_pParams))
return false;
pStr = pNextPart;
}
while(pStr && *pStr);
return true;
}
void CConsole::ExecuteLineStroked(int Stroke, const char *pStr)
{
while(pStr && *pStr)
{
CResult Result;
const char *pEnd = pStr;
const char *pNextPart = 0;
int InString = 0;
while(*pEnd)
{
if(*pEnd == '"')
InString ^= 1;
else if(*pEnd == '\\') // escape sequences
{
if(pEnd[1] == '"')
pEnd++;
}
else if(!InString)
{
if(*pEnd == ';') // command separator
{
pNextPart = pEnd+1;
break;
}
else if(*pEnd == '#') // comment, no need to do anything more
break;
}
pEnd++;
}
if(ParseStart(&Result, pStr, (pEnd-pStr) + 1) != 0)
return;
if(!*Result.m_pCommand)
return;
CCommand *pCommand = FindCommand(Result.m_pCommand, m_FlagMask);
if(pCommand)
{
if(pCommand->GetAccessLevel() >= m_AccessLevel)
{
int IsStrokeCommand = 0;
if(Result.m_pCommand[0] == '+')
{
// insert the stroke direction token
Result.AddArgument(m_paStrokeStr[Stroke]);
IsStrokeCommand = 1;
}
if(Stroke || IsStrokeCommand)
{
if(ParseArgs(&Result, pCommand->m_pParams))
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "Invalid arguments... Usage: %s %s", pCommand->m_pName, pCommand->m_pParams);
Print(OUTPUT_LEVEL_STANDARD, "Console", aBuf);
}
else if(m_StoreCommands && pCommand->m_Flags&CFGFLAG_STORE)
{
m_ExecutionQueue.AddEntry();
m_ExecutionQueue.m_pLast->m_pfnCommandCallback = pCommand->m_pfnCallback;
m_ExecutionQueue.m_pLast->m_pCommandUserData = pCommand->m_pUserData;
m_ExecutionQueue.m_pLast->m_Result = Result;
}
else
pCommand->m_pfnCallback(&Result, pCommand->m_pUserData);
}
}
else if(Stroke)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "Access for command %s denied.", Result.m_pCommand);
Print(OUTPUT_LEVEL_STANDARD, "Console", aBuf);
}
}
else if(Stroke)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "No such command: %s.", Result.m_pCommand);
Print(OUTPUT_LEVEL_STANDARD, "Console", aBuf);
}
pStr = pNextPart;
}
}
void CConsole::ExecuteLineStroked(int Stroke, const char *_pStr)
{
/* The following feature makes it possible to execute commands on key release
making it possible to do binds such as:
bind f "cl_nameplates 1; cl_nameplates_always 1 | cl_nameplates 0; cl_nameplates_always 0"
which will show nameplates for the time of pressing the key */
const char *pStr = _pStr;
{
const char* ptr;
if(!Stroke) { // on release try to handle other part of the command
if((ptr = str_find(pStr, "|")) != NULL) {
pStr = ptr + 1;
Stroke = 1; // treat a non stroke command as a stroke one
}
}
pStr = str_skip_whitespaces((char*)pStr);
}
while(pStr && *pStr)
{
CResult *pResult = new(&m_ExecutionQueue.m_pLast->m_Result) CResult;
const char *pEnd = pStr;
const char *pNextPart = 0;
int InString = 0;
while(*pEnd)
{
if(*pEnd == '"')
InString ^= 1;
else if(*pEnd == '\\') // escape sequences
{
if(pEnd[1] == '"')
pEnd++;
}
else if(!InString)
{
if(*pEnd == ';') // command separator
{
pNextPart = pEnd+1;
break;
}
else if(*pEnd == '#') // comment, no need to do anything more
break;
else if(*pEnd == '|') // the other part of the string is handled
break; //on the begining of the function
}
pEnd++;
}
if(ParseStart(pResult, pStr, (pEnd-pStr) + 1) != 0)
return;
CCommand *pCommand = FindCommand(pResult->m_pCommand, m_FlagMask);
if(pCommand)
{
int IsStrokeCommand = 0;
if(pResult->m_pCommand[0] == '+')
{
// insert the stroke direction token
pResult->AddArgument(m_paStrokeStr[Stroke]);
IsStrokeCommand = 1;
}
if(Stroke || IsStrokeCommand)
{
if(ParseArgs(pResult, pCommand->m_pParams))
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "Invalid arguments... Usage: %s %s", pCommand->m_pName, pCommand->m_pParams);
Print(OUTPUT_LEVEL_STANDARD, "Console", aBuf);
}
else if(m_StoreCommands && pCommand->m_Flags&CFGFLAG_STORE)
{
m_ExecutionQueue.m_pLast->m_pfnCommandCallback = pCommand->m_pfnCallback;
m_ExecutionQueue.m_pLast->m_pCommandUserData = pCommand->m_pUserData;
m_ExecutionQueue.AddEntry();
}
else
pCommand->m_pfnCallback(pResult, pCommand->m_pUserData);
}
}
else if(Stroke)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "No such command: %s.", pResult->m_pCommand);
Print(OUTPUT_LEVEL_STANDARD, "Console", aBuf);
}
pStr = pNextPart;
}
}
void CConsole::ExecuteLineStroked(int Stroke, const char *pStr, int ClientID)
{
while(pStr && *pStr)
{
CResult Result;
Result.m_ClientID = ClientID;
const char *pEnd = pStr;
const char *pNextPart = 0;
int InString = 0;
while(*pEnd)
{
if(*pEnd == '"')
InString ^= 1;
else if(*pEnd == '\\') // escape sequences
{
if(pEnd[1] == '"')
pEnd++;
}
else if(!InString)
{
if(*pEnd == ';') // command separator
{
pNextPart = pEnd+1;
break;
}
else if(*pEnd == '#') // comment, no need to do anything more
break;
}
pEnd++;
}
if(ParseStart(&Result, pStr, (pEnd-pStr) + 1) != 0)
return;
if(!*Result.m_pCommand)
return;
CCommand *pCommand = FindCommand(Result.m_pCommand, m_FlagMask);
if(pCommand)
{
if(ClientID == IConsole::CLIENT_ID_GAME
&& !(pCommand->m_Flags & CFGFLAG_GAME))
{
if(Stroke)
{
char aBuf[96];
str_format(aBuf, sizeof(aBuf), "Command '%s' cannot be executed from a map.", Result.m_pCommand);
Print(OUTPUT_LEVEL_STANDARD, "console", aBuf);
}
}
else if(ClientID == IConsole::CLIENT_ID_NO_GAME
&& pCommand->m_Flags & CFGFLAG_GAME)
{
if(Stroke)
{
char aBuf[96];
str_format(aBuf, sizeof(aBuf), "Command '%s' cannot be executed from a non-map config file.", Result.m_pCommand);
Print(OUTPUT_LEVEL_STANDARD, "console", aBuf);
str_format(aBuf, sizeof(aBuf), "Hint: Put the command in '%s.cfg' instead of '%s.map.cfg' ", g_Config.m_SvMap, g_Config.m_SvMap);
Print(OUTPUT_LEVEL_STANDARD, "console", aBuf);
}
}
else if(pCommand->GetAccessLevel() >= m_AccessLevel)
{
int IsStrokeCommand = 0;
if(Result.m_pCommand[0] == '+')
{
// insert the stroke direction token
Result.AddArgument(m_paStrokeStr[Stroke]);
IsStrokeCommand = 1;
}
if(Stroke || IsStrokeCommand)
{
if(ParseArgs(&Result, pCommand->m_pParams))
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "Invalid arguments... Usage: %s %s", pCommand->m_pName, pCommand->m_pParams);
Print(OUTPUT_LEVEL_STANDARD, "console", aBuf);
}
else if(m_StoreCommands && pCommand->m_Flags&CFGFLAG_STORE)
{
m_ExecutionQueue.AddEntry();
m_ExecutionQueue.m_pLast->m_pfnCommandCallback = pCommand->m_pfnCallback;
m_ExecutionQueue.m_pLast->m_pCommandUserData = pCommand->m_pUserData;
m_ExecutionQueue.m_pLast->m_Result = Result;
}
else
{
if(Result.GetVictim() == CResult::VICTIM_ME)
Result.SetVictim(ClientID);
if(pCommand->m_Flags&CMDFLAG_TEST && !g_Config.m_SvTestingCommands)
return;
if (Result.HasVictim())
{
if(Result.GetVictim() == CResult::VICTIM_ALL)
{
for (int i = 0; i < MAX_CLIENTS; i++)
{
Result.SetVictim(i);
pCommand->m_pfnCallback(&Result, pCommand->m_pUserData);
}
}
else
pCommand->m_pfnCallback(&Result, pCommand->m_pUserData);
}
else
pCommand->m_pfnCallback(&Result, pCommand->m_pUserData);
if (pCommand->m_Flags&CMDFLAG_TEST)
m_Cheated = true;
}
}
}
else if(Stroke)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "Access for command %s denied.", Result.m_pCommand);
Print(OUTPUT_LEVEL_STANDARD, "console", aBuf);
}
}
else if(Stroke)
{
char aBuf[256];
str_format(aBuf, sizeof(aBuf), "No such command: %s.", Result.m_pCommand);
Print(OUTPUT_LEVEL_STANDARD, "console", aBuf);
}
pStr = pNextPart;
}
}
