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
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, 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 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, 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, 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) {
/*----------------------------------------------------------------------------
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 option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
/* We have no options. We use the parser just to gripe if user
specifies an option. But when we add an option in the future,
it will go right here with an OPTENT3() macro invocation.
*/
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. */
initUintSet(&cmdlineP->imageSeqList, argc-1);
{
unsigned int i;
for (i = 0; i < argc-1; ++i) {
if (strlen(argv[i+1]) == 0)
pm_error("An image sequence argument is a null string!");
else {
char * endPtr;
int const strtolResult = strtol(argv[i+1], &endPtr, 10);
if (*endPtr != '\0')
pm_error("Garbage in sequence number argument '%s': '%s'",
argv[i+1], endPtr);
if (strtolResult < 0)
pm_error("Image sequence number cannot be negative. "
"You specified %d", strtolResult);
addToUintSet(&cmdlineP->imageSeqList, strtolResult);
}
}
}
free(option_def);
}
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) {
/* --------------------------------------------------------------------------
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 *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,
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 * 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 * 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 *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, const 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;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
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 */
OPTENTINIT;
optParseOptions3(&argc, (char**)argv, opt, sizeof opt, 0);
/* Uses and sets argc, argv, and some of *cmdlineP and others. */
if (argc-1 < 2)
pm_error("You must specify at least two parameters: "
"width and height. You specified %u",
argc-1);
else {
cmdlineP->width = pm_parse_width(argv[1]);
cmdlineP->height = pm_parse_height(argv[2]);
if (argc-1 > 2) {
cmdlineP->inputFileName = argv[3];
if (argc-1 > 3)
pm_error("There are at most three arguments: "
"width, height, file name. You specified %u",
argc-1);
} else
cmdlineP->inputFileName = "-";
}
}
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, 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) {
/*----------------------------------------------------------------------------
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];
}
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 optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int widthSpec, heightSpec, dumpSpec, sizeSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "dump", OPT_STRING,
&cmdlineP->dump, &dumpSpec, 0);
OPTENT3(0, "width", OPT_UINT,
&cmdlineP->width, &widthSpec, 0);
OPTENT3(0, "height", OPT_UINT,
&cmdlineP->height, &heightSpec, 0);
OPTENT3(0, "size", OPT_FLAG,
NULL, &sizeSpec, 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 (!widthSpec)
cmdlineP->width = 3;
if (!heightSpec)
cmdlineP->height = 3;
if (!dumpSpec)
cmdlineP->dump = NULL;
if (sizeSpec) {
/* -size is strictly for backward compatibility. This program
used to use a different command line processor and had
irregular syntax in which the -size option had two values,
e.g. "-size <width> <height>" And the options had to go
before the arguments. So an old pnmsmooth command looks to us
like a command with the -size flag option and the first two
arguments being the width and height.
*/
if (widthSpec || heightSpec)
pm_error("-size is obsolete. Use -width and -height instead");
if (argc-1 > 3)
pm_error("Too many arguments. With -size, there are at most "
"3 arguments.");
else if (argc-1 < 2)
pm_error("Not enough arguments. With -size, the first two "
"arguments are width and height");
else {
cmdlineP->width = atoi(argv[1]);
cmdlineP->height = atoi(argv[2]);
if (argc-1 < 3)
cmdlineP->inputFilespec = "-";
else
cmdlineP->inputFilespec = argv[3];
}
} else {
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];
}
if (cmdlineP->width % 2 != 1)
pm_error("The convolution matrix must have an odd number of columns. "
"You specified %u", cmdlineP->width);
if (cmdlineP->height % 2 != 1)
pm_error("The convolution matrix must have an odd number of rows. "
"You specified %u", cmdlineP->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;
/* Instructions to optParseOptions3 on how to parse our options.
*/
optStruct3 opt;
unsigned int option_def_index;
unsigned int patfileSpec, dpiSpec, eyesepSpec, depthSpec,
guidesizeSpec, magnifypatSpec, xshiftSpec, yshiftSpec, randomseedSpec;
unsigned int blackandwhite, grayscale, color;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "verbose", OPT_FLAG, NULL,
(unsigned int *)&cmdlineP->verbose, 0);
OPTENT3(0, "crosseyed", OPT_FLAG, NULL,
&cmdlineP->crosseyed, 0);
OPTENT3(0, "makemask", OPT_FLAG, NULL,
&cmdlineP->makemask, 0);
OPTENT3(0, "blackandwhite", OPT_FLAG, NULL,
&blackandwhite, 0);
OPTENT3(0, "grayscale", OPT_FLAG, NULL,
&grayscale, 0);
OPTENT3(0, "color", OPT_FLAG, NULL,
&color, 0);
OPTENT3(0, "dpi", OPT_UINT, &cmdlineP->dpi,
&dpiSpec, 0);
OPTENT3(0, "eyesep", OPT_FLOAT, &cmdlineP->eyesep,
&eyesepSpec, 0);
OPTENT3(0, "depth", OPT_FLOAT, &cmdlineP->depth,
&depthSpec, 0);
OPTENT3(0, "maxval", OPT_UINT, &cmdlineP->maxval,
&cmdlineP->maxvalSpec, 0);
OPTENT3(0, "guidesize", OPT_INT, &cmdlineP->guidesize,
&guidesizeSpec, 0);
OPTENT3(0, "magnifypat", OPT_UINT, &cmdlineP->magnifypat,
&magnifypatSpec, 0);
OPTENT3(0, "xshift", OPT_UINT, &cmdlineP->xshift,
&xshiftSpec, 0);
OPTENT3(0, "yshift", OPT_UINT, &cmdlineP->yshift,
&yshiftSpec, 0);
OPTENT3(0, "patfile", OPT_STRING, &cmdlineP->patFilespec,
&patfileSpec, 0);
OPTENT3(0, "randomseed", OPT_UINT, &cmdlineP->randomseed,
&randomseedSpec, 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 (blackandwhite + grayscale + color == 0)
cmdlineP->outputType = OUTPUT_BW;
else if (blackandwhite + grayscale + color > 1)
pm_error("You may specify only one of -blackandwhite, -grayscale, "
"and -color");
else {
if (blackandwhite)
cmdlineP->outputType = OUTPUT_BW;
else if (grayscale)
cmdlineP->outputType = OUTPUT_GRAYSCALE;
else {
assert(color);
cmdlineP->outputType = OUTPUT_COLOR;
}
}
if (!patfileSpec)
cmdlineP->patFilespec = NULL;
if (!dpiSpec)
cmdlineP->dpi = 96;
else if (cmdlineP->dpi < 1)
pm_error("The argument to -dpi must be a positive integer");
if (!eyesepSpec)
cmdlineP->eyesep = 2.5;
else if (cmdlineP->eyesep <= 0.0)
pm_error("The argument to -eyesep must be a positive number");
if (!depthSpec)
cmdlineP->depth = (1.0/3.0);
else if (cmdlineP->depth < 0.0 || cmdlineP->depth > 1.0)
pm_error("The argument to -depth must be a number from 0.0 to 1.0");
if (cmdlineP->maxvalSpec) {
if (cmdlineP->maxval < 1)
pm_error("-maxval must be at least 1");
else if (cmdlineP->maxval > PNM_OVERALLMAXVAL)
pm_error("-maxval must be at most %u. You specified %u",
PNM_OVERALLMAXVAL, cmdlineP->maxval);
}
if (!guidesizeSpec)
cmdlineP->guidesize = 0;
if (!magnifypatSpec)
cmdlineP->magnifypat = 1;
else if (cmdlineP->magnifypat < 1)
pm_error("The argument to -magnifypat must be a positive integer");
if (!xshiftSpec)
cmdlineP->xshift = 0;
if (!yshiftSpec)
cmdlineP->yshift = 0;
if (!randomseedSpec)
cmdlineP->randomseed = time(NULL);
if (xshiftSpec && !cmdlineP->patFilespec)
pm_error("-xshift is valid only with -patfile");
if (yshiftSpec && !cmdlineP->patFilespec)
pm_error("-yshift is valid only with -patfile");
if (cmdlineP->makemask && cmdlineP->patFilespec)
pm_error("You may not specify both -makemask and -patfile");
if (cmdlineP->patFilespec && blackandwhite)
pm_error("-blackandwhite is not valid with -patfile");
if (cmdlineP->patFilespec && grayscale)
pm_error("-grayscale is not valid with -patfile");
if (cmdlineP->patFilespec && color)
pm_error("-color is not valid with -patfile");
if (cmdlineP->patFilespec && cmdlineP->maxvalSpec)
pm_error("-maxval is not valid with -patfile");
if (argc-1 < 1)
cmdlineP->inputFilespec = "-";
else if (argc-1 == 1)
cmdlineP->inputFilespec = argv[1];
else
pm_error("Too many non-option arguments: %d. Only argument is "
"input file name", argc-1);
}
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;
optStruct3 opt;
unsigned int none, packbits, lzw, g3, g4, msb2lsb, lsb2msb, opt_2d, fill;
unsigned int flate, adobeflate;
char * indexbits;
char * resolutionUnit;
unsigned int predictorSpec, rowsperstripSpec, xresolutionSpec,
yresolutionSpec, indexbitsSpec, resolutionUnitSpec, tagSpec;
unsigned int option_def_index;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
OPTENT3(0, "append", OPT_FLAG, NULL, &cmdlineP->append, 0);
OPTENT3(0, "none", OPT_FLAG, NULL, &none, 0);
OPTENT3(0, "packbits", OPT_FLAG, NULL, &packbits, 0);
OPTENT3(0, "lzw", OPT_FLAG, NULL, &lzw, 0);
OPTENT3(0, "g3", OPT_FLAG, NULL, &g3, 0);
OPTENT3(0, "g4", OPT_FLAG, NULL, &g4, 0);
OPTENT3(0, "flate", OPT_FLAG, NULL, &flate, 0);
OPTENT3(0, "adobeflate", OPT_FLAG, NULL, &adobeflate, 0);
OPTENT3(0, "msb2lsb", OPT_FLAG, NULL, &msb2lsb, 0);
OPTENT3(0, "lsb2msb", OPT_FLAG, NULL, &lsb2msb, 0);
OPTENT3(0, "2d", OPT_FLAG, NULL, &opt_2d, 0);
OPTENT3(0, "fill", OPT_FLAG, NULL, &fill, 0);
OPTENT3(0, "minisblack", OPT_FLAG, NULL, &cmdlineP->minisblack, 0);
OPTENT3(0, "mb", OPT_FLAG, NULL, &cmdlineP->minisblack, 0);
OPTENT3(0, "miniswhite", OPT_FLAG, NULL, &cmdlineP->miniswhite, 0);
OPTENT3(0, "mw", OPT_FLAG, NULL, &cmdlineP->miniswhite, 0);
OPTENT3(0, "truecolor", OPT_FLAG, NULL, &cmdlineP->truecolor, 0);
OPTENT3(0, "color", OPT_FLAG, NULL, &cmdlineP->color, 0);
OPTENT3(0, "predictor", OPT_UINT, &cmdlineP->predictor,
&predictorSpec, 0);
OPTENT3(0, "rowsperstrip", OPT_UINT, &cmdlineP->rowsperstrip,
&rowsperstripSpec, 0);
OPTENT3(0, "xresolution", OPT_FLOAT, &cmdlineP->xresolution,
&xresolutionSpec, 0);
OPTENT3(0, "yresolution", OPT_FLOAT, &cmdlineP->yresolution,
&yresolutionSpec, 0);
OPTENT3(0, "resolutionunit", OPT_STRING, &resolutionUnit,
&resolutionUnitSpec, 0);
OPTENT3(0, "indexbits", OPT_STRING, &indexbits,
&indexbitsSpec, 0);
OPTENT3(0, "tag", OPT_NAMELIST, &cmdlineP->taglist, &tagSpec, 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 (none + packbits + lzw + g3 + g4 + flate + adobeflate > 1)
pm_error("You specified more than one compression option. "
"Only one of -none, -packbits, -lze, -g3, and -g4 "
"is allowed.");
if (none)
cmdlineP->compression = COMPRESSION_NONE;
else if (packbits)
cmdlineP->compression = COMPRESSION_PACKBITS;
else if (lzw)
cmdlineP->compression = COMPRESSION_LZW;
else if (g3)
cmdlineP->compression = COMPRESSION_CCITTFAX3;
else if (g4)
cmdlineP->compression = COMPRESSION_CCITTFAX4;
else if (adobeflate)
cmdlineP->compression = COMPRESSION_ADOBE_DEFLATE;
else if (flate)
cmdlineP->compression = COMPRESSION_DEFLATE;
else
cmdlineP->compression = COMPRESSION_NONE;
if (msb2lsb + lsb2msb > 1)
pm_error("You specified both -msb2lsb and -lsb2msb. "
"These are conflicting options.");
if (msb2lsb)
cmdlineP->fillorder = FILLORDER_MSB2LSB;
else if (lsb2msb)
cmdlineP->fillorder = FILLORDER_LSB2MSB;
else
cmdlineP->fillorder = FILLORDER_MSB2LSB;
if (cmdlineP->miniswhite && cmdlineP->minisblack)
pm_error("You cannot specify both -miniswhite and -minisblack");
cmdlineP->g3options = 0; /* initial value */
if (opt_2d)
cmdlineP->g3options |= GROUP3OPT_2DENCODING;
if (fill)
cmdlineP->g3options |= GROUP3OPT_FILLBITS;
if (predictorSpec) {
if (cmdlineP->predictor != 1 && cmdlineP->predictor != 2)
pm_error("-predictor may be only 1 or 2. You specified %d.",
cmdlineP->predictor);
} else
cmdlineP->predictor = -1;
if (rowsperstripSpec) {
if (cmdlineP->rowsperstrip < 1)
pm_error("-rowsperstrip must be positive. You specified %d.",
cmdlineP->rowsperstrip);
} else
cmdlineP->rowsperstrip = -1;
if (xresolutionSpec) {
if (cmdlineP->xresolution < 1)
pm_error("-xresolution must be positive. You specified %f.",
cmdlineP->xresolution);
} else
cmdlineP->xresolution = -1;
if (yresolutionSpec) {
if (cmdlineP->yresolution < 1)
pm_error("-yresolution must be positive. You specified %f.",
cmdlineP->yresolution);
} else
cmdlineP->yresolution = -1;
if (resolutionUnitSpec) {
if (streq(resolutionUnit, "inch"))
cmdlineP->resolutionUnit = RESUNIT_INCH;
else if (streq(resolutionUnit, "in"))
cmdlineP->resolutionUnit = RESUNIT_INCH;
else if (streq(resolutionUnit, "centimeter"))
cmdlineP->resolutionUnit = RESUNIT_CENTIMETER;
else if (streq(resolutionUnit, "cm"))
cmdlineP->resolutionUnit = RESUNIT_CENTIMETER;
else if (streq(resolutionUnit, "none"))
cmdlineP->resolutionUnit = RESUNIT_NONE;
else if (streq(resolutionUnit, "no"))
cmdlineP->resolutionUnit = RESUNIT_NONE;
else
pm_error("The only acceptable values for -resolutionunit are "
"inch, centimeter, none, in, cm, and no. "
"You specified '%s'.", resolutionUnit);
} else
cmdlineP->resolutionUnit = RESUNIT_INCH;
if (indexbitsSpec) {
if (strstr(indexbits, "1"))
cmdlineP->indexsizeAllowed.b1 = TRUE;
else
cmdlineP->indexsizeAllowed.b1 = FALSE;
if (strstr(indexbits, "2"))
cmdlineP->indexsizeAllowed.b2 = TRUE;
else
cmdlineP->indexsizeAllowed.b2 = FALSE;
if (strstr(indexbits, "4"))
cmdlineP->indexsizeAllowed.b4 = TRUE;
else
cmdlineP->indexsizeAllowed.b4 = FALSE;
if (strstr(indexbits, "8"))
cmdlineP->indexsizeAllowed.b8 = TRUE;
else
cmdlineP->indexsizeAllowed.b8 = FALSE;
} else {
cmdlineP->indexsizeAllowed.b1 = FALSE;
cmdlineP->indexsizeAllowed.b2 = FALSE;
cmdlineP->indexsizeAllowed.b4 = FALSE;
cmdlineP->indexsizeAllowed.b8 = TRUE;
}
if (tagSpec)
validateTagList(cmdlineP->taglist);
else {
MALLOCARRAY_NOFAIL(cmdlineP->taglist, 1);
cmdlineP->taglist[0].name = NULL;
cmdlineP->taglist[0].value = NULL;
}
if (argc-1 == 0)
cmdlineP->input_filespec = "-";
else if (argc-1 != 1)
pm_error("Program takes zero or one argument (filename). You "
"specified %d", argc-1);
else
cmdlineP->input_filespec = 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;
unsigned int mapSpec;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "map", OPT_STRING, &cmdlineP->map,
&mapSpec, 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 (!mapSpec)
cmdlineP->map = NULL;
if (mapSpec) {
/* No color argument; only argument is file name */
if (argc-1 < 1)
cmdlineP->inputFilename = "-";
else {
cmdlineP->inputFilename = argv[1];
if (argc-1 > 1)
pm_error("With -map option, there is at most one argument: "
"the file name. You specified %u", argc-1);
}
} else {
/* Arguments are color or color range and file name */
if (argc-1 < 1) {
cmdlineP->colorBlack = "black";
cmdlineP->colorWhite = "white";
} else {
char * buffer = strdup(argv[1]);
char * hyphenPos = strchr(buffer, '-');
if (hyphenPos) {
*hyphenPos = '\0';
cmdlineP->colorBlack = buffer;
cmdlineP->colorWhite = hyphenPos+1;
} else {
cmdlineP->colorBlack = "black";
cmdlineP->colorWhite = buffer;
}
}
if (argc-1 < 2)
cmdlineP->inputFilename = "-";
else
cmdlineP->inputFilename = argv[2];
if (argc-1 > 2)
pm_error("Program takes at most 2 arguments: "
"color name/range and input file name. "
"You specified %u", argc-1);
}
}
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 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, "left", OPT_INT, &cmdlineP->left, NULL, 0);
OPTENT3(0, "right", OPT_INT, &cmdlineP->right, NULL, 0);
OPTENT3(0, "top", OPT_INT, &cmdlineP->top, NULL, 0);
OPTENT3(0, "bottom", OPT_INT, &cmdlineP->bottom, NULL, 0);
OPTENT3(0, "width", OPT_INT, &cmdlineP->width, NULL, 0);
OPTENT3(0, "height", OPT_INT, &cmdlineP->height, NULL, 0);
OPTENT3(0, "pad", OPT_FLAG, NULL, &cmdlineP->pad, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL, &cmdlineP->verbose, 0);
/* Set the defaults */
cmdlineP->left = UNSPEC;
cmdlineP->right = UNSPEC;
cmdlineP->top = UNSPEC;
cmdlineP->bottom = UNSPEC;
cmdlineP->width = UNSPEC;
cmdlineP->height = UNSPEC;
opt.opt_table = option_def;
opt.short_allowed = FALSE; /* We have no short (old-fashioned) options */
opt.allowNegNum = TRUE; /* 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 (cmdlineP->width < 0)
pm_error("-width may not be negative.");
if (cmdlineP->height < 0)
pm_error("-height may not be negative.");
if ((argc-1) != 0 && (argc-1) != 1 && (argc-1) != 4 && (argc-1) != 5)
pm_error("Wrong number of arguments: %u. The only argument in "
"the preferred syntax is an optional input file name. "
"In older syntax, there are also forms with 4 and 5 "
"arguments.", argc-1);
switch (argc-1) {
case 0:
cmdlineP->inputFilespec = "-";
break;
case 1:
cmdlineP->inputFilespec = argv[1];
break;
case 4:
case 5: {
int warg, harg; /* The "width" and "height" command line arguments */
if (sscanf(argv[1], "%d", &cmdlineP->left) != 1)
pm_error("Invalid number for left column argument");
if (sscanf(argv[2], "%d", &cmdlineP->top) != 1)
pm_error("Invalid number for right column argument");
if (sscanf(argv[3], "%d", &warg) != 1)
pm_error("Invalid number for width argument");
if (sscanf(argv[4], "%d", &harg) != 1)
pm_error("Invalid number for height argument");
if (warg > 0) {
cmdlineP->width = warg;
cmdlineP->right = UNSPEC;
} else {
cmdlineP->width = UNSPEC;
cmdlineP->right = warg -1;
}
if (harg > 0) {
cmdlineP->height = harg;
cmdlineP->bottom = UNSPEC;
} else {
cmdlineP->height = UNSPEC;
cmdlineP->bottom = harg - 1;
}
if (argc-1 == 4)
cmdlineP->inputFilespec = "-";
else
cmdlineP->inputFilespec = argv[5];
break;
}
}
}
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 widthSpec, heightSpec, cutoffSpec, typeSpec;
const char * type;
MALLOCARRAY_NOFAIL(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "width", OPT_UINT, &cmdlineP->width,
&widthSpec, 0);
OPTENT3(0, "height", OPT_UINT, &cmdlineP->height,
&heightSpec, 0);
OPTENT3(0, "cutoff", OPT_UINT, &cmdlineP->cutoff,
&cutoffSpec, 0);
OPTENT3(0, "type", OPT_STRING, &type,
&typeSpec, 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 (!widthSpec)
cmdlineP->width = 3;
if (!heightSpec)
cmdlineP->height = 3;
if (!cutoffSpec)
cmdlineP->cutoff = 250;
if (typeSpec) {
if (STREQ(type, "histogram_sort"))
cmdlineP->type = HISTOGRAM_SORT_MEDIAN;
else if (STREQ(type, "select"))
cmdlineP->type = SELECT_MEDIAN;
else
pm_error("Invalid value '%s' for -type. Valid values are "
"'histogram_sort' and 'select'", type);
} else
cmdlineP->type = MEDIAN_UNSPECIFIED;
if (argc-1 < 1)
cmdlineP->inputFileName = "-";
else {
cmdlineP->inputFileName = argv[1];
if (argc-1 > 1)
pm_error ("Too many arguments. The only argument is "
"the optional input file name");
}
}
int
main(int argc, char **argv)
{
struct pam *imgs;
struct pam outimg;
struct pam p;
int nfiles;
int i, j;
unsigned int q[10];
coord *coords;
const char *headfname = NULL;
const char *datafname = NULL;
const char *prefix = "";
FILE *header;
FILE *data;
char **names;
char *c;
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, "data", OPT_STRING, &datafname, NULL, 0);
OPTENT3( 0, "header", OPT_STRING, &headfname, NULL, 0);
OPTENT3('q', "quality", OPT_UINT, &qfactor, NULL, 0);
OPTENT3('p', "prefix", OPT_STRING, &prefix, NULL, 0);
OPTENT3('0', "0", OPT_FLAG, NULL, &q[0], 0);
OPTENT3('1', "1", OPT_FLAG, NULL, &q[1], 0);
OPTENT3('2', "2", OPT_FLAG, NULL, &q[2], 0);
OPTENT3('3', "3", OPT_FLAG, NULL, &q[3], 0);
OPTENT3('4', "4", OPT_FLAG, NULL, &q[4], 0);
OPTENT3('5', "5", OPT_FLAG, NULL, &q[5], 0);
OPTENT3('6', "6", OPT_FLAG, NULL, &q[6], 0);
OPTENT3('7', "7", OPT_FLAG, NULL, &q[7], 0);
OPTENT3('8', "8", OPT_FLAG, NULL, &q[8], 0);
OPTENT3('9', "9", OPT_FLAG, NULL, &q[9], 0);
opt.opt_table = option_def;
opt.short_allowed = FALSE;
opt.allowNegNum = FALSE;
pnm_init(&argc, argv);
/* Check for flags. */
optParseOptions3(&argc, argv, opt, sizeof(opt), 0);
if (headfname)
header = pm_openw(headfname);
if (datafname)
data = pm_openw(datafname);
for (i = 0; i < 10; ++i)
{
if (q[i])
{
quality = i;
switch (quality)
{
case 0: case 1: break;
case 2: case 3: case 4: case 5: case 6:
qfactor = 100 * (8 - quality);
break;
case 7: qfactor = 150; break;
case 8: qfactor = 125; break;
case 9: qfactor = 100; break;
}
}
}
if (1 < argc)
nfiles = argc - 1;
else
nfiles = 1;
MALLOCARRAY(imgs, nfiles);
MALLOCARRAY(coords, nfiles);
MALLOCARRAY(names, nfiles);
if (!imgs || !coords || !names)
pm_error("out of memory");
if (1 < argc)
{
for (i = 0; i < nfiles; ++i)
{
if (strchr(argv[i+1], ':'))
{
imgs[i].file = pm_openr(strchr(argv[i+1], ':') + 1);
*strchr(argv[i+1], ':') = 0;
names[i] = argv[i+1];
}
else
{
imgs[i].file = pm_openr(argv[i+1]);
names[i] = argv[i+1];
}
}
}
else
{
imgs[0].file = stdin;
}
pnm_readpaminit(imgs[0].file, &imgs[0], PAM_STRUCT_SIZE(tuple_type));
outimg.maxval = imgs[0].maxval;
outimg.format = imgs[0].format;
memcpy(outimg.tuple_type, imgs[0].tuple_type, sizeof(imgs[0].tuple_type));
outimg.depth = imgs[0].depth;
for (i = 1; i < nfiles; ++i)
{
pnm_readpaminit(imgs[i].file, &imgs[i], PAM_STRUCT_SIZE(tuple_type));
if (PAM_FORMAT_TYPE(imgs[i].format) > PAM_FORMAT_TYPE(outimg.format))
outimg.format = imgs[i].format,
memcpy(outimg.tuple_type, imgs[i].tuple_type,
sizeof(imgs[i].tuple_type));
outimg.maxval = imax(imgs[i].maxval, outimg.maxval);
outimg.depth = imax(imgs[i].depth, outimg.depth);
}
for (i = 0; i < nfiles - 1; ++i)
for (j = i + 1; j < nfiles; ++j)
if (imgs[j].width * imgs[j].height > imgs[i].width * imgs[i].height)
p = imgs[i], imgs[i] = imgs[j], imgs[j] = p,
c = names[i], names[i] = names[j], names[j] = c;
findpack(imgs, nfiles, coords);
outimg.height = outimg.width = 0;
for (i = 0; i < nfiles; ++i)
{
outimg.width = imax(outimg.width, imgs[i].width + coords[i].x);
outimg.height = imax(outimg.height, imgs[i].height + coords[i].y);
}
outimg.size = sizeof(outimg);
outimg.len = sizeof(outimg);
outimg.file = stdout;
outimg.bytes_per_sample = 0;
for (i = outimg.maxval; i; i >>= 8)
++outimg.bytes_per_sample;
writePam(&outimg, nfiles, coords, imgs);
if (datafname)
{
fprintf(data, ":0:0:%u:%u\n", outimg.width, outimg.height);
for (i = 0; i < nfiles; ++i)
{
fprintf(data, "%s:%u:%u:%u:%u\n", names[i], coords[i].x,
coords[i].y, imgs[i].width, imgs[i].height);
}
}
if (headfname)
{
fprintf(header, "#define %sOVERALLX %u\n"
"#define %sOVERALLY %u\n"
"\n",
prefix, outimg.width,
prefix, outimg.height);
for (i = 0; i < nfiles; ++i)
{
*strchr(names[i], '.') = 0;
for (j = 0; names[i][j]; ++j)
{
if (ISLOWER(names[i][j]))
names[i][j] = TOUPPER(names[i][j]);
}
fprintf(header, "#define %s%sX %u\n"
"#define %s%sY %u\n"
"#define %s%sSZX %u\n"
"#define %s%sSZY %u\n"
"\n",
prefix, names[i], coords[i].x,
prefix, names[i], coords[i].y,
prefix, names[i], imgs[i].width,
prefix, names[i], imgs[i].height);
}
}
for (i = 0; i < nfiles; ++i)
pm_close(imgs[i].file);
pm_close(stdout);
if (headfname)
pm_close(header);
if (datafname)
pm_close(data);
return 0;
}
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;
unsigned int planesSpec, xposSpec, yposSpec, paletteSpec;
MALLOCARRAY(option_def, 100);
option_def_index = 0; /* incremented by OPTENT3 */
OPTENT3(0, "24bit", OPT_FLAG, NULL,
&cmdlineP->truecolor, 0);
OPTENT3(0, "8bit", OPT_FLAG, NULL,
&cmdlineP->use_8_bit, 0);
OPTENT3(0, "planes", OPT_UINT, &cmdlineP->planes,
&planesSpec, 0);
OPTENT3(0, "packed", OPT_FLAG, NULL,
&cmdlineP->packed, 0);
OPTENT3(0, "verbose", OPT_FLAG, NULL,
&cmdlineP->verbose, 0);
OPTENT3(0, "stdpalette", OPT_FLAG, NULL,
&cmdlineP->stdpalette, 0);
OPTENT3(0, "palette", OPT_STRING, &cmdlineP->palette,
&paletteSpec, 0);
OPTENT3(0, "xpos", OPT_INT, &cmdlineP->xpos, &xposSpec, 0);
OPTENT3(0, "ypos", OPT_INT, &cmdlineP->ypos, &yposSpec, 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 (!xposSpec)
cmdlineP->xpos = 0;
else if (cmdlineP->xpos < -32767 || cmdlineP->xpos > 32768)
pm_error("-xpos value (%d) is outside acceptable range "
"(-32767, 32768)", cmdlineP->xpos);
if (!yposSpec)
cmdlineP->ypos = 0;
else if (cmdlineP->ypos < -32767 || cmdlineP->ypos > 32768)
pm_error("-ypos value (%d) is outside acceptable range "
"(-32767, 32768)", cmdlineP->ypos);
if (!planesSpec)
cmdlineP->planes = 0; /* 0 means minimum */
if (planesSpec) {
if (cmdlineP->planes > 4 || cmdlineP->planes < 1)
pm_error("The only possible numbers of planes are 1-4. "
"You specified %u", cmdlineP->planes);
if (cmdlineP->packed)
pm_error("-planes is meaningless with -packed.");
if (cmdlineP->truecolor)
pm_error("-planes is meaningless with -24bit");
if (cmdlineP->use_8_bit)
pm_error("-planes is meaningless with -8bit");
}
if (paletteSpec && cmdlineP->stdpalette)
pm_error("You can't specify both -palette and -stdpalette");
if (!paletteSpec)
cmdlineP->palette = NULL;
if (cmdlineP->use_8_bit && cmdlineP->truecolor)
pm_error("You cannot specify both -8bit and -truecolor");
if (argc-1 < 1)
cmdlineP->inputFilespec = "-";
else if (argc-1 == 1)
cmdlineP->inputFilespec = argv[1];
else
pm_error("Program takes at most one argument "
"(input file specification). You specified %d",
argc-1);
}
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 * 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;
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);
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 (!xoffSpec)
cmdlineP->xoff = 0;
if (!yoffSpec)
cmdlineP->yoff = 0;
if (!alphaSpec)
cmdlineP->alphaFilespec = NULL;
if (alignSpec) {
if (strcasecmp(align, "BEYONDLEFT") == 0)
cmdlineP->align = BEYONDLEFT;
else if (strcasecmp(align, "LEFT") == 0)
cmdlineP->align = LEFT;
else if (strcasecmp(align, "CENTER") == 0)
cmdlineP->align = CENTER;
else if (strcasecmp(align, "RIGHT") == 0)
cmdlineP->align = RIGHT;
else if (strcasecmp(align, "BEYONDRIGHT") == 0)
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 (strcasecmp(valign, "ABOVE") == 0)
cmdlineP->valign = ABOVE;
else if (strcasecmp(valign, "TOP") == 0)
cmdlineP->valign = TOP;
else if (strcasecmp(valign, "MIDDLE") == 0)
cmdlineP->valign = MIDDLE;
else if (strcasecmp(valign, "BOTTOM") == 0)
cmdlineP->valign = BOTTOM;
else if (strcasecmp(valign, "BELOW") == 0)
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");
}
