IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
May 30, 2007, 6:09:46 PM (19 years ago)
Author:
jhoblitt
Message:

start to split dettoolConfig() into smaller functions

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/src/dettoolConfig.c

    r13564 r13565  
    4949}
    5050
     51
    5152static void printUsageMode(int argc, char **argv, const char *modeName, psMetadata *argSet)
    5253{
    … …  
    5657    psArgumentHelpSimple(stderr, argSet);
    5758}
     59
     60
     61static bool parseOptions(int argc, char **argv, pxConfig *config, psMetadata *modes, psMetadata *argSets)
     62{
     63    // figure out what mode we're running in
     64    psMetadataIterator *iter = psMetadataIteratorAlloc(modes, PS_LIST_HEAD, NULL);
     65    psMetadataItem *item = NULL; // Item from iterator
     66    while ((item = psMetadataGetAndIncrement(iter))) {
     67        int N = 0;
     68        if ((N = psArgumentGet(argc, argv, item->name))) {
     69            psArgumentRemove(N, &argc, argv);
     70            // check for duplicate mode specification
     71            if (config->mode) {
     72                psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed");
     73                fprintf(stderr, "only one mode selection is allowed\n");
     74                printUsage(argc, argv, modes);
     75                return NULL;
     76            }
     77
     78            config->mode = item->data.U32;
     79            config->modeName = psStringCopy(item->name);
     80
     81            bool status = false;
     82            psMetadata *argset = psMetadataLookupMetadata(&status, argSets, item->name);
     83            // make sure we can find the argSet for the sepcified mode
     84            if (!status) {
     85                psError(PS_ERR_UNKNOWN, true, "can not find arguments for mode");
     86                fprintf(stderr, "can not find arugments for mode");
     87                return NULL;
     88            }
     89
     90            config->args = psMemIncrRefCounter(argset);
     91        }
     92
     93    }
     94
     95    psFree(iter);
     96
     97    // make sure we found a mode
     98    if (config->mode == DETTOOL_MODE_NONE) {
     99        psError(PS_ERR_UNKNOWN, true, "mode argument is required");
     100        fprintf(stderr, "mode argument is required\n");
     101        printUsage(argc, argv, modes);
     102        return NULL;
     103    }
     104
     105    // actually parse the command line
     106    if (!psArgumentParse(config->args, &argc, argv)) {
     107        psError(PS_ERR_UNKNOWN, true, "error parsing arguments");
     108        fprintf(stderr, "error parsing arguments\n");
     109        printUsageMode(argc, argv, config->modeName, config->args);
     110        return NULL;
     111    }
     112
     113    // look for left overs on the command line
     114    if (argc != 1) {
     115        psError(PS_ERR_UNKNOWN, true, "extra arguments: ");
     116        fprintf(stderr, "extra arguments: ");
     117        for (int i = 1; i < argc; i++) {
     118            fprintf (stderr, "%s ", argv[i]);
     119        }
     120        fprintf(stderr, "\n");
     121        printUsageMode(argc, argv, config->modeName, config->args);
     122        return NULL;
     123    }
     124
     125    // make sure that all required parameters have been specified
     126    iter = psMetadataIteratorAlloc(config->args, PS_LIST_HEAD, NULL);
     127    item = NULL; // Item from iterator
     128    while ((item = psMetadataGetAndIncrement(iter))) {
     129        if (strstr(item->comment, "require") == NULL) {
     130            continue;
     131        }
     132
     133        switch (item->type) {
     134            case PS_DATA_BOOL:
     135                psError(PS_ERR_UNKNOWN, false, "boolean type can not be required");
     136                fprintf(stderr, "boolean type can not be required\n");
     137                return NULL;
     138                break;
     139            case PS_DATA_S8:
     140            case PS_DATA_S16:
     141            case PS_DATA_S32:
     142            case PS_DATA_S64:
     143                if (item->data.S64 != 0) {
     144                    break;
     145                }
     146                goto ARG_REQUIRED;
     147            case PS_DATA_U8:
     148            case PS_DATA_U16:
     149            case PS_DATA_U32:
     150            case PS_DATA_U64:
     151                if (item->data.U64 != 0) {
     152                    break;
     153                }
     154                goto ARG_REQUIRED;
     155            case PS_DATA_F32:
     156            case PS_DATA_F64:
     157                if (!isnan(item->data.F64)) {
     158                    break;
     159                }
     160                goto ARG_REQUIRED;
     161            case PS_DATA_STRING:
     162            case PS_DATA_METADATA:
     163                if (item->data.V) {
     164                    break;
     165                }
     166                goto ARG_REQUIRED;
     167            default:
     168                psError(PS_ERR_UNKNOWN, false, "unknown argument type");
     169                fprintf(stderr, "unknown argument type\n");
     170                return NULL;
     171            ARG_REQUIRED:               
     172                psError(PS_ERR_UNKNOWN, false, "argument %s is required", item->name);
     173                fprintf(stderr, "argument %s is required\n", item->name);
     174                printUsageMode(argc, argv, config->modeName, config->args);
     175                return NULL;
     176        }
     177
     178    }
     179
     180    psFree(iter);
     181
     182    return true;
     183}
     184
    58185
    59186pxConfig *dettoolConfig(pxConfig *config, int argc, char **argv) {
    … …  
    855982
    856983
    857     // figure out what mode we're running in
    858     char *modeName = NULL;
    859     psMetadataIterator *iter = psMetadataIteratorAlloc(modes, PS_LIST_HEAD, NULL);
    860     psMetadataItem *item = NULL; // Item from iterator
    861     while ((item = psMetadataGetAndIncrement(iter))) {
    862         int N = 0;
    863         if ((N = psArgumentGet(argc, argv, item->name))) {
    864             psArgumentRemove(N, &argc, argv);
    865             // check for duplicate mode specification
    866             if (config->mode) {
    867                 psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed");
    868                 fprintf(stderr, "only one mode selection is allowed\n");
    869                 printUsage(argc, argv, modes);
    870                 psFree(argSets);
    871                 psFree(modes);
    872                 psFree(config);
    873                 return NULL;
    874             }
    875 
    876             config->mode = item->data.U32;
    877             modeName = item->name;
    878 
    879             bool status = false;
    880             psMetadata *argset = psMetadataLookupMetadata(&status, argSets, item->name);
    881             // make sure we can find the argSet for the sepcified mode
    882             if (!status) {
    883                 psError(PS_ERR_UNKNOWN, true, "can not find arguments for mode");
    884                 fprintf(stderr, "can not find arugments for mode");
    885                 psFree(argSets);
    886                 psFree(modes);
    887                 psFree(config);
    888                 return NULL;
    889             }
    890 
    891             config->args = psMemIncrRefCounter(argset);
    892         }
    893 
    894     }
    895 
    896     psFree(iter);
    897     psFree(argSets);
    898 
    899     // make sure we found a mode
    900     if (config->mode == DETTOOL_MODE_NONE) {
    901         psError(PS_ERR_UNKNOWN, true, "mode argument is required");
    902         fprintf(stderr, "mode argument is required\n");
    903         printUsage(argc, argv, modes);
    904 
     984    if (!parseOptions(argc, argv, config, modes, argSets)) {
     985        psError(PS_ERR_UNKNOWN, true, "option parsing failed");
     986        psFree(argSets);
    905987        psFree(modes);
    906988        psFree(config);
    907989        return NULL;
    908990    }
    909 
    910     psFree(modes);
    911 
    912     // actually parse the command line
    913     if (!psArgumentParse(config->args, &argc, argv)) {
    914         psError(PS_ERR_UNKNOWN, true, "error parsing arguments");
    915         fprintf(stderr, "error parsing arguments\n");
    916         printUsageMode(argc, argv, modeName, config->args);
    917 
    918         psFree(config);
    919         return NULL;
    920     }
    921 
    922     // look for left overs on the command line
    923     if (argc != 1) {
    924         psError(PS_ERR_UNKNOWN, true, "extra arguments: ");
    925         fprintf(stderr, "extra arguments: ");
    926         for (int i = 1; i < argc; i++) {
    927             fprintf (stderr, "%s ", argv[i]);
    928         }
    929         fprintf(stderr, "\n");
    930         printUsageMode(argc, argv, modeName, config->args);
    931 
    932         psFree(config);
    933         return NULL;
    934     }
    935 
    936     // make sure that all require parameters have been specified
    937     iter = psMetadataIteratorAlloc(config->args, PS_LIST_HEAD, NULL);
    938     item = NULL; // Item from iterator
    939     while ((item = psMetadataGetAndIncrement(iter))) {
    940         if (strstr(item->comment, "require") == NULL) {
    941             continue;
    942         }
    943 
    944         switch (item->type) {
    945             case PS_DATA_BOOL:
    946                 psError(PS_ERR_UNKNOWN, false, "boolean type can not be required");
    947                 fprintf(stderr, "boolean type can not be required\n");
    948                 psFree(iter);
    949                 psFree(config);
    950                 return NULL;
    951                 break;
    952             case PS_DATA_S8:
    953             case PS_DATA_S16:
    954             case PS_DATA_S32:
    955             case PS_DATA_S64:
    956                 if (item->data.S64 != 0) {
    957                     break;
    958                 }
    959                 goto ARG_REQUIRED;
    960             case PS_DATA_U8:
    961             case PS_DATA_U16:
    962             case PS_DATA_U32:
    963             case PS_DATA_U64:
    964                 if (item->data.U64 != 0) {
    965                     break;
    966                 }
    967                 goto ARG_REQUIRED;
    968             case PS_DATA_F32:
    969             case PS_DATA_F64:
    970                 if (!isnan(item->data.F64)) {
    971                     break;
    972                 }
    973                 goto ARG_REQUIRED;
    974             case PS_DATA_STRING:
    975             case PS_DATA_METADATA:
    976                 if (item->data.V) {
    977                     break;
    978                 }
    979                 goto ARG_REQUIRED;
    980             default:
    981                 psError(PS_ERR_UNKNOWN, false, "unknown argument type");
    982                 fprintf(stderr, "unknown argument type\n");
    983                 psFree(iter);
    984                 psFree(config);
    985                 return NULL;
    986             ARG_REQUIRED:               
    987                 psError(PS_ERR_UNKNOWN, false, "argument %s is required", item->name);
    988                 fprintf(stderr, "argument %s is required\n", item->name);
    989                 printUsageMode(argc, argv, modeName, config->args);
    990                 psFree(iter);
    991                 psFree(config);
    992                 return NULL;
    993         }
    994 
    995     }
    996     psFree(iter);
    997991
    998992    // setup search criterion
Note: See TracChangeset for help on using the changeset viewer.