mlp.c

NIST Handwriting OCR Testbed

}

/*******************************************************************/

/* parse_cmd_line: Parses, using getopt, the command line.

The usage is:

  mlp [-c] [<specfile>]

where:
  -c means: do checking of specfile only, i.e. do not run mlp even if
     specfile has no errors.
  <specfile> is the filename of the spec (specification) file; if
     this arg is abset, specfile is set to file "spec" in current dir.

If the optional specfile name is present, it must be the last arg on
the command line; and if that filename begins with a -, the arg must
be preceded by the special arg --.

Usage examples:

  mlp
    (Runs, using specfile "spec".)

  mlp ../foo
    (Runs, using specfile "../foo".)

  mlp -c
    (Checks specfile only; specfile is "spec".)

  mlp -c ../foo
    (Checks specfile only; specfile is "../foo".)


Input args:   
  argc, argv: The arg-count and arg-vector args of the "main"
    function.

Output args:   
  check_only: TRUE (FALSE) if command line did (did not) set the "-c"
    option, which means that mlp should only check the specfile.  
  specfile: Spec (specification) file name; this buffer must be
    provided already allocated (to at least a reasonable size) by
    caller.
*/

void
parse_cmd_line(argc, argv, check_only, specfile)
int argc;
char **argv, *check_only, specfile[];
{
  char str[300];
  static char usage_str[] = "Usage: mlp [-c] [<specfile>]";
  int c;
  extern char *optarg;
  extern int optind, opterr;

  opterr = 0; /* turn off getopt's writing of error messages */

  *check_only = FALSE;

  while((c = getopt(argc, argv, "c")) != -1)
    switch(c) {

    case 'c':
      *check_only = TRUE;
      break;

    case '?':
      fatalerr(usage_str, NULL, NULL);
      break;
    }

  /* After any options and their args, there should be either nothing,
  or a specfile name. */
  if(optind == argc)
    /* Nothing, i.e. no specfile name; set name to empty string. */
    strcpy(specfile, "");

  else if(optind == argc - 1)
    /* One arg: specfile name */
    strcpy(specfile, argv[optind]);

  else
    /* Two or more args: not allowed */
    fatalerr(usage_str, NULL, NULL);

}

/*******************************************************************/

/* get_parms_vals: Gets just the "val" members of the parm-specific
members of the PARMS structure.  Putting all this mess down here
allows the main routine to be cleaner (few member references).

(Obvious) WARNING: If the PARMS structure typedef (in parms.h) is
changed, then this routine has to be changed accordingly. */

void
get_parms_vals(parms, long_outfile, short_outfile, patterns_infile,
  wts_infile, wts_outfile, class_wts_infile, pattern_wts_infile,
  lcn_scn_infile, npats, ninps, nhids, nouts, seed, niter_max, nfreq,
  nokdel, lbfgs_mem, regfac, alpha, temperature, egoal, gwgoal,
  errdel, oklvl, errfunc, purpose, boltzmann, train_or_test,
  acfunc_hids, acfunc_outs, priors, patsfile_ascii_or_binary,
  do_confuse, show_acs_times_1000, do_cvr, trgoff, scg_earlystop_pct,
  lbfgs_gtol)
PARMS *parms;
char **long_outfile, **short_outfile, **patterns_infile, **wts_infile,
  **wts_outfile, **class_wts_infile, **pattern_wts_infile,
  **lcn_scn_infile, *errfunc, *purpose, *boltzmann,
  *train_or_test, *acfunc_hids, *acfunc_outs, *priors,
  *patsfile_ascii_or_binary, *do_confuse, *show_acs_times_1000,
  *do_cvr;
int *npats, *ninps, *nhids, *nouts, *seed, *niter_max, *nfreq, *nokdel,
  *lbfgs_mem;
float *regfac, *alpha, *temperature, *egoal, *gwgoal, *errdel, *oklvl,
  *trgoff, *scg_earlystop_pct, *lbfgs_gtol;
{
  void get_a_parms_val();

  get_a_parms_val(PARMTYPE_FILENAME, (char *)(&(parms->long_outfile)),
    (char *)long_outfile);
  get_a_parms_val(PARMTYPE_FILENAME, (char *)(&(parms->short_outfile)),
    (char *)short_outfile);
  get_a_parms_val(PARMTYPE_FILENAME,
    (char *)(&(parms->patterns_infile)), (char *)patterns_infile);
  get_a_parms_val(PARMTYPE_FILENAME, (char *)(&(parms->wts_infile)),
    (char *)wts_infile);
  get_a_parms_val(PARMTYPE_FILENAME, (char *)(&(parms->wts_outfile)),
    (char *)wts_outfile);
  get_a_parms_val(PARMTYPE_FILENAME,
    (char *)(&(parms->class_wts_infile)),
    (char *)class_wts_infile);
  get_a_parms_val(PARMTYPE_FILENAME,
    (char *)(&(parms->pattern_wts_infile)),
    (char *)pattern_wts_infile);
  get_a_parms_val(PARMTYPE_FILENAME,
    (char *)(&(parms->lcn_scn_infile)), (char *)lcn_scn_infile);
  get_a_parms_val(PARMTYPE_INT, (char *)(&(parms->npats)),
    (char *)npats);
  get_a_parms_val(PARMTYPE_INT, (char *)(&(parms->ninps)),
    (char *)ninps);
  get_a_parms_val(PARMTYPE_INT, (char *)(&(parms->nhids)),
    (char *)nhids);
  get_a_parms_val(PARMTYPE_INT, (char *)(&(parms->nouts)),
    (char *)nouts);
  get_a_parms_val(PARMTYPE_INT, (char *)(&(parms->seed)),
    (char *)seed);
  get_a_parms_val(PARMTYPE_INT, (char *)(&(parms->niter_max)),
    (char *)niter_max);
  get_a_parms_val(PARMTYPE_INT, (char *)(&(parms->nfreq)),
    (char *)nfreq);
  get_a_parms_val(PARMTYPE_INT, (char *)(&(parms->nokdel)),
    (char *)nokdel);
  get_a_parms_val(PARMTYPE_INT, (char *)(&(parms->lbfgs_mem)),
    (char *)lbfgs_mem);
  get_a_parms_val(PARMTYPE_FLOAT, (char *)(&(parms->regfac)),
    (char *)regfac);
  get_a_parms_val(PARMTYPE_FLOAT, (char *)(&(parms->alpha)),
    (char *)alpha);
  get_a_parms_val(PARMTYPE_FLOAT, (char *)(&(parms->temperature)),
    (char *)temperature);
  get_a_parms_val(PARMTYPE_FLOAT, (char *)(&(parms->egoal)),
    (char *)egoal);
  get_a_parms_val(PARMTYPE_FLOAT, (char *)(&(parms->gwgoal)),
    (char *)gwgoal);
  get_a_parms_val(PARMTYPE_FLOAT, (char *)(&(parms->errdel)),
    (char *)errdel);
  get_a_parms_val(PARMTYPE_FLOAT, (char *)(&(parms->oklvl)),
    (char *)oklvl);
  get_a_parms_val(PARMTYPE_SWITCH, (char *)(&(parms->errfunc)),
    (char *)errfunc);
  get_a_parms_val(PARMTYPE_SWITCH, (char *)(&(parms->purpose)),
    (char *)purpose);
  get_a_parms_val(PARMTYPE_SWITCH,
    (char *)(&(parms->boltzmann)),
    (char *)boltzmann);
  get_a_parms_val(PARMTYPE_SWITCH, (char *)(&(parms->train_or_test)),
    (char *)train_or_test);
  get_a_parms_val(PARMTYPE_SWITCH, (char *)(&(parms->acfunc_hids)),
    (char *)acfunc_hids);
  get_a_parms_val(PARMTYPE_SWITCH, (char *)(&(parms->acfunc_outs)),
    (char *)acfunc_outs);
  get_a_parms_val(PARMTYPE_SWITCH, (char *)(&(parms->priors)),
    (char *)priors);
  get_a_parms_val(PARMTYPE_SWITCH,
    (char *)(&(parms->patsfile_ascii_or_binary)),
    (char *)patsfile_ascii_or_binary);
  get_a_parms_val(PARMTYPE_SWITCH, (char *)(&(parms->do_confuse)),
    (char *)do_confuse);
  get_a_parms_val(PARMTYPE_SWITCH,
    (char *)(&(parms->show_acs_times_1000)),
    (char *)show_acs_times_1000);
  get_a_parms_val(PARMTYPE_SWITCH, (char *)(&(parms->do_cvr)),
    (char *)do_cvr);
  get_a_parms_val(PARMTYPE_FLOAT, (char *)(&(parms->trgoff)),
    (char *)trgoff);
  get_a_parms_val(PARMTYPE_FLOAT,
    (char *)(&(parms->scg_earlystop_pct)), (char *)scg_earlystop_pct);
  get_a_parms_val(PARMTYPE_FLOAT, (char *)(&(parms->lbfgs_gtol)),
    (char *)lbfgs_gtol);
}

/*******************************************************************/

#define MYNULL 0

/* get_a_parms_val: For use by get_parms_vals.  Copies a parm out; but
if the parm is not set, the output gets loaded with MYNULL. */

void
get_a_parms_val(parmtype, member, val)
char parmtype, *member, *val;
{
  char str[100];

  switch(parmtype) {

  case PARMTYPE_FILENAME:
    *((char **)val) = ((((PARM_FILENAME *)member)->ssl).set ?
      ((PARM_FILENAME *)member)->val : (char *)MYNULL);
    break;

  case PARMTYPE_INT:
    *((int *)val) = ((((PARM_INT *)member)->ssl).set ?
      ((PARM_INT *)member)->val : (int)MYNULL);
    break;

  case PARMTYPE_FLOAT:
    *((float *)val) = ((((PARM_FLOAT *)member)->ssl).set ?
      ((PARM_FLOAT *)member)->val : (float)MYNULL);
    break;

  case PARMTYPE_SWITCH:
    *val = ((((PARM_SWITCH *)member)->ssl).set ?
      ((PARM_SWITCH *)member)->val : (char)MYNULL);
    break;

  default:
    sprintf(str, "parmtype must be PARMTYPE_FILENAME (%d), \
PARMTYPE_INT (%d), PARMTYPE_FLOAT (%d), or PARMTYPE_SWITCH \
(%d); it is %d", (int)PARMTYPE_FILENAME, (int)PARMTYPE_INT,
      (int)PARMTYPE_FLOAT, (int)PARMTYPE_SWITCH, (int)parmtype);
    fatalerr("get_a_parms_val (mlp.c)", str, MYNULL);
    break;

  }
}

/*******************************************************************/