IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 11997


Ignore:
Timestamp:
Feb 21, 2007, 6:49:43 PM (19 years ago)
Author:
jhoblitt
Message:

rename p[x]tools -> [foo]tools

Location:
trunk/ippTools/src
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/ippTools/src/Makefile.am

    r11814 r11997  
    33        detselect \
    44        dettool \
    5         p0tool \
    6         p2tool \
    7         p3tool \
    8         p4tool \
    9         p5tool \
    10         p6tool \
     5        regtool \
     6        chiptool \
     7        camtool \
     8        warptool \
     9        difftool \
     10        stacktool \
    1111        pxadmin \
    1212        pxinject \
    … …  
    5757    pztoolConfig.c
    5858
    59 p0tool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
    60 p0tool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
    61 p0tool_SOURCES = \
     59regtool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     60regtool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     61regtool_SOURCES = \
    6262    p0tool.c \
    6363    p0toolConfig.c
    6464
    65 p1tool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
    66 p1tool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
    67 p1tool_SOURCES = \
     65guidetool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     66guidetool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     67guidetool_SOURCES = \
    6868    p1tool.c \
    6969    p1toolConfig.c
    7070
    71 p2tool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
    72 p2tool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
    73 p2tool_SOURCES = \
     71chiptool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     72chiptool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     73chiptool_SOURCES = \
    7474    p2tool.c \
    7575    p2toolConfig.c
    7676
    77 p3tool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
    78 p3tool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
    79 p3tool_SOURCES = \
     77camtool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     78camtool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     79camtool_SOURCES = \
    8080    p3tool.c \
    8181    p3toolConfig.c
    8282
    83 p4tool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
    84 p4tool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
    85 p4tool_SOURCES = \
     83warptool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     84warptool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     85warptool_SOURCES = \
    8686    p4tool.c \
    8787    p4toolConfig.c
    8888
    89 p5tool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
    90 p5tool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
    91 p5tool_SOURCES = \
     89difftool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     90difftool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     91difftool_SOURCES = \
    9292    p5tool.c \
    9393    p5toolConfig.c
    9494
    95 p6tool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
    96 p6tool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
    97 p6tool_SOURCES = \
     95stacktool_CFLAGS = $(PSLIB_CFLAGS) $(PSMODULES_CFLAGS) $(IPPDB_CFLAGS)
     96stacktool_LDADD = $(PSLIB_LIBS) $(PSMODULES_LIBS) $(IPPDB_LIBS) libpxtools.la
     97stacktool_SOURCES = \
    9898    p6tool.c \
    9999    p6toolConfig.c

  • trunk/ippTools/src/camtool.c

    r11875 r11997  
    4747    psLibInit(NULL);
    4848
    49     pxConfig *config = p3toolConfig(NULL, argc, argv);
     49    pxConfig *config = camtoolConfig(NULL, argc, argv);
    5050    if (!config) {
    5151        psError(PXTOOLS_ERR_CONFIG, false, "failed to configure");
    … …  
    5454
    5555    switch (config->mode) {
    56         MODECASE(P3TOOL_MODE_PENDINGEXP,        pendingexpMode);
    57         MODECASE(P3TOOL_MODE_PENDINGIMFILE,     pendingimfileMode);
    58         MODECASE(P3TOOL_MODE_ADDPROCESSEDEXP,   addprocessedexpMode);
    59         MODECASE(P3TOOL_MODE_PROCESSEDEXP,      processedexpMode);
    60         MODECASE(P3TOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpMode);
    61         MODECASE(P3TOOL_MODE_BLOCK,             blockMode);
    62         MODECASE(P3TOOL_MODE_MASKED,            maskedMode);
    63         MODECASE(P3TOOL_MODE_UNBLOCK,           unblockMode);
     56        MODECASE(CAMTOOL_MODE_PENDINGEXP,        pendingexpMode);
     57        MODECASE(CAMTOOL_MODE_PENDINGIMFILE,     pendingimfileMode);
     58        MODECASE(CAMTOOL_MODE_ADDPROCESSEDEXP,   addprocessedexpMode);
     59        MODECASE(CAMTOOL_MODE_PROCESSEDEXP,      processedexpMode);
     60        MODECASE(CAMTOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpMode);
     61        MODECASE(CAMTOOL_MODE_BLOCK,             blockMode);
     62        MODECASE(CAMTOOL_MODE_MASKED,            maskedMode);
     63        MODECASE(CAMTOOL_MODE_UNBLOCK,           unblockMode);
    6464        default:
    6565            psAbort("invalid option (this should not happen)");

  • trunk/ippTools/src/camtool.h

    r11075 r11997  
    1818 */
    1919
    20 #ifndef P3TOOL_H
    21 #define P3TOOL_H 1
     20#ifndef CAMTOOL_H
     21#define CAMTOOL_H 1
    2222
    2323#include "pxtools.h"
    2424
    2525typedef enum {
    26     P3TOOL_MODE_NONE      = 0x0,
    27     P3TOOL_MODE_PENDINGEXP,
    28     P3TOOL_MODE_PENDINGIMFILE,
    29     P3TOOL_MODE_ADDPROCESSEDEXP,
    30     P3TOOL_MODE_PROCESSEDEXP,
    31     P3TOOL_MODE_UPDATEPROCESSEDEXP,
    32     P3TOOL_MODE_BLOCK,
    33     P3TOOL_MODE_MASKED,
    34     P3TOOL_MODE_UNBLOCK
    35 } p3toolMode;
     26    CAMTOOL_MODE_NONE      = 0x0,
     27    CAMTOOL_MODE_PENDINGEXP,
     28    CAMTOOL_MODE_PENDINGIMFILE,
     29    CAMTOOL_MODE_ADDPROCESSEDEXP,
     30    CAMTOOL_MODE_PROCESSEDEXP,
     31    CAMTOOL_MODE_UPDATEPROCESSEDEXP,
     32    CAMTOOL_MODE_BLOCK,
     33    CAMTOOL_MODE_MASKED,
     34    CAMTOOL_MODE_UNBLOCK
     35} camtoolMode;
    3636
    37 pxConfig *p3toolConfig(pxConfig *config, int argc, char **argv);
     37pxConfig *camtoolConfig(pxConfig *config, int argc, char **argv);
    3838
    39 #endif // P3TOOL_H
     39#endif // CAMTOOL_H

  • trunk/ippTools/src/camtoolConfig.c

    r11844 r11997  
    2828#include "p3tool.h"
    2929
    30 pxConfig *p3toolConfig(pxConfig *config, int argc, char **argv)
     30pxConfig *camtoolConfig(pxConfig *config, int argc, char **argv)
    3131{
    3232    if (!config) {
    … …  
    165165    psMetadata *argSets = psMetadataAlloc();
    166166    // find which mode we're running under
    167     PXTOOL_MODE("-pendingexp",   P3TOOL_MODE_PENDINGEXP,    pendingexpArgs);
    168     PXTOOL_MODE("-pendingimfile",P3TOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
    169     PXTOOL_MODE("-addprocessedexp", P3TOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
    170     PXTOOL_MODE("-processedexp", P3TOOL_MODE_PROCESSEDEXP,  processedexpArgs);
    171     PXTOOL_MODE("-updateprocessedexp", P3TOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpArgs);
    172     PXTOOL_MODE("-block",        P3TOOL_MODE_BLOCK,         blockArgs);
    173     PXTOOL_MODE("-masked",       P3TOOL_MODE_MASKED,        maskedArgs);
    174     PXTOOL_MODE("-unblock",      P3TOOL_MODE_UNBLOCK,       unblockArgs);
     167    PXTOOL_MODE("-pendingexp",   CAMTOOL_MODE_PENDINGEXP,    pendingexpArgs);
     168    PXTOOL_MODE("-pendingimfile",CAMTOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
     169    PXTOOL_MODE("-addprocessedexp", CAMTOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
     170    PXTOOL_MODE("-processedexp", CAMTOOL_MODE_PROCESSEDEXP,  processedexpArgs);
     171    PXTOOL_MODE("-updateprocessedexp", CAMTOOL_MODE_UPDATEPROCESSEDEXP,updateprocessedexpArgs);
     172    PXTOOL_MODE("-block",        CAMTOOL_MODE_BLOCK,         blockArgs);
     173    PXTOOL_MODE("-masked",       CAMTOOL_MODE_MASKED,        maskedArgs);
     174    PXTOOL_MODE("-unblock",      CAMTOOL_MODE_UNBLOCK,       unblockArgs);
    175175
    176176    bool argErr = false;
    177     if (config->mode == P3TOOL_MODE_NONE) {
     177    if (config->mode == CAMTOOL_MODE_NONE) {
    178178        argErr = true;
    179179        fprintf (stderr, "mode argument is required\n");
    … …  
    184184
    185185    if (argErr) {
    186         printf("\nPan-STARRS Phase 3 Tool\n");
     186        printf("\nPan-STARRS Camera Tool\n");
    187187        printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    188188        printf(" <mode> :\n\n");

  • trunk/ippTools/src/chiptool.c

    r11972 r11997  
    5353    psLibInit(NULL);
    5454
    55     pxConfig *config = p2toolConfig(NULL, argc, argv);
     55    pxConfig *config = chiptoolConfig(NULL, argc, argv);
    5656    if (!config) {
    5757        psError(PXTOOLS_ERR_CONFIG, false, "failed to configure");
    … …  
    6060
    6161    switch (config->mode) {
    62         MODECASE(P2TOOL_MODE_QUEUERAWEXP,           queuerawexpMode);
    63         MODECASE(P2TOOL_MODE_PENDINGIMFILE,         pendingimfileMode);
    64         MODECASE(P2TOOL_MODE_ADDPROCESSEDIMFILE,    addprocessedimfileMode);
    65         MODECASE(P2TOOL_MODE_PROCESSEDIMFILE,       processedimfileMode);
    66         MODECASE(P2TOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileMode);
    67         MODECASE(P2TOOL_MODE_BLOCK,                 blockMode);
    68         MODECASE(P2TOOL_MODE_MASKED,                maskedMode);
    69         MODECASE(P2TOOL_MODE_UNBLOCK,               unblockMode);
     62        MODECASE(CHIPTOOL_MODE_QUEUERAWEXP,           queuerawexpMode);
     63        MODECASE(CHIPTOOL_MODE_PENDINGIMFILE,         pendingimfileMode);
     64        MODECASE(CHIPTOOL_MODE_ADDPROCESSEDIMFILE,    addprocessedimfileMode);
     65        MODECASE(CHIPTOOL_MODE_PROCESSEDIMFILE,       processedimfileMode);
     66        MODECASE(CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileMode);
     67        MODECASE(CHIPTOOL_MODE_BLOCK,                 blockMode);
     68        MODECASE(CHIPTOOL_MODE_MASKED,                maskedMode);
     69        MODECASE(CHIPTOOL_MODE_UNBLOCK,               unblockMode);
    7070        default:
    7171            psAbort("invalid option (this should not happen)");

  • trunk/ippTools/src/chiptool.h

    r11562 r11997  
    1818 */
    1919
    20 #ifndef P2TOOL_H
    21 #define P2TOOL_H 1
     20#ifndef CHIPTOOL_H
     21#define CHIPTOOL_H 1
    2222
    2323#include "pxtools.h"
    2424
    2525typedef enum {
    26     P2TOOL_MODE_NONE      = 0x0,
    27     P2TOOL_MODE_QUEUERAWEXP,
    28     P2TOOL_MODE_PENDINGIMFILE,
    29     P2TOOL_MODE_ADDPROCESSEDIMFILE,
    30     P2TOOL_MODE_PROCESSEDIMFILE,
    31     P2TOOL_MODE_UPDATEPROCESSEDIMFILE,
    32     P2TOOL_MODE_BLOCK,
    33     P2TOOL_MODE_MASKED,
    34     P2TOOL_MODE_UNBLOCK
    35 } p2toolMode;
     26    CHIPTOOL_MODE_NONE      = 0x0,
     27    CHIPTOOL_MODE_QUEUERAWEXP,
     28    CHIPTOOL_MODE_PENDINGIMFILE,
     29    CHIPTOOL_MODE_ADDPROCESSEDIMFILE,
     30    CHIPTOOL_MODE_PROCESSEDIMFILE,
     31    CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,
     32    CHIPTOOL_MODE_BLOCK,
     33    CHIPTOOL_MODE_MASKED,
     34    CHIPTOOL_MODE_UNBLOCK
     35} chiptoolMode;
    3636
    37 pxConfig *p2toolConfig(pxConfig *config, int argc, char **argv);
     37pxConfig *chiptoolConfig(pxConfig *config, int argc, char **argv);
    3838
    39 #endif // P2TOOL_H
     39#endif // CHIPTOOL_H

  • trunk/ippTools/src/chiptoolConfig.c

    r11843 r11997  
    2727#include "p2tool.h"
    2828
    29 pxConfig *p2toolConfig(pxConfig *config, int argc, char **argv) {
     29pxConfig *chiptoolConfig(pxConfig *config, int argc, char **argv) {
    3030    if (!config) {
    3131        config = pxConfigAlloc();
    … …  
    199199
    200200    psMetadata *argSets = psMetadataAlloc();
    201     PXTOOL_MODE("-queuerawexp",     P2TOOL_MODE_QUEUERAWEXP,   queuerawexpArgs);
    202     PXTOOL_MODE("-pendingimfile",   P2TOOL_MODE_PENDINGIMFILE,  pendingimfileArgs);
    203     PXTOOL_MODE("-addprocessedimfile",P2TOOL_MODE_ADDPROCESSEDIMFILE,addprocessedimfileArgs);
    204     PXTOOL_MODE("-processedimfile",P2TOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
    205     PXTOOL_MODE("-updateprocessedimfile",P2TOOL_MODE_UPDATEPROCESSEDIMFILE,    updateprocessedimfileArgs);
    206     PXTOOL_MODE("-block",           P2TOOL_MODE_BLOCK,          blockArgs);
    207     PXTOOL_MODE("-masked",          P2TOOL_MODE_MASKED,         maskedArgs);
    208     PXTOOL_MODE("-unblock",         P2TOOL_MODE_UNBLOCK,        unblockArgs);
     201    PXTOOL_MODE("-queuerawexp",     CHIPTOOL_MODE_QUEUERAWEXP,   queuerawexpArgs);
     202    PXTOOL_MODE("-pendingimfile",   CHIPTOOL_MODE_PENDINGIMFILE,  pendingimfileArgs);
     203    PXTOOL_MODE("-addprocessedimfile",CHIPTOOL_MODE_ADDPROCESSEDIMFILE,addprocessedimfileArgs);
     204    PXTOOL_MODE("-processedimfile",CHIPTOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
     205    PXTOOL_MODE("-updateprocessedimfile",CHIPTOOL_MODE_UPDATEPROCESSEDIMFILE,    updateprocessedimfileArgs);
     206    PXTOOL_MODE("-block",           CHIPTOOL_MODE_BLOCK,          blockArgs);
     207    PXTOOL_MODE("-masked",          CHIPTOOL_MODE_MASKED,         maskedArgs);
     208    PXTOOL_MODE("-unblock",         CHIPTOOL_MODE_UNBLOCK,        unblockArgs);
    209209
    210210    bool argErr = false;
    211     if (config->mode == P2TOOL_MODE_NONE) {
     211    if (config->mode == CHIPTOOL_MODE_NONE) {
    212212            argErr = true;
    213213        fprintf (stderr, "mode argument is required\n");
    … …  
    218218
    219219    if (argErr) {
    220         printf("\nPan-STARRS Phase 2 Search Tool\n\n");
     220        printf("\nPan-STARRS Chip Tool\n\n");
    221221        printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    222222        printf(" <mode> :\n\n");

  • trunk/ippTools/src/difftool.c

    r11994 r11997  
    5252    psLibInit(NULL);
    5353
    54     pxConfig *config = p5toolConfig(NULL, argc, argv);
     54    pxConfig *config = difftoolConfig(NULL, argc, argv);
    5555    if (!config) {
    5656        psError(PXTOOLS_ERR_CONFIG, false, "failed to configure");
    … …  
    5959
    6060    switch (config->mode) {
    61         MODECASE(P5TOOL_MODE_DEFINERUN,         definerunMode);
    62         MODECASE(P5TOOL_MODE_UPDATERUN,         updaterunMode);
    63         MODECASE(P5TOOL_MODE_ADDINPUTSKYFILE,    addinputskyfileMode);
    64         MODECASE(P5TOOL_MODE_INPUTSKYFILE,       inputskyfileMode);
    65         MODECASE(P5TOOL_MODE_TODIFFSKYFILE,      todiffskyfileMode);
    66         MODECASE(P5TOOL_MODE_ADDDIFFSKYFILE,     adddiffskyfileMode);
    67         MODECASE(P5TOOL_MODE_DIFFSKYFILE,        diffskyfileMode);
     61        MODECASE(DIFFTOOL_MODE_DEFINERUN,         definerunMode);
     62        MODECASE(DIFFTOOL_MODE_UPDATERUN,         updaterunMode);
     63        MODECASE(DIFFTOOL_MODE_ADDINPUTSKYFILE,    addinputskyfileMode);
     64        MODECASE(DIFFTOOL_MODE_INPUTSKYFILE,       inputskyfileMode);
     65        MODECASE(DIFFTOOL_MODE_TODIFFSKYFILE,      todiffskyfileMode);
     66        MODECASE(DIFFTOOL_MODE_ADDDIFFSKYFILE,     adddiffskyfileMode);
     67        MODECASE(DIFFTOOL_MODE_DIFFSKYFILE,        diffskyfileMode);
    6868        default:
    6969            psAbort("invalid option (this should not happen)");

  • trunk/ippTools/src/difftool.h

    r11985 r11997  
    1818 */
    1919
    20 #ifndef P5TOOL_H
    21 #define P5TOOL_H 1
     20#ifndef DIFFTOOL_H
     21#define DIFFTOOL_H 1
    2222
    2323#include "pxtools.h"
    2424
    2525typedef enum {
    26     P5TOOL_MODE_NONE           = 0x0,
    27     P5TOOL_MODE_DEFINERUN,
    28     P5TOOL_MODE_UPDATERUN,
    29     P5TOOL_MODE_ADDINPUTSKYFILE,
    30     P5TOOL_MODE_INPUTSKYFILE,
    31     P5TOOL_MODE_TODIFFSKYFILE,
    32     P5TOOL_MODE_ADDDIFFSKYFILE,
    33     P5TOOL_MODE_DIFFSKYFILE,
    34 } p5toolMode;
     26    DIFFTOOL_MODE_NONE           = 0x0,
     27    DIFFTOOL_MODE_DEFINERUN,
     28    DIFFTOOL_MODE_UPDATERUN,
     29    DIFFTOOL_MODE_ADDINPUTSKYFILE,
     30    DIFFTOOL_MODE_INPUTSKYFILE,
     31    DIFFTOOL_MODE_TODIFFSKYFILE,
     32    DIFFTOOL_MODE_ADDDIFFSKYFILE,
     33    DIFFTOOL_MODE_DIFFSKYFILE,
     34} difftoolMode;
    3535
    36 pxConfig *p5toolConfig(pxConfig *config, int argc, char **argv);
     36pxConfig *difftoolConfig(pxConfig *config, int argc, char **argv);
    3737
    38 #endif // P5TOOL_H
     38#endif // DIFFTOOL_H

  • trunk/ippTools/src/difftoolConfig.c

    r11985 r11997  
    2727#include "p5tool.h"
    2828
    29 pxConfig *p5toolConfig(pxConfig *config, int argc, char **argv)
     29pxConfig *difftoolConfig(pxConfig *config, int argc, char **argv)
    3030{
    3131    if (!config) {
    … …  
    163163    psMetadata *argSets = psMetadataAlloc();
    164164    // find which mode we're running under
    165     PXTOOL_MODE("-definerun",       P5TOOL_MODE_DEFINERUN,      definerunArgs);
    166     PXTOOL_MODE("-updaterun",       P5TOOL_MODE_UPDATERUN,      updaterunArgs);
    167     PXTOOL_MODE("-addinputskyfile",  P5TOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
    168     PXTOOL_MODE("-inputskyfile",     P5TOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
    169     PXTOOL_MODE("-todiffskyfile",    P5TOOL_MODE_TODIFFSKYFILE,   todiffskyfileArgs);
    170     PXTOOL_MODE("-adddiffskyfile",   P5TOOL_MODE_ADDDIFFSKYFILE,  adddiffskyfileArgs);
    171     PXTOOL_MODE("-diffskyfile",      P5TOOL_MODE_DIFFSKYFILE,     diffskyfileArgs);
     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);
    172172
    173173    bool argErr = false;
    174     if (config->mode == P5TOOL_MODE_NONE) {
     174    if (config->mode == DIFFTOOL_MODE_NONE) {
    175175        argErr = true;
    176176        fprintf (stderr, "mode argument is required\n");
    … …  
    181181
    182182    if (argErr) {
    183         printf("\nPan-STARRS Phase 4 Tool\n");
     183        printf("\nPan-STARRS Difference Tool\n");
    184184        printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    185185        printf(" <mode> :\n\n");

  • trunk/ippTools/src/guidetool.c

    r11702 r11997  
    3333int main(int argc, char **argv)
    3434{
    35     pxConfig *config = p1toolConfig(NULL, argc, argv);
     35    pxConfig *config = guidetoolConfig(NULL, argc, argv);
    3636
    3737    switch (config->mode) {

  • trunk/ippTools/src/guidetool.h

    r9392 r11997  
    1818 */
    1919
    20 #ifndef P1TOOL_H
    21 #define P1TOOL_H 1
     20#ifndef GUIDETOOL_H
     21#define GUIDETOOL_H 1
    2222
    2323#include "pxtools.h"
    2424
    25 pxConfig *p1toolConfig(pxConfig *config, int argc, char **argv);
     25pxConfig *guidetoolConfig(pxConfig *config, int argc, char **argv);
    2626
    27 #endif // P1TOOL_H
     27#endif // GUIDETOOL_H

  • trunk/ippTools/src/guidetoolConfig.c

    r11089 r11997  
    2828// this function can not fail -- exits on error
    2929
    30 pxConfig *p1toolConfig(pxConfig *config, int argc, char **argv) {
     30pxConfig *guidetoolConfig(pxConfig *config, int argc, char **argv) {
    3131    if (!config) {
    3232        config = pxConfigAlloc();
    … …  
    129129
    130130    if (argErr) {
    131         printf("\nPan-STARRS Phase 1 Search Tool\n");
     131        printf("\nPan-STARRS Guide Star Tool\n");
    132132        printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    133133        printf(" <mode> : -pending | -define\n\n");

  • trunk/ippTools/src/regtool.c

    r11875 r11997  
    5858    psLibInit(NULL);
    5959
    60     pxConfig *config = p0toolConfig(NULL, argc, argv);
     60    pxConfig *config = regtoolConfig(NULL, argc, argv);
    6161    if (!config) {
    6262        psError(PXTOOLS_ERR_CONFIG, false, "failed to configure");
    … …  
    6565
    6666    switch (config->mode) {
    67         MODECASE(P0TOOL_MODE_PENDINGIMFILE,         pendingimfileMode);
    68         MODECASE(P0TOOL_MODE_ADDPROCESSEDIMFILE,    addprocessedimfileMode);
    69         MODECASE(P0TOOL_MODE_PROCESSEDIMFILE,       processedimfileMode);
    70         MODECASE(P0TOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileMode);
    71         MODECASE(P0TOOL_MODE_PENDINGEXP,            pendingexpMode);
    72         MODECASE(P0TOOL_MODE_ADDPROCESSEDEXP,       addprocessedexpMode);
    73         MODECASE(P0TOOL_MODE_PROCESSEDEXP,          processedexpMode);
    74         MODECASE(P0TOOL_MODE_UPDATEPROCESSEDEXP,    updateprocessedexpMode);
     67        MODECASE(REGTOOL_MODE_PENDINGIMFILE,         pendingimfileMode);
     68        MODECASE(REGTOOL_MODE_ADDPROCESSEDIMFILE,    addprocessedimfileMode);
     69        MODECASE(REGTOOL_MODE_PROCESSEDIMFILE,       processedimfileMode);
     70        MODECASE(REGTOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileMode);
     71        MODECASE(REGTOOL_MODE_PENDINGEXP,            pendingexpMode);
     72        MODECASE(REGTOOL_MODE_ADDPROCESSEDEXP,       addprocessedexpMode);
     73        MODECASE(REGTOOL_MODE_PROCESSEDEXP,          processedexpMode);
     74        MODECASE(REGTOOL_MODE_UPDATEPROCESSEDEXP,    updateprocessedexpMode);
    7575        default:
    7676            psAbort("invalid option (this should not happen)");

  • trunk/ippTools/src/regtool.h

    r11047 r11997  
    1818 */
    1919
    20 #ifndef P0TOOL_H
    21 #define P0TOOL_H 1
     20#ifndef REGTOOL_H
     21#define REGTOOL_H 1
    2222
    2323#include "pxtools.h"
    2424
    2525typedef enum {
    26     P0TOOL_MODE_NONE      = 0x0,
    27     P0TOOL_MODE_PENDINGIMFILE,
    28     P0TOOL_MODE_ADDPROCESSEDIMFILE,
    29     P0TOOL_MODE_PROCESSEDIMFILE,
    30     P0TOOL_MODE_UPDATEPROCESSEDIMFILE,
    31     P0TOOL_MODE_PENDINGEXP,
    32     P0TOOL_MODE_ADDPROCESSEDEXP,
    33     P0TOOL_MODE_PROCESSEDEXP,
    34     P0TOOL_MODE_UPDATEPROCESSEDEXP,
    35 } p0toolMode;
     26    REGTOOL_MODE_NONE      = 0x0,
     27    REGTOOL_MODE_PENDINGIMFILE,
     28    REGTOOL_MODE_ADDPROCESSEDIMFILE,
     29    REGTOOL_MODE_PROCESSEDIMFILE,
     30    REGTOOL_MODE_UPDATEPROCESSEDIMFILE,
     31    REGTOOL_MODE_PENDINGEXP,
     32    REGTOOL_MODE_ADDPROCESSEDEXP,
     33    REGTOOL_MODE_PROCESSEDEXP,
     34    REGTOOL_MODE_UPDATEPROCESSEDEXP,
     35} regtoolMode;
    3636
    37 pxConfig *p0toolConfig(pxConfig *config, int argc, char **argv);
     37pxConfig *regtoolConfig(pxConfig *config, int argc, char **argv);
    3838
    39 #endif // P0TOOL_H
     39#endif // REGTOOL_H

  • trunk/ippTools/src/regtoolConfig.c

    r11842 r11997  
    2828#include "p0tool.h"
    2929
    30 pxConfig *p0toolConfig(pxConfig *config, int argc, char **argv)
     30pxConfig *regtoolConfig(pxConfig *config, int argc, char **argv)
    3131{
    3232    if (!config) {
    … …  
    229229    psMetadata *argSets = psMetadataAlloc();
    230230    // find which mode we're running under
    231     PXTOOL_MODE("-pendingimfile",   P0TOOL_MODE_PENDINGIMFILE, pendingimfileArgs);
    232     PXTOOL_MODE("-addprocessedimfile", P0TOOL_MODE_ADDPROCESSEDIMFILE, addprocessedimfileArgs);
    233     PXTOOL_MODE("-processedimfile", P0TOOL_MODE_PROCESSEDIMFILE, processedimfileArgs);
    234     PXTOOL_MODE("-updateprocessedimfile",  P0TOOL_MODE_UPDATEPROCESSEDIMFILE, updateprocessedimfileArgs);
    235     PXTOOL_MODE("-pendingexp",      P0TOOL_MODE_PENDINGEXP,pendingexpArgs);
    236     PXTOOL_MODE("-addprocessedexp", P0TOOL_MODE_ADDPROCESSEDEXP, addprocessedexpArgs);
    237     PXTOOL_MODE("-processedexp",    P0TOOL_MODE_PROCESSEDEXP, processedexpArgs);
    238     PXTOOL_MODE("-updateprocessedexp", P0TOOL_MODE_UPDATEPROCESSEDEXP,      updatedprocessedexpArgs);
     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);
    239239
    240240    bool argErr = false;
    241     if (config->mode == P0TOOL_MODE_NONE) {
     241    if (config->mode == REGTOOL_MODE_NONE) {
    242242        psError(PXTOOLS_ERR_CONFIG, false, "missing mode argument");
    243243        fprintf (stderr, "mode argument is required\n");
    … …  
    250250
    251251    if (argErr) {
    252         printf("\nPan-STARRS Phase 0 Tool\n");
     252        printf("\nPan-STARRS Registration Tool\n");
    253253        printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    254254        printf(" <mode> :\n\n");

  • trunk/ippTools/src/stacktool.c

    r11986 r11997  
    5252    psLibInit(NULL);
    5353
    54     pxConfig *config = p6toolConfig(NULL, argc, argv);
     54    pxConfig *config = stacktoolConfig(NULL, argc, argv);
    5555    if (!config) {
    5656        psError(PXTOOLS_ERR_CONFIG, false, "failed to configure");
    … …  
    5959
    6060    switch (config->mode) {
    61         MODECASE(P6TOOL_MODE_DEFINERUN,         definerunMode);
    62         MODECASE(P6TOOL_MODE_UPDATERUN,         updaterunMode);
    63         MODECASE(P6TOOL_MODE_ADDINPUTSKYFILE,    addinputskyfileMode);
    64         MODECASE(P6TOOL_MODE_INPUTSKYFILE,       inputskyfileMode);
    65         MODECASE(P6TOOL_MODE_TOSUM,             tosumMode);
    66         MODECASE(P6TOOL_MODE_ADDSUMSKYFILE,      addsumskyfileMode);
    67         MODECASE(P6TOOL_MODE_SUMSKYFILE,         sumskyfileMode);
     61        MODECASE(STACKTOOL_MODE_DEFINERUN,         definerunMode);
     62        MODECASE(STACKTOOL_MODE_UPDATERUN,         updaterunMode);
     63        MODECASE(STACKTOOL_MODE_ADDINPUTSKYFILE,    addinputskyfileMode);
     64        MODECASE(STACKTOOL_MODE_INPUTSKYFILE,       inputskyfileMode);
     65        MODECASE(STACKTOOL_MODE_TOSUM,             tosumMode);
     66        MODECASE(STACKTOOL_MODE_ADDSUMSKYFILE,      addsumskyfileMode);
     67        MODECASE(STACKTOOL_MODE_SUMSKYFILE,         sumskyfileMode);
    6868        default:
    6969            psAbort("invalid option (this should not happen)");

  • trunk/ippTools/src/stacktool.h

    r11985 r11997  
    1818 */
    1919
    20 #ifndef P6TOOL_H
    21 #define P6TOOL_H 1
     20#ifndef STACKTOOL_H
     21#define STACKTOOL_H 1
    2222
    2323#include "pxtools.h"
    2424
    2525typedef enum {
    26     P6TOOL_MODE_NONE           = 0x0,
    27     P6TOOL_MODE_DEFINERUN,
    28     P6TOOL_MODE_UPDATERUN,
    29     P6TOOL_MODE_ADDINPUTSKYFILE,
    30     P6TOOL_MODE_INPUTSKYFILE,
    31     P6TOOL_MODE_TOSUM,
    32     P6TOOL_MODE_ADDSUMSKYFILE,
    33     P6TOOL_MODE_SUMSKYFILE,
    34 } p6toolMode;
     26    STACKTOOL_MODE_NONE           = 0x0,
     27    STACKTOOL_MODE_DEFINERUN,
     28    STACKTOOL_MODE_UPDATERUN,
     29    STACKTOOL_MODE_ADDINPUTSKYFILE,
     30    STACKTOOL_MODE_INPUTSKYFILE,
     31    STACKTOOL_MODE_TOSUM,
     32    STACKTOOL_MODE_ADDSUMSKYFILE,
     33    STACKTOOL_MODE_SUMSKYFILE,
     34} stacktoolMode;
    3535
    36 pxConfig *p6toolConfig(pxConfig *config, int argc, char **argv);
     36pxConfig *stacktoolConfig(pxConfig *config, int argc, char **argv);
    3737
    38 #endif // P6TOOL_H
     38#endif // STACKTOOL_H

  • trunk/ippTools/src/stacktoolConfig.c

    r11986 r11997  
    2727#include "p6tool.h"
    2828
    29 pxConfig *p6toolConfig(pxConfig *config, int argc, char **argv) {
     29pxConfig *stacktoolConfig(pxConfig *config, int argc, char **argv) {
    3030    if (!config) {
    3131        config = pxConfigAlloc();
    … …  
    150150    psMetadata *argSets = psMetadataAlloc();
    151151    // find which mode we're running under
    152     PXTOOL_MODE("-definerun",       P6TOOL_MODE_DEFINERUN,      definerunArgs);
    153     PXTOOL_MODE("-updaterun",       P6TOOL_MODE_UPDATERUN,      updaterunArgs);
    154     PXTOOL_MODE("-addinputskyfile",  P6TOOL_MODE_ADDINPUTSKYFILE, addinputskyfileArgs);
    155     PXTOOL_MODE("-inputskyfile",     P6TOOL_MODE_INPUTSKYFILE,    inputskyfileArgs);
    156     PXTOOL_MODE("-tosum",           P6TOOL_MODE_TOSUM,          tosumArgs);
    157     PXTOOL_MODE("-addsumskyfile",    P6TOOL_MODE_ADDSUMSKYFILE,   addsumskyfileArgs);
    158     PXTOOL_MODE("-sumskyfile",       P6TOOL_MODE_SUMSKYFILE,      sumskyfileArgs);
     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);
    159159
    160160    bool argErr = false;
    161     if (config->mode == P6TOOL_MODE_NONE) {
     161    if (config->mode == STACKTOOL_MODE_NONE) {
    162162        argErr = true;
    163163        fprintf (stderr, "mode argument is required\n");
    … …  
    168168
    169169    if (argErr) {
    170         printf("\nPan-STARRS Phase 4 Tool\n");
     170        printf("\nPan-STARRS Stack Tool\n");
    171171        printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    172172        printf(" <mode> :\n\n");

  • trunk/ippTools/src/warptool.c

    r11985 r11997  
    5959    psLibInit(NULL);
    6060
    61     pxConfig *config = p4toolConfig(NULL, argc, argv);
     61    pxConfig *config = warptoolConfig(NULL, argc, argv);
    6262    if (!config) {
    6363        psError(PXTOOLS_ERR_CONFIG, false, "failed to configure");
    … …  
    6666
    6767    switch (config->mode) {
    68         MODECASE(P4TOOL_MODE_DEFINERUN,         definerunMode);
    69         MODECASE(P4TOOL_MODE_UPDATERUN,         updaterunMode);
    70         MODECASE(P4TOOL_MODE_ADDINPUTEXP,       addinputexpMode);
    71         MODECASE(P4TOOL_MODE_EXP,               expMode);
    72         MODECASE(P4TOOL_MODE_IMFILE,            imfileMode);
    73         MODECASE(P4TOOL_MODE_TOOVERLAP,         tooverlapMode);
    74         MODECASE(P4TOOL_MODE_ADDOVERLAP,        addoverlapMode);
    75         MODECASE(P4TOOL_MODE_SCMAP,             scmapMode);
    76         MODECASE(P4TOOL_MODE_TOWARPED,          towarpedMode);
    77         MODECASE(P4TOOL_MODE_ADDWARPED,         addwarpedMode);
    78         MODECASE(P4TOOL_MODE_WARPED,            warpedMode);
     68        MODECASE(WARPTOOL_MODE_DEFINERUN,         definerunMode);
     69        MODECASE(WARPTOOL_MODE_UPDATERUN,         updaterunMode);
     70        MODECASE(WARPTOOL_MODE_ADDINPUTEXP,       addinputexpMode);
     71        MODECASE(WARPTOOL_MODE_EXP,               expMode);
     72        MODECASE(WARPTOOL_MODE_IMFILE,            imfileMode);
     73        MODECASE(WARPTOOL_MODE_TOOVERLAP,         tooverlapMode);
     74        MODECASE(WARPTOOL_MODE_ADDOVERLAP,        addoverlapMode);
     75        MODECASE(WARPTOOL_MODE_SCMAP,             scmapMode);
     76        MODECASE(WARPTOOL_MODE_TOWARPED,          towarpedMode);
     77        MODECASE(WARPTOOL_MODE_ADDWARPED,         addwarpedMode);
     78        MODECASE(WARPTOOL_MODE_WARPED,            warpedMode);
    7979        default:
    8080            psAbort("invalid option (this should not happen)");

  • trunk/ippTools/src/warptool.h

    r11763 r11997  
    1818 */
    1919
    20 #ifndef P4TOOL_H
    21 #define P4TOOL_H 1
     20#ifndef WARPTOOL_H
     21#define WARPTOOL_H 1
    2222
    2323#include "pxtools.h"
    2424
    2525typedef enum {
    26     P4TOOL_MODE_NONE           = 0x0,
    27     P4TOOL_MODE_DEFINERUN,
    28     P4TOOL_MODE_UPDATERUN,
    29     P4TOOL_MODE_ADDINPUTEXP,
    30     P4TOOL_MODE_EXP,
    31     P4TOOL_MODE_IMFILE,
    32     P4TOOL_MODE_TOOVERLAP,
    33     P4TOOL_MODE_ADDOVERLAP,
    34     P4TOOL_MODE_SCMAP,
    35     P4TOOL_MODE_TOWARPED,
    36     P4TOOL_MODE_ADDWARPED,
    37     P4TOOL_MODE_WARPED,
    38 } p4toolMode;
     26    WARPTOOL_MODE_NONE           = 0x0,
     27    WARPTOOL_MODE_DEFINERUN,
     28    WARPTOOL_MODE_UPDATERUN,
     29    WARPTOOL_MODE_ADDINPUTEXP,
     30    WARPTOOL_MODE_EXP,
     31    WARPTOOL_MODE_IMFILE,
     32    WARPTOOL_MODE_TOOVERLAP,
     33    WARPTOOL_MODE_ADDOVERLAP,
     34    WARPTOOL_MODE_SCMAP,
     35    WARPTOOL_MODE_TOWARPED,
     36    WARPTOOL_MODE_ADDWARPED,
     37    WARPTOOL_MODE_WARPED,
     38} warptoolMode;
    3939
    40 pxConfig *p4toolConfig(pxConfig *config, int argc, char **argv);
     40pxConfig *warptoolConfig(pxConfig *config, int argc, char **argv);
    4141
    42 #endif // P4TOOL_H
     42#endif // WARPTOOL_H

  • trunk/ippTools/src/warptoolConfig.c

    r11981 r11997  
    2727#include "p4tool.h"
    2828
    29 pxConfig *p4toolConfig(pxConfig *config, int argc, char **argv) {
     29pxConfig *warptoolConfig(pxConfig *config, int argc, char **argv) {
    3030    if (!config) {
    3131        config = pxConfigAlloc();
    … …  
    198198    psMetadata *argSets = psMetadataAlloc();
    199199    // find which mode we're running under
    200     PXTOOL_MODE("-definerun",       P4TOOL_MODE_DEFINERUN,      definerunArgs);
    201     PXTOOL_MODE("-updaterun",       P4TOOL_MODE_UPDATERUN,      updaterunArgs);
    202     PXTOOL_MODE("-addinputexp",     P4TOOL_MODE_ADDINPUTEXP,    addinputexpArgs);
    203     PXTOOL_MODE("-exp",             P4TOOL_MODE_EXP,            expArgs);
    204     PXTOOL_MODE("-imfile",          P4TOOL_MODE_IMFILE,         imfileArgs);
    205     PXTOOL_MODE("-tooverlap",       P4TOOL_MODE_TOOVERLAP,      tooverlapArgs);
    206     PXTOOL_MODE("-addoverlap",      P4TOOL_MODE_ADDOVERLAP,     addoverlapArgs);
    207     PXTOOL_MODE("-scmap",           P4TOOL_MODE_SCMAP,          scmapArgs);
    208     PXTOOL_MODE("-towarped",        P4TOOL_MODE_TOWARPED,       towarpedArgs);
    209     PXTOOL_MODE("-addwarped",       P4TOOL_MODE_ADDWARPED,      addwarpedArgs);
    210     PXTOOL_MODE("-warped",          P4TOOL_MODE_WARPED,         warpedArgs);
     200    PXTOOL_MODE("-definerun",       WARPTOOL_MODE_DEFINERUN,      definerunArgs);
     201    PXTOOL_MODE("-updaterun",       WARPTOOL_MODE_UPDATERUN,      updaterunArgs);
     202    PXTOOL_MODE("-addinputexp",     WARPTOOL_MODE_ADDINPUTEXP,    addinputexpArgs);
     203    PXTOOL_MODE("-exp",             WARPTOOL_MODE_EXP,            expArgs);
     204    PXTOOL_MODE("-imfile",          WARPTOOL_MODE_IMFILE,         imfileArgs);
     205    PXTOOL_MODE("-tooverlap",       WARPTOOL_MODE_TOOVERLAP,      tooverlapArgs);
     206    PXTOOL_MODE("-addoverlap",      WARPTOOL_MODE_ADDOVERLAP,     addoverlapArgs);
     207    PXTOOL_MODE("-scmap",           WARPTOOL_MODE_SCMAP,          scmapArgs);
     208    PXTOOL_MODE("-towarped",        WARPTOOL_MODE_TOWARPED,       towarpedArgs);
     209    PXTOOL_MODE("-addwarped",       WARPTOOL_MODE_ADDWARPED,      addwarpedArgs);
     210    PXTOOL_MODE("-warped",          WARPTOOL_MODE_WARPED,         warpedArgs);
    211211#if 0
    212     PXTOOL_MODE("-tostackedimfile", P4TOOL_MODE_TOSTACKEDIMFILE, tostackedimfileArgs);
    213     PXTOOL_MODE("-addstackedimfile", P4TOOL_MODE_ADDSTACKEDIMFILE, addstackedimfileArgs);
    214     PXTOOL_MODE("-stackedimfile",   P4TOOL_MODE_STACKEDIMFILE, stackedimfileArgs);
    215     PXTOOL_MODE("-todiffimfile", P4TOOL_MODE_TODIFFIMFILE, todiffimfileArgs);
    216     PXTOOL_MODE("-adddiffimfile", P4TOOL_MODE_ADDDIFFIMFILE, adddiffimfileArgs);
    217     PXTOOL_MODE("-diffimfile",   P4TOOL_MODE_DIFFIMFILE, diffimfileArgs);
     212    PXTOOL_MODE("-tostackedimfile", WARPTOOL_MODE_TOSTACKEDIMFILE, tostackedimfileArgs);
     213    PXTOOL_MODE("-addstackedimfile", WARPTOOL_MODE_ADDSTACKEDIMFILE, addstackedimfileArgs);
     214    PXTOOL_MODE("-stackedimfile",   WARPTOOL_MODE_STACKEDIMFILE, stackedimfileArgs);
     215    PXTOOL_MODE("-todiffimfile", WARPTOOL_MODE_TODIFFIMFILE, todiffimfileArgs);
     216    PXTOOL_MODE("-adddiffimfile", WARPTOOL_MODE_ADDDIFFIMFILE, adddiffimfileArgs);
     217    PXTOOL_MODE("-diffimfile",   WARPTOOL_MODE_DIFFIMFILE, diffimfileArgs);
    218218#endif
    219219
    220220    bool argErr = false;
    221     if (config->mode == P4TOOL_MODE_NONE) {
     221    if (config->mode == WARPTOOL_MODE_NONE) {
    222222        argErr = true;
    223223        fprintf (stderr, "mode argument is required\n");
    … …  
    228228
    229229    if (argErr) {
    230         printf("\nPan-STARRS Phase 4 Tool\n");
     230        printf("\nPan-STARRS Warp Tool\n");
    231231        printf("Usage: %s <mode> [<options>]\n\n", argv[0]);
    232232        printf(" <mode> :\n\n");
Note: See TracChangeset for help on using the changeset viewer.