IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 14537


Ignore:
Timestamp:
Aug 16, 2007, 11:48:15 AM (19 years ago)
Author:
jhoblitt
Message:

stub out magictool options

Location:
trunk/ippTools/src
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/src/magictool.c

    r14481 r14537  
    2929
    3030#include "pxtools.h"
    31 #include "warptool.h"
     31#include "magictool.h"
    3232
    3333static psS64 definerunMode(pxConfig *config);
    34 static bool runoneMode(pxConfig *config);
    3534static bool updaterunMode(pxConfig *config);
    36 static bool addinputexpMode(pxConfig *config);
    37 static bool expMode(pxConfig *config);
    38 static bool imfileMode(pxConfig *config);
    39 static bool tooverlapMode(pxConfig *config);
    40 static bool addoverlapMode(pxConfig *config);
    41 static bool scmapMode(pxConfig *config);
    42 static bool towarpedMode(pxConfig *config);
    43 static bool addwarpedMode(pxConfig *config);
    44 static bool warpedMode(pxConfig *config);
    45 static bool revertwarpedMode(pxConfig *config);
    46 
    47 static bool parseAndInsertSkyCellMap(pxConfig *config, const char *mapfile);
    48 static bool setwarpRunState(pxConfig *config, psS64 warp_id, const char *state);
    49 static bool isValidMode(pxConfig *config, const char *mode);
    50 bool warpCompletedRuns(pxConfig *config);
     35static bool addinputskyfileMode(pxConfig *config);
     36static bool inputtreeMode(pxConfig *config);
     37static bool toprocessMode(pxConfig *config);
     38static bool addresultMode(pxConfig *config);
     39static bool tomaskMode(pxConfig *config);
     40static bool addmaskMode(pxConfig *config);
     41static bool toskyfilemaskMode(pxConfig *config);
     42static bool addskyfilemaskMode(pxConfig *config);
    5143
    5244# define MODECASE(caseName, func) \
    … …  
    6153    psLibInit(NULL);
    6254
    63     pxConfig *config = warptoolConfig(NULL, argc, argv);
     55    pxConfig *config = magictoolConfig(NULL, argc, argv);
    6456    if (!config) {
    6557        psError(PXTOOLS_ERR_CONFIG, false, "failed to configure");
    … …  
    6860
    6961    switch (config->mode) {
    70         MODECASE(WARPTOOL_MODE_DEFINERUN,         definerunMode);
    71         MODECASE(WARPTOOL_MODE_RUNONE,            runoneMode);
    72         MODECASE(WARPTOOL_MODE_UPDATERUN,         updaterunMode);
    73         MODECASE(WARPTOOL_MODE_ADDINPUTEXP,       addinputexpMode);
    74         MODECASE(WARPTOOL_MODE_EXP,               expMode);
    75         MODECASE(WARPTOOL_MODE_IMFILE,            imfileMode);
    76         MODECASE(WARPTOOL_MODE_TOOVERLAP,         tooverlapMode);
    77         MODECASE(WARPTOOL_MODE_ADDOVERLAP,        addoverlapMode);
    78         MODECASE(WARPTOOL_MODE_SCMAP,             scmapMode);
    79         MODECASE(WARPTOOL_MODE_TOWARPED,          towarpedMode);
    80         MODECASE(WARPTOOL_MODE_ADDWARPED,         addwarpedMode);
    81         MODECASE(WARPTOOL_MODE_WARPED,            warpedMode);
    82         MODECASE(WARPTOOL_MODE_REVERTWARPED,      revertwarpedMode);
     62        MODECASE(MAGICTOOL_MODE_DEFINERUN,      definerunMode);
     63        MODECASE(MAGICTOOL_MODE_UPDATERUN,      updaterunMode);
     64        MODECASE(MAGICTOOL_MODE_ADDINPUTSKYFILE,addinputskyfileMode);
     65        MODECASE(MAGICTOOL_MODE_INPUTTREE,      inputtreeMode);
     66        MODECASE(MAGICTOOL_MODE_TOPROCESS,      toprocessMode);
     67        MODECASE(MAGICTOOL_MODE_ADDRESULT,      addresultMode);
     68        MODECASE(MAGICTOOL_MODE_TOMASK,         tomaskMode);
     69        MODECASE(MAGICTOOL_MODE_ADDMASK,        addmaskMode);
     70        MODECASE(MAGICTOOL_MODE_TOSKYFILEMASK,  toskyfilemaskMode);
     71        MODECASE(MAGICTOOL_MODE_ADDSKYFILEMASK, addskyfilemaskMode);
    8372        default:
    8473            psAbort("invalid option (this should not happen)");
    … …  
    10291}
    10392
     93static psS64 definerunMode(pxConfig *config)
     94{
     95    PS_ASSERT_PTR_NON_NULL(config, false);
     96    return 0;
     97}
     98
     99
     100static bool updaterunMode(pxConfig *config)
     101{
     102    PS_ASSERT_PTR_NON_NULL(config, false);
     103    return true;
     104}
     105
     106
     107static bool addinputskyfileMode(pxConfig *config)
     108{
     109    PS_ASSERT_PTR_NON_NULL(config, false);
     110    return true;
     111}
     112
     113
     114static bool inputtreeMode(pxConfig *config)
     115{
     116    PS_ASSERT_PTR_NON_NULL(config, false);
     117    return true;
     118}
     119
     120
     121static bool toprocessMode(pxConfig *config)
     122{
     123    PS_ASSERT_PTR_NON_NULL(config, false);
     124    return true;
     125}
     126
     127
     128static bool addresultMode(pxConfig *config)
     129{
     130    PS_ASSERT_PTR_NON_NULL(config, false);
     131    return true;
     132}
     133
     134
     135static bool tomaskMode(pxConfig *config)
     136{
     137    PS_ASSERT_PTR_NON_NULL(config, false);
     138    return true;
     139}
     140
     141
     142static bool addmaskMode(pxConfig *config)
     143{
     144    PS_ASSERT_PTR_NON_NULL(config, false);
     145    return true;
     146}
     147
     148
     149static bool toskyfilemaskMode(pxConfig *config)
     150{
     151    PS_ASSERT_PTR_NON_NULL(config, false);
     152    return true;
     153}
     154
     155
     156static bool addskyfilemaskMode(pxConfig *config)
     157{
     158    PS_ASSERT_PTR_NON_NULL(config, false);
     159    return true;
     160}
     161
     162#if 0
    104163
    105164static psS64 definerunMode(pxConfig *config)
    … …  
    12741333    return true;
    12751334}
     1335#endif

  • trunk/ippTools/src/magictool.h

    r14481 r14537  
    11/*
    2  * warptool.h
     2 * magictool.h
    33 *
    4  * Copyright (C) 2006  Joshua Hoblitt
     4 * Copyright (C) 2007  Joshua Hoblitt
    55 *
    66 * This program is free software; you can redistribute it and/or modify it
    … …  
    1818 */
    1919
    20 #ifndef WARPTOOL_H
    21 #define WARPTOOL_H 1
     20#ifndef MAGICTOOL_H
     21#define MAGICTOOL_H 1
    2222
    2323#include "pxtools.h"
    2424
    2525typedef enum {
    26     WARPTOOL_MODE_NONE           = 0x0,
    27     WARPTOOL_MODE_DEFINERUN,
    28     WARPTOOL_MODE_RUNONE,
    29     WARPTOOL_MODE_UPDATERUN,
    30     WARPTOOL_MODE_ADDINPUTEXP,
    31     WARPTOOL_MODE_EXP,
    32     WARPTOOL_MODE_IMFILE,
    33     WARPTOOL_MODE_TOOVERLAP,
    34     WARPTOOL_MODE_ADDOVERLAP,
    35     WARPTOOL_MODE_SCMAP,
    36     WARPTOOL_MODE_TOWARPED,
    37     WARPTOOL_MODE_ADDWARPED,
    38     WARPTOOL_MODE_WARPED,
    39     WARPTOOL_MODE_REVERTWARPED,
    40 } warptoolMode;
     26    MAGICTOOL_MODE_NONE           = 0x0,
     27    MAGICTOOL_MODE_DEFINERUN,
     28    MAGICTOOL_MODE_UPDATERUN,
     29    MAGICTOOL_MODE_ADDINPUTSKYFILE,
     30    MAGICTOOL_MODE_INPUTTREE,
     31    MAGICTOOL_MODE_TOPROCESS,
     32    MAGICTOOL_MODE_ADDRESULT,
     33    MAGICTOOL_MODE_TOMASK,
     34    MAGICTOOL_MODE_ADDMASK,
     35    MAGICTOOL_MODE_TOSKYFILEMASK,
     36    MAGICTOOL_MODE_ADDSKYFILEMASK,
     37} MAGICtoolMode;
    4138
    42 pxConfig *warptoolConfig(pxConfig *config, int argc, char **argv);
     39pxConfig *magictoolConfig(pxConfig *config, int argc, char **argv);
    4340
    44 #endif // WARPTOOL_H
     41#endif // MAGICTOOL_H

  • trunk/ippTools/src/magictoolConfig.c

    r14481 r14537  
    11/*
    2  * warptoolConfig.c
    3  *
    4  * Copyright (C) 2006  Joshua Hoblitt
     2 * magictoolConfig.c
     3 *
     4 * Copyright (C) 2007  Joshua Hoblitt
    55 *
    66 * This program is free software; you can redistribute it and/or modify it
    … …  
    2727
    2828#include "pxtools.h"
    29 #include "warptool.h"
    30 
    31 pxConfig *warptoolConfig(pxConfig *config, int argc, char **argv)
     29#include "magictool.h"
     30
     31pxConfig *magictoolConfig(pxConfig *config, int argc, char **argv)
    3232{
    3333    if (!config) {
    … …  
    5151    // -definerun
    5252    psMetadata *definerunArgs = psMetadataAlloc();
    53     psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-mode", 0,
    54             "define mode (required)", NULL);
    5553    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-workdir", 0,
    5654            "define workdir (required)", NULL);
     55    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-label", 0,
     56            "define label", NULL);
     57    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-dvodb", 0,
     58            "define dvodb", NULL);
    5759    psMetadataAddStr(definerunArgs, PS_LIST_TAIL, "-registered",  0,
    5860            "time detrend run was registered", now);
    … …  
    6062            "use the simple output format", false);
    6163
    62     // -runone
    63     psMetadata *runoneArgs = psMetadataAlloc();
    64     psMetadataAddStr(runoneArgs, PS_LIST_TAIL, "-mode", 0,
    65             "define mode (required)", NULL);
    66     psMetadataAddStr(runoneArgs, PS_LIST_TAIL, "-workdir", 0,
    67             "define workdir (required)", NULL);
    68     psMetadataAddStr(runoneArgs, PS_LIST_TAIL, "-registered",  0,
    69             "time detrend run was registered", now);
    70     psMetadataAddStr(runoneArgs, PS_LIST_TAIL, "-cam_id", 0,
    71             "define camtool ID (required)", NULL);
    72     psMetadataAddBool(runoneArgs, PS_LIST_TAIL, "-magiced",  0,
    73             "has this exposure been magiced", false);
    74     psMetadataAddBool(runoneArgs, PS_LIST_TAIL, "-simple",  0,
    75             "use the simple output format", false);
    76 
    7764    // -updaterun
    7865    psMetadata *updaterunArgs = psMetadataAlloc();
    79     psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-warp_id", 0,
     66    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-magic_id", 0,
    8067            "define warptool ID (required)", NULL);
    8168    psMetadataAddStr(updaterunArgs, PS_LIST_TAIL, "-state", 0,
    … …  
    8875#endif
    8976
    90     // -addinputexp
    91     psMetadata *addinputexpArgs = psMetadataAlloc();
    92     psMetadataAddStr(addinputexpArgs, PS_LIST_TAIL, "-warp_id", 0,
    93             "define warptool ID (required)", NULL);
    94     psMetadataAddStr(addinputexpArgs, PS_LIST_TAIL, "-cam_id", 0,
    95             "define camtool ID (required)", NULL);
    96     psMetadataAddBool(addinputexpArgs, PS_LIST_TAIL, "-magiced",  0,
    97             "has this exposure been magiced", false);
    98 
    99     // -exp
    100     psMetadata *expArgs = psMetadataAlloc();
    101     psMetadataAddStr(expArgs, PS_LIST_TAIL, "-warp_id", 0,
    102             "search by warptool ID", NULL);
    103     psMetadataAddStr(expArgs, PS_LIST_TAIL, "-cam_id", 0,
    104             "search by camtool ID", NULL);
    105     psMetadataAddU64(expArgs, PS_LIST_TAIL, "-limit",  0,
     77    // -addinputskyfile
     78    psMetadata *addinputskyfileArgs = psMetadataAlloc();
     79    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-magic_id", 0,
     80            "define magictool ID (required)", NULL);
     81    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-diff_id", 0,
     82            "define difftool ID (required)", NULL);
     83    psMetadataAddStr(addinputskyfileArgs, PS_LIST_TAIL, "-node",  0,
     84            "define symbolic node name (required)", NULL);
     85
     86    // -inputtree
     87    psMetadata *inputtreeArgs = psMetadataAlloc();
     88    psMetadataAddStr(inputtreeArgs, PS_LIST_TAIL, "-magic_id", 0,
     89            "define magictool ID (required)", NULL);
     90    psMetadataAddStr(inputtreeArgs, PS_LIST_TAIL, "-dep_file", 0,
     91            "order of operations dep. file (required)", NULL);
     92
     93    // -tooprocess
     94    psMetadata *toprocessArgs = psMetadataAlloc();
     95    psMetadataAddStr(toprocessArgs, PS_LIST_TAIL, "-magic_id", 0,
     96            "search by magic ID", NULL);
     97    psMetadataAddU64(toprocessArgs, PS_LIST_TAIL, "-limit",  0,
    10698            "limit result set to N items", 0);
    107     psMetadataAddBool(expArgs, PS_LIST_TAIL, "-simple",  0,
    108             "use the simple output format", false);
    109 
    110     // -imfile
    111     psMetadata *imfileArgs = psMetadataAlloc();
    112     psMetadataAddStr(imfileArgs, PS_LIST_TAIL, "-warp_id", 0,
    113             "search by warptool ID", NULL);
    114     psMetadataAddStr(imfileArgs, PS_LIST_TAIL, "-cam_id", 0,
    115             "search by camtool ID", NULL);
    116     psMetadataAddU64(imfileArgs, PS_LIST_TAIL, "-limit",  0,
     99    psMetadataAddBool(toprocessArgs, PS_LIST_TAIL, "-simple",  0,
     100            "use the simple output format", false);
     101
     102    // -addresult
     103    psMetadata *addresultArgs = psMetadataAlloc();
     104    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-magic_id", 0,
     105            "define magictool ID (required)", NULL);
     106    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-node",  0,
     107            "define symbolic node name (required)", NULL);
     108    psMetadataAddStr(addresultArgs, PS_LIST_TAIL, "-uri",  0,
     109            "define URI (required)", NULL);
     110
     111    // -tomask
     112    psMetadata *tomaskArgs = psMetadataAlloc();
     113    psMetadataAddStr(tomaskArgs, PS_LIST_TAIL, "-magic_id", 0,
     114            "search by magic ID", NULL);
     115    psMetadataAddU64(tomaskArgs, PS_LIST_TAIL, "-limit",  0,
    117116            "limit result set to N items", 0);
    118     psMetadataAddBool(imfileArgs, PS_LIST_TAIL, "-simple",  0,
    119             "use the simple output format", false);
    120 
    121     // -tooverlap
    122     psMetadata *tooverlapArgs = psMetadataAlloc();
    123     psMetadataAddStr(tooverlapArgs, PS_LIST_TAIL, "-warp_id", 0,
    124             "search by warp ID", NULL);
    125     psMetadataAddU64(tooverlapArgs, PS_LIST_TAIL, "-limit",  0,
     117    psMetadataAddBool(tomaskArgs, PS_LIST_TAIL, "-simple",  0,
     118            "use the simple output format", false);
     119
     120    // -addmask
     121    psMetadata *addmaskArgs = psMetadataAlloc();
     122    psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-magic_id", 0,
     123            "define magictool ID (required)", NULL);
     124    psMetadataAddStr(addmaskArgs, PS_LIST_TAIL, "-uri",  0,
     125            "define URI (required)", NULL);
     126
     127    // -toskyfilemask
     128    psMetadata *toskyfilemaskArgs = psMetadataAlloc();
     129    psMetadataAddStr(toskyfilemaskArgs, PS_LIST_TAIL, "-magic_id", 0,
     130            "search by magic ID", NULL);
     131    psMetadataAddU64(toskyfilemaskArgs, PS_LIST_TAIL, "-limit",  0,
    126132            "limit result set to N items", 0);
    127     psMetadataAddBool(tooverlapArgs, PS_LIST_TAIL, "-simple",  0,
    128             "use the simple output format", false);
    129 
    130     // -addoverlap
    131     psMetadata *addoverlapArgs = psMetadataAlloc();
    132     psMetadataAddStr(addoverlapArgs, PS_LIST_TAIL, "-mapfile", 0,
    133             "path to skycell <-> imfile mapping file", NULL);
    134 
    135     // -scmap
    136     psMetadata *scmapArgs = psMetadataAlloc();
    137     psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-warp_id", 0,
    138             "search by warptool ID", NULL);
    139     psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-skycell_id", 0,
    140             "searcy by skycell ID", NULL);
    141     psMetadataAddStr(scmapArgs, PS_LIST_TAIL, "-tess_id", 0,
    142             "searcy by tess ID", NULL);
    143     psMetadataAddU64(scmapArgs, PS_LIST_TAIL, "-limit",  0,
    144             "limit result set to N items", 0);
    145     psMetadataAddBool(scmapArgs, PS_LIST_TAIL, "-simple",  0,
    146             "use the simple output format", false);
    147 
    148     // -towarped
    149     psMetadata *towarpedArgs = psMetadataAlloc();
    150     psMetadataAddStr(towarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    151             "search by warptool ID", NULL);
    152     psMetadataAddU64(towarpedArgs, PS_LIST_TAIL, "-limit",  0,
    153             "limit result set to N items", 0);
    154     psMetadataAddBool(towarpedArgs, PS_LIST_TAIL, "-simple",  0,
    155             "use the simple output format", false);
    156 
    157     // -addwarped
    158     psMetadata *addwarpedArgs = psMetadataAlloc();
    159     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    160             "define warptool ID (required)", NULL);
    161     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    162             "define skycell ID (required)", NULL);
    163     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    164             "define tessellation ID (required)", NULL);
    165     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-uri", 0,
    166             "define URI of file (required)", 0);
    167     psMetadataAddStr(addwarpedArgs, PS_LIST_TAIL, "-path_base", 0,
    168             "define base output location (required)", 0);
    169     psMetadataAddF64(addwarpedArgs, PS_LIST_TAIL, "-bg",  0,
    170             "define exposure background", NAN);
    171     psMetadataAddF64(addwarpedArgs, PS_LIST_TAIL, "-bg_stdev",  0,
    172             "define exposure background stdev", NAN);
    173     psMetadataAddF64(addwarpedArgs, PS_LIST_TAIL, "-pixel_fill",  0,
    174             "define %% of live pixels", NAN);
    175     psMetadataAddS16(addwarpedArgs, PS_LIST_TAIL, "-code",  0,
    176             "set fault code", 0);
    177 
    178 
    179     // -warped
    180     psMetadata *warpedArgs = psMetadataAlloc();
    181     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    182             "search by warptool ID", NULL);
    183     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    184             "define skycell ID", NULL);
    185     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    186             "define tessellation ID", NULL);
    187     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-exp_id", 0,
    188             "define exposure tag", NULL);
    189     psMetadataAddStr(warpedArgs, PS_LIST_TAIL, "-cam_id", 0,
    190             "define phase 3 version of exposure tag", NULL);
    191     psMetadataAddU64(warpedArgs, PS_LIST_TAIL, "-limit",  0,
    192             "limit result set to N items", 0);
    193     psMetadataAddBool(warpedArgs, PS_LIST_TAIL, "-simple",  0,
    194             "use the simple output format", false);
    195 
    196     // -revertwarped
    197     psMetadata *revertwarpedArgs = psMetadataAlloc();
    198     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-warp_id", 0,
    199             "search by warptool ID (required)", NULL);
    200     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-skycell_id",  0,
    201             "search by skycell ID", NULL);
    202     psMetadataAddStr(revertwarpedArgs, PS_LIST_TAIL, "-tess_id",  0,
    203             "searcy by tessellation ID", NULL);
    204     psMetadataAddS16(revertwarpedArgs, PS_LIST_TAIL, "-code",  0,
    205             "search by fault code", 0);
    206 
     133    psMetadataAddBool(toskyfilemaskArgs, PS_LIST_TAIL, "-simple",  0,
     134            "use the simple output format", false);
     135
     136    // -addskyfilemask
     137    psMetadata *addskyfilemaskArgs = psMetadataAlloc();
     138    psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-magic_id", 0,
     139            "define magictool ID (required)", NULL);
     140    psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-diff_id",  0,
     141            "define difftool ID (required)", NULL);
     142    psMetadataAddStr(addskyfilemaskArgs, PS_LIST_TAIL, "-uri",  0,
     143            "define URI (required)", NULL);
    207144
    208145    psFree(now);
    … …  
    211148    psMetadata *modes   = psMetadataAlloc();
    212149
    213     PXTOOL_ADD_MODE("-definerun",       "", WARPTOOL_MODE_DEFINERUN,      definerunArgs);
    214     PXTOOL_ADD_MODE("-runone",          "", WARPTOOL_MODE_RUNONE,         runoneArgs);
    215     PXTOOL_ADD_MODE("-updaterun",       "", WARPTOOL_MODE_UPDATERUN,      updaterunArgs);
    216     PXTOOL_ADD_MODE("-addinputexp",     "", WARPTOOL_MODE_ADDINPUTEXP,    addinputexpArgs);
    217     PXTOOL_ADD_MODE("-exp",             "", WARPTOOL_MODE_EXP,            expArgs);
    218     PXTOOL_ADD_MODE("-imfile",          "", WARPTOOL_MODE_IMFILE,         imfileArgs);
    219     PXTOOL_ADD_MODE("-tooverlap",       "", WARPTOOL_MODE_TOOVERLAP,      tooverlapArgs);
    220     PXTOOL_ADD_MODE("-addoverlap",      "", WARPTOOL_MODE_ADDOVERLAP,     addoverlapArgs);
    221     PXTOOL_ADD_MODE("-scmap",           "", WARPTOOL_MODE_SCMAP,          scmapArgs);
    222     PXTOOL_ADD_MODE("-towarped",        "", WARPTOOL_MODE_TOWARPED,       towarpedArgs);
    223     PXTOOL_ADD_MODE("-addwarped",       "", WARPTOOL_MODE_ADDWARPED,      addwarpedArgs);
    224     PXTOOL_ADD_MODE("-warped",          "", WARPTOOL_MODE_WARPED,         warpedArgs);
    225     PXTOOL_ADD_MODE("-revertwarped",    "", WARPTOOL_MODE_REVERTWARPED,   revertwarpedArgs);
     150    PXTOOL_ADD_MODE("-definerun",       "", MAGICTOOL_MODE_DEFINERUN,       definerunArgs);
     151    PXTOOL_ADD_MODE("-updaterun",       "", MAGICTOOL_MODE_UPDATERUN,       updaterunArgs);
     152    PXTOOL_ADD_MODE("-addinputskyfile", "", MAGICTOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
     153    PXTOOL_ADD_MODE("-inputtree",       "", MAGICTOOL_MODE_INPUTTREE,       inputtreeArgs);
     154    PXTOOL_ADD_MODE("-toprocess",       "", MAGICTOOL_MODE_TOPROCESS,       toprocessArgs);
     155    PXTOOL_ADD_MODE("-addresult",       "", MAGICTOOL_MODE_ADDRESULT,       addresultArgs);
     156    PXTOOL_ADD_MODE("-tomask",          "", MAGICTOOL_MODE_TOMASK,          tomaskArgs);
     157    PXTOOL_ADD_MODE("-addmask",         "", MAGICTOOL_MODE_ADDMASK,         addmaskArgs);
     158    PXTOOL_ADD_MODE("-toskyfilemask",   "", MAGICTOOL_MODE_TOSKYFILEMASK,   toskyfilemaskArgs);
     159    PXTOOL_ADD_MODE("-addskyfilemask",  "", MAGICTOOL_MODE_ADDSKYFILEMASK,  addskyfilemaskArgs);
    226160
    227161    if (!pxGetOptions(stderr, argc, argv, config, modes, argSets)) {
Note: See TracChangeset for help on using the changeset viewer.