static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to as as the argv array.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "allimages", OPT_FLAG, NULL, &cmdlineP->allimages, 0);
OPTENT3(0, "count", OPT_FLAG, NULL, &cmdlineP->count, 0);
OPTENT3(0, "comments", OPT_FLAG, NULL, &cmdlineP->comments, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others */
cmdlineP->inputFilespec = (const char **)&argv[1];
cmdlineP->inputFileCount = argc - 1;
}
static void
parseCommandLine ( int argc, char ** argv,
struct cmdlineInfo *cmdlineP ) {
/*----------------------------------------------------------------------------
parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def = malloc(100*sizeof(optEntry));
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "allicons", OPT_FLAG, NULL,
&cmdlineP->allicons, 0 );
OPTENT3(0, "bestqual", OPT_FLAG, NULL,
&cmdlineP->bestqual, 0 );
OPTENT3(0, "writeands", OPT_FLAG, NULL,
&cmdlineP->writeands, 0 );
OPTENT3(0, "multippm", OPT_FLAG, NULL,
&cmdlineP->multippm, 0 );
OPTENT3(0, "verbose", OPT_FLAG, NULL,
&cmdlineP->verbose, 0 );
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3( &argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (argc-1 < 1)
cmdlineP->inputFilespec = "-";
else
cmdlineP->inputFilespec = argv[1];
if (argc-1 < 2) {
cmdlineP->outputFilespec = "-";
if (cmdlineP->writeands || cmdlineP->allicons)
pm_error("If you specify the -writeands or -allicons option, "
"you must also specify an output file name argument.");
} else
cmdlineP->outputFilespec = argv[2];
if (argc-1 > 2)
pm_error("Too many arguments (%d). Input filespec and "
"output filespec are the only possible arguments.",
argc-1);
}
static void
parseCommandLine(int argc,
const char ** argv,
struct cmdlineInfo * const cmdlineP ) {
/*----------------------------------------------------------------------------
Parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to pm_optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int lr, tb;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "lr", OPT_FLAG, NULL,
&lr, 0);
OPTENT3(0, "tb", OPT_FLAG, NULL,
&tb, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!lr && !tb)
pm_error("You must specify either -lr or -tb");
else if (lr && tb)
pm_error("You may not specify both -lr and -tb");
else
cmdlineP->direction = lr ? DIR_LR : DIR_TB;
if (argc-1 < 1)
cmdlineP->inputFileName = "-";
else {
cmdlineP->inputFileName = argv[1];
if (argc-1 > 1)
pm_error("Too many arguments: %u. "
"The only possible argument is the "
"optional input file name", argc-1);
}
}
static void
parseCommandLine(int argc,
char ** argv,
struct cmdlineInfo * const cmdlineP) {
/* --------------------------------------------------------------------------
Parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
--------------------------------------------------------------------------*/
optEntry *option_def = malloc( 100*sizeof( optEntry ) );
/* Instructions to optParseOptions3 on how to parse our options. */
optStruct3 opt;
unsigned int option_def_index;
unsigned int maxvalSpec;
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "maxval", OPT_UINT, &cmdlineP->maxval, &maxvalSpec, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3( &argc, argv, opt, sizeof(opt), 0 );
/* Uses and sets argc, argv, and some of *cmdline_p and others. */
if (!maxvalSpec)
cmdlineP->maxval = PNM_MAXMAXVAL;
if (cmdlineP->maxval > PNM_OVERALLMAXVAL)
pm_error("Maximum allowed -maxval is %u. You specified %u",
PNM_OVERALLMAXVAL, (unsigned)cmdlineP->maxval);
else if (cmdlineP->maxval == 0)
pm_error("-maxval cannot be 0");
/* Get the program parameters */
if (argc-1 >= 1)
cmdlineP->inputFilespec = argv[1];
else
cmdlineP->inputFilespec = "-";
if (argc-1 > 1)
pm_error("Program takes at most one argument: the file name. "
"You specified %d", argc-1);
}
static void
parseCommandLine(int argc, char ** const argv,
struct cmdlineInfo * const cmdlineP) {
optStruct3 opt;
optEntry option_def[100];
unsigned int option_def_index = 0;
unsigned int xresSpec, yresSpec;
unsigned int xres, yres;
unsigned int slowMode;
OPTENT3(0, "xres", OPT_UINT, &xres, &xresSpec, 0);
OPTENT3(0, "yres", OPT_UINT, &yres, &yresSpec, 0);
OPTENT3(0, "slow", OPT_FLAG, NULL, &slowMode, 0);
opt.opt_table = option_def;
opt.short_allowed = 0;
opt.allowNegNum = 0;
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!xresSpec)
pm_error("You must specify the -xres option");
if (!yresSpec)
pm_error("You must specify the -yres option");
switch (xres) {
case 60: cmdlineP->graph_mode = 'K'; break;
case 120: cmdlineP->graph_mode = slowMode ? 'L' : 'Y'; break;
case 240: cmdlineP->graph_mode = 'Z'; break;
default:
pm_error("Please specify 60, 120, or 240 for -xres");
}
if (yres != 60 && yres != 120 && yres != 240)
pm_error("Please specify 60, 120, or 240 for -yres");
cmdlineP->passes = yres / 60;
cmdlineP->nFiles = MAX(argc-1, 1);
MALLOCARRAY_NOFAIL(cmdlineP->inputFile, cmdlineP->nFiles);
if (argc-1 < 1)
cmdlineP->inputFile[0] = "-";
else {
unsigned int i;
for (i = 0; i < argc-1; ++i)
cmdlineP->inputFile[i] = argv[i+1];
}
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int rmapSpec, wmapSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "rmap", OPT_STRING, &cmdlineP->rmap,
&rmapSpec, 0);
OPTENT3(0, "wmap", OPT_STRING, &cmdlineP->wmap,
&wmapSpec, 0);
OPTENT3(0, "gray", OPT_FLAG, NULL,
&cmdlineP->gray, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL,
&cmdlineP->verbose, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We may have parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!wmapSpec)
cmdlineP->wmap = NULL;
if (!rmapSpec)
cmdlineP->rmap = NULL;
if (argc-1 < 1)
cmdlineP->inputFileName = "-";
else {
cmdlineP->inputFileName = argv[1];
if (argc-1 > 1)
pm_error("Too many arguments (%d). The only argument is the "
"input file name.", argc-1);
}
}
static void
parseCommandLine(int argc, char **argv,
struct cmdlineInfo *cmdlineP) {
optEntry *option_def = malloc(100*sizeof(optEntry));
/* Instructions to OptParseOptions3 on how to parse our options */
optStruct3 opt;
unsigned int option_def_index;
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
switch (argc-1) {
case 0:
cmdlineP->inputFilespec = "-";
break;
case 1:
cmdlineP->inputFilespec = argv[1];
break;
case 2:
break;
}
}
static void
parseCommandLine(int argc, char ** const argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to OptParseOptions2 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (argc-1 < 1)
cmdlineP->inputFileName = "-";
else {
cmdlineP->inputFileName = argv[1];
if (argc-1 > 1)
pm_error("There is at most one argument: input file name. "
"You specified %d", argc-1);
}
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry *option_def = malloc( 100*sizeof( optEntry ) );
/* Instructions to pm_optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
pm_optParseOptions3( &argc, argv, opt, sizeof(opt), 0 );
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (argc-1 < 1)
cmdlineP->inputFilespec = "-";
else if (argc-1 == 1)
cmdlineP->inputFilespec = argv[1];
else
pm_error("Too many arguments.");
}
static void
parse_command_line(int argc, char ** argv,
struct cmdline_info *cmdlineP) {
optStruct3 opt;
unsigned int option_def_index = 0;
optEntry *option_def = malloc(100*sizeof(optEntry));
OPTENT3(0, "noantialias", OPT_FLAG, NULL, &cmdlineP->noantialias, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE;
opt.allowNegNum = TRUE;
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
if (argc-1 < 1)
pm_error("Need an argument: the shear angle.\n");
else {
char *endptr;
cmdlineP->angle = strtod(argv[1], &endptr) * M_PI / 180;
if (*endptr != '\0' || strlen(argv[1]) == 0)
pm_error("Angle argument is not a valid floating point number: "
"'%s'", argv[1]);
if (argc-1 < 2)
cmdlineP->input_filespec = "-";
else {
cmdlineP->input_filespec = argv[2];
if (argc-1 > 2)
pm_error("too many arguments (%d). "
"The only arguments are shear angle and filespec.",
argc-1);
}
}
}
static void
parseCommandLine(int argc, const char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to pm_optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int notefileSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "notefile", OPT_STRING, &cmdlineP->notefile,
¬efileSpec, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL,
&cmdlineP->verbose, 0);
opt.opt_table = option_def;
opt.short_allowed = false; /* We have no short (old-fashioned) options */
opt.allowNegNum = false; /* We have no parms that are negative numbers */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!notefileSpec)
cmdlineP->notefile = NULL;
if (argc-1 < 1)
cmdlineP->inputFileName = "-";
else if (argc-1 == 1)
cmdlineP->inputFileName = argv[1];
else
pm_error("Program takes at most one argument: input file name");
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the pointers we place into *cmdlineP are sometimes to storage
in the argv array.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to OptParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int padnameSpec;
unsigned int option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "debug", OPT_FLAG, NULL, &cmdlineP->debug, 0);
OPTENT3(0, "padname", OPT_UINT, &cmdlineP->padname, &padnameSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!padnameSpec)
cmdlineP->padname = 0;
if (argc - 1 < 1)
cmdlineP->inputFileName = "-";
else
cmdlineP->inputFileName = argv[1];
if (argc -1 < 2)
cmdlineP->outputFilePattern = "image%d";
else
cmdlineP->outputFilePattern = argv[2];
if (!strstr(cmdlineP->outputFilePattern, "%d"))
pm_error("output file spec pattern parameter must include the "
"string '%%d',\n"
"to stand for the image sequence number.\n"
"You specified '%s'.", cmdlineP->outputFilePattern);
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Convert program invocation arguments (argc,argv) into a format the
program can use easily, struct cmdlineInfo. Validate arguments along
the way and exit program with message if invalid.
Note that some string information we return as *cmdlineP is in the storage
argv[] points to.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to OptParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int maxvalSpec;
unsigned int option_def_index;
MALLOCARRAY(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "maxval", OPT_UINT, &cmdlineP->maxval, &maxvalSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = false; /* We have no short (old-fashioned) options */
opt.allowNegNum = false; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!maxvalSpec)
cmdlineP->maxval = PPM_MAXMAXVAL;
else {
if (cmdlineP->maxval > PPM_OVERALLMAXVAL)
pm_error("The value you specified for -maxval (%u) is too big. "
"Max allowed is %u", cmdlineP->maxval, PPM_OVERALLMAXVAL);
if (cmdlineP->maxval < 1)
pm_error("You cannot specify 0 for -maxval");
}
if (argc-1 < 3)
pm_error("Need 3 arguments: color, width, height.");
else if (argc-1 > 3)
pm_error("Only 3 arguments allowed: color, width, height. "
"You specified %d", argc-1);
else {
cmdlineP->color = ppm_parsecolor(argv[1], cmdlineP->maxval);
cmdlineP->cols = atoi(argv[2]);
cmdlineP->rows = atoi(argv[3]);
if (cmdlineP->cols <= 0)
pm_error("width argument must be a positive number. You "
"specified '%s'", argv[2]);
if (cmdlineP->rows <= 0)
pm_error("height argument must be a positive number. You "
"specified '%s'", argv[3]);
}
}
static void
parseCommandLine(int argc, const char ** argv,
struct CmdlineInfo *cmdlineP) {
optStruct3 opt;
unsigned int option_def_index = 0;
optEntry * option_def;
unsigned int backgroundSpec;
MALLOCARRAY(option_def, 100);
OPTENT3(0, "noantialias", OPT_FLAG, NULL, &cmdlineP->noantialias, 0);
OPTENT3(0, "background", OPT_STRING, &cmdlineP->background,
&backgroundSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE;
opt.allowNegNum = TRUE;
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
if (!backgroundSpec)
cmdlineP->background = NULL;
if (argc-1 < 1)
pm_error("Need an argument: the shear angle.\n");
else {
char *endptr;
cmdlineP->angle = strtod(argv[1], &endptr) * M_PI / 180;
if (*endptr != '\0' || strlen(argv[1]) == 0)
pm_error("Angle argument is not a valid floating point number: "
"'%s'", argv[1]);
if (argc-1 < 2)
cmdlineP->inputFileName = "-";
else {
cmdlineP->inputFileName = argv[2];
if (argc-1 > 2)
pm_error("too many arguments (%d). "
"The only arguments are shear angle and filespec.",
argc-1);
}
}
free(option_def);
}
static void
parseCommandLine(int argc, const char ** const argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry *option_def = malloc(100*sizeof(optEntry));
/* Instructions to OptParseOptions2 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
char * dpiOpt;
unsigned int dpiOptSpec;
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "bbonly", OPT_FLAG, NULL, &cmdlineP->bbonly, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
OPTENT3(0, "dpi", OPT_STRING, &dpiOpt, &dpiOptSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (dpiOptSpec)
parseDpi(dpiOpt, &cmdlineP->dpiX, &cmdlineP->dpiY);
else
cmdlineP->dpiX = cmdlineP->dpiY = 72;
if ((argc-1) > 1)
pm_error("Too many arguments (%d). Only argument is input file name",
argc-1);
if (argc-1 == 0)
cmdlineP->inputFileName = "-";
else
cmdlineP->inputFileName = argv[1];
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo *cmdlineP) {
optStruct3 opt;
unsigned int option_def_index = 0;
optEntry *option_def = malloc(100*sizeof(optEntry));
unsigned int compressSpec, resolutionSpec;
opt.opt_table = option_def;
opt.short_allowed = FALSE;
opt.allowNegNum = FALSE;
OPTENT3(0, "compress", OPT_UINT, &cmdlineP->compress,
&compressSpec, 0);
OPTENT3(0, "resolution", OPT_UINT, &cmdlineP->resolution,
&resolutionSpec, 0);
pm_optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
if (argc-1 > 1)
pm_error("Too many arguments: %d. "
"Only argument is the filename", argc-1);
if (compressSpec) {
if (cmdlineP->compress != 0 && cmdlineP->compress != 1)
pm_error("Invalid -compress value: %u. Only 0 and 1 are valid.",
cmdlineP->compress);
} else
cmdlineP->compress = 1;
if (resolutionSpec) {
if (cmdlineP->resolution != 360 && cmdlineP->resolution != 180)
pm_error("Invalid -resolution value: %u. "
"Only 180 and 360 are valid.", cmdlineP->resolution);
} else
cmdlineP->resolution = 360;
if (argc-1 == 1)
cmdlineP->inputFileName = argv[1];
else
cmdlineP->inputFileName = "-";
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo *cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optStruct3 opt; /* set by OPTENT3 */
optEntry *option_def;
unsigned int option_def_index;
unsigned int takeeven, takeodd;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "takeeven", OPT_FLAG, NULL, &takeeven, 0);
OPTENT3(0, "takeodd", OPT_FLAG, NULL, &takeodd, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (takeeven && takeodd)
pm_error("You cannot specify both -takeeven and -takeodd options.");
if (takeodd)
cmdlineP->rowsToTake = ODD;
else
cmdlineP->rowsToTake = EVEN;
if (argc-1 < 1)
cmdlineP->inputFilespec = "-";
else if (argc-1 == 1)
cmdlineP->inputFilespec = argv[1];
else
pm_error("You specified too many arguments (%d). The only "
"argument is the optional input file specification.",
argc-1);
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that many of the strings that this function returns in the
*cmdline_p structure are actually in the supplied argv array. And
sometimes, one of these strings is actually just a suffix of an entry
in argv!
-----------------------------------------------------------------------------*/
optEntry *option_def;
optStruct3 opt;
unsigned int debuglevelSpec;
unsigned int option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "verbose", OPT_FLAG, NULL,
&cmdlineP->verbose, 0);
OPTENT3(0, "debuglevel", OPT_UINT, &cmdlineP->debuglevel,
&debuglevelSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
if (!debuglevelSpec)
cmdlineP->debuglevel = 0;
if (argc - 1 == 0)
cmdlineP->inputFilename = strdup("-"); /* he wants stdin */
else if (argc - 1 == 1)
cmdlineP->inputFilename = strdup(argv[1]);
else
pm_error("Too many arguments. The only argument accepted\n"
"is the input file specification");
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to OptParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int dpiSpec, copiesSpec, compressSpec;
MALLOCARRAY(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "resolution", OPT_UINT, &cmdlineP->dpi,
&dpiSpec, 0);
OPTENT3(0, "copies", OPT_UINT, &cmdlineP->copies,
&copiesSpec, 0);
OPTENT3(0, "float", OPT_FLAG, NULL,
&cmdlineP->floating, 0);
OPTENT3(0, "noreset", OPT_FLAG, NULL,
&cmdlineP->noreset, 0);
OPTENT3(0, "packbits", OPT_FLAG, NULL,
&cmdlineP->pack, 0);
OPTENT3(0, "delta", OPT_FLAG, NULL,
&cmdlineP->delta, 0);
OPTENT3(0, "compress", OPT_FLAG, NULL,
&compressSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We may have parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (argc-1 == 0)
cmdlineP->inputFilename = "-";
else if (argc-1 != 1)
pm_error("Program takes zero or one argument (filename). You "
"specified %d", argc-1);
else
cmdlineP->inputFilename = argv[1];
if (!dpiSpec)
cmdlineP->dpi = 75;
if (!copiesSpec)
cmdlineP->copies = 1;
if (compressSpec) {
cmdlineP->pack = 1;
cmdlineP->delta = 1;
}
}
static void
parseCommandLine(int argc, char *argv[],
struct cmdlineInfo * const cmdlineP) {
static optEntry option_def[50];
static optStruct3 opt;
unsigned int option_def_index;
/* set defaults */
cmdlineP->hstep = 11; /* read only every 11th column */
cmdlineP->vstep = 5; /* calc differences every 5th row */
cmdlineP->dstep = 2; /* check for differences two rows down */
cmdlineP->maxangle = 10.0; /* assume skew is less than +/- ten degrees */
cmdlineP->astep = 1.0; /* initially check by one-degree increments */
cmdlineP->qmin = 1.0; /* don't require S/N better than 1.0 */
/* initialize option table */
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "fast", OPT_FLAG, NULL, &cmdlineP->fast, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
OPTENT3(0, "angle", OPT_FLOAT, &cmdlineP->maxangle, NULL, 0);
OPTENT3(0, "quality", OPT_FLOAT, &cmdlineP->qmin, NULL, 0);
OPTENT3(0, "astep", OPT_FLOAT, &cmdlineP->astep, NULL, 0);
OPTENT3(0, "hstep", OPT_UINT, &cmdlineP->hstep, NULL, 0);
OPTENT3(0, "vstep", OPT_UINT, &cmdlineP->vstep, NULL, 0);
OPTENT3(0, "dstep", OPT_UINT, &cmdlineP->dstep, NULL, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* no short options used */
opt.allowNegNum = FALSE; /* don't allow negative values */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
if (cmdlineP->hstep < 1)
pm_error("-hstep must be at least 1 column.");
if (cmdlineP->vstep < 1)
pm_error("-vstep must be at least 1 row.");
if (cmdlineP->dstep < 1)
pm_error("-dstep must be at least 1 row.");
if (cmdlineP->maxangle < 1 || cmdlineP->maxangle > 45)
pm_error("-maxangle must be between 1 and 45 degrees.");
if (argc-1 < 1) /* if input file name given */
cmdlineP->inputFilename = "-";
else {
cmdlineP->inputFilename = argv[1];
if (argc-1 > 1)
pm_error("There is at most one argument. You specified %d",
argc-1);
}
}
static void
parseCommandLine( int argc, const char ** const argv,
struct cmdlineInfo * const cmdlineP ) {
/*--------------------------------------------------------------------
Parse the command line into a structure.
----------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to OptParseOptions3 on how to parse our options */
optStruct3 opt;
unsigned int option_def_index;
int maxgrayval;
maxgrayval = 63; /* default */
MALLOCARRAY(option_def, 100);
option_def_index = 0; /* Incremented by OPTENTRY */
MEMSZERO(cmdlineP);
cmdlineP->separation = -1;
OPTENT3('s', "sep", OPT_INT, &cmdlineP->separation, NULL, 0);
OPTENT3('g', "gray", OPT_INT, &maxgrayval, NULL, 0);
OPTENT3('i', "invert", OPT_FLAG, &cmdlineP->swapEyes, NULL, 0);
OPTENT3('m', "minsep", OPT_INT, &cmdlineP->minSeparation, NULL, 0);
opt.opt_table = option_def;
opt.short_allowed = 1;
opt.allowNegNum = 0;
pm_optParseOptions3( &argc, (char **)argv, opt, sizeof(opt), 0 );
if (argc-1 < 1)
cmdlineP->inputFilename = "-";
else {
cmdlineP->inputFilename = argv[1];
if (argc-1 > 1)
pm_error("Too many arguments: %u. The only argument is the "
"optional input file name", argc-1);
}
cmdlineP->maxGrayVal = (gray) maxgrayval;
}
static void
parseCommandLine(int argc,
char ** argv,
struct cmdlineInfo *cmdlineP ) {
/*----------------------------------------------------------------------------
Parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def = malloc(100*sizeof(optEntry));
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "ccir601", OPT_FLAG, NULL,
&cmdlineP->ccir601, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3( &argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (argc-1 !=3)
pm_error("You must specify 3 arguments. "
"You specified %d", argc-1);
else {
int width, height;
cmdlineP->filenameBase = argv[1];
width = atoi(argv[2]);
if (width < 1)
pm_error("Width must be at least 1. You specified %d", width);
height = atoi(argv[3]);
if (height < 1)
pm_error("Height must be at least 1. You specified %d", height);
cmdlineP->width = width;
cmdlineP->height = height;
}
}
static void
parseCommandLine ( int argc, char ** argv,
struct cmdlineInfo *cmdlineP ) {
/*----------------------------------------------------------------------------
parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def = malloc(100*sizeof(optEntry));
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int contextSpec;
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "context", OPT_UINT, &cmdlineP->context,
&contextSpec, 0 );
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3( &argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!contextSpec)
cmdlineP->context = 1;
if (cmdlineP->context < 1)
pm_error("-context must be at least 1");
if (argc-1 > 1)
pm_error("The only argument is the input file name");
else if (argc-1 < 1)
cmdlineP->inputFilespec = "-";
else
cmdlineP->inputFilespec = argv[1];
}
static void
parseCommandLine(int argc,
char ** argv,
struct cmdlineInfo * const cmdlineP) {
/* --------------------------------------------------------------------------
Parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
--------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to optParseOptions3 on how to parse our options. */
optStruct3 opt;
unsigned int option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "trace", OPT_FLAG, NULL,
&cmdlineP->trace, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3( &argc, argv, opt, sizeof(opt), 0 );
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (argc-1 < 1)
cmdlineP->inputFileName = "-";
else {
cmdlineP->inputFileName = argv[1];
if (argc-1 > 1)
pm_error("Too many arguments (%u). The only non-option argument "
"is the input file name.", argc-1);
}
}
static void
parseCommandLine(int argc, const char ** const argv,
struct CmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to OptParseOptions2 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int lookupfileSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "lookupfile", OPT_STRING, &cmdlineP->lookupfile,
&lookupfileSpec, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We may have parms that are negative numbers */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!lookupfileSpec)
pm_error("You must specify the -lookupfile option");
if (argc-1 < 1)
cmdlineP->inputFileName = "-";
else
cmdlineP->inputFileName = argv[1];
free(option_def);
}
static void
parseCommandLine(int const argc,
char ** const argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Note that many of the strings that this function returns in the
*cmdlineP structure are actually in the supplied argv array. And
sometimes, one of these strings is actually just a suffix of an entry
in argv!
On the other hand, unlike other option processing functions, we do
not change argv at all.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int i; /* local loop variable */
const char * maxmemory;
const char * dctval;
unsigned int adobe, notadobe;
unsigned int tracelevelSpec, exifSpec, dctvalSpec, maxmemorySpec;
unsigned int option_def_index;
int argc_parse; /* argc, except we modify it as we parse */
char ** argv_parse;
MALLOCARRAY_NOFAIL(option_def, 100);
MALLOCARRAY_NOFAIL(argv_parse, argc);
/* argv, except we modify it as we parse */
option_def_index = 0; /* incremented by OPTENTRY */
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
OPTENT3(0, "dct", OPT_STRING, &dctval,
&dctvalSpec, 0);
OPTENT3(0, "maxmemory", OPT_STRING, &maxmemory,
&maxmemorySpec, 0);
OPTENT3(0, "nosmooth", OPT_FLAG, NULL, &cmdlineP->nosmooth, 0);
OPTENT3(0, "tracelevel", OPT_UINT, &cmdlineP->trace_level,
&tracelevelSpec, 0);
OPTENT3(0, "adobe", OPT_FLAG, NULL, &adobe, 0);
OPTENT3(0, "notadobe", OPT_FLAG, NULL, ¬adobe, 0);
OPTENT3(0, "comments", OPT_FLAG, NULL, &cmdlineP->comments, 0);
OPTENT3(0, "exif", OPT_STRING, &cmdlineP->exif_filespec,
&exifSpec, 0);
OPTENT3(0, "dumpexif", OPT_FLAG, NULL, &cmdlineP->dumpexif, 0);
OPTENT3(0, "multiple", OPT_FLAG, NULL, &cmdlineP->multiple, 0);
OPTENT3(0, "repair", OPT_FLAG, NULL, &cmdlineP->repair, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We may have parms that are negative numbers */
/* Make private copy of arguments for optParseOptions to corrupt */
argc_parse = argc;
for (i=0; i < argc; ++i)
argv_parse[i] = argv[i];
optParseOptions3( &argc_parse, argv_parse, opt, sizeof(opt), 0);
/* Uses and sets argc_parse, argv_parse,
and some of *cmdlineP and others. */
if (!tracelevelSpec)
cmdlineP->trace_level = 0;
if (!exifSpec)
cmdlineP->exif_filespec = NULL;
if (argc_parse - 1 == 0)
cmdlineP->input_filespec = strdup("-"); /* he wants stdin */
else if (argc_parse - 1 == 1)
cmdlineP->input_filespec = strdup(argv_parse[1]);
else
pm_error("Too many arguments. The only argument accepted "
"is the input file specification");
if (!dctvalSpec)
cmdlineP->dct_method = JDCT_DEFAULT;
else {
if (streq(dctval, "int"))
cmdlineP->dct_method = JDCT_ISLOW;
else if (streq(dctval, "fast"))
cmdlineP->dct_method = JDCT_IFAST;
else if (streq(dctval, "float"))
cmdlineP->dct_method = JDCT_FLOAT;
else pm_error("Invalid value for the --dct option: '%s'.", dctval);
}
interpret_maxmemory(maxmemorySpec, maxmemory,
&cmdlineP->max_memory_to_use);
interpret_adobe(adobe, notadobe, &cmdlineP->inklevel);
free(argv_parse);
}
static void
parseCommandLine (int argc, char ** argv,
struct cmdlineInfo *cmdlineP) {
/*----------------------------------------------------------------------------
parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to pm_optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int spreadbrightness, spreadluminosity;
unsigned int center, meancolor, meanpixel;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "spreadbrightness", OPT_FLAG,
NULL, &spreadbrightness, 0);
OPTENT3(0, "spreadluminosity", OPT_FLAG,
NULL, &spreadluminosity, 0);
OPTENT3(0, "center", OPT_FLAG,
NULL, ¢er, 0);
OPTENT3(0, "meancolor", OPT_FLAG,
NULL, &meancolor, 0);
OPTENT3(0, "meanpixel", OPT_FLAG,
NULL, &meanpixel, 0);
OPTENT3(0, "sort", OPT_FLAG, NULL,
&cmdlineP->sort, 0 );
OPTENT3(0, "square", OPT_FLAG, NULL,
&cmdlineP->square, 0 );
OPTENT3(0, "verbose", OPT_FLAG, NULL,
&cmdlineP->verbose, 0 );
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
pm_optParseOptions3( &argc, argv, opt, sizeof(opt), 0 );
/* Uses and sets argc, argv, and some of *cmdline_p and others. */
if (spreadbrightness && spreadluminosity)
pm_error("You cannot specify both -spreadbrightness and "
"spreadluminosity.");
if (spreadluminosity)
cmdlineP->methodForLargest = LARGE_LUM;
else
cmdlineP->methodForLargest = LARGE_NORM;
if (center + meancolor + meanpixel > 1)
pm_error("You can specify only one of -center, -meancolor, and "
"-meanpixel.");
if (meancolor)
cmdlineP->methodForRep = REP_AVERAGE_COLORS;
else if (meanpixel)
cmdlineP->methodForRep = REP_AVERAGE_PIXELS;
else
cmdlineP->methodForRep = REP_CENTER_BOX;
if (argc-1 > 2)
pm_error("Program takes at most two arguments: number of colors "
"and input file specification. "
"You specified %d arguments.", argc-1);
else {
if (argc-1 < 2)
cmdlineP->inputFilespec = "-";
else
cmdlineP->inputFilespec = argv[2];
if (argc-1 < 1)
pm_error("You must specify the number of colors in the "
"output as an argument.");
else {
if (strcmp(argv[1], "all") == 0)
cmdlineP->allcolors = TRUE;
else {
char * tail;
long int const newcolors = strtol(argv[1], &tail, 10);
if (*tail != '\0')
pm_error("The number of colors argument '%s' is not "
"a number or 'all'", argv[1]);
else if (newcolors < 1)
pm_error("The number of colors must be positive");
else if (newcolors == 1)
pm_error("The number of colors must be greater than 1.");
else {
cmdlineP->newcolors = newcolors;
cmdlineP->allcolors = FALSE;
}
}
}
}
}
static void
parseCommandLine(int argc,
const char ** argv,
struct cmdlineInfo * const cmdlineP ) {
/*----------------------------------------------------------------------------
Parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry *option_def;
/* Instructions to pm_optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
char *align, *valign;
unsigned int xoffSpec, yoffSpec, alignSpec, valignSpec, opacitySpec,
alphaSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "invert", OPT_FLAG, NULL,
&cmdlineP->alphaInvert, 0);
OPTENT3(0, "xoff", OPT_INT, &cmdlineP->xoff,
&xoffSpec, 0);
OPTENT3(0, "yoff", OPT_INT, &cmdlineP->yoff,
&yoffSpec, 0);
OPTENT3(0, "opacity", OPT_FLOAT, &cmdlineP->opacity,
&opacitySpec, 0);
OPTENT3(0, "alpha", OPT_STRING, &cmdlineP->alphaFilespec,
&alphaSpec, 0);
OPTENT3(0, "align", OPT_STRING, &align,
&alignSpec, 0);
OPTENT3(0, "valign", OPT_STRING, &valign,
&valignSpec, 0);
OPTENT3(0, "linear", OPT_FLAG, NULL,
&cmdlineP->linear, 0);
OPTENT3(0, "mixtransparency", OPT_FLAG, NULL,
&cmdlineP->mixtransparency, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (!xoffSpec)
cmdlineP->xoff = 0;
if (!yoffSpec)
cmdlineP->yoff = 0;
if (!alphaSpec)
cmdlineP->alphaFilespec = NULL;
if (alignSpec) {
if (strcaseeq(align, "BEYONDLEFT"))
cmdlineP->align = BEYONDLEFT;
else if (strcaseeq(align, "LEFT"))
cmdlineP->align = LEFT;
else if (strcaseeq(align, "CENTER"))
cmdlineP->align = CENTER;
else if (strcaseeq(align, "RIGHT"))
cmdlineP->align = RIGHT;
else if (strcaseeq(align, "BEYONDRIGHT"))
cmdlineP->align = BEYONDRIGHT;
else
pm_error("Invalid value for align option: '%s'. Only LEFT, "
"RIGHT, CENTER, BEYONDLEFT, and BEYONDRIGHT are valid.",
align);
} else
cmdlineP->align = LEFT;
if (valignSpec) {
if (strcaseeq(valign, "ABOVE"))
cmdlineP->valign = ABOVE;
else if (strcaseeq(valign, "TOP"))
cmdlineP->valign = TOP;
else if (strcaseeq(valign, "MIDDLE"))
cmdlineP->valign = MIDDLE;
else if (strcaseeq(valign, "BOTTOM"))
cmdlineP->valign = BOTTOM;
else if (strcaseeq(valign, "BELOW"))
cmdlineP->valign = BELOW;
else
pm_error("Invalid value for valign option: '%s'. Only TOP, "
"BOTTOM, MIDDLE, ABOVE, and BELOW are valid.",
align);
} else
cmdlineP->valign = TOP;
if (!opacitySpec)
cmdlineP->opacity = 1.0;
if (argc-1 < 1)
pm_error("Need at least one argument: file specification of the "
"overlay image.");
cmdlineP->overlayFilespec = argv[1];
if (argc-1 >= 2)
cmdlineP->underlyingFilespec = argv[2];
else
cmdlineP->underlyingFilespec = "-";
if (argc-1 >= 3)
cmdlineP->outputFilespec = argv[3];
else
cmdlineP->outputFilespec = "-";
if (argc-1 > 3)
pm_error("Too many arguments. Only acceptable arguments are: "
"overlay image, underlying image, output image");
}
static void
parseCommandLine (int argc, const char ** argv,
struct CmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
parse program command line described in Unix standard form by argc
and argv. Return the information in the options as *cmdlineP.
If command line is internally inconsistent (invalid options, etc.),
issue error message to stderr and abort program.
Note that the strings we return are stored in the storage that
was passed to us as the argv array. We also trash *argv.
-----------------------------------------------------------------------------*/
optEntry * option_def;
/* Instructions to pm_optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int nofloyd, firstisdefault;
unsigned int missingSpec, mapfileSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "floyd", OPT_FLAG,
NULL, &cmdlineP->floyd, 0);
OPTENT3(0, "fs", OPT_FLAG,
NULL, &cmdlineP->floyd, 0);
OPTENT3(0, "nofloyd", OPT_FLAG,
NULL, &nofloyd, 0);
OPTENT3(0, "nofs", OPT_FLAG,
NULL, &nofloyd, 0);
OPTENT3(0, "norandom", OPT_FLAG,
NULL, &cmdlineP->norandom, 0);
OPTENT3(0, "firstisdefault", OPT_FLAG,
NULL, &firstisdefault, 0);
OPTENT3(0, "mapfile", OPT_STRING,
&cmdlineP->mapFilespec, &mapfileSpec, 0);
OPTENT3(0, "missingcolor", OPT_STRING,
&cmdlineP->missingcolor, &missingSpec, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL,
&cmdlineP->verbose, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
cmdlineP->missingcolor = NULL; /* default value */
pm_optParseOptions3(&argc, (char **)argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdline_p and others. */
if (cmdlineP->floyd && nofloyd)
pm_error("You cannot specify both -floyd and -nofloyd options.");
if (firstisdefault && missingSpec)
pm_error("You cannot specify both -missing and -firstisdefault.");
if (firstisdefault)
cmdlineP->missingMethod = MISSING_FIRST;
else if (missingSpec)
cmdlineP->missingMethod = MISSING_SPECIFIED;
else
cmdlineP->missingMethod = MISSING_CLOSE;
if (!mapfileSpec)
pm_error("You must specify the -mapfile option.");
if (argc-1 > 1)
pm_error("Program takes at most one argument: the input file "
"specification. "
"You specified %d arguments.", argc-1);
if (argc-1 < 1)
cmdlineP->inputFilespec = "-";
else
cmdlineP->inputFilespec = argv[1];
free(option_def);
}
static void
parseCommandLine(int argc, char ** argv,
struct cmdlineInfo * const cmdlineP) {
/*----------------------------------------------------------------------------
Parse the program arguments (given by argc and argv) into a form
the program can deal with more easily -- a cmdline_info structure.
If the syntax is invalid, issue a message and exit the program via
pm_error().
Note that the file spec array we return is stored in the storage that
was passed to us as the argv array.
-----------------------------------------------------------------------------*/
optStruct3 opt; /* set by OPTENT3 */
optEntry *option_def = malloc(100*sizeof(optEntry));
unsigned int option_def_index;
unsigned int outNameSpec;
unsigned int cmap, mono, rgb;
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "name", OPT_STRING,
&cmdlineP->outName, &outNameSpec, 0);
OPTENT3(0, "cmap", OPT_FLAG,
NULL, &cmap, 0);
OPTENT3(0, "mono", OPT_FLAG,
NULL, &mono, 0);
OPTENT3(0, "rgb", OPT_FLAG,
NULL, &rgb, 0);
OPTENT3(0, "norle", OPT_FLAG,
NULL, &cmdlineP->norle, 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = FALSE; /* We have no parms that are negative numbers */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
/* Uses and sets argc, argv, and some of *cmdline_p and others. */
if (cmap + mono + rgb > 1)
pm_error("You may specify only one of -cmap, -mono, and -rgb.");
if (cmap + mono + rgb == 0)
cmdlineP->defaultFormat = TRUE;
else {
cmdlineP->defaultFormat = FALSE;
if (cmap)
cmdlineP->imgType = TGA_MAP_TYPE;
else if (mono)
cmdlineP->imgType = TGA_MONO_TYPE;
else if (rgb)
cmdlineP->imgType = TGA_RGB_TYPE;
}
if (!outNameSpec)
cmdlineP->outName = NULL;
if (argc-1 == 0)
cmdlineP->inputFilespec = "-";
else if (argc-1 != 1)
pm_error("Program takes zero or one argument (filename). You "
"specified %d", argc-1);
else
cmdlineP->inputFilespec = argv[1];
}
