IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 13575


Ignore:
Timestamp:
May 31, 2007, 12:44:19 PM (19 years ago)
Author:
jhoblitt
Message:

make dettoolConfig.c's option handling functions global

Location:
trunk/ippTools/src
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/src/dettool.h

    r12066 r13575  
    2424
    2525typedef enum {
    26     DETTOOL_MODE_NONE           = 0x0,
     26    DETTOOL_MODE_NONE           = PXTOOL_MODE_NONE,
    2727    DETTOOL_MODE_PENDING,
    2828    DETTOOL_MODE_DEFINEBYTAG,

  • trunk/ippTools/src/dettoolConfig.c

    r13573 r13575  
    2222#endif
    2323
    24 #include <string.h>
    25 
    2624#include <psmodules.h>
    2725
    … …  
    2927#include "dettool.h"
    3028
    31 #define PXTOOL_MODE(option, comment, modeval, argset) \
    32 { \
    33     if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, comment, argset)) {;\
    34         psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option); \
    35     } \
    36     psFree(argset); \
    37 \
    38     if (!psMetadataAddU32(modes, PS_LIST_TAIL, option, 0, comment, modeval)) {;\
    39         psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option); \
    40     } \
    41 }
    42 
    43 static void printUsage(int argc, char **argv, psMetadata *modes)
     29pxConfig *dettoolConfig(pxConfig *config, int argc, char **argv)
    4430{
    45     printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    46     printf("<mode>:\n");
    47 
    48     psArgumentHelpSimple(stderr, modes);
    49 }
    50 
    51 
    52 static void printUsageMode(int argc, char **argv, const char *modeName, psMetadata *argSet)
    53 {
    54     printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    55     printf("%s:\n", modeName);
    56 
    57     psArgumentHelpSimple(stderr, argSet);
    58 }
    59 
    60 
    61 static 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;
    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 
    185 
    186 pxConfig *dettoolConfig(pxConfig *config, int argc, char **argv) {
    18731    if (!config) {
    18832        config = pxConfigAlloc();
    … …  
    941785
    942786    // find which mode we're running under
    943     PXTOOL_MODE("-pending",         "list active detruns", DETTOOL_MODE_PENDING,       pendingArgs);
    944     PXTOOL_MODE("-definebytag",     "", DETTOOL_MODE_DEFINEBYTAG,   definebytagArgs);
    945     PXTOOL_MODE("-definebyquery",   "", DETTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
    946     PXTOOL_MODE("-definebydetrun",  "", DETTOOL_MODE_DEFINEBYDETRUN, definebydetrunArgs);
    947     PXTOOL_MODE("-raw",             "", DETTOOL_MODE_RAW,           rawArgs);
    948     PXTOOL_MODE("-runs",            "", DETTOOL_MODE_RUNS,          runsArgs);
    949     PXTOOL_MODE("-childlessrun",    "", DETTOOL_MODE_CHILDLESSRUN,  childlessrunArgs);
    950     PXTOOL_MODE("-input",           "", DETTOOL_MODE_INPUT,         inputArgs);
    951     PXTOOL_MODE("-toprocessedimfile", "", DETTOOL_MODE_TOPROCESSEDIMFILE, toprocessedimfileArgs);
    952     PXTOOL_MODE("-addprocessedimfile", "", DETTOOL_MODE_ADDPROCESSEDIMFILE,  addprocessedimfileArgs);
    953     PXTOOL_MODE("-processedimfile", "", DETTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
    954     PXTOOL_MODE("-toprocessedexp",  "", DETTOOL_MODE_TOPROCESSEDEXP,  toprocessedexpArgs);
    955     PXTOOL_MODE("-addprocessedexp", "", DETTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
    956     PXTOOL_MODE("-processedexp",    "", DETTOOL_MODE_PROCESSEDEXP, processedexpArgs);
    957     PXTOOL_MODE("-tostacked",       "", DETTOOL_MODE_TOSTACKED,     tostackedArgs);
    958     PXTOOL_MODE("-addstacked",      "", DETTOOL_MODE_ADDSTACKED,    addstackedArgs);
    959     PXTOOL_MODE("-stacked",         "", DETTOOL_MODE_STACKED,       stackedArgs);
    960     PXTOOL_MODE("-tonormalize",     "", DETTOOL_MODE_TONORMALIZE,   tonormalizeArgs);
    961     PXTOOL_MODE("-addnormalizedstat",     "", DETTOOL_MODE_ADDNORMALIZEDSTAT,   addnormstatArgs);
    962     PXTOOL_MODE("-tonormalizedstat",      "", DETTOOL_MODE_TONORMALIZEDSTAT,    tonormstatArgs);
    963     PXTOOL_MODE("-addnormalizedimfile", "", DETTOOL_MODE_ADDNORMALIZEDIMFILE,addnormalizedimfileArgs);
    964     PXTOOL_MODE("-normalizedimfile","", DETTOOL_MODE_NORMALIZEDIMFILE, normalizedimfileArgs);
    965     PXTOOL_MODE("-tonormalizedexp", "", DETTOOL_MODE_TONORMALIZEDEXP, tonormalizedexpArgs);
    966     PXTOOL_MODE("-addnormalizedexp", "", DETTOOL_MODE_ADDNORMALIZEDEXP, addnormalizedexpArgs);
    967     PXTOOL_MODE("-normalizedexp",   "", DETTOOL_MODE_NORMALIZEDEXP, normalizedexpArgs);
    968     PXTOOL_MODE("-toresidimfile",   "", DETTOOL_MODE_TORESIDIMFILE, toresidimfileArgs);
    969     PXTOOL_MODE("-addresidimfile",  "", DETTOOL_MODE_ADDRESIDIMFILE,  addresidimfileArgs);
    970     PXTOOL_MODE("-residimfile",     "", DETTOOL_MODE_RESIDIMFILE,    residimfileArgs);
    971     PXTOOL_MODE("-toresidexp",      "", DETTOOL_MODE_TORESIDEXP,    toresidexpArgs);
    972     PXTOOL_MODE("-addresidexp",     "", DETTOOL_MODE_ADDRESIDEXP,  addresidexpArgs);
    973     PXTOOL_MODE("-residexp",        "", DETTOOL_MODE_RESIDEXP,     residexpArgs);
    974     PXTOOL_MODE("-residdetrun",     "", DETTOOL_MODE_RESIDDETRUN,  residdetrunArgs);
    975     PXTOOL_MODE("-updateresidexp", "", DETTOOL_MODE_UPDATERESIDEXP,updateresidexpArgs);
    976     PXTOOL_MODE("-adddetrunsummary", "", DETTOOL_MODE_ADDDETRUNSUMMARY,adddetrunsummaryArgs);
    977     PXTOOL_MODE("-detrunsummary", "", DETTOOL_MODE_DETRUNSUMMARY,detrunsummaryArgs);
    978     PXTOOL_MODE("-updatedetrun", "", DETTOOL_MODE_UPDATEDETRUN, updatedetrunArgs);
    979     PXTOOL_MODE("-rerun",           "", DETTOOL_MODE_RERUN,         rerunArgs);
    980     PXTOOL_MODE("-register_detrend", "", DETTOOL_MODE_REGISTER_DETREND, register_detrendArgs);
    981     PXTOOL_MODE("-register_detrend_imfile", "", DETTOOL_MODE_REGISTER_DETREND_IMFILE, register_detrend_imfileArgs);
    982 
    983 
    984     if (!parseOptions(argc, argv, config, modes, argSets)) {
     787    PXTOOL_ADD_MODE("-pending",         "list active detruns", DETTOOL_MODE_PENDING,       pendingArgs);
     788    PXTOOL_ADD_MODE("-definebytag",     "", DETTOOL_MODE_DEFINEBYTAG,   definebytagArgs);
     789    PXTOOL_ADD_MODE("-definebyquery",   "", DETTOOL_MODE_DEFINEBYQUERY, definebyqueryArgs);
     790    PXTOOL_ADD_MODE("-definebydetrun",  "", DETTOOL_MODE_DEFINEBYDETRUN, definebydetrunArgs);
     791    PXTOOL_ADD_MODE("-raw",             "", DETTOOL_MODE_RAW,           rawArgs);
     792    PXTOOL_ADD_MODE("-runs",            "", DETTOOL_MODE_RUNS,          runsArgs);
     793    PXTOOL_ADD_MODE("-childlessrun",    "", DETTOOL_MODE_CHILDLESSRUN,  childlessrunArgs);
     794    PXTOOL_ADD_MODE("-input",           "", DETTOOL_MODE_INPUT,         inputArgs);
     795    PXTOOL_ADD_MODE("-toprocessedimfile", "", DETTOOL_MODE_TOPROCESSEDIMFILE, toprocessedimfileArgs);
     796    PXTOOL_ADD_MODE("-addprocessedimfile", "", DETTOOL_MODE_ADDPROCESSEDIMFILE,  addprocessedimfileArgs);
     797    PXTOOL_ADD_MODE("-processedimfile", "", DETTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
     798    PXTOOL_ADD_MODE("-toprocessedexp",  "", DETTOOL_MODE_TOPROCESSEDEXP,  toprocessedexpArgs);
     799    PXTOOL_ADD_MODE("-addprocessedexp", "", DETTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     800    PXTOOL_ADD_MODE("-processedexp",    "", DETTOOL_MODE_PROCESSEDEXP, processedexpArgs);
     801    PXTOOL_ADD_MODE("-tostacked",       "", DETTOOL_MODE_TOSTACKED,     tostackedArgs);
     802    PXTOOL_ADD_MODE("-addstacked",      "", DETTOOL_MODE_ADDSTACKED,    addstackedArgs);
     803    PXTOOL_ADD_MODE("-stacked",         "", DETTOOL_MODE_STACKED,       stackedArgs);
     804    PXTOOL_ADD_MODE("-tonormalize",     "", DETTOOL_MODE_TONORMALIZE,   tonormalizeArgs);
     805    PXTOOL_ADD_MODE("-addnormalizedstat",     "", DETTOOL_MODE_ADDNORMALIZEDSTAT,   addnormstatArgs);
     806    PXTOOL_ADD_MODE("-tonormalizedstat",      "", DETTOOL_MODE_TONORMALIZEDSTAT,    tonormstatArgs);
     807    PXTOOL_ADD_MODE("-addnormalizedimfile", "", DETTOOL_MODE_ADDNORMALIZEDIMFILE,addnormalizedimfileArgs);
     808    PXTOOL_ADD_MODE("-normalizedimfile","", DETTOOL_MODE_NORMALIZEDIMFILE, normalizedimfileArgs);
     809    PXTOOL_ADD_MODE("-tonormalizedexp", "", DETTOOL_MODE_TONORMALIZEDEXP, tonormalizedexpArgs);
     810    PXTOOL_ADD_MODE("-addnormalizedexp", "", DETTOOL_MODE_ADDNORMALIZEDEXP, addnormalizedexpArgs);
     811    PXTOOL_ADD_MODE("-normalizedexp",   "", DETTOOL_MODE_NORMALIZEDEXP, normalizedexpArgs);
     812    PXTOOL_ADD_MODE("-toresidimfile",   "", DETTOOL_MODE_TORESIDIMFILE, toresidimfileArgs);
     813    PXTOOL_ADD_MODE("-addresidimfile",  "", DETTOOL_MODE_ADDRESIDIMFILE,  addresidimfileArgs);
     814    PXTOOL_ADD_MODE("-residimfile",     "", DETTOOL_MODE_RESIDIMFILE,    residimfileArgs);
     815    PXTOOL_ADD_MODE("-toresidexp",      "", DETTOOL_MODE_TORESIDEXP,    toresidexpArgs);
     816    PXTOOL_ADD_MODE("-addresidexp",     "", DETTOOL_MODE_ADDRESIDEXP,  addresidexpArgs);
     817    PXTOOL_ADD_MODE("-residexp",        "", DETTOOL_MODE_RESIDEXP,     residexpArgs);
     818    PXTOOL_ADD_MODE("-residdetrun",     "", DETTOOL_MODE_RESIDDETRUN,  residdetrunArgs);
     819    PXTOOL_ADD_MODE("-updateresidexp", "", DETTOOL_MODE_UPDATERESIDEXP,updateresidexpArgs);
     820    PXTOOL_ADD_MODE("-adddetrunsummary", "", DETTOOL_MODE_ADDDETRUNSUMMARY,adddetrunsummaryArgs);
     821    PXTOOL_ADD_MODE("-detrunsummary", "", DETTOOL_MODE_DETRUNSUMMARY,detrunsummaryArgs);
     822    PXTOOL_ADD_MODE("-updatedetrun", "", DETTOOL_MODE_UPDATEDETRUN, updatedetrunArgs);
     823    PXTOOL_ADD_MODE("-rerun",           "", DETTOOL_MODE_RERUN,         rerunArgs);
     824    PXTOOL_ADD_MODE("-register_detrend", "", DETTOOL_MODE_REGISTER_DETREND, register_detrendArgs);
     825    PXTOOL_ADD_MODE("-register_detrend_imfile", "", DETTOOL_MODE_REGISTER_DETREND_IMFILE, register_detrend_imfileArgs);
     826
     827
     828    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
    985829        psError(PS_ERR_UNKNOWN, true, "option parsing failed");
    986830        psFree(argSets);

  • trunk/ippTools/src/pxconfig.c

    r13564 r13575  
    2121#include <config.h>
    2222#endif
     23
     24#include <string.h>
     25
     26#include <pslib.h>
     27#include <psmodules.h>
    2328
    2429#include "pxtools.h"
    … …  
    5156    psFree(config->args);
    5257}
     58
     59void pxUsage(FILE *stream, int argc, char **argv, psMetadata *modes)
     60{
     61    fprintf(stream, "Usage: %s <mode> [<options>]\n\n", argv[0]);
     62    fprintf(stream, "<mode>:\n");
     63
     64    psArgumentHelpSimple(stream, modes);
     65}
     66
     67
     68void pxUsageMode(FILE *stream, int argc, char **argv, const char *modeName, psMetadata *argSet)
     69{
     70    fprintf(stream, "Usage: %s <mode> [<options>]\n\n", argv[0]);
     71    fprintf(stream, "%s:\n", modeName);
     72
     73    psArgumentHelpSimple(stream, argSet);
     74}
     75
     76
     77bool pxGetOptions(FILE *stream, int argc, char **argv, pxConfig *config, psMetadata *modes, psMetadata *argSets)
     78{
     79    // figure out what mode we're running in
     80    psMetadataIterator *iter = psMetadataIteratorAlloc(modes, PS_LIST_HEAD, NULL);
     81    psMetadataItem *item = NULL;
     82    while ((item = psMetadataGetAndIncrement(iter))) {
     83        int N = 0;
     84        if ((N = psArgumentGet(argc, argv, item->name))) {
     85            psArgumentRemove(N, &argc, argv);
     86            // check for duplicate mode specification
     87            if (config->mode) {
     88                psError(PS_ERR_UNKNOWN, true, "only one mode selection is allowed");
     89                fprintf(stream, "only one mode selection is allowed\n");
     90                pxUsage(stream, argc, argv, modes);
     91                return NULL;
     92            }
     93
     94            config->mode = item->data.U32;
     95            config->modeName = psStringCopy(item->name);
     96
     97            bool status = false;
     98            psMetadata *argset = psMetadataLookupMetadata(&status, argSets, item->name);
     99            // make sure we can find the argSet for the sepcified mode
     100            if (!status) {
     101                psError(PS_ERR_UNKNOWN, true, "can not find arguments for mode");
     102                fprintf(stderr, "can not find arugments for mode");
     103                return NULL;
     104            }
     105
     106            config->args = psMemIncrRefCounter(argset);
     107        }
     108
     109    }
     110
     111    psFree(iter);
     112
     113    // make sure we found a mode
     114    if (config->mode == PXTOOL_MODE_NONE) {
     115        psError(PS_ERR_UNKNOWN, true, "mode argument is required");
     116        fprintf(stderr, "mode argument is required\n");
     117        pxUsage(stream, argc, argv, modes);
     118        return NULL;
     119    }
     120
     121    // actually parse the command line
     122    if (!psArgumentParse(config->args, &argc, argv)) {
     123        psError(PS_ERR_UNKNOWN, true, "error parsing arguments");
     124        fprintf(stderr, "error parsing arguments\n");
     125        pxUsageMode(stream, argc, argv, config->modeName, config->args);
     126        return NULL;
     127    }
     128
     129    // look for left overs on the command line
     130    if (argc != 1) {
     131        psError(PS_ERR_UNKNOWN, true, "extra arguments: ");
     132        fprintf(stderr, "extra arguments: ");
     133        for (int i = 1; i < argc; i++) {
     134            fprintf (stderr, "%s ", argv[i]);
     135        }
     136        fprintf(stderr, "\n");
     137        pxUsageMode(stream, argc, argv, config->modeName, config->args);
     138        return NULL;
     139    }
     140
     141    // make sure that all required parameters have been specified
     142    iter = psMetadataIteratorAlloc(config->args, PS_LIST_HEAD, NULL);
     143    item = NULL; // Item from iterator
     144    while ((item = psMetadataGetAndIncrement(iter))) {
     145        if (strstr(item->comment, "require") == NULL) {
     146            continue;
     147        }
     148
     149        switch (item->type) {
     150            case PS_DATA_BOOL:
     151                psError(PS_ERR_UNKNOWN, false, "boolean type can not be required");
     152                fprintf(stderr, "boolean type can not be required\n");
     153                return NULL;
     154                break;
     155            case PS_DATA_S8:
     156            case PS_DATA_S16:
     157            case PS_DATA_S32:
     158            case PS_DATA_S64:
     159                if (item->data.S64 != 0) {
     160                    break;
     161                }
     162                goto ARG_REQUIRED;
     163            case PS_DATA_U8:
     164            case PS_DATA_U16:
     165            case PS_DATA_U32:
     166            case PS_DATA_U64:
     167                if (item->data.U64 != 0) {
     168                    break;
     169                }
     170                goto ARG_REQUIRED;
     171            case PS_DATA_F32:
     172            case PS_DATA_F64:
     173                if (!isnan(item->data.F64)) {
     174                    break;
     175                }
     176                goto ARG_REQUIRED;
     177            case PS_DATA_STRING:
     178            case PS_DATA_METADATA:
     179                if (item->data.V) {
     180                    break;
     181                }
     182                goto ARG_REQUIRED;
     183            default:
     184                psError(PS_ERR_UNKNOWN, false, "unknown argument type");
     185                fprintf(stream, "unknown argument type\n");
     186                return NULL;
     187            ARG_REQUIRED:               
     188                psError(PS_ERR_UNKNOWN, false, "argument %s is required", item->name);
     189                fprintf(stream, "argument %s is required\n", item->name);
     190                pxUsageMode(stream, argc, argv, config->modeName, config->args);
     191                return NULL;
     192        }
     193
     194    }
     195
     196    psFree(iter);
     197
     198    return true;
     199}

  • trunk/ippTools/src/pxtools.h

    r13564 r13575  
    3232# include "pxdata.h"
    3333
    34 // load these values from the db in the init stage
    35 # define P2_TYPE_OBJECT 1
    36 # define P2_STATE_READY 2
    37 # define RECIPE "PHASE2"
    3834# define MAX_ROWS 10e9
     35# define PXTOOL_MODE_NONE 0x0
    3936
    4037typedef struct {
    … …  
    5754psExit pxerrorGetExitStatus ();
    5855
     56void pxUsage(FILE *stream, int argc, char **argv, psMetadata *modes);
     57void pxUsageMode(FILE *stream, int argc, char **argv, const char *modeName, psMetadata *argSet);
     58bool pxGetOptions(FILE *stream, int argc, char **argv, pxConfig *config, psMetadata *modes, psMetadata *argSets);
     59
     60#define PXTOOL_ADD_MODE(option, comment, modeval, argset) \
     61{ \
     62    if (!psMetadataAddMetadata(argSets, PS_LIST_TAIL, option, 0, comment, argset)) {;\
     63        psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option); \
     64    } \
     65    psFree(argset); \
     66\
     67    if (!psMetadataAddU32(modes, PS_LIST_TAIL, option, 0, comment, modeval)) {;\
     68        psError(PS_ERR_UNKNOWN, false, "failed to add argset for %s", option); \
     69    } \
     70}
     71
    5972#endif // PXTOOLS_H
Note: See TracChangeset for help on using the changeset viewer.