/*
============
Cmd_List_f
============
*/
void Cmd_List_f(void)
{
cmd_function_t *cmd;
int i = 0;
char *match;
if (Cmd_Argc() > 1)
{
match = Cmd_Argv(1);
}
else
{
match = NULL;
}
for (cmd = cmd_functions ; cmd ; cmd = cmd->next)
{
if (match && !Com_Filter(match, cmd->name, qfalse))
{
continue;
}
Com_Printf("%s\n", cmd->name);
i++;
}
Com_Printf("%i commands\n", i);
}
/**
* @brief Opens the directory and returns the first file that matches our searchrules
* @sa Sys_FindNext
* @sa Sys_FindClose
*/
char *Sys_FindFirst (const char *path, unsigned musthave, unsigned canhave)
{
struct dirent *d;
char *p;
if (fdir)
Sys_Error("Sys_BeginFind without close");
Q_strncpyz(findbase, path, sizeof(findbase));
if ((p = strrchr(findbase, '/')) != NULL) {
*p = 0;
Q_strncpyz(findpattern, p + 1, sizeof(findpattern));
} else
Q_strncpyz(findpattern, "*", sizeof(findpattern));
if (Q_streq(findpattern, "*.*"))
Q_strncpyz(findpattern, "*", sizeof(findpattern));
if ((fdir = opendir(findbase)) == NULL)
return NULL;
while ((d = readdir(fdir)) != NULL) {
if (!*findpattern || Com_Filter(findpattern, d->d_name)) {
if (CompareAttributes(findbase, d->d_name, musthave, canhave)) {
Com_sprintf(findpath, sizeof(findpath), "%s/%s", findbase, d->d_name);
return findpath;
}
}
}
return NULL;
}
/*
============
Cmd_List_f
============
*/
void Cmd_List_f (void)
{
cmd_function_t *cmd = NULL;
int i, j;
char *match = NULL;
if ( Cmd_Argc() > 1 ) {
match = Cmd_Argv( 1 );
}
for ( cmd=cmd_functions, i=0, j=0;
cmd;
cmd=cmd->next, i++ )
{
if ( !cmd->name || (match && !Com_Filter( match, cmd->name, qfalse )) )
continue;
Com_Printf (" %s\n", cmd->name);
j++;
}
Com_Printf ("\n%i total commands\n", i);
if ( i != j )
Com_Printf( "%i matching commands\n", j );
}
/*
============
Cvar_List_f
============
*/
void Cvar_List_f( void ) {
cvar_t *var = NULL;
int i = 0;
char *match = NULL;
if ( Cmd_Argc() > 1 )
match = Cmd_Argv( 1 );
for ( var=cvar_vars, i=0;
var;
var=var->next, i++ )
{
if ( !var->name || (match && !Com_Filter( match, var->name, qfalse )) )
continue;
if (var->flags & CVAR_SERVERINFO) Com_Printf( "S" ); else Com_Printf( " " );
if (var->flags & CVAR_SYSTEMINFO) Com_Printf( "s" ); else Com_Printf( " " );
if (var->flags & CVAR_USERINFO) Com_Printf( "U" ); else Com_Printf( " " );
if (var->flags & CVAR_ROM) Com_Printf( "R" ); else Com_Printf( " " );
if (var->flags & CVAR_INIT) Com_Printf( "I" ); else Com_Printf( " " );
if (var->flags & CVAR_ARCHIVE) Com_Printf( "A" ); else Com_Printf( " " );
if (var->flags & CVAR_LATCH) Com_Printf( "L" ); else Com_Printf( " " );
if (var->flags & CVAR_CHEAT) Com_Printf( "C" ); else Com_Printf( " " );
if (var->flags & CVAR_USER_CREATED) Com_Printf( "?" ); else Com_Printf( " " );
Com_Printf( S_COLOR_WHITE " %s = " S_COLOR_GREY "\"" S_COLOR_WHITE "%s" S_COLOR_GREY "\"" S_COLOR_WHITE, var->name, var->string );
if ( var->latchedString )
Com_Printf( ", latched = " S_COLOR_GREY "\"" S_COLOR_WHITE "%s" S_COLOR_GREY "\"" S_COLOR_WHITE, var->latchedString );
Com_Printf( "\n" );
}
Com_Printf( "\n%i total cvars\n", i );
if ( i != cvar_numIndexes )
Com_Printf( "%i cvar indexes\n", cvar_numIndexes );
}
/*
============
Cmd_List_f
============
*/
static void Cmd_List_f( void ) {
cmd_function_t *cmd;
int i;
char *match;
if ( Cmd_Argc() > 1 ) {
match = Cmd_Argv( 1 );
} else {
match = NULL;
}
i = 0;
for ( cmd = cmd_functions ; cmd ; cmd = cmd->next ) {
if ( (match && !Com_Filter( match, (char*)cmd->name, qfalse ))
|| Cmd_GetInvokerPower() < cmd->minPower || ((cmd->minPower == 0) && Cmd_GetInvokerPower() != 100))
{
if(!Auth_CanPlayerUseCommand(Cmd_GetInvokerClnum(), (char*)cmd->name))
{
continue;
}
}
Com_Printf( "%s\n", cmd->name );
i++;
}
Com_Printf( "%i commands\n", i );
}
/*
============
Com_FilterPath
============
*/
int Com_FilterPath(const char *filter, const char *name, int casesensitive)
{
int i;
char new_filter[MAX_QPATH];
char new_name[MAX_QPATH];
for (i = 0; i < MAX_QPATH-1 && filter[i]; i++) {
if ( filter[i] == '\\' || filter[i] == ':' ) {
new_filter[i] = '/';
}
else {
new_filter[i] = filter[i];
}
}
new_filter[i] = '\0';
for (i = 0; i < MAX_QPATH-1 && name[i]; i++) {
if ( name[i] == '\\' || name[i] == ':' ) {
new_name[i] = '/';
}
else {
new_name[i] = name[i];
}
}
new_name[i] = '\0';
return Com_Filter(new_filter, new_name, casesensitive);
}
/*
============
Cvar_List_f
============
*/
void Cvar_List_f( void ) {
cvar_t *var;
int i;
char *match;
if ( Cmd_Argc() > 1 ) {
match = Cmd_Argv( 1 );
} else {
match = NULL;
}
i = 0;
for (var = cvar_vars ; var ; var = var->next, i++)
{
if (match && !Com_Filter(match, var->name, qfalse)) continue;
if (var->flags & CVAR_SERVERINFO) {
Com_Printf("S");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_USERINFO) {
Com_Printf("U");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_ROM) {
Com_Printf("R");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_INIT) {
Com_Printf("I");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_ARCHIVE) {
Com_Printf("A");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_LATCH) {
Com_Printf("L");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_CHEAT) {
Com_Printf("C");
} else {
Com_Printf(" ");
}
Com_Printf (" %s \"%s\"\n", var->name, var->string);
}
Com_Printf ("\n%i total cvars\n", i);
Com_Printf ("%i cvar indexes\n", cvar_numIndexes);
}
void Svcmd_EntityList_f()
{
int entityNum;
int i;
int currentEntityCount;
gentity_t *displayedEntity;
char* filter;
displayedEntity = g_entities;
if(trap_Argc() > 1)
{
filter = ConcatArgs( 1 );
}
else
{
filter = nullptr;
}
for ( entityNum = 0, currentEntityCount = 0; entityNum < level.num_entities; entityNum++, displayedEntity++ )
{
if ( !displayedEntity->inuse )
{
continue;
}
currentEntityCount++;
if(filter && !Com_Filter(filter, displayedEntity->classname, false) )
{
for (i = 0; i < MAX_ENTITY_ALIASES && displayedEntity->names[i]; ++i)
{
if( Com_Filter(filter, displayedEntity->names[i], false) )
{
PrintEntityOverviewLine( displayedEntity );
break;
}
}
continue;
}
PrintEntityOverviewLine( displayedEntity );
}
G_Printf( "A total of %i entities are currently in use.\n", currentEntityCount);
}
static void Cmd_List_f()
{
const char* match = (Cmd_Argc() > 1) ? Cmd_Argv(1) : NULL;
int i = 0;
for (const cmd_function_t* cmd = cmd_functions; cmd; cmd = cmd->next) {
if (match && !Com_Filter(match, cmd->name))
continue;
Com_Printf( "%s\n", cmd->name );
++i;
}
Com_Printf( "%i commands\n", i );
}
/**
* @brief Returns the next file of the already opened directory (Sys_FindFirst) that matches our search mask
* @sa Sys_FindClose
* @sa Sys_FindFirst
* @sa static var findpattern
*/
char *Sys_FindNext (unsigned musthave, unsigned canhave)
{
struct dirent *d;
if (fdir == NULL)
return NULL;
while ((d = readdir(fdir)) != NULL) {
if (!*findpattern || Com_Filter(findpattern, d->d_name)) {
if (CompareAttributes(findbase, d->d_name, musthave, canhave)) {
Com_sprintf(findpath, sizeof(findpath), "%s/%s", findbase, d->d_name);
return findpath;
}
}
}
return NULL;
}
/*
============
Cmd_AliasList_f
============
*/
void Cmd_AliasList_f (void)
{
cmd_alias_t *alias;
int i;
char *match;
if (Cmd_Argc() > 1)
match = Cmd_Argv( 1 );
else
match = NULL;
i = 0;
for (alias = cmd_aliases; alias; alias = alias->next)
{
if (match && !Com_Filter(match, alias->name, false))
continue;
Com_Printf ("%s ==> %s\n", alias->name, alias->exec);
i++;
}
Com_Printf ("%i aliases\n", i);
}
void Sys_ListFilteredFiles (const char *basedir, const char *subdirs, const char *filter, linkedList_t **list)
{
char search[MAX_OSPATH], newsubdirs[MAX_OSPATH];
char filename[MAX_OSPATH];
DIR *directory;
struct dirent *d;
struct stat st;
if (subdirs[0] != '\0') {
Com_sprintf(search, sizeof(search), "%s/%s", basedir, subdirs);
} else {
Com_sprintf(search, sizeof(search), "%s", basedir);
}
if ((directory = opendir(search)) == NULL)
return;
while ((d = readdir(directory)) != NULL) {
Com_sprintf(filename, sizeof(filename), "%s/%s", search, d->d_name);
if (stat(filename, &st) == -1)
continue;
if (st.st_mode & S_IFDIR) {
if (Q_strcasecmp(d->d_name, ".") && Q_strcasecmp(d->d_name, "..")) {
if (subdirs[0] != '\0') {
Com_sprintf(newsubdirs, sizeof(newsubdirs), "%s/%s", subdirs, d->d_name);
} else {
Com_sprintf(newsubdirs, sizeof(newsubdirs), "%s", d->d_name);
}
Sys_ListFilteredFiles(basedir, newsubdirs, filter, list);
}
}
Com_sprintf(filename, sizeof(filename), "%s/%s", subdirs, d->d_name);
if (!Com_Filter(filter, filename))
continue;
LIST_AddString(list, filename);
}
closedir(directory);
}
static void Cmd_ListPower_f() {
cmd_function_t *cmd;
int i, hidden, j, l;
char *match;
if ( Cmd_Argc() > 1 ) {
match = Cmd_Argv( 1 );
} else {
match = NULL;
}
i = 0;
hidden = 0;
for ( cmd = cmd_functions ; cmd ; cmd = cmd->next ) {
if ( (match && !Com_Filter( match, (char*)cmd->name, qfalse ))) {
continue;
}
if(cmd->minPower == 100 || cmd->minPower == 0){
hidden++;
continue;
}
Com_Printf ("%s", cmd->name );
l = 24 - strlen(cmd->name);
j = 0;
do
{
Com_Printf (" ");
j++;
} while(j < l);
Com_Printf( "%d\n", cmd->minPower );
i++;
}
Com_Printf( "\n%i commands with specified power settings are shown\n", i );
Com_Printf( "%i commands are hidden because the required power level for those commands is set to 100 or 0\n", hidden );
Com_Printf( "Type cmdlist to get a complete list of all commands\n");
}
/*
============
Cmd_List_f
============
*/
void Cmd_List_f (void)
{
cmd_function_t *cmd;
int i;
char *match;
if ( Cmd_Argc() > 1 ) {
match = Cmd_Argv( 1 );
} else {
match = NULL;
}
i = 0;
for ( int c = 0; c < CMD_MAX_NUM; ++c )
{
cmd = cmd_functions + c;
if (match && !Com_Filter(match, cmd->name, qfalse)) continue;
Com_Printf ("%s\n", cmd->name);
i++;
}
Com_Printf ("%i commands\n", i);
}
void Sys_ListFilteredFiles (const char* basedir, const char* subdirs, const char* filter, linkedList_t** list)
{
char search[MAX_OSPATH], newsubdirs[MAX_OSPATH];
char filename[MAX_OSPATH];
int findhandle;
struct _wfinddata_t findinfo;
if (subdirs[0] != '\0') {
Com_sprintf(search, sizeof(search), "%s\\%s\\*", basedir, subdirs);
} else {
Com_sprintf(search, sizeof(search), "%s\\*", basedir);
}
Sys_Utf8ToUtf16(search, wfindpath, lengthof(wfindpath));
findhandle = _wfindfirst(wfindpath, &findinfo);
if (findhandle == -1)
return;
do {
Sys_Utf16ToUtf8(findinfo.name, findname, sizeof(findname));
if (findinfo.attrib & _A_SUBDIR) {
if (Q_strcasecmp(findname, ".") && Q_strcasecmp(findname, "..")) {
if (subdirs[0] != '\0') {
Com_sprintf(newsubdirs, sizeof(newsubdirs), "%s\\%s", subdirs, findname);
} else {
Com_sprintf(newsubdirs, sizeof(newsubdirs), "%s", findname);
}
Sys_ListFilteredFiles(basedir, newsubdirs, filter, list);
}
}
Com_sprintf(filename, sizeof(filename), "%s\\%s", subdirs, findname);
if (!Com_Filter(filter, filename))
continue;
LIST_AddString(list, filename);
} while (_wfindnext(findhandle, &findinfo) != -1);
_findclose(findhandle);
}
/**
* @brief Like Com_Filter, but match PATTERN against any final segment of TEXT.
*/
static int Com_FilterAfterStar (const char* pattern, const char* text)
{
register const char* p = pattern, *t = text;
register char c, c1;
while ((c = *p++) == '?' || c == '*')
if (c == '?' && *t++ == '\0')
return 0;
if (c == '\0')
return 1;
if (c == '\\')
c1 = *p;
else
c1 = c;
while (1) {
if ((c == '[' || *t == c1) && Com_Filter(p - 1, t))
return 1;
if (*t++ == '\0')
return 0;
}
}
static void Cvar_List_f( void )
{
const char* match = (Cmd_Argc() > 1) ? Cmd_Argv(1) : NULL;
int i = 0;
for (const cvar_t* var = cvar_vars; var; var = var->next, ++i)
{
if (match && !Com_Filter(match, var->name))
continue;
Com_Printf( (var->flags & CVAR_SERVERINFO) ? "S" : " " );
Com_Printf( (var->flags & CVAR_USERINFO) ? "U" : " " );
Com_Printf( (var->flags & CVAR_ROM) ? "R" : " " );
Com_Printf( (var->flags & CVAR_INIT) ? "I" : " " );
Com_Printf( (var->flags & CVAR_ARCHIVE) ? "A" : " " );
Com_Printf( (var->flags & CVAR_LATCH) ? "L" : " " );
Com_Printf( (var->flags & CVAR_CHEAT) ? "C" : " " );
Com_Printf(" %s \"%s\"\n", var->name, var->string);
}
Com_Printf("\n%i total cvars\n", i);
Com_Printf("%i cvar indexes\n", cvar_numIndexes);
}
/*
============
Cvar_ListModified_f
============
*/
void Cvar_ListModified_f( void ) {
cvar_t *var;
int totalModified;
char *value;
char *match;
if ( Cmd_Argc() > 1 ) {
match = Cmd_Argv( 1 );
} else {
match = NULL;
}
totalModified = 0;
for (var = cvar_vars ; var ; var = var->next)
{
if ( !var->name || !var->modificationCount )
continue;
value = var->latchedString ? var->latchedString : var->string;
if ( !strcmp( value, var->resetString ) )
continue;
totalModified++;
if (match && !Com_Filter(match, var->name, qfalse))
continue;
if (var->flags & CVAR_SERVERINFO) {
Com_Printf("S");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_SYSTEMINFO) {
Com_Printf("s");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_USERINFO) {
Com_Printf("U");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_ROM) {
Com_Printf("R");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_INIT) {
Com_Printf("I");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_ARCHIVE) {
Com_Printf("A");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_LATCH) {
Com_Printf("L");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_CHEAT) {
Com_Printf("C");
} else {
Com_Printf(" ");
}
if (var->flags & CVAR_USER_CREATED) {
Com_Printf("?");
} else {
Com_Printf(" ");
}
Com_Printf (" %s \"%s\", default \"%s\"\n", var->name, value, var->resetString);
}
Com_Printf ("\n%i total modified cvars\n", totalModified);
}
/*
============
Cvar_List_f
============
*/
void Cvar_List_f( void )
{
cvar_t *var;
int i = 0;
char *match = NULL;
qboolean raw = qfalse;
if ( Cmd_Argc() > 1 )
{
match = Cmd_Argv( 1 );
if ( !Q_stricmp( match, "-raw" ) )
{
raw = qtrue;
match = ( Cmd_Argc() > 2 ) ? Cmd_Argv( 2 ) : NULL;
}
}
for ( var = cvar_vars; var; var = var->next, i++ )
{
if ( match && !Com_Filter( match, var->name, qfalse ) )
{
continue;
}
if ( var->flags & CVAR_SERVERINFO )
{
Com_Printf( "S" );
}
else
{
Com_Printf( " " );
}
if ( var->flags & CVAR_SYSTEMINFO )
{
Com_Printf( "s" );
}
else
{
Com_Printf( " " );
}
if ( var->flags & CVAR_USERINFO )
{
Com_Printf( "U" );
}
else
{
Com_Printf( " " );
}
if ( var->flags & CVAR_ROM )
{
Com_Printf( "R" );
}
else
{
Com_Printf( " " );
}
if ( var->flags & CVAR_INIT )
{
Com_Printf( "I" );
}
else
{
Com_Printf( " " );
}
if ( var->flags & CVAR_ARCHIVE )
{
Com_Printf( "A" );
}
else
{
Com_Printf( " " );
}
if ( var->flags & CVAR_LATCH )
{
Com_Printf( "L" );
}
else
{
Com_Printf( " " );
}
if ( var->flags & CVAR_CHEAT )
{
Com_Printf( "C" );
}
else
{
Com_Printf( " " );
}
if ( var->flags & CVAR_USER_CREATED )
{
Com_Printf( "?" );
}
else
{
Com_Printf( " " );
}
if ( var->transient )
{
Com_Printf( "T" );
}
else
{
Com_Printf( " " );
}
if ( raw )
{
char *index;
Com_Printf( " %s \"", var->name );
for ( index = var->string; ; )
{
char *hat = strchr( index, '^' );
if ( !hat ) break;
Com_Printf( "%.*s", (int)( hat + 1 - index ), index );
index = hat + 1;
}
Com_Printf( "%s\"\n", index );
}
else
{
Com_Printf( " %s \"%s\"\n", var->name, var->string );
}
}
Com_Printf( "\n%i total cvars\n", i );
Com_Printf( "%i cvar indexes\n", cvar_numIndexes );
}
cellInfo_t sql_eval( sqlInfo_t *db, Expr expr, tableInfo_t * table, cellInfo_t * row, int index, int total, sqlData_t * params, cellInfo_t * aggregate )
{
value_t stack[ 64 ];
int sp;
int i;
static char buffer[ 16384 ]; // FIX ME: this is the source of bugs
static int size = 0;
int top = size;
for ( i=0,sp=0; expr[ i ] != OP_END; ) {
op_t op = READ_OP;
switch( op ) {
case OP_PUSH_INTEGER: stack[ sp++ ].i = READ_INT; break;
case OP_PUSH_STRING: stack[ sp++ ].s = READ_STRING; break;
case OP_PUSH_COLUMN: stack[ sp++ ].p = table->columns + READ_OP; break;
case OP_PUSH_COLUMN_VAL: stack[ sp++ ].i = row[ READ_OP ].integer; break;
case OP_PUSH_STRING_PARAM: stack[ sp++ ].s = params[ READ_OP ].payload.string; break;
case OP_PUSH_INTEGER_PARAM: stack[ sp++ ].i = params[ READ_OP ].payload.integer; break;
case OP_ROWINDEX: stack[ sp++ ].i = (row - table->rows) / table->column_count; break;
case OP_ROWNUMBER: stack[ sp++ ].i = index; break;
case OP_ROWTOTAL: stack[ sp++ ].i = total; break;
case OP_ROWCOUNT: stack[ sp++ ].i = table->row_count; break;
case OP_SYS_TIME: stack[ sp++ ].i = Sys_Milliseconds(); break;
case OP_SUBTRACT: LVALUE.i = LEFT_OPERAND.i - RIGHT_OPERAND.i; sp--; break;
case OP_ADD: LVALUE.i = LEFT_OPERAND.i + RIGHT_OPERAND.i; sp--; break;
case OP_DIVIDE: LVALUE.i = LEFT_OPERAND.i / RIGHT_OPERAND.i; sp--; break;
case OP_MULTIPLY: LVALUE.i = LEFT_OPERAND.i * RIGHT_OPERAND.i; sp--; break;
case OP_MODULUS: LVALUE.i = LEFT_OPERAND.i % RIGHT_OPERAND.i; sp--; break;
case OP_LOGICAL_AND: LVALUE.i = LEFT_OPERAND.i && RIGHT_OPERAND.i; sp--; break;
case OP_LOGICAL_OR: LVALUE.i = LEFT_OPERAND.i || RIGHT_OPERAND.i; sp--; break;
case OP_BITWISE_AND: LVALUE.i = LEFT_OPERAND.i & RIGHT_OPERAND.i; sp--; break;
case OP_BITWISE_OR: LVALUE.i = LEFT_OPERAND.i | RIGHT_OPERAND.i; sp--; break;
case OP_GT: LVALUE.i = LEFT_OPERAND.i > RIGHT_OPERAND.i; sp--; break;
case OP_LT: LVALUE.i = LEFT_OPERAND.i < RIGHT_OPERAND.i; sp--; break;
case OP_GE: LVALUE.i = LEFT_OPERAND.i >= RIGHT_OPERAND.i; sp--; break;
case OP_LE: LVALUE.i = LEFT_OPERAND.i <= RIGHT_OPERAND.i; sp--; break;
case OP_EQ: LVALUE.i = LEFT_OPERAND.i == RIGHT_OPERAND.i; sp--; break;
case OP_NE: LVALUE.i = LEFT_OPERAND.i != RIGHT_OPERAND.i; sp--; break;
case OP_ATOI:
if (stack[ sp-1 ].s) {
stack[ sp-1 ].i = atoi( stack[ sp-1 ].s );
} else {
stack[ sp-1 ].i = -1;
}
break;
case OP_LIKE: LVALUE.i = Q_stricmp( LEFT_OPERAND.s, RIGHT_OPERAND.s ) == 0; sp--; break;
case OP_MATCH: LVALUE.i = Com_Filter( RIGHT_OPERAND.s, LEFT_OPERAND.s, 0 ); sp--; break;
case OP_NOTLIKE: LVALUE.i = Q_stricmp( LEFT_OPERAND.s, RIGHT_OPERAND.s ) != 0; sp--; break;
case OP_INT_MIN: LVALUE.i = (LEFT_OPERAND.i<RIGHT_OPERAND.i)?LEFT_OPERAND.i:RIGHT_OPERAND.i; sp--; break;
case OP_INT_MAX: LVALUE.i = (LEFT_OPERAND.i>RIGHT_OPERAND.i)?LEFT_OPERAND.i:RIGHT_OPERAND.i; sp--; break;
case OP_ABS: stack[ sp-1 ].i = abs( stack[ sp-1 ].i ); break;
case OP_UMINUS:
stack[ sp-1 ].i = -stack[ sp-1 ].i;
break;
case OP_NOT:
stack[ sp-1 ].i = !(stack[ sp-1 ].i);
break;
case OP_REMOVE:
{
int p = READ_OP;
int n = min( params[ p ].payload.integer, stack[ sp-1 ].i );
params[ p ].payload.integer -= n;
stack[ sp-1 ].i = n;
} break;
case OP_ASSIGN_INT_TO_COLUMN:
{
columnInfo_t * c = (columnInfo_t*)LEFT_OPERAND.p;
ASSERT( c->num >= 0 && c->num < table->column_count );
if ( row[ c->num ].integer != RIGHT_OPERAND.i ) {
table->modified |= (1<<c->num);
}
LVALUE.i = row[ c->num ].integer = RIGHT_OPERAND.i; sp--;
} break;
case OP_ASSIGN_STRING_TO_COLUMN:
{
// a string is being inserted into a table. this string is expected to remain
// constant throughout the life of the table. strings stored in tables do not
// change. string cells can not be modified with an 'UPDATE' command
columnInfo_t * c = (columnInfo_t*)LEFT_OPERAND.p;
cellInfo_t * cell = row + c->num;
const char * o = cell->string;
ASSERT( c->format == STRING );
//ASSERT( cell->string == 0 );
// help!!
if ( abs(RIGHT_OPERAND.i) < 0x10000 ) {
// can't figure out data type for cases like: INSERT INTO missions VALUES(7,'wealth',500); 3rd column in text
// so trying to guess
LVALUE.s = cell->string = sql_alloc_string( db, fn( RIGHT_OPERAND.i, FN_PLAIN ) ); sp--;
} else {
LVALUE.s = cell->string = sql_alloc_string( db, RIGHT_OPERAND.s ); sp--;
}
if ( Q_stricmp( o, cell->string ) ) {
table->modified |= (1<<c->num);
}
} break;
case OP_ASSIGN_CS_TO_ROW:
{
row_cs( db, table, row, stack[ sp-1 ].s );
} break;
case OP_COUNT: (*aggregate).integer++; break;
case OP_MAX:
{
int v = stack[ sp-1 ].i;
(*aggregate).integer = (index==0)?v:max( (*aggregate).integer, v );
} break;
case OP_MIN:
{
int v = stack[ sp-1 ].i;
(*aggregate).integer = (index==0)?v:min( (*aggregate).integer, v );
} break;
case OP_SUM:
(*aggregate).integer += stack[ sp-1 ].i;
break;
case OP_FORMAT:
{
char * s = buffer + size;
int flags = READ_INT;
size += fn_buffer( s, stack[ sp-1 ].i, flags );
stack[ sp-1 ].s = s;
} break;
case OP_CONCAT:
{
LVALUE.s = concat( LEFT_OPERAND.s, RIGHT_OPERAND.s, buffer, sizeof(buffer), &size ); sp--;
} break;
case OP_COLLAPSE:
{
char * s = buffer + size;
size += concat2( s, sizeof(buffer)-size, stack, sp );
stack[ 0 ].s = s;
sp = 1;
} break;
case OP_CVAR:
{
stack[ sp-1 ].s = Cvar_VariableString( stack[ sp-1 ].s );
} break;
case OP_ACCESS_TABLE:
{
tableInfo_t * table;
columnInfo_t * c;
table = find_table( db, LEFT_OPERAND.s );
// allow table access outside current db
if ( !table ) {
table = find_table( sql_getclientdb(), LEFT_OPERAND.s );
if ( !table ) {
table = find_table( sql_getserverdb(), LEFT_OPERAND.s );
if ( !table ) {
table = find_table( sql_getcommondb(), LEFT_OPERAND.s );
}
}
}
#ifdef DEVELOPER
if ( !table ) {
Com_Error( ERR_FATAL, "table '%s' does not exist.\n\n%s", LEFT_OPERAND.s, CURRENT_STMT );
}
#endif
c = find_column( table, RIGHT_OPERAND.s );
#ifdef DEVELOPER
if ( !c ) {
Com_Error( ERR_FATAL, "column '%s' expected on table '%s'.\n\n%s\n", RIGHT_OPERAND.s, LEFT_OPERAND.s, CURRENT_STMT );
}
#endif
LVALUE.p = table; sp--;
stack[ sp++ ].p = c;
} break;
case OP_LOOKUP_I:
{
tableInfo_t * t = stack[ sp-3 ].p;
columnInfo_t * c = stack[ sp-2 ].p;
cellInfo_t k;
int index;
k.integer = stack[ sp-1 ].i;
if ( !c->index ) {
sql_create_index( db, t, c );
}
#ifdef DEVELOPER
if ( !c->index ) {
Com_Error( ERR_FATAL, "index needed for column '%s' on table '%s'.\n\n%s", c->name, t->name, CURRENT_STMT );
}
if ( c->format != INTEGER ) {
Com_Error( ERR_FATAL, "expecting column '%s' on table '%s' to be integer, not string.\n\n%s", c->name, t->name, CURRENT_STMT );
}
#endif
if ( t->last_changed != t->last_indexed )
sql_table_reindex( t );
index = search_index_i( c->index, t->row_count, t->rows, t->column_count, c->num, k );
LVALUE.i = (index>=0)?c->index[ index ]:index; sp--;
} break;
case OP_ACCESS_ROW_I:
{
tableInfo_t * t = stack[ sp-3 ].p;
int r = stack[ sp-2 ].i;
columnInfo_t * c = find_column( t, stack[ sp-1 ].s );
#ifdef DEVELOPER
if ( !t ) {
Com_Error( ERR_FATAL, "table '%s' does not exist.\n\n%s", stack[sp-3].s, CURRENT_STMT );
}
if ( !c ) {
Com_Error( ERR_FATAL, "could not find column '%s' on table '%s' in statement:\n\n%s", stack[ sp-1 ].s, stack[sp-3].s, CURRENT_STMT );
}
#endif
sp -= 3;
if ( r < 0 ) {
stack[ sp++ ].i = -1;
} else {
int cell = (t->column_count*r) + c->num;
if ( c->format == STRING ) {
stack[ sp++ ].i = atoi( t->rows[ cell ].string );
} else {
stack[ sp++ ].i = t->rows[ cell ].integer;
}
}
} break;
case OP_LOOKUP_S:
{
tableInfo_t * t = stack[ sp-3 ].p;
columnInfo_t * c = stack[ sp-2 ].p;
cellInfo_t k;
int index;
k.string = stack[ sp-1 ].s;
if ( !c->index ) {
sql_create_index( db, t, c );
}
#ifdef DEVELOPER
if ( !c->index ) {
Com_Error( ERR_FATAL, "index needed for column '%s' on table '%s'.\n\n%s", c->name, t->name, CURRENT_STMT );
}
if ( c->format != STRING ) {
Com_Error( ERR_FATAL, "expecting column '%s' on table '%s' to be string, not integer.\n\n%s", c->name, t->name, CURRENT_STMT );
}
#endif
if ( t->last_changed != t->last_indexed )
sql_table_reindex( t );
index = search_index_s( c->index, t->row_count, t->rows, t->column_count, c->num, k );
LVALUE.i = (index>=0)?c->index[ index ]:index; sp--;
} break;
case OP_ACCESS_ROW_S:
{
tableInfo_t * t = stack[ sp-3 ].p;
int r = stack[ sp-2 ].i;
columnInfo_t * c = find_column( t, stack[ sp-1 ].s );
#ifdef DEVELOPER
if ( !t ) {
Com_Error( ERR_FATAL, "table does not exist.\n\n%s", CURRENT_STMT );
}
if ( !c ) {
Com_Error( ERR_FATAL, "invalid column for table '%s' in statement:\n\n%s", t->name, CURRENT_STMT );
}
#endif
sp -= 3;
stack[ sp++ ].s = (r>=0)?t->rows[ (t->column_count*r) + c->num ].string:"???";
} break;
case OP_PUSH_GS:
{
int offset = READ_INT;
stack[ sp++ ].i = db->gs[ offset ];
} break;
case OP_PUSH_GS_OFFSET:
{
int offset = READ_INT;
stack[ sp-1 ].i = db->gs[ offset + stack[ sp-1 ].i ];
} break;
case OP_PUSH_PS_CLIENT:
{
int offset = READ_INT;
stack[ sp++ ].i = db->ps[ offset ];
} break;
case OP_PUSH_PS_CLIENT_OFFSET:
{
int offset = READ_INT;
stack[ sp-1 ].i = db->ps[ offset + stack[ sp-1 ].i ];
} break;
case OP_IFTHENELSE:
{
int c = stack[ sp-1 ].i;
value_t a = stack[ sp-2 ];
value_t b = stack[ sp-3 ];
sp -= 3;
stack[ sp++ ] = (c)?b:a;
} break;
case OP_SHADER:
{
ASSERT( db->shader );
stack[ sp-1 ].i = db->shader( stack[ sp-1 ].s );
} break;
case OP_SOUND:
{
ASSERT( db->sound );
stack[ sp-1 ].i = db->sound( stack[ sp-1 ].s );
} break;
case OP_MODEL:
{
ASSERT( db->model );
stack[ sp-1 ].i = db->model( stack[ sp-1 ].s );
} break;
case OP_PORTRAIT:
{
ASSERT( db->portrait );
stack[ sp-1 ].i = db->portrait( stack[ sp-1 ].s );
} break;
case OP_PUSH_INTEGER_GLOBAL:
{
const char * global_id = READ_STRING;
ASSERT( db->global_int );
stack[ sp++ ].i = db->global_int( global_id );
} break;
// recursive integer call
case OP_EVAL:
{
const char * s = stack[ sp-1 ].s;
int r;
switch ( SWITCHSTRING(s) )
{
case 0:
case CS('0',0,0,0):
r = 0;
break;
case CS('1',0,0,0):
r = 1;
break;
default:
{
Expr e;
parseInfo_t pi = { 0 };
char tmp[ SQL_STMT_ALLOC ];
sqlStack_t* save = db->stmt_buffer.c;
db->stmt_buffer.c = (sqlStack_t*)tmp;
db->stmt_buffer.c->top = sizeof(sqlStack_t);
pi.db = db;
e = parse_expression( &s, &pi );
ASSERT( pi.rt == INTEGER );
ASSERT( pi.more == 0 );
r = sql_eval( db, e, table, row, index, total, params, aggregate ).integer;
db->stmt_buffer.c = save;
} break;
}
stack[ sp-1 ].i = r;
} break;
// recursive string call
case OP_PRINT:
{
const char * s = stack[ sp-1 ].s;
Expr e;
parseInfo_t pi = { 0 };
char tmp[ SQL_STMT_ALLOC ];
sqlStack_t* save = db->stmt_buffer.c;
db->stmt_buffer.c = (sqlStack_t*)tmp;
db->stmt_buffer.c->top = sizeof(sqlStack_t);
pi.db = db;
pi.flags = PARSE_STRINGLITERAL;
e = parse_expression( &s, &pi );
ASSERT( pi.rt == STRING );
ASSERT( pi.more == 0 );
stack[ sp-1 ].s = sql_eval( db, e, table, row, index, total, params, aggregate ).string;
db->stmt_buffer.c = save;
} break;
// execute a precompiled expression, returns string
case OP_RUN:
{
int index = stack[ sp-1 ].i;
if ( index < 0 || index >= db->stmts_byindex_count || !db->stmts_byindex[ index ] ) {
stack[ sp-1 ].s = "???";
break;
}
stack[ sp-1 ].s = sql_eval( db, ((formatInfo_t*)db->stmts_byindex[ index ])->print, 0, 0, 0, 0, 0, 0 ).string;
size += strlen(stack[ sp-1 ].s) + 1;
} break;
case OP_RND:
{
LVALUE.i = Rand_NextInt32InRange( &db->rand, LEFT_OPERAND.i, RIGHT_OPERAND.i ); sp--;
} break;
#if DEVELOPER
default:
{
Com_Error(ERR_FATAL, "invalid sql op code: '%d'.\n", op );
} break;
#endif
}
#ifdef DEVELOPER
db->ops++;
#endif
}
ASSERT( size <= sizeof(buffer) ); // stack overflow
size = top;
if ( sp == 0 )
{
cellInfo_t c;
c.integer = 0;
return c;
}
ASSERT( sp == 1 );
return *(cellInfo_t*)stack;
}
