Annotation of quake2/qcommon/cvar.c, revision 1.1.1.2

1.1       root        1: // cvar.c -- dynamic variable tracking
1.1.1.2 ! root        2: 
1.1       root        3: #include "qcommon.h"
1.1.1.2 ! root        4: 
1.1       root        5: cvar_t *cvar_vars;
1.1.1.2 ! root        6: 
1.1       root        7: /*
                      8: ============
                      9: Cvar_InfoValidate
                     10: ============
                     11: */
                     12: static qboolean Cvar_InfoValidate (char *s)
                     13: {
                     14:        if (strstr (s, "\\"))
                     15:                return false;
                     16:        if (strstr (s, "\""))
                     17:                return false;
                     18:        if (strstr (s, ";"))
                     19:                return false;
                     20:        return true;
                     21: }
                     22: 
                     23: /*
                     24: ============
                     25: Cvar_FindVar
                     26: ============
                     27: */
                     28: static cvar_t *Cvar_FindVar (char *var_name)
                     29: {
                     30:        cvar_t  *var;
                     31:        
                     32:        for (var=cvar_vars ; var ; var=var->next)
                     33:                if (!strcmp (var_name, var->name))
                     34:                        return var;
1.1.1.2 ! root       35: 
1.1       root       36:        return NULL;
                     37: }
1.1.1.2 ! root       38: 
1.1       root       39: /*
                     40: ============
                     41: Cvar_VariableValue
                     42: ============
                     43: */
                     44: float Cvar_VariableValue (char *var_name)
                     45: {
                     46:        cvar_t  *var;
                     47:        
                     48:        var = Cvar_FindVar (var_name);
                     49:        if (!var)
                     50:                return 0;
                     51:        return atof (var->string);
                     52: }
1.1.1.2 ! root       53: 
        !            54: 
1.1       root       55: /*
                     56: ============
                     57: Cvar_VariableString
                     58: ============
                     59: */
                     60: char *Cvar_VariableString (char *var_name)
                     61: {
                     62:        cvar_t *var;
                     63:        
                     64:        var = Cvar_FindVar (var_name);
                     65:        if (!var)
                     66:                return "";
                     67:        return var->string;
                     68: }
1.1.1.2 ! root       69: 
        !            70: 
1.1       root       71: /*
                     72: ============
                     73: Cvar_CompleteVariable
                     74: ============
                     75: */
                     76: char *Cvar_CompleteVariable (char *partial)
                     77: {
                     78:        cvar_t          *cvar;
                     79:        int                     len;
                     80:        
                     81:        len = strlen(partial);
                     82:        
                     83:        if (!len)
                     84:                return NULL;
                     85:                
                     86:        // check exact match
                     87:        for (cvar=cvar_vars ; cvar ; cvar=cvar->next)
                     88:                if (!strcmp (partial,cvar->name))
                     89:                        return cvar->name;
1.1.1.2 ! root       90: 
1.1       root       91:        // check partial match
                     92:        for (cvar=cvar_vars ; cvar ; cvar=cvar->next)
                     93:                if (!strncmp (partial,cvar->name, len))
                     94:                        return cvar->name;
1.1.1.2 ! root       95: 
1.1       root       96:        return NULL;
                     97: }
1.1.1.2 ! root       98: 
        !            99: 
1.1       root      100: /*
                    101: ============
                    102: Cvar_Get
1.1.1.2 ! root      103: 
1.1       root      104: If the variable already exists, the value will not be set
                    105: The flags will be or'ed in if the variable exists.
                    106: ============
                    107: */
                    108: cvar_t *Cvar_Get (char *var_name, char *var_value, int flags)
                    109: {
                    110:        cvar_t  *var;
                    111:        
                    112:        if (flags & (CVAR_USERINFO | CVAR_SERVERINFO))
                    113:        {
                    114:                if (!Cvar_InfoValidate (var_name))
                    115:                {
                    116:                        Com_Printf("invalid info cvar name\n");
                    117:                        return NULL;
                    118:                }
                    119:        }
                    120: 
                    121:        var = Cvar_FindVar (var_name);
                    122:        if (var)
                    123:        {
                    124:                var->flags |= flags;
                    125:                return var;
                    126:        }
1.1.1.2 ! root      127: 
1.1       root      128:        if (!var_value)
                    129:                return NULL;
                    130: 
                    131:        if (flags & (CVAR_USERINFO | CVAR_SERVERINFO))
                    132:        {
                    133:                if (!Cvar_InfoValidate (var_value))
                    134:                {
                    135:                        Com_Printf("invalid info cvar value\n");
                    136:                        return NULL;
                    137:                }
                    138:        }
                    139: 
                    140:        var = Z_Malloc (sizeof(*var));
                    141:        var->name = CopyString (var_name);
                    142:        var->string = CopyString (var_value);
                    143:        var->modified = true;
                    144:        var->value = atof (var->string);
1.1.1.2 ! root      145: 
1.1       root      146:        // link the variable in
                    147:        var->next = cvar_vars;
                    148:        cvar_vars = var;
1.1.1.2 ! root      149: 
1.1       root      150:        var->flags = flags;
1.1.1.2 ! root      151: 
1.1       root      152:        return var;
                    153: }
1.1.1.2 ! root      154: 
1.1       root      155: /*
                    156: ============
                    157: Cvar_Set2
                    158: ============
                    159: */
                    160: cvar_t *Cvar_Set2 (char *var_name, char *value, qboolean force)
                    161: {
                    162:        cvar_t  *var;
                    163: 
                    164:        var = Cvar_FindVar (var_name);
                    165:        if (!var)
                    166:        {       // create it
                    167:                return Cvar_Get (var_name, value, 0);
                    168:        }
1.1.1.2 ! root      169: 
1.1       root      170:        if (var->flags & (CVAR_USERINFO | CVAR_SERVERINFO))
                    171:        {
                    172:                if (!Cvar_InfoValidate (value))
                    173:                {
                    174:                        Com_Printf("invalid info cvar value\n");
                    175:                        return var;
                    176:                }
                    177:        }
                    178: 
                    179:        if (!force)
                    180:        {
                    181:                if (var->flags & CVAR_NOSET)
                    182:                {
                    183:                        Com_Printf ("%s is write protected.\n", var_name);
                    184:                        return var;
                    185:                }
1.1.1.2 ! root      186: 
1.1       root      187:                if (var->flags & CVAR_LATCH)
                    188:                {
                    189:                        if (var->latched_string)
                    190:                        {
                    191:                                if (strcmp(value, var->latched_string) == 0)
                    192:                                        return var;
                    193:                                Z_Free (var->latched_string);
                    194:                        }
                    195:                        else
                    196:                        {
                    197:                                if (strcmp(value, var->string) == 0)
                    198:                                        return var;
                    199:                        }
                    200: 
                    201:                        if (Com_ServerState())
                    202:                        {
                    203:                                Com_Printf ("%s will be changed for next game.\n", var_name);
                    204:                                var->latched_string = CopyString(value);
                    205:                        }
                    206:                        else
                    207:                        {
                    208:                                var->string = CopyString(value);
                    209:                                var->value = atof (var->string);
                    210:                                if (!strcmp(var->name, "game"))
                    211:                                {
                    212:                                        FS_SetGamedir (var->string);
                    213:                                        FS_ExecAutoexec ();
                    214:                                }
                    215:                        }
                    216:                        return var;
                    217:                }
                    218:        }
                    219:        else
                    220:        {
                    221:                if (var->latched_string)
                    222:                {
                    223:                        Z_Free (var->latched_string);
                    224:                        var->latched_string = NULL;
                    225:                }
                    226:        }
1.1.1.2 ! root      227: 
1.1       root      228:        if (!strcmp(value, var->string))
                    229:                return var;             // not changed
1.1.1.2 ! root      230: 
1.1       root      231:        var->modified = true;
1.1.1.2 ! root      232: 
1.1       root      233:        if (var->flags & CVAR_USERINFO)
                    234:                userinfo_modified = true;       // transmit at next oportunity
                    235:        
                    236:        Z_Free (var->string);   // free the old value string
                    237:        
                    238:        var->string = CopyString(value);
                    239:        var->value = atof (var->string);
1.1.1.2 ! root      240: 
1.1       root      241:        return var;
                    242: }
1.1.1.2 ! root      243: 
1.1       root      244: /*
                    245: ============
                    246: Cvar_ForceSet
                    247: ============
                    248: */
                    249: cvar_t *Cvar_ForceSet (char *var_name, char *value)
                    250: {
                    251:        return Cvar_Set2 (var_name, value, true);
                    252: }
1.1.1.2 ! root      253: 
1.1       root      254: /*
                    255: ============
                    256: Cvar_Set
                    257: ============
                    258: */
                    259: cvar_t *Cvar_Set (char *var_name, char *value)
                    260: {
                    261:        return Cvar_Set2 (var_name, value, false);
                    262: }
1.1.1.2 ! root      263: 
1.1       root      264: /*
                    265: ============
                    266: Cvar_FullSet
                    267: ============
                    268: */
                    269: cvar_t *Cvar_FullSet (char *var_name, char *value, int flags)
                    270: {
                    271:        cvar_t  *var;
                    272:        
                    273:        var = Cvar_FindVar (var_name);
                    274:        if (!var)
                    275:        {       // create it
                    276:                return Cvar_Get (var_name, value, flags);
                    277:        }
1.1.1.2 ! root      278: 
1.1       root      279:        var->modified = true;
1.1.1.2 ! root      280: 
1.1       root      281:        if (var->flags & CVAR_USERINFO)
                    282:                userinfo_modified = true;       // transmit at next oportunity
                    283:        
                    284:        Z_Free (var->string);   // free the old value string
                    285:        
                    286:        var->string = CopyString(value);
                    287:        var->value = atof (var->string);
                    288:        var->flags = flags;
1.1.1.2 ! root      289: 
1.1       root      290:        return var;
                    291: }
1.1.1.2 ! root      292: 
1.1       root      293: /*
                    294: ============
                    295: Cvar_SetValue
                    296: ============
                    297: */
                    298: void Cvar_SetValue (char *var_name, float value)
                    299: {
                    300:        char    val[32];
                    301: 
                    302:        if (value == (int)value)
                    303:                Com_sprintf (val, sizeof(val), "%i",(int)value);
                    304:        else
                    305:                Com_sprintf (val, sizeof(val), "%f",value);
                    306:        Cvar_Set (var_name, val);
                    307: }
1.1.1.2 ! root      308: 
        !           309: 
1.1       root      310: /*
                    311: ============
                    312: Cvar_GetLatchedVars
1.1.1.2 ! root      313: 
1.1       root      314: Any variables with latched values will now be updated
                    315: ============
                    316: */
                    317: void Cvar_GetLatchedVars (void)
                    318: {
                    319:        cvar_t  *var;
1.1.1.2 ! root      320: 
1.1       root      321:        for (var = cvar_vars ; var ; var = var->next)
                    322:        {
                    323:                if (!var->latched_string)
                    324:                        continue;
                    325:                Z_Free (var->string);
                    326:                var->string = var->latched_string;
                    327:                var->latched_string = NULL;
                    328:                var->value = atof(var->string);
                    329:                if (!strcmp(var->name, "game"))
                    330:                {
                    331:                        FS_SetGamedir (var->string);
                    332:                        FS_ExecAutoexec ();
                    333:                }
                    334:        }
                    335: }
1.1.1.2 ! root      336: 
1.1       root      337: /*
                    338: ============
                    339: Cvar_Command
1.1.1.2 ! root      340: 
1.1       root      341: Handles variable inspection and changing from the console
                    342: ============
                    343: */
                    344: qboolean Cvar_Command (void)
                    345: {
                    346:        cvar_t                  *v;
1.1.1.2 ! root      347: 
1.1       root      348: // check variables
                    349:        v = Cvar_FindVar (Cmd_Argv(0));
                    350:        if (!v)
                    351:                return false;
                    352:                
                    353: // perform a variable print or set
                    354:        if (Cmd_Argc() == 1)
                    355:        {
                    356:                Com_Printf ("\"%s\" is \"%s\"\n", v->name, v->string);
                    357:                return true;
                    358:        }
1.1.1.2 ! root      359: 
1.1       root      360:        Cvar_Set (v->name, Cmd_Argv(1));
                    361:        return true;
                    362: }
1.1.1.2 ! root      363: 
        !           364: 
1.1       root      365: /*
                    366: ============
                    367: Cvar_Set_f
1.1.1.2 ! root      368: 
1.1       root      369: Allows setting and defining of arbitrary cvars from console
                    370: ============
                    371: */
                    372: void Cvar_Set_f (void)
                    373: {
                    374:        int             c;
                    375:        int             flags;
1.1.1.2 ! root      376: 
1.1       root      377:        c = Cmd_Argc();
                    378:        if (c != 3 && c != 4)
                    379:        {
                    380:                Com_Printf ("usage: set <variable> <value> [u / s]\n");
                    381:                return;
                    382:        }
1.1.1.2 ! root      383: 
1.1       root      384:        if (c == 4)
                    385:        {
                    386:                if (!strcmp(Cmd_Argv(3), "u"))
                    387:                        flags = CVAR_USERINFO;
                    388:                else if (!strcmp(Cmd_Argv(3), "s"))
                    389:                        flags = CVAR_SERVERINFO;
                    390:                else
                    391:                {
                    392:                        Com_Printf ("flags can only be 'u' or 's'\n");
                    393:                        return;
                    394:                }
                    395:                Cvar_FullSet (Cmd_Argv(1), Cmd_Argv(2), flags);
                    396:        }
                    397:        else
                    398:                Cvar_Set (Cmd_Argv(1), Cmd_Argv(2));
                    399: }
1.1.1.2 ! root      400: 
        !           401: 
1.1       root      402: /*
                    403: ============
                    404: Cvar_WriteVariables
1.1.1.2 ! root      405: 
1.1       root      406: Appends lines containing "set variable value" for all variables
                    407: with the archive flag set to true.
                    408: ============
                    409: */
                    410: void Cvar_WriteVariables (char *path)
                    411: {
                    412:        cvar_t  *var;
                    413:        char    buffer[1024];
                    414:        FILE    *f;
1.1.1.2 ! root      415: 
1.1       root      416:        f = fopen (path, "a");
                    417:        for (var = cvar_vars ; var ; var = var->next)
                    418:        {
                    419:                if (var->flags & CVAR_ARCHIVE)
                    420:                {
                    421:                        Com_sprintf (buffer, sizeof(buffer), "set %s \"%s\"\n", var->name, var->string);
                    422:                        fprintf (f, "%s", buffer);
                    423:                }
                    424:        }
                    425:        fclose (f);
                    426: }
1.1.1.2 ! root      427: 
1.1       root      428: /*
                    429: ============
                    430: Cvar_List_f
1.1.1.2 ! root      431: 
1.1       root      432: ============
                    433: */
                    434: void Cvar_List_f (void)
                    435: {
                    436:        cvar_t  *var;
                    437:        int             i;
1.1.1.2 ! root      438: 
1.1       root      439:        i = 0;
                    440:        for (var = cvar_vars ; var ; var = var->next, i++)
                    441:        {
                    442:                if (var->flags & CVAR_ARCHIVE)
                    443:                        Com_Printf ("*");
                    444:                else
                    445:                        Com_Printf (" ");
                    446:                if (var->flags & CVAR_USERINFO)
                    447:                        Com_Printf ("U");
                    448:                else
                    449:                        Com_Printf (" ");
                    450:                if (var->flags & CVAR_SERVERINFO)
                    451:                        Com_Printf ("S");
                    452:                else
                    453:                        Com_Printf (" ");
                    454:                if (var->flags & CVAR_NOSET)
                    455:                        Com_Printf ("-");
                    456:                else if (var->flags & CVAR_LATCH)
                    457:                        Com_Printf ("L");
                    458:                else
                    459:                        Com_Printf (" ");
                    460:                Com_Printf (" %s \"%s\"\n", var->name, var->string);
                    461:        }
                    462:        Com_Printf ("%i cvars\n", i);
                    463: }
1.1.1.2 ! root      464: 
        !           465: 
1.1       root      466: qboolean userinfo_modified;
1.1.1.2 ! root      467: 
        !           468: 
1.1       root      469: char   *Cvar_BitInfo (int bit)
                    470: {
                    471:        static char     info[MAX_INFO_STRING];
                    472:        cvar_t  *var;
1.1.1.2 ! root      473: 
1.1       root      474:        info[0] = 0;
1.1.1.2 ! root      475: 
1.1       root      476:        for (var = cvar_vars ; var ; var = var->next)
                    477:        {
                    478:                if (var->flags & bit)
                    479:                        Info_SetValueForKey (info, var->name, var->string);
                    480:        }
                    481:        return info;
                    482: }
1.1.1.2 ! root      483: 
1.1       root      484: // returns an info string containing all the CVAR_USERINFO cvars
                    485: char   *Cvar_Userinfo (void)
                    486: {
                    487:        return Cvar_BitInfo (CVAR_USERINFO);
                    488: }
1.1.1.2 ! root      489: 
1.1       root      490: // returns an info string containing all the CVAR_SERVERINFO cvars
                    491: char   *Cvar_Serverinfo (void)
                    492: {
                    493:        return Cvar_BitInfo (CVAR_SERVERINFO);
                    494: }
1.1.1.2 ! root      495: 
1.1       root      496: /*
                    497: ============
                    498: Cvar_Init
1.1.1.2 ! root      499: 
1.1       root      500: Reads in all archived cvars
                    501: ============
                    502: */
                    503: void Cvar_Init (void)
                    504: {
                    505:        Cmd_AddCommand ("set", Cvar_Set_f);
                    506:        Cmd_AddCommand ("cvarlist", Cvar_List_f);
1.1.1.2 ! root      507: 
1.1       root      508: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.