source: trunk/kitgen/8.x/blt/generic/bltSwitch.c

/*
 * bltSwitch.c --
 *
 *      This module implements command/argument switch parsing 
 *      procedures for the BLT toolkit.
 *
 * Copyright 1991-1998 Lucent Technologies, Inc.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby
 * granted, provided that the above copyright notice appear in all
 * copies and that both that the copyright notice and warranty
 * disclaimer appear in supporting documentation, and that the names
 * of Lucent Technologies any of their entities not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 *
 * Lucent Technologies disclaims all warranties with regard to this
 * software, including all implied warranties of merchantability and
 * fitness.  In no event shall Lucent Technologies be liable for any
 * special, indirect or consequential damages or any damages
 * whatsoever resulting from loss of use, data or profits, whether in
 * an action of contract, negligence or other tortuous action, arising
 * out of or in connection with the use or performance of this
 * software.
 */

#include "bltInt.h"
#if defined(__STDC__)
#include <stdarg.h>
#else
#include <varargs.h>
#endif

#include "bltSwitch.h"

/*
 *--------------------------------------------------------------
 *
 * FindSwitchSpec --
 *
 *      Search through a table of configuration specs, looking for
 *      one that matches a given argvName.
 *
 * Results:
 *      The return value is a pointer to the matching entry, or NULL
 *      if nothing matched.  In that case an error message is left
 *      in the interp's result.
 *
 * Side effects:
 *      None.
 *
 *--------------------------------------------------------------
 */
static Blt_SwitchSpec *
FindSwitchSpec(interp, specs, name, needFlags, hateFlags)
    Tcl_Interp *interp;         /* Used for reporting errors. */
    Blt_SwitchSpec *specs;      /* Pointer to table of configuration
                                 * specifications for a widget. */
    char *name;                 /* Name (suitable for use in a "switch"
                                 * command) identifying particular option. */
    int needFlags;              /* Flags that must be present in matching
                                 * entry. */
    int hateFlags;              /* Flags that must NOT be present in
                                 * matching entry. */
{
    register Blt_SwitchSpec *specPtr;
    register char c;            /* First character of current argument. */
    Blt_SwitchSpec *matchPtr;   /* Matching spec, or NULL. */
    size_t length;

    c = name[1];
    length = strlen(name);
    matchPtr = NULL;
    
    for (specPtr = specs; specPtr->type != BLT_SWITCH_END; specPtr++) {
        if (specPtr->switchName == NULL) {
            continue;
        }
        if ((specPtr->switchName[1] != c) 
            || (strncmp(specPtr->switchName, name, length) != 0)) {
            continue;
        }
        if (((specPtr->flags & needFlags) != needFlags)
            || (specPtr->flags & hateFlags)) {
            continue;
        }
        if (specPtr->switchName[length] == 0) {
            return specPtr;     /* Stop on a perfect match. */
        }
        if (matchPtr != NULL) {
            Tcl_AppendResult(interp, "ambiguous option \"", name, "\"", 
                (char *) NULL);
            return (Blt_SwitchSpec *) NULL;
        }
        matchPtr = specPtr;
    }

    if (matchPtr == NULL) {
        Tcl_AppendResult(interp, "unknown option \"", name, "\"", (char *)NULL);
        return (Blt_SwitchSpec *) NULL;
    }
    return matchPtr;
}

/*
 *--------------------------------------------------------------
 *
 * DoSwitch --
 *
 *      This procedure applies a single configuration option
 *      to a widget record.
 *
 * Results:
 *      A standard Tcl return value.
 *
 * Side effects:
 *      WidgRec is modified as indicated by specPtr and value.
 *      The old value is recycled, if that is appropriate for
 *      the value type.
 *
 *--------------------------------------------------------------
 */
static int
DoSwitch(interp, specPtr, string, record)
    Tcl_Interp *interp;         /* Interpreter for error reporting. */
    Blt_SwitchSpec *specPtr;    /* Specifier to apply. */
    char *string;               /* Value to use to fill in widgRec. */
    ClientData record;          /* Record whose fields are to be
                                 * modified.  Values must be properly
                                 * initialized. */
{
    char *ptr;
    int isNull;
    int count;

    isNull = ((*string == '\0') && (specPtr->flags & BLT_SWITCH_NULL_OK));
    do {
        ptr = (char *)record + specPtr->offset;
        switch (specPtr->type) {
        case BLT_SWITCH_BOOLEAN:
            if (Tcl_GetBoolean(interp, string, (int *)ptr) != TCL_OK) {
                return TCL_ERROR;
            }
            break;

        case BLT_SWITCH_INT:
            if (Tcl_GetInt(interp, string, (int *)ptr) != TCL_OK) {
                return TCL_ERROR;
            }
            break;

        case BLT_SWITCH_INT_NONNEGATIVE:
            if (Tcl_GetInt(interp, string, &count) != TCL_OK) {
                return TCL_ERROR;
            }
            if (count < 0) {
                Tcl_AppendResult(interp, "bad value \"", string, "\": ",
                                 "can't be negative", (char *)NULL);
                return TCL_ERROR;
            }
            *((int *)ptr) = count;
            break;

        case BLT_SWITCH_INT_POSITIVE:
            if (Tcl_GetInt(interp, string, &count) != TCL_OK) {
                return TCL_ERROR;
            }
            if (count <= 0) {
                Tcl_AppendResult(interp, "bad value \"", string, "\": ",
                        "must be positive", (char *)NULL);
                return TCL_ERROR;
            }
            *((int *)ptr) = count;
            break;

        case BLT_SWITCH_DOUBLE:
            if (Tcl_GetDouble(interp, string, (double *)ptr) != TCL_OK) {
                return TCL_ERROR;
            }
            break;

        case BLT_SWITCH_STRING: 
            {
                char *old, *new, **strPtr;
                
                strPtr = (char **)ptr;
                if (isNull) {
                    new = NULL;
                } else {
                    new = Blt_Strdup(string);
                }
                old = *strPtr;
                if (old != NULL) {
                    Blt_Free(old);
                }
                *strPtr = new;
            }
            break;

        case BLT_SWITCH_LIST:
            if (Tcl_SplitList(interp, string, &count, (char ***)ptr) 
                != TCL_OK) {
                return TCL_ERROR;
            }
            break;

        case BLT_SWITCH_CUSTOM:
            if ((*specPtr->customPtr->parseProc) \
                (specPtr->customPtr->clientData, interp, specPtr->switchName,
                        string, record, specPtr->offset) != TCL_OK) {
                return TCL_ERROR;
            }
            break;

        default: 
            Tcl_AppendResult(interp, "bad switch table: unknown type \"",
                 Blt_Itoa(specPtr->type), "\"", (char *)NULL);
            return TCL_ERROR;
        }
        specPtr++;
    } while ((specPtr->switchName == NULL) && 
             (specPtr->type != BLT_SWITCH_END));
    return TCL_OK;
}

/*
 *--------------------------------------------------------------
 *
 * Blt_ProcessSwitches --
 *
 *      Process command-line options and database options to
 *      fill in fields of a widget record with resources and
 *      other parameters.
 *
 * Results:
 *      Returns the number of arguments comsumed by parsing the
 *      command line.  If an error occurred, -1 will be returned
 *      and an error messages can be found as the interpreter
 *      result.
 *
 * Side effects:
 *      The fields of widgRec get filled in with information
 *      from argc/argv and the option database.  Old information
 *      in widgRec's fields gets recycled.
 *
 *--------------------------------------------------------------
 */
int
Blt_ProcessSwitches(interp, specs, argc, argv, record, flags)
    Tcl_Interp *interp;         /* Interpreter for error reporting. */
    Blt_SwitchSpec *specs;      /* Describes legal options. */
    int argc;                   /* Number of elements in argv. */
    char **argv;                /* Command-line options. */
    char *record;               /* Record whose fields are to be
                                 * modified.  Values must be properly
                                 * initialized. */
    int flags;                  /* Used to specify additional flags
                                 * that must be present in switch specs
                                 * for them to be considered.  Also,
                                 * may have BLT_SWITCH_ARGV_ONLY set. */
{
    register int count;
    char *arg;
    register Blt_SwitchSpec *specPtr;
    int needFlags;              /* Specs must contain this set of flags
                                 * or else they are not considered. */
    int hateFlags;              /* If a spec contains any bits here, it's
                                 * not considered. */

    needFlags = flags & ~(BLT_SWITCH_USER_BIT - 1);
    hateFlags = 0;

    /*
     * Pass 1:  Clear the change flags on all the specs so that we 
     *          can check it later.
     */
    for (specPtr = specs; specPtr->type != BLT_SWITCH_END; specPtr++) {
        specPtr->flags &= ~BLT_SWITCH_SPECIFIED;
    }
    /*
     * Pass 2:  Process the arguments that match entries in the specs.
     *          It's an error if the argument doesn't match anything.
     */
    for (count = 0; count < argc; count++) {
        arg = argv[count];
        if (flags & BLT_SWITCH_OBJV_PARTIAL) {
            if ((arg[0] != '-') || ((arg[1] == '-') && (argv[2] == '\0'))) {
                /* 
                 * If the argument doesn't start with a '-' (not a switch)
                 * or is '--', stop processing and return the number of
                 * arguments comsumed. 
                 */
                return count;
            }
        }
        specPtr = FindSwitchSpec(interp, specs, arg, needFlags, hateFlags);
        if (specPtr == NULL) {
            return -1;
        }
        if (specPtr->type == BLT_SWITCH_FLAG) {
            char *ptr;
            
            ptr = record + specPtr->offset;
            *((int *)ptr) |= specPtr->value;
        } else if (specPtr->type == BLT_SWITCH_VALUE) {
            char *ptr;
            
            ptr = record + specPtr->offset;
            *((int *)ptr) = specPtr->value;
        } else {
            if ((count + 1) == argc) {
                Tcl_AppendResult(interp, "value for \"", arg, "\" missing", 
                        (char *) NULL);
                return -1;
            }
            count++;
            if (DoSwitch(interp, specPtr, argv[count], record) != TCL_OK) {
                char msg[100];

                sprintf(msg, "\n    (processing \"%.40s\" option)", 
                        specPtr->switchName);
                Tcl_AddErrorInfo(interp, msg);
                return -1;
            }
        }
        specPtr->flags |= BLT_SWITCH_SPECIFIED;
    }
    return count;
}

#if (TCL_VERSION_NUMBER >= _VERSION(8,0,0)) 

/*
 *--------------------------------------------------------------
 *
 * Blt_ProcessObjSwitches --
 *
 *      Process command-line options and database options to
 *      fill in fields of a widget record with resources and
 *      other parameters.
 *
 * Results:
 *      Returns the number of arguments comsumed by parsing the
 *      command line.  If an error occurred, -1 will be returned
 *      and an error messages can be found as the interpreter
 *      result.
 *
 * Side effects:
 *      The fields of widgRec get filled in with information
 *      from argc/argv and the option database.  Old information
 *      in widgRec's fields gets recycled.
 *
 *--------------------------------------------------------------
 */
int
Blt_ProcessObjSwitches(interp, specs, objc, objv, record, flags)
    Tcl_Interp *interp;         /* Interpreter for error reporting. */
    Blt_SwitchSpec *specs;      /* Describes legal options. */
    int objc;                   /* Number of elements in argv. */
    Tcl_Obj *CONST *objv;       /* Command-line options. */
    char *record;               /* Record whose fields are to be
                                 * modified.  Values must be properly
                                 * initialized. */
    int flags;                  /* Used to specify additional flags
                                 * that must be present in switch specs
                                 * for them to be considered.  Also,
                                 * may have BLT_SWITCH_ARGV_ONLY set. */
{
    register Blt_SwitchSpec *specPtr;
    register int count;
    int needFlags;              /* Specs must contain this set of flags
                                 * or else they are not considered. */
    int hateFlags;              /* If a spec contains any bits here, it's
                                 * not considered. */

    needFlags = flags & ~(BLT_SWITCH_USER_BIT - 1);
    hateFlags = 0;

    /*
     * Pass 1:  Clear the change flags on all the specs so that we 
     *          can check it later.
     */
    for (specPtr = specs; specPtr->type != BLT_SWITCH_END; specPtr++) {
        specPtr->flags &= ~BLT_SWITCH_SPECIFIED;
    }
    /*
     * Pass 2:  Process the arguments that match entries in the specs.
     *          It's an error if the argument doesn't match anything.
     */
    for (count = 0; count < objc; count++) {
        char *arg;

        arg = Tcl_GetString(objv[count]);
        if (flags & BLT_SWITCH_OBJV_PARTIAL) {
            if ((arg[0] != '-') || ((arg[1] == '-') && (arg[2] == '\0'))) {
                /* 
                 * If the argument doesn't start with a '-' (not a switch)
                 * or is '--', stop processing and return the number of
                 * arguments comsumed. 
                 */
                return count;
            }
        }
        specPtr = FindSwitchSpec(interp, specs, arg, needFlags, hateFlags);
        if (specPtr == NULL) {
            return -1;
        }
        if (specPtr->type == BLT_SWITCH_FLAG) {
            char *ptr;
            
            ptr = record + specPtr->offset;
            *((int *)ptr) |= specPtr->value;
        } else if (specPtr->type == BLT_SWITCH_VALUE) {
            char *ptr;
            
            ptr = record + specPtr->offset;
            *((int *)ptr) = specPtr->value;
        } else {
            count++;
            if (count == objc) {
                Tcl_AppendResult(interp, "value for \"", arg, "\" missing", 
                                 (char *) NULL);
                return -1;
            }
            arg = Tcl_GetString(objv[count]);
            if (DoSwitch(interp, specPtr, arg, record) != TCL_OK) {
                char msg[100];

                sprintf(msg, "\n    (processing \"%.40s\" option)", 
                        specPtr->switchName);
                Tcl_AddErrorInfo(interp, msg);
                return -1;
            }
        }
        specPtr->flags |= BLT_SWITCH_SPECIFIED;
    }
    return count;
}
#endif

/*
 *----------------------------------------------------------------------
 *
 * Blt_FreeSwitches --
 *
 *      Free up all resources associated with switch options.
 *
 * Results:
 *      None.
 *
 *----------------------------------------------------------------------
 */

/* ARGSUSED */
void
Blt_FreeSwitches(specs, record, needFlags)
    Blt_SwitchSpec *specs;      /* Describes legal options. */
    char *record;               /* Record whose fields contain current
                                 * values for options. */
    int needFlags;              /* Used to specify additional flags
                                 * that must be present in config specs
                                 * for them to be considered. */
{
    register Blt_SwitchSpec *specPtr;

    for (specPtr = specs; specPtr->type != BLT_SWITCH_END; specPtr++) {
        if ((specPtr->flags & needFlags) == needFlags) {
            char *ptr;

            ptr = record + specPtr->offset;
            switch (specPtr->type) {
            case BLT_SWITCH_STRING:
            case BLT_SWITCH_LIST:
                if (*((char **) ptr) != NULL) {
                    Blt_Free(*((char **) ptr));
                    *((char **) ptr) = NULL;
                }
                break;

            case BLT_SWITCH_CUSTOM:
                if ((*(char **)ptr != NULL) && 
                    (specPtr->customPtr->freeProc != NULL)) {
                    (*specPtr->customPtr->freeProc)(*(char **)ptr);
                    *((char **) ptr) = NULL;
                }
                break;

            default:
                break;
            }
        }
    }
}


/*
 *----------------------------------------------------------------------
 *
 * Blt_SwitchModified --
 *
 *      Given the configuration specifications and one or more option
 *      patterns (terminated by a NULL), indicate if any of the matching
 *      configuration options has been reset.
 *
 * Results:
 *      Returns 1 if one of the options has changed, 0 otherwise.
 *
 *----------------------------------------------------------------------
 */
int Blt_SwitchChanged
TCL_VARARGS_DEF(Blt_SwitchSpec *, arg1)
{
    va_list argList;
    Blt_SwitchSpec *specs;
    register Blt_SwitchSpec *specPtr;
    register char *switchName;

    specs = TCL_VARARGS_START(Blt_SwitchSpec *, arg1, argList);
    while ((switchName = va_arg(argList, char *)) != NULL) {
        for (specPtr = specs; specPtr->type != BLT_SWITCH_END; specPtr++) {
            if ((Tcl_StringMatch(specPtr->switchName, switchName)) &&
                (specPtr->flags & BLT_SWITCH_SPECIFIED)) {
                va_end(argList);
                return 1;
            }
        }
    }
    va_end(argList);
    return 0;
}