IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 13578


Ignore:
Timestamp:
May 31, 2007, 2:58:32 PM (19 years ago)
Author:
jhoblitt
Message:

convert to mulit-level option help

Location:
trunk/ippTools/src
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/src/camtoolConfig.c

    r12237 r13578  
    154154            "define banana 1", NULL);
    155155    psMetadataAddS16(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    156             "set fault code (required)", 0);
     156            "set fault code", 0);
    157157    psMetadataAddBool(addprocessedexpArgs, PS_LIST_TAIL, "-faulted",  0,
    158158            "only return imfiles with a fault status set", false);
    … …  
    199199            "name of a label to unmask", NULL);
    200200
    201 #define PXTOOL_MODE(option, modeval, argset) \
    202 { \
    203     int N = 0; \
    204     if ((N = psArgumentGet (argc, argv, option))) { \
    205         psArgumentRemove (N, &argc, argv); \
    206         if (config->mode) { \
    207             psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); \
    208             psFree(config); \
    209             return NULL; \
    210         } \
    211         config->mode = modeval; \
    212         config->args = psMemIncrRefCounter(argset); \
    213     } \
    214     if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, NULL, argset)) {;\
    215         psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option);\
    216     } \
    217     psFree(argset); \
    218 }
    219 
    220201    psMetadata *argSets = psMetadataAlloc();
    221     // find which mode we're running under
    222     PXTOOL_MODE("-queue",           CAMTOOL_MODE_QUEUE,         queueArgs);
    223     PXTOOL_MODE("-pendingexp",      CAMTOOL_MODE_PENDINGEXP,    pendingexpArgs);
    224     PXTOOL_MODE("-pendingimfile",CAMTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
    225     PXTOOL_MODE("-addprocessedexp", CAMTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
    226     PXTOOL_MODE("-processedexp", CAMTOOL_MODE_PROCESSEDEXP,  processedexpArgs);
    227     PXTOOL_MODE("-updateprocessedexp", CAMTOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpArgs);
    228     PXTOOL_MODE("-block",           CAMTOOL_MODE_BLOCK,         blockArgs);
    229     PXTOOL_MODE("-masked",          CAMTOOL_MODE_MASKED,        maskedArgs);
    230     PXTOOL_MODE("-unblock",         CAMTOOL_MODE_UNBLOCK,       unblockArgs);
    231 
    232     bool argErr = false;
    233     if (config->mode == CAMTOOL_MODE_NONE) {
    234         argErr = true;
    235         fprintf (stderr, "mode argument is required\n");
    236     } else if (! psArgumentParse(config->args, &argc, argv) || argc != 1) {
    237         argErr = true;
    238         fprintf (stderr, "error parsing arguments\n");
    239     }
    240 
    241     if (argErr) {
    242         printf("\nPan-STARRS Camera Tool\n");
    243         printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    244         printf(" <mode> :\n\n");
    245 
    246         psMetadataIterator *iter = psMetadataIteratorAlloc(argSets, 0, NULL);
    247         psMetadataItem *item = NULL;
    248         while ((item = psMetadataGetAndIncrement(iter))) {
    249             if (!item->type == PS_DATA_METADATA) {
    250                 psAbort("all options must be specified as a metadata");            }
    251 
    252             fprintf(stdout, "%s ", item->name);
    253             psArgumentHelp(item->data.md);
    254         }
    255         psFree(iter);
    256 
     202    psMetadata *modes = psMetadataAlloc();
     203
     204    PXTOOL_ADD_MODE("-queue",               "", CAMTOOL_MODE_QUEUE,         queueArgs);
     205    PXTOOL_ADD_MODE("-pendingexp",          "", CAMTOOL_MODE_PENDINGEXP,    pendingexpArgs);
     206    PXTOOL_ADD_MODE("-pendingimfile",       "", CAMTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
     207    PXTOOL_ADD_MODE("-addprocessedexp",     "", CAMTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     208    PXTOOL_ADD_MODE("-processedexp",        "", CAMTOOL_MODE_PROCESSEDEXP,  processedexpArgs);
     209    PXTOOL_ADD_MODE("-updateprocessedexp",  "", CAMTOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpArgs);
     210    PXTOOL_ADD_MODE("-block",               "", CAMTOOL_MODE_BLOCK,         blockArgs);
     211    PXTOOL_ADD_MODE("-masked",              "", CAMTOOL_MODE_MASKED,        maskedArgs);
     212    PXTOOL_ADD_MODE("-unblock",             "", CAMTOOL_MODE_UNBLOCK,       unblockArgs);
     213
     214    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
     215        psError(PS_ERR_UNKNOWN, true, "option parsing failed");
    257216        psFree(argSets);
     217        psFree(modes);
    258218        psFree(config);
    259219        return NULL;
    … …  
    261221
    262222    psFree(argSets);
     223    psFree(modes);
    263224
    264225    // setup search criterion
    … …  
    346307    }
    347308
    348     // save argv/argc
    349     config->argv = argv;
    350     config->argc = argc;
    351 
    352309    return config;
    353310}

  • trunk/ippTools/src/chiptool.h

    r12232 r13578  
    3232    CHIPTOOL_MODE_BLOCK,
    3333    CHIPTOOL_MODE_MASKED,
    34     CHIPTOOL_MODE_UNBLOCK
     34    CHIPTOOL_MODE_UNBLOCK,
     35    CHIPTOOL_MODE_RETRYPROCESSEDIMFILE
    3536} chiptoolMode;
    3637

  • trunk/ippTools/src/chiptoolConfig.c

    r12232 r13578  
    2727#include "chiptool.h"
    2828
    29 pxConfig *chiptoolConfig(pxConfig *config, int argc, char **argv) {
     29pxConfig *chiptoolConfig(pxConfig *config, int argc, char **argv)
     30{
    3031    if (!config) {
    3132        config = pxConfigAlloc();
    … …  
    135136            "define banana 1", NULL);
    136137    psMetadataAddS8(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
    137             "set fault code (required)", 0);
     138            "set fault code", 0);
    138139
    139140    // -processedimfile
    … …  
    173174            "set fault code (required)", 0);
    174175
     176    // -retryprocessedimfile
     177    psMetadata *retryprocessedimfileArgs = psMetadataAlloc();
     178    psMetadataAddStr(retryprocessedimfileArgs, PS_LIST_TAIL, "-chip_id",  0,
     179            "define chip ID (required)", NULL);
     180    psMetadataAddStr(retryprocessedimfileArgs, PS_LIST_TAIL, "-exp_tag",  0,
     181            "search by exposure ID", NULL);
     182    psMetadataAddStr(retryprocessedimfileArgs, PS_LIST_TAIL, "-class",  0,
     183            "search by class", NULL);
     184    psMetadataAddStr(retryprocessedimfileArgs, PS_LIST_TAIL, "-class_id",  0,
     185            "search by class ID", NULL);
    175186
    176187    // -block
    … …  
    189200            "name of a label to unmask", NULL);
    190201
    191 #define PXTOOL_MODE(option, modeval, argset) \
    192 { \
    193     int N = 0; \
    194     if ((N = psArgumentGet (argc, argv, option))) { \
    195         psArgumentRemove (N, &argc, argv); \
    196         if (config->mode) { \
    197             psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); \
    198             psFree(config); \
    199             return NULL; \
    200         } \
    201         config->mode = modeval; \
    202         config->args = psMemIncrRefCounter(argset); \
    203     } \
    204     if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, NULL, argset)) {; \
    205         psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option); \
    206     } \
    207     psFree(argset); \
    208 }
    209 
    210202    psMetadata *argSets = psMetadataAlloc();
    211     PXTOOL_MODE("-queue",           CHIPTOOL_MODE_QUEUE,          queueArgs);
    212     PXTOOL_MODE("-pendingimfile",   CHIPTOOL_MODE_PENDINGIMFILE,  pendingimfileArgs);
    213     PXTOOL_MODE("-addprocessedimfile",CHIPTOOL_MODE_ADDPROCESSEDIMFILE,addprocessedimfileArgs);
    214     PXTOOL_MODE("-processedimfile",CHIPTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
    215     PXTOOL_MODE("-updateprocessedimfile",CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,    updateprocessedimfileArgs);
    216     PXTOOL_MODE("-block",           CHIPTOOL_MODE_BLOCK,          blockArgs);
    217     PXTOOL_MODE("-masked",          CHIPTOOL_MODE_MASKED,         maskedArgs);
    218     PXTOOL_MODE("-unblock",         CHIPTOOL_MODE_UNBLOCK,        unblockArgs);
    219 
    220     bool argErr = false;
    221     if (config->mode == CHIPTOOL_MODE_NONE) {
    222             argErr = true;
    223         fprintf (stderr, "mode argument is required\n");
    224     } else if (! psArgumentParse(config->args, &argc, argv) || argc != 1) {
    225         argErr = true;
    226         fprintf (stderr, "error parsing arguments\n");
    227     }
    228 
    229     if (argErr) {
    230         printf("\nPan-STARRS Chip Tool\n\n");
    231         printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    232         printf(" <mode> :\n\n");
    233 
    234         psMetadataIterator *iter = psMetadataIteratorAlloc(argSets, 0, NULL);
    235         psMetadataItem *item = NULL;
    236         while ((item = psMetadataGetAndIncrement(iter))) {
    237             if (!item->type == PS_DATA_METADATA) {
    238                 psAbort("all options must be specified as a metadata");            }
    239 
    240             fprintf(stdout, "%s ", item->name);
    241             psArgumentHelp(item->data.md);
    242         }
    243         psFree(iter);
    244 
     203    psMetadata *modes = psMetadataAlloc();
     204
     205    PXTOOL_ADD_MODE("-queue",               "", CHIPTOOL_MODE_QUEUE,          queueArgs);
     206    PXTOOL_ADD_MODE("-pendingimfile",       "", CHIPTOOL_MODE_PENDINGIMFILE,  pendingimfileArgs);
     207    PXTOOL_ADD_MODE("-addprocessedimfile",  "", CHIPTOOL_MODE_ADDPROCESSEDIMFILE,addprocessedimfileArgs);
     208    PXTOOL_ADD_MODE("-processedimfile",     "", CHIPTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
     209    PXTOOL_ADD_MODE("-updateprocessedimfile", "", CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,    updateprocessedimfileArgs);
     210    PXTOOL_ADD_MODE("-retryprocessedimfile", "", CHIPTOOL_MODE_RETRYPROCESSEDIMFILE,    retryprocessedimfileArgs);
     211    PXTOOL_ADD_MODE("-block",               "",            CHIPTOOL_MODE_BLOCK,          blockArgs);
     212    PXTOOL_ADD_MODE("-masked",              "",      CHIPTOOL_MODE_MASKED,         maskedArgs);
     213    PXTOOL_ADD_MODE("-unblock",             "",  CHIPTOOL_MODE_UNBLOCK,        unblockArgs);
     214
     215    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
     216        psError(PS_ERR_UNKNOWN, true, "option parsing failed");
    245217        psFree(argSets);
     218        psFree(modes);
    246219        psFree(config);
    247220        return NULL;
    … …  
    249222
    250223    psFree(argSets);
     224    psFree(modes);
    251225
    252226    // setup search criterion
    … …  
    321295    }
    322296
    323     // save argv/argc
    324     config->argv = argv;
    325     config->argc = argc;
    326 
    327297    return config;
    328298}

  • trunk/ippTools/src/detselectConfig.c

    r11856 r13578  
    7878            "use the simple output format", false);
    7979   
    80 #define PXTOOL_MODE(option, modeval, argset) \
    81 { \
    82     int N = 0; \
    83     if ((N = psArgumentGet (argc, argv, option))) { \
    84         psArgumentRemove (N, &argc, argv); \
    85         if (config->mode) { \
    86             psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); \
    87             psFree(config); \
    88             return NULL; \
    89         } \
    90         config->mode = modeval; \
    91         config->args = psMemIncrRefCounter(argset); \
    92     } \
    93     if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, NULL, argset)) {;\
    94         psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option);\
    95     } \
    96     psFree(argset); \
    97 }
    98 
    9980    psMetadata *argSets = psMetadataAlloc();
    100     // find which mode we're running under
    101     PXTOOL_MODE("-search",  DETSELECT_MODE_SEARCH, searchArgs);
    102     PXTOOL_MODE("-select",  DETSELECT_MODE_SELECT, selectArgs);
    103 
    104     bool argErr = false;
    105     if (config->mode == DETSELECT_MODE_NONE) {
    106         argErr = true;
    107         fprintf (stderr, "mode argument is required\n");
    108     } else if (! psArgumentParse(config->args, &argc, argv) || argc != 1) {
    109         argErr = true;
    110         fprintf (stderr, "error parsing arguments\n");
    111     }
    112 
    113     if (argErr) {
    114         printf("\nPan-STARRS detrend select Tool\n");
    115         printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    116         printf(" <mode> :\n\n");
    117 
    118         psMetadataIterator *iter = psMetadataIteratorAlloc(argSets, 0, NULL);
    119         psMetadataItem *item = NULL;
    120         while ((item = psMetadataGetAndIncrement(iter))) {
    121             if (!item->type == PS_DATA_METADATA) {
    122                 psAbort("all options must be specified as a metadata");            }
    123 
    124             fprintf(stdout, "%s ", item->name);
    125             psArgumentHelp(item->data.md);
    126         }
    127         psFree(iter);
    128 
     81    psMetadata *modes = psMetadataAlloc();
     82
     83    PXTOOL_ADD_MODE("-search",  "search for an appropriate detrend", DETSELECT_MODE_SEARCH, searchArgs);
     84    PXTOOL_ADD_MODE("-select",  "retreive detrend information", DETSELECT_MODE_SELECT, selectArgs);
     85
     86    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
     87        psError(PS_ERR_UNKNOWN, true, "option parsing failed");
    12988        psFree(argSets);
     89        psFree(modes);
    13090        psFree(config);
    13191        return NULL;
    … …  
    13393
    13494    psFree(argSets);
     95    psFree(modes);
    13596
    13697    // setup search criterion
    … …  
    262223    }
    263224
    264     // save argv/argc
    265     config->argv = argv;
    266     config->argc = argc;
    267 
    268225    return config;
    269226}

  • trunk/ippTools/src/dettoolConfig.c

    r13576 r13578  
    934934    }
    935935
    936     // save argv/argc
    937     config->argv = argv;
    938     config->argc = argc;
    939 
    940936    return config;
    941937}

  • trunk/ippTools/src/difftoolConfig.c

    r12131 r13578  
    9191    psMetadata *inputskyfileArgs = psMetadataAlloc();
    9292    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
    93             "search by diff ID (required)", NULL);
     93            "search by diff ID", NULL);
    9494    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    95             "search by warp ID (required)", NULL);
     95            "search by warp ID", NULL);
    9696    psMetadataAddStr(inputskyfileArgs, PS_LIST_TAIL, "-skycell_id", 0,
    9797            "search by skycell ID", NULL);
    … …  
    132132            "search by warp ID", NULL);
    133133    psMetadataAddStr(diffskyfileArgs , PS_LIST_TAIL, "-skycell_id",  0,
    134             "define skycell ID (required)", NULL);
     134            "define skycell ID", NULL);
    135135    psMetadataAddStr(diffskyfileArgs, PS_LIST_TAIL, "-tess_id",  0,
    136             "define tessellation ID (required)", NULL);
     136            "define tessellation ID", NULL);
    137137    psMetadataAddU64(diffskyfileArgs, PS_LIST_TAIL, "-limit",  0,
    138138            "limit result set to N items", 0);
    … …  
    142142    psFree(now);
    143143
    144 #define PXTOOL_MODE(option, modeval, argset) \
    145 { \
    146     int N = 0; \
    147     if ((N = psArgumentGet (argc, argv, option))) { \
    148         psArgumentRemove (N, &argc, argv); \
    149         if (config->mode) { \
    150             psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); \
    151             psFree(config); \
    152             return NULL; \
    153         } \
    154         config->mode = modeval; \
    155         config->args = psMemIncrRefCounter(argset); \
    156     } \
    157     if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, NULL, argset)) {;\
    158         psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option); \
    159     } \
    160     psFree(argset); \
    161 }
    162 
    163144    psMetadata *argSets = psMetadataAlloc();
    164     // find which mode we're running under
    165     PXTOOL_MODE("-definerun",       DIFFTOOL_MODE_DEFINERUN,      definerunArgs);
    166     PXTOOL_MODE("-updaterun",       DIFFTOOL_MODE_UPDATERUN,      updaterunArgs);
    167     PXTOOL_MODE("-addinputskyfile",  DIFFTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
    168     PXTOOL_MODE("-inputskyfile",     DIFFTOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
    169     PXTOOL_MODE("-todiffskyfile",    DIFFTOOL_MODE_TODIFFSKYFILE,   todiffskyfileArgs);
    170     PXTOOL_MODE("-adddiffskyfile",   DIFFTOOL_MODE_ADDDIFFSKYFILE,  adddiffskyfileArgs);
    171     PXTOOL_MODE("-diffskyfile",      DIFFTOOL_MODE_DIFFSKYFILE,     diffskyfileArgs);
    172 
    173     bool argErr = false;
    174     if (config->mode == DIFFTOOL_MODE_NONE) {
    175         argErr = true;
    176         fprintf (stderr, "mode argument is required\n");
    177     } else if (! psArgumentParse(config->args, &argc, argv) || argc != 1) {
    178         argErr = true;
    179         fprintf (stderr, "error parsing arguments\n");
    180     }
    181 
    182     if (argErr) {
    183         printf("\nPan-STARRS Difference Tool\n");
    184         printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    185         printf(" <mode> :\n\n");
    186 
    187         psMetadataIterator *iter = psMetadataIteratorAlloc(argSets, 0, NULL);
    188         psMetadataItem *item = NULL;
    189         while ((item = psMetadataGetAndIncrement(iter))) {
    190             if (!item->type == PS_DATA_METADATA) {
    191                 psAbort("all options must be specified as a metadata");
    192             }
    193 
    194             fprintf(stdout, "%s ", item->name);
    195             psArgumentHelp(item->data.md);
    196         }
    197         psFree(iter);
    198 
     145    psMetadata *modes = psMetadataAlloc();
     146
     147    PXTOOL_ADD_MODE("-definerun",       "", DIFFTOOL_MODE_DEFINERUN,      definerunArgs);
     148    PXTOOL_ADD_MODE("-updaterun",       "",       DIFFTOOL_MODE_UPDATERUN,      updaterunArgs);
     149    PXTOOL_ADD_MODE("-addinputskyfile", "",  DIFFTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
     150    PXTOOL_ADD_MODE("-inputskyfile",    "",     DIFFTOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
     151    PXTOOL_ADD_MODE("-todiffskyfile",   "",    DIFFTOOL_MODE_TODIFFSKYFILE,   todiffskyfileArgs);
     152    PXTOOL_ADD_MODE("-adddiffskyfile",  "",   DIFFTOOL_MODE_ADDDIFFSKYFILE,  adddiffskyfileArgs);
     153    PXTOOL_ADD_MODE("-diffskyfile",     "",      DIFFTOOL_MODE_DIFFSKYFILE,     diffskyfileArgs);
     154
     155    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
     156        psError(PS_ERR_UNKNOWN, true, "option parsing failed");
    199157        psFree(argSets);
     158        psFree(modes);
    200159        psFree(config);
    201160        return NULL;
    … …  
    203162
    204163    psFree(argSets);
     164    psFree(modes);
    205165
    206166    // setup search criterion
    … …  
    275235    }
    276236
    277     // save argv/argc
    278     config->argv = argv;
    279     config->argc = argc;
    280 
    281237    return config;
    282238}

  • trunk/ippTools/src/pxconfig.c

    r13576 r13578  
    201201    psFree(iter);
    202202
     203    // save argv/argc
     204    config->argv = argv;
     205    config->argc = argc;
     206
    203207    return true;
    204208}

  • trunk/ippTools/src/pxinjectConfig.c

    r12025 r13578  
    6969        "define the URI (required)", NULL);
    7070
    71 #define PXTOOL_MODE(option, modeval, argset) \
    72 { \
    73     int N = 0; \
    74     if ((N = psArgumentGet (argc, argv, option))) { \
    75         psArgumentRemove (N, &argc, argv); \
    76         if (config->mode) { \
    77             psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); \
    78         } \
    79         config->mode = modeval; \
    80         config->args = psMemIncrRefCounter(argset); \
    81     } \
    82 }
     71    psMetadata *argSets = psMetadataAlloc();
     72    psMetadata *modes = psMetadataAlloc();
    8373
    84     // find which mode we're running under
    85     PXTOOL_MODE("-newExp",          PXINJECT_MODE_NEWEXP,       newExpArgs);
    86     PXTOOL_MODE("-newImfile",       PXINJECT_MODE_NEWIMFILE,    newImfileArgs);
     74    PXTOOL_ADD_MODE("-newExp",      "", PXINJECT_MODE_NEWEXP,       newExpArgs);
     75    PXTOOL_ADD_MODE("-newImfile",   "", PXINJECT_MODE_NEWIMFILE,    newImfileArgs);
    8776
    88     bool argErr = false;
    89     if (config->mode == PXINJECT_MODE_NONE) {
    90         argErr = true;
    91         fprintf (stderr, "mode argument is required\n");
    92     } else if (! psArgumentParse(config->args, &argc, argv) || argc != 1) {
    93         argErr = true;
    94         fprintf (stderr, "error parsing arguments\n");
    95     }
    96 
    97     if (argErr) {
    98         printf("\nPan-STARRS Detrend Tool\n");
    99         printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    100         printf(" <mode> : [-newExp|-newImfile]\n\n");
    101         fprintf (stdout, "-newExp ");
    102         psArgumentHelp(newExpArgs);
    103         psFree(newExpArgs);
    104         fprintf (stdout, "-newImfile ");
    105         psArgumentHelp(newImfileArgs);
    106         psFree(newImfileArgs);
    107 
     77    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
     78        psError(PS_ERR_UNKNOWN, true, "option parsing failed");
     79        psFree(argSets);
     80        psFree(modes);
    10881        psFree(config);
    10982        return NULL;
    11083    }
    11184
    112     psFree(newExpArgs);
    113     psFree(newImfileArgs);
     85    psFree(argSets);
     86    psFree(modes);
    11487
    11588    // setup search criterion
    … …  
    211184    }
    212185
    213     // save argv/argc
    214     config->argv = argv;
    215     config->argc = argc;
    216 
    217186    return config;
    218187}

  • trunk/ippTools/src/regtoolConfig.c

    r12347 r13578  
    9696        "define observation time", NULL);
    9797    psMetadataAddS8(addprocessedimfileArgs, PS_LIST_TAIL, "-code",  0,
    98         "set fault code (required)", 0);
     98        "set fault code", 0);
    9999
    100100    // -processedimfile
    … …  
    179179        "define label for phase 2 processing (non-detrend data only)", NULL);
    180180    psMetadataAddS8(addprocessedexpArgs, PS_LIST_TAIL, "-code",  0,
    181         "set fault code (required)", 0);
     181        "set fault code", 0);
    182182    /*
    183183    psMetadataAddStr(updateArgs, PS_LIST_TAIL, "-recip",  0,
    … …  
    208208   
    209209
    210 #define PXTOOL_MODE(option, modeval, argset) \
    211 { \
    212     int N = 0; \
    213     if ((N = psArgumentGet (argc, argv, option))) { \
    214         psArgumentRemove (N, &argc, argv); \
    215         if (config->mode) { \
    216             psError(PXTOOLS_ERR_CONFIG, true, "only one mode selection is allowed"); \
    217             psFree(config); \
    218             return NULL; \
    219         } \
    220         config->mode = modeval; \
    221         config->args = psMemIncrRefCounter(argset); \
    222     } \
    223     if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, NULL, argset)) {;\
    224         psError(PXTOOLS_ERR_PROG, false, "failed to add argset for %s", option);\
    225     } \
    226     psFree(argset); \
    227 }
    228 
    229210    psMetadata *argSets = psMetadataAlloc();
    230     // find which mode we're running under
    231     PXTOOL_MODE("-pendingimfile",   REGTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
    232     PXTOOL_MODE("-addprocessedimfile", REGTOOL_MODE_ADDPROCESSEDIMFILE, addprocessedimfileArgs);
    233     PXTOOL_MODE("-processedimfile", REGTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
    234     PXTOOL_MODE("-updateprocessedimfile",  REGTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs);
    235     PXTOOL_MODE("-pendingexp",      REGTOOL_MODE_PENDINGEXP,pendingexpArgs);
    236     PXTOOL_MODE("-addprocessedexp", REGTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
    237     PXTOOL_MODE("-processedexp",    REGTOOL_MODE_PROCESSEDEXP, processedexpArgs);
    238     PXTOOL_MODE("-updateprocessedexp", REGTOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
    239 
    240     bool argErr = false;
    241     if (config->mode == REGTOOL_MODE_NONE) {
    242         psError(PXTOOLS_ERR_CONFIG, false, "missing mode argument");
    243         fprintf (stderr, "mode argument is required\n");
    244         argErr = true;
    245     } else if (! psArgumentParse(config->args, &argc, argv) || argc != 1) {
    246         psError(PXTOOLS_ERR_CONFIG, false, "unknown argument");
    247         fprintf (stderr, "error parsing arguments\n");
    248         argErr = true;
    249     }
    250 
    251     if (argErr) {
    252         printf("\nPan-STARRS Registration Tool\n");
    253         printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    254         printf(" <mode> :\n\n");
    255 
    256         psMetadataIterator *iter = psMetadataIteratorAlloc(argSets, 0, NULL);
    257         psMetadataItem *item = NULL;
    258         while ((item = psMetadataGetAndIncrement(iter))) {
    259             if (!item->type == PS_DATA_METADATA) {
    260                 psAbort("all options must be specified as a metadata");            }
    261 
    262             fprintf(stdout, "%s ", item->name);
    263             psArgumentHelp(item->data.md);
    264         }
    265         psFree(iter);
    266 
     211    psMetadata *modes = psMetadataAlloc();
     212
     213    PXTOOL_ADD_MODE("-pendingimfile",           "", REGTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
     214    PXTOOL_ADD_MODE("-addprocessedimfile",      "",  REGTOOL_MODE_ADDPROCESSEDIMFILE, addprocessedimfileArgs);
     215    PXTOOL_ADD_MODE("-processedimfile",         "", REGTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
     216    PXTOOL_ADD_MODE("-updateprocessedimfile",   "",   REGTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs);
     217    PXTOOL_ADD_MODE("-pendingexp",              "",       REGTOOL_MODE_PENDINGEXP,pendingexpArgs);
     218    PXTOOL_ADD_MODE("-addprocessedexp",         "",  REGTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     219    PXTOOL_ADD_MODE("-processedexp",            "",     REGTOOL_MODE_PROCESSEDEXP, processedexpArgs);
     220    PXTOOL_ADD_MODE("-updateprocessedexp",      "",  REGTOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
     221
     222    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
     223        psError(PS_ERR_UNKNOWN, true, "option parsing failed");
    267224        psFree(argSets);
     225        psFree(modes);
    268226        psFree(config);
    269227        return NULL;
    … …  
    271229
    272230    psFree(argSets);
     231    psFree(modes);
    273232
    274233    // setup search criterion
    … …  
    333292    }
    334293
    335     // save argv/argc
    336     config->argv = argv;
    337     config->argc = argc;
    338 
    339294    return config;
    340295}

  • trunk/ippTools/src/stacktoolConfig.c

    r12131 r13578  
    2727#include "stacktool.h"
    2828
    29 pxConfig *stacktoolConfig(pxConfig *config, int argc, char **argv) {
     29pxConfig *stacktoolConfig(pxConfig *config, int argc, char **argv)
     30{
    3031    if (!config) {
    3132        config = pxConfigAlloc();
    … …  
    129130    psFree(now);
    130131
    131 #define PXTOOL_MODE(option, modeval, argset) \
    132 { \
    133     int N = 0; \
    134     if ((N = psArgumentGet (argc, argv, option))) { \
    135         psArgumentRemove (N, &argc, argv); \
    136         if (config->mode) { \
    137             psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); \
    138             psFree(config); \
    139             return NULL; \
    140         } \
    141         config->mode = modeval; \
    142         config->args = psMemIncrRefCounter(argset); \
    143     } \
    144     if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, NULL, argset)) {;\
    145         psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option); \
    146     } \
    147     psFree(argset); \
    148 }
    149 
    150132    psMetadata *argSets = psMetadataAlloc();
    151     // find which mode we're running under
    152     PXTOOL_MODE("-definerun",       STACKTOOL_MODE_DEFINERUN,      definerunArgs);
    153     PXTOOL_MODE("-updaterun",       STACKTOOL_MODE_UPDATERUN,      updaterunArgs);
    154     PXTOOL_MODE("-addinputskyfile",  STACKTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
    155     PXTOOL_MODE("-inputskyfile",     STACKTOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
    156     PXTOOL_MODE("-tosum",           STACKTOOL_MODE_TOSUM,          tosumArgs);
    157     PXTOOL_MODE("-addsumskyfile",    STACKTOOL_MODE_ADDSUMSKYFILE,   addsumskyfileArgs);
    158     PXTOOL_MODE("-sumskyfile",       STACKTOOL_MODE_SUMSKYFILE,      sumskyfileArgs);
    159 
    160     bool argErr = false;
    161     if (config->mode == STACKTOOL_MODE_NONE) {
    162         argErr = true;
    163         fprintf (stderr, "mode argument is required\n");
    164     } else if (! psArgumentParse(config->args, &argc, argv) || argc != 1) {
    165         argErr = true;
    166         fprintf (stderr, "error parsing arguments\n");
    167     }
    168 
    169     if (argErr) {
    170         printf("\nPan-STARRS Stack Tool\n");
    171         printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    172         printf(" <mode> :\n\n");
    173 
    174         psMetadataIterator *iter = psMetadataIteratorAlloc(argSets, 0, NULL);
    175         psMetadataItem *item = NULL;
    176         while ((item = psMetadataGetAndIncrement(iter))) {
    177             if (!item->type == PS_DATA_METADATA) {
    178                 psAbort("all options must be specified as a metadata");
    179             }
    180 
    181             fprintf(stdout, "%s ", item->name);
    182             psArgumentHelp(item->data.md);
    183         }
    184         psFree(iter);
    185 
     133    psMetadata *modes   = psMetadataAlloc();
     134
     135    PXTOOL_ADD_MODE("-definerun",       "", STACKTOOL_MODE_DEFINERUN,      definerunArgs);
     136    PXTOOL_ADD_MODE("-updaterun",       "", STACKTOOL_MODE_UPDATERUN,      updaterunArgs);
     137    PXTOOL_ADD_MODE("-addinputskyfile", "", STACKTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
     138    PXTOOL_ADD_MODE("-inputskyfile",    "", STACKTOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
     139    PXTOOL_ADD_MODE("-tosum",           "", STACKTOOL_MODE_TOSUM,          tosumArgs);
     140    PXTOOL_ADD_MODE("-addsumskyfile",   "", STACKTOOL_MODE_ADDSUMSKYFILE,   addsumskyfileArgs);
     141    PXTOOL_ADD_MODE("-sumskyfile",      "", STACKTOOL_MODE_SUMSKYFILE,      sumskyfileArgs);
     142
     143    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
     144        psError(PS_ERR_UNKNOWN, true, "option parsing failed");
    186145        psFree(argSets);
     146        psFree(modes);
    187147        psFree(config);
    188148        return NULL;
    … …  
    190150
    191151    psFree(argSets);
     152    psFree(modes);
    192153
    193154    // setup search criterion
    … …  
    252213    }
    253214
    254     // save argv/argc
    255     config->argv = argv;
    256     config->argc = argc;
    257 
    258215    return config;
    259216}

  • trunk/ippTools/src/warptoolConfig.c

    r12131 r13578  
    2727#include "warptool.h"
    2828
    29 pxConfig *warptoolConfig(pxConfig *config, int argc, char **argv) {
     29pxConfig *warptoolConfig(pxConfig *config, int argc, char **argv)
     30{
    3031    if (!config) {
    3132        config = pxConfigAlloc();
    … …  
    157158            "search by warptool ID", NULL);
    158159    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    159             "define skycell ID (required)", NULL);
     160            "define skycell ID", NULL);
    160161    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    161             "define tessellation ID (required)", NULL);
     162            "define tessellation ID", NULL);
    162163    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-exp_tag", 0,
    163             "define exposure tag (required)", NULL);
     164            "define exposure tag", NULL);
    164165    psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-cam_id", 0,
    165             "define phase 3 version of exposure tag (required)", NULL);
     166            "define phase 3 version of exposure tag", NULL);
    166167    psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,
    167168            "limit result set to N items", 0);
    … …  
    171172    psFree(now);
    172173
    173 #define PXTOOL_MODE(option, modeval, argset) \
    174 { \
    175     int N = 0; \
    176     if ((N = psArgumentGet (argc, argv, option))) { \
    177         psArgumentRemove (N, &argc, argv); \
    178         if (config->mode) { \
    179             psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed"); \
    180             psFree(config); \
    181             return NULL; \
    182         } \
    183         config->mode = modeval; \
    184         config->args = psMemIncrRefCounter(argset); \
    185     } \
    186     if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, NULL, argset)) {;\
    187         psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option); \
    188     } \
    189     psFree(argset); \
    190 }
    191 
    192174    psMetadata *argSets = psMetadataAlloc();
    193     // find which mode we're running under
    194     PXTOOL_MODE("-definerun",       WARPTOOL_MODE_DEFINERUN,      definerunArgs);
    195     PXTOOL_MODE("-updaterun",       WARPTOOL_MODE_UPDATERUN,      updaterunArgs);
    196     PXTOOL_MODE("-addinputexp",     WARPTOOL_MODE_ADDINPUTEXP,    addinputexpArgs);
    197     PXTOOL_MODE("-exp",             WARPTOOL_MODE_EXP,            expArgs);
    198     PXTOOL_MODE("-imfile",          WARPTOOL_MODE_IMFILE,         imfileArgs);
    199     PXTOOL_MODE("-tooverlap",       WARPTOOL_MODE_TOOVERLAP,      tooverlapArgs);
    200     PXTOOL_MODE("-addoverlap",      WARPTOOL_MODE_ADDOVERLAP,     addoverlapArgs);
    201     PXTOOL_MODE("-scmap",           WARPTOOL_MODE_SCMAP,          scmapArgs);
    202     PXTOOL_MODE("-towarped",        WARPTOOL_MODE_TOWARPED,       towarpedArgs);
    203     PXTOOL_MODE("-addwarped",       WARPTOOL_MODE_ADDWARPED,      addwarpedArgs);
    204     PXTOOL_MODE("-warped",          WARPTOOL_MODE_WARPED,         warpedArgs);
     175    psMetadata *modes   = psMetadataAlloc();
     176
     177    PXTOOL_ADD_MODE("-definerun",       "", WARPTOOL_MODE_DEFINERUN,      definerunArgs);
     178    PXTOOL_ADD_MODE("-updaterun",       "", WARPTOOL_MODE_UPDATERUN,      updaterunArgs);
     179    PXTOOL_ADD_MODE("-addinputexp",     "", WARPTOOL_MODE_ADDINPUTEXP,    addinputexpArgs);
     180    PXTOOL_ADD_MODE("-exp",             "", WARPTOOL_MODE_EXP,            expArgs);
     181    PXTOOL_ADD_MODE("-imfile",          "", WARPTOOL_MODE_IMFILE,         imfileArgs);
     182    PXTOOL_ADD_MODE("-tooverlap",       "", WARPTOOL_MODE_TOOVERLAP,      tooverlapArgs);
     183    PXTOOL_ADD_MODE("-addoverlap",      "", WARPTOOL_MODE_ADDOVERLAP,     addoverlapArgs);
     184    PXTOOL_ADD_MODE("-scmap",           "", WARPTOOL_MODE_SCMAP,          scmapArgs);
     185    PXTOOL_ADD_MODE("-towarped",        "", WARPTOOL_MODE_TOWARPED,       towarpedArgs);
     186    PXTOOL_ADD_MODE("-addwarped",       "", WARPTOOL_MODE_ADDWARPED,      addwarpedArgs);
     187    PXTOOL_ADD_MODE("-warped",          "", WARPTOOL_MODE_WARPED,         warpedArgs);
    205188#if 0
    206     PXTOOL_MODE("-tostackedimfile", WARPTOOL_MODE_TOSTACKEDIMFILE, tostackedimfileArgs);
    207     PXTOOL_MODE("-addstackedimfile", WARPTOOL_MODE_ADDSTACKEDIMFILE, addstackedimfileArgs);
    208     PXTOOL_MODE("-stackedimfile",   WARPTOOL_MODE_STACKEDIMFILE, stackedimfileArgs);
    209     PXTOOL_MODE("-todiffimfile", WARPTOOL_MODE_TODIFFIMFILE, todiffimfileArgs);
    210     PXTOOL_MODE("-adddiffimfile", WARPTOOL_MODE_ADDDIFFIMFILE, adddiffimfileArgs);
    211     PXTOOL_MODE("-diffimfile",   WARPTOOL_MODE_DIFFIMFILE, diffimfileArgs);
     189    PXTOOL_ADD_MODE("-tostackedimfile", WARPTOOL_MODE_TOSTACKEDIMFILE, tostackedimfileArgs);
     190    PXTOOL_ADD_MODE("-addstackedimfile", WARPTOOL_MODE_ADDSTACKEDIMFILE, addstackedimfileArgs);
     191    PXTOOL_ADD_MODE("-stackedimfile",   WARPTOOL_MODE_STACKEDIMFILE, stackedimfileArgs);
     192    PXTOOL_ADD_MODE("-todiffimfile", WARPTOOL_MODE_TODIFFIMFILE, todiffimfileArgs);
     193    PXTOOL_ADD_MODE("-adddiffimfile", WARPTOOL_MODE_ADDDIFFIMFILE, adddiffimfileArgs);
     194    PXTOOL_ADD_MODE("-diffimfile",   WARPTOOL_MODE_DIFFIMFILE, diffimfileArgs);
    212195#endif
    213196
    214     bool argErr = false;
    215     if (config->mode == WARPTOOL_MODE_NONE) {
    216         argErr = true;
    217         fprintf (stderr, "mode argument is required\n");
    218     } else if (! psArgumentParse(config->args, &argc, argv) || argc != 1) {
    219         argErr = true;
    220         fprintf (stderr, "error parsing arguments\n");
    221     }
    222 
    223     if (argErr) {
    224         printf("\nPan-STARRS Warp Tool\n");
    225         printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    226         printf(" <mode> :\n\n");
    227 
    228         psMetadataIterator *iter = psMetadataIteratorAlloc(argSets, 0, NULL);
    229         psMetadataItem *item = NULL;
    230         while ((item = psMetadataGetAndIncrement(iter))) {
    231             if (!item->type == PS_DATA_METADATA) {
    232                 psAbort("all options must be specified as a metadata");
    233             }
    234 
    235             fprintf(stdout, "%s ", item->name);
    236             psArgumentHelp(item->data.md);
    237         }
    238         psFree(iter);
    239 
     197    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
     198        psError(PS_ERR_UNKNOWN, true, "option parsing failed");
    240199        psFree(argSets);
     200        psFree(modes);
    241201        psFree(config);
    242202        return NULL;
    … …  
    244204
    245205    psFree(argSets);
     206    psFree(modes);
    246207
    247208    // setup search criterion
    … …  
    306267    }
    307268
    308     // save argv/argc
    309     config->argv = argv;
    310     config->argc = argc;
    311 
    312269    return config;
    313270}
Note: See TracChangeset for help on using the changeset viewer.