readcfg.c

Go to the documentation of this file.

#include "edtinc.h"
#include "initcam.h"

#define COMPARE(str1, str2) (strcasecmp(str1, str2) == 0)

/* shorthand debug level */
#define DEBUG0 PDVLIB_MSG_FATAL
#define DEBUG1 PDVLIB_MSG_INFO_1
#define DEBUG2 PDVLIB_MSG_INFO_2

u_char *xilinx;                 /* pointer to programmable Xilinx area */
static char xilinx_file[512];
static char xilinx_link[512];
int     nser = 0;

void clear_dependent(Dependent * dd_p);
int check_method_param(char *s, Dependent * dd_p, Edtinfo * ei_p, char *cfgfile);
int check_other_param(char *s, Dependent * dd_p, char *cfgfile);
int check_xilinx_param(char *s, Dependent * dd_p, char *cfgfile);
int check_cls_param(char *s, Dependent * dd_p, char *cfgfile);
int is_method(char *method_type, char *name);
void strip_ctrlm(char *s);
void strip_extra_whitespace(char *s);
int resolve_cameratype(Dependent *dd_p);


/* utility routine for embedded (nofs) config file arrays -- copies and changes '\"' to '"'*/
char *
get_next_string(int nofs_cfg, FILE *cfg_fp, char *ss, char *ds)
{
    char *dp = ds;
#ifdef NO_FS
    char *sp ;
#endif

#ifdef NO_FS
    if (nofs_cfg)
    {
        sp = ss;
        if (!*sp)
            return 0;

        while(*sp)
        {
            if ((*sp == '\\') && (*(sp+1) == '\"'))
                ++sp;
            *dp++ = *sp++;
        }
        *dp = '\0';

        return 1;
    }
    else
#endif
    
    return fgets(ds, 255, cfg_fp);
}


#ifdef NO_FS
/*
 * embedded config files, for 
 */
#include "nofs_config.h"
#endif


char *dmy_cfg[] = {""};

void
dep_set_default(PdvDependent * dd_p)

{
    int i;

   /*
     * clear dependent struct and set defaults to nonsense values
     */
    clear_dependent(dd_p);
    dd_p->rbtfile[0] = '\0';
    dd_p->cameratype[0] = '\0';
    dd_p->shutter_speed = NOT_SET;
    dd_p->default_shutter_speed = NOT_SET;
    dd_p->default_gain = NOT_SET;
    dd_p->default_offset = NOT_SET;
    dd_p->default_aperture = NOT_SET;
    dd_p->binx = 1;
    dd_p->biny = 1;
    dd_p->byteswap = NOT_SET;
    dd_p->serial_timeout = 1000;
    dd_p->serial_response[0] = '\r';
    dd_p->xilinx_rev = NOT_SET;
    dd_p->timeout = NOT_SET;
    dd_p->user_timeout = NOT_SET;
    dd_p->mode_cntl_norm = NOT_SET;
    dd_p->mc4 = 0;
    dd_p->pulnix = 0;
    dd_p->dbl_trig = 0;
    dd_p->shift = NOT_SET;
    dd_p->mask = 0xffff;
    dd_p->mode16 = NOT_SET;
    dd_p->serial_baud = NOT_SET;
    dd_p->serial_waitc = NOT_SET ;
    dd_p->serial_format = SERIAL_ASCII;
    strcpy(dd_p->serial_term, "\r");    /* term for most ASCII exc. ES4.0 */
    
    dd_p->kbs_red_row_first = 1;
    dd_p->kbs_green_pixel_first = 0;
  

    dd_p->htaps = 1;
    dd_p->vtaps = 1;

    dd_p->cameralink = 0;
    dd_p->start_delay = 0;
    dd_p->frame_period = NOT_SET;
    dd_p->frame_timing = NOT_SET;

    dd_p->strobe_enabled = NOT_SET;
    dd_p->register_wrap = 0;
    dd_p->serial_init_delay = NOT_SET;


    /*
     * xregwrite registers can be 0-ff. We need a way to flag the
     * end of the array, so just waste ff and call that "not set"
     */
    for (i=0; i<32; i++)
        dd_p->xilinx_flag[i] = 0xff;

}

int
readcfg(char *cfgfile, Dependent * dd_p, Edtinfo * ei_p, int nofs_cfg)
{


    int     pdv_unit = 0;
    int     ret;
    char    **vx_p = dmy_cfg;
    FILE   *cfg_fp;
    char    s[256];
    char    *sp;
    int     lineno = 0;
#ifdef NO_FS
    char    *cf;
#endif

    edt_msg(DEBUG2, "Reading/processing config file %s:\n\n", cfgfile);

    if (!nofs_cfg)
    {
        /*
         * Read and process the configuration file for this camera.
         */
        if ((cfg_fp = fopen(cfgfile, "r")) == NULL)
        {
            perror(cfgfile);
            return -1;
        }
    }

    dep_set_default(dd_p);

    ei_p->startdma = NOT_SET;
    ei_p->enddma = NOT_SET;
    ei_p->flushdma = NOT_SET;

     dd_p->startdma = NOT_SET;
    dd_p->enddma = NOT_SET;
    dd_p->flushdma = NOT_SET;
   

    strncpy(dd_p->cfgname, cfgfile, sizeof(dd_p->cfgname) - 1);
 
#ifdef NO_FS
    if (nofs_cfg)
    {
        char *p;

        if ((cf = strrchr(cfgfile, '/')) != NULL)
            ++cf;
        else cf = cfgfile;
        p = cf;

        if ((strlen(cf) > 4) && (strcasecmp(&cf[strlen(cf)-4], ".cfg") == 0))
            cf[strlen(cf)-4] = '\0';

        /*
         * change dashes to underscores in name, to match variable names
         */
        do
        {
            if (*p == '-')
                (*p = '_');
        } while(*(++p));
        MAPCONFIG(cf, vx_p); /* macro in nofs_config.h */

        if (vx_p == NULL)
        {
            printf("embedded specified, but no header file for '%s' included in source (nofs_config.h)\n", cf);
            exit(1);
        }
    }
#endif

    while (get_next_string(nofs_cfg, cfg_fp, *vx_p, s))
    {
        char tmpstr[256];
        if (nofs_cfg)
            ++vx_p;

        lineno++;

        /* debug string printf */
        if (s[strlen(s)-1] == '\n')
            strcpy(tmpstr, s);
        else sprintf(tmpstr, "%s\n", s);
        edt_msg(DEBUG2, tmpstr);

        if (*s == '#' || *s == '\n' || *s == '\r')
            continue;

        strip_ctrlm(s);
        strip_extra_whitespace(s);

        if (*s == '#' || *s == '\n' || *s == '\r')
            continue;

        if ((ret = check_method_param(s, dd_p, ei_p, cfgfile)) < 0)
            return -1;
        if (ret == 1)
            continue;

        if ((ret = check_xilinx_param(s, dd_p, cfgfile)) < 0)
            return -1;
        if (ret == 1)
            continue;

        if ((ret = check_other_param(s, dd_p, cfgfile)) < 0)
            return -1;

        if (ret == 1)
            continue;

        if ((ret = check_cls_param(s, dd_p, cfgfile)) < 0)
            return -1;

        if (ret == 1)
            continue;

        {
            char    kw[256];

            sscanf(s, "%s", kw);
            edt_msg(DEBUG0, "WARNING: unrecognized argument \"%s\" line %d (ignored)\n", kw, lineno);
        }
    }

#ifndef NO_FS
    fclose(cfg_fp);
#endif

    /*
     * the cameratype directive (not the parameter though) is obsolete
     * so make it up from class and model if they are present (should be!)
     */
    resolve_cameratype(dd_p);

    /*
     * pdv uses .bit files, not .rbt files, but some older config
     * might still reference the old extension
     */
    if (dd_p->rbtfile[0])
    {
        if ((sp = strrchr(dd_p->rbtfile, '.')) == NULL)
            sp = strchr(dd_p->rbtfile, '\0');
        if ((sp != NULL) && ((strcmp(sp, ".rbt") == 0) || (*sp == '\0')))
            sprintf(sp, ".bit");
    }

    return 0;
}

int
pdv_readcfg(char *cfgfile, Dependent * dd_p, Edtinfo *ei_p)
{
    return readcfg(cfgfile, dd_p, ei_p, 0);
}

int
pdv_readcfg_emb(char *cfgfile, Dependent * dd_p, Edtinfo *ei_p)
{
    return readcfg(cfgfile, dd_p, ei_p, 1);
}


translate_method_arg(char *method_arg, int *method_number)
{
    /* Translate the method_arg to a method number */
    if (COMPARE(method_arg, "AIA_MCL_100US"))
        *method_number = AIA_MCL_100US;
    else if (COMPARE(method_arg, "AIA_MCL"))
        *method_number = AIA_MCL;
    else if (COMPARE(method_arg, "AIA_TRIG"))
        *method_number = AIA_TRIG;
    else if (COMPARE(method_arg, "KODAK_AIA_MCL"))
        *method_number = KODAK_AIA_MCL;
    else if (COMPARE(method_arg, "AIA_MC4"))
        *method_number = AIA_MC4;
    else if (COMPARE(method_arg, "HAMAMATSU_4880_8X"))
        *method_number = HAM_4880_8X;
    else if (COMPARE(method_arg, "HAMAMATSU_4880_SER"))
        *method_number = HAM_4880_SER;
    else if (COMPARE(method_arg, "SU320_SERIAL"))
        *method_number = SU320_SERIAL;
    else if (COMPARE(method_arg, "BASLER202K_SERIAL"))
        *method_number = BASLER202K_SERIAL;
    else if (COMPARE(method_arg, "ADIMEC_SERIAL"))
        *method_number = ADIMEC_SERIAL;
    else if (COMPARE(method_arg, "TIMC1001_SERIAL"))
        *method_number = TIMC1001_SERIAL;
    else if (COMPARE(method_arg, "PTM6710_SERIAL"))
        *method_number = PTM6710_SERIAL;
    else if (COMPARE(method_arg, "PTM1020_SERIAL"))
        *method_number = PTM1020_SERIAL;
    else if (COMPARE(method_arg, "PULNIX_TM1000"))
        *method_number = PULNIX_TM1000;
    else if (COMPARE(method_arg, "PULNIX_TM9700"))
        *method_number = PULNIX_TM9700;
    else if (COMPARE(method_arg, "IRC_160"))
        *method_number = IRC_160;
    else if (COMPARE(method_arg, "KODAK_AIA_SER_CTRL"))
        *method_number = KODAK_AIA_SER_CTRL;
    else if (COMPARE(method_arg, "AIA_SER_CTRL"))
        *method_number = AIA_SER_CTRL;
    else if (COMPARE(method_arg, "KODAK_AIA_SER"))
        *method_number = KODAK_AIA_SER;
    else if (COMPARE(method_arg, "SMD_SERIAL"))
        *method_number = SMD_SERIAL;
    else if (COMPARE(method_arg, "AIA_SER_ES40"))
        *method_number = AIA_SERIAL_ES40;
    else if (COMPARE(method_arg, "AIA_SER"))
        *method_number = AIA_SERIAL;
    else if (COMPARE(method_arg, "KODAK_SER_14I"))
        *method_number = KODAK_SER_14I;
    else if (COMPARE(method_arg, "SER_14I"))
        *method_number = KODAK_SER_14I;
    else if (COMPARE(method_arg, "SPECINST_SERIAL"))
        *method_number = SPECINST_SERIAL;
    else if (COMPARE(method_arg, "KODAK_XHF_INTLC"))
        *method_number = PDV_BYTE_INTLV;
    else if (COMPARE(method_arg, "BYTE_INTLV"))
        *method_number = PDV_BYTE_INTLV;
    else if (COMPARE(method_arg, "FIELD_INTLC"))
        *method_number = PDV_FIELD_INTLC;
    else if (COMPARE(method_arg, "BYTE_TEST1"))
        *method_number = PDV_BYTE_TEST1;
    else if (COMPARE(method_arg, "BYTE_TEST2"))
        *method_number = PDV_BYTE_TEST2;
    else if (COMPARE(method_arg, "BYTE_TEST3"))
        *method_number = PDV_BYTE_TEST3;
    else if (COMPARE(method_arg, "WORD_INTLV_HILO"))
        *method_number = PDV_WORD_INTLV_HILO;
    else if (COMPARE(method_arg, "WORD_INTLV_ODD"))
        *method_number = PDV_WORD_INTLV_ODD;
    else if (COMPARE(method_arg, "ES10_WORD_INTLC"))
        *method_number = PDV_WORD_INTLV;
    else if (COMPARE(method_arg, "WORD_INTLV"))
        *method_number = PDV_WORD_INTLV;
    else if (COMPARE(method_arg, "DALSA_4CH_INTLV"))
        *method_number = PDV_DALSA_4CH_INTLV;
    else if (COMPARE(method_arg, "PIRANHA_4CH_INTLV"))
        *method_number = PDV_PIRANHA_4CH_INTLV;
    else if (COMPARE(method_arg, "PIRANHA_4CH_HWINTLV"))
        *method_number = PDV_PIRANHA_4CH_HWINTLV;
    else if (COMPARE(method_arg, "SPECINST_4PORT_INTLV"))
        *method_number = PDV_SPECINST_4PORT_INTLV;
    else if (COMPARE(method_arg, "ILLUNIS_INTLV"))
        *method_number = PDV_ILLUNIS_INTLV;
    else if (COMPARE(method_arg, "ES10_BGGR_INTLV"))
        *method_number = PDV_ES10_BGGR;
    else if (COMPARE(method_arg, "ES10_WORD_BGGR_INTLV"))
        *method_number = PDV_ES10_WORD_BGGR;
    else if (COMPARE(method_arg, "ES10_WORD_ODD_BGGR_INTLV"))
        *method_number = PDV_ES10_WORD_ODD_BGGR;
    else if (COMPARE(method_arg, "ILLUNIS_BGGR"))
        *method_number = PDV_ILLUNIS_BGGR;
    else if (COMPARE(method_arg, "QUADRANT_INTLV"))
        *method_number = PDV_QUADRANT_INTLV;
    else if (COMPARE(method_arg, "DALSA_2CH_INTLV"))
        *method_number = PDV_DALSA_2CH_INTLV;
    else if (COMPARE(method_arg, "INVERT_RIGHT_INTLV_24_12"))
        *method_number = PDV_INV_RT_INTLV_24_12;
    else if (COMPARE(method_arg, "INTLV_24_12"))
        *method_number = PDV_INTLV_24_12;
   else if (COMPARE(method_arg, "INTLV_1_8_MSB7"))
        *method_number = PDV_INTLV_1_8_MSB7;
   else if (COMPARE(method_arg, "INTLV_1_8_MSB0"))
        *method_number = PDV_INTLV_1_8_MSB0;
    else if (COMPARE(method_arg, "INVERT_RIGHT_INTLV"))
        *method_number = PDV_INVERT_RIGHT_INTLV;
    else if (COMPARE(method_arg, "INVERT_RIGHT_BGGR_INTLV"))
        *method_number = PDV_INVERT_RIGHT_BGGR_INTLV;
    else if (COMPARE(method_arg, "DALSA_2M30_INTLV"))
        *method_number = PDV_DALSA_2M30_INTLV;
    else if (COMPARE(method_arg, "EVEN_RIGHT_INTLV"))
        *method_number = PDV_EVEN_RIGHT_INTLV;
    else if (COMPARE(method_arg, "BGGR_DUAL"))
        *method_number = PDV_BGGR_DUAL;
    else if (COMPARE(method_arg, "BGGR_WORD"))
        *method_number = PDV_BGGR_WORD;
    else if (COMPARE(method_arg, "BGGR"))
        *method_number = PDV_BGGR;
    else if (COMPARE(method_arg, "BGR_2_RGB"))
        *method_number = PDV_INTLV_BGR_2_RGB;
    else if (COMPARE(method_arg, "KODAK_XHF_SKIP"))
        *method_number = PDV_BYTE_INTLV_SKIP;
    else if (COMPARE(method_arg, "BYTE_INTLV_SKIP"))
        *method_number = PDV_BYTE_INTLV_SKIP;
    else if (COMPARE(method_arg, "HW_ONLY"))
        *method_number = HW_ONLY;
    else if (COMPARE(method_arg, "FMRATE_ENABLE"))
        *method_number = PDV_FMRATE_ENABLE;
    else if (COMPARE(method_arg, "FVAL_ADJUST"))
        *method_number = PDV_FVAL_ADJUST;
    else if (COMPARE(method_arg, "BASLER_202K"))
        *method_number = BASLER_202K;
    else if (COMPARE(method_arg, "DUNCAN_2131"))
        *method_number = DUNCAN_2131;

    else if (COMPARE(method_arg, "FOI_REMOTE_AIA"))
        *method_number = FOI_REMOTE_AIA;

    else if (COMPARE(method_arg, "DALSA_CONTINUOUS"))
        *method_number = DALSA_CONTINUOUS;

    else if (COMPARE(method_arg, "EDT_ACT_NEVER"))
        *method_number = EDT_ACT_NEVER;
    else if (COMPARE(method_arg, "EDT_ACT_ONCE"))
        *method_number = EDT_ACT_ONCE;
    else if (COMPARE(method_arg, "EDT_ACT_ALWAYS"))
        *method_number = EDT_ACT_ALWAYS;
    else if (COMPARE(method_arg, "EDT_ACT_ONELEFT"))
        *method_number = EDT_ACT_ONELEFT;
    else if (COMPARE(method_arg, "EDT_ACT_CYCLE"))
        *method_number = EDT_ACT_CYCLE;
    else if (COMPARE(method_arg, "EDT_ACT_KBS"))
        *method_number = EDT_ACT_KBS;

    else if (COMPARE(method_arg, "BINARY"))
        *method_number = SERIAL_BINARY;
    else if (COMPARE(method_arg, "ASCII_HEX"))
        *method_number = SERIAL_ASCII_HEX;
    else if (COMPARE(method_arg, "ASCII"))
        *method_number = SERIAL_ASCII;
    else if (COMPARE(method_arg, "PULNIX_1010"))
        *method_number = SERIAL_PULNIX_1010;
    else if (COMPARE(method_arg, "DALSA_LS"))
        *method_number = PDV_DALSA_LS;
    else if (COMPARE(method_arg, "HEADER_BEFORE"))
        *method_number = PDV_HEADER_BEFORE;
    else if (COMPARE(method_arg, "HEADER_AFTER"))
        *method_number = PDV_HEADER_AFTER;
    else if (COMPARE(method_arg, "HEADER_WITHIN"))
        *method_number = PDV_HEADER_WITHIN;
    else if (COMPARE(method_arg, "DDCAM"))
        *method_number = PDV_DDCAM;
    else if (COMPARE(method_arg, "RS232"))
        *method_number = PDV_SERIAL_RS232;
    else if (COMPARE(method_arg, "BASLER_FRAMING"))
        *method_number = SERIAL_BASLER_FRAMING;
    else if (COMPARE(method_arg, "DUNCAN_FRAMING"))
        *method_number = SERIAL_DUNCAN_FRAMING;
    else
        return 0;

    return 1;
}

check_label(char *str, char *label)
{
    char    tmplabel[64];

    sprintf(tmplabel, "%s:", label);
    if (strncmp(str, tmplabel, strlen(tmplabel)) == 0)
        return 1;
    return 0;
}

set_method(Dependent * dd_p, Edtinfo * ei_p, char *method_type, int method_number)
{
    /* new for speed only */
    if (is_method(method_type, "camera_shutter_speed"))
        dd_p->camera_shutter_speed = method_number;

    /* ALERT: OBSOLETE */
    else if (is_method(method_type, "shutter_speed"))
        dd_p->camera_shutter_timing = method_number;

    else if (is_method(method_type, "camera_shutter_timing"))
        dd_p->camera_shutter_timing = method_number;

    else if (is_method(method_type, "lock_shutter"))
        dd_p->lock_shutter = method_number;

    else if (is_method(method_type, "camera_continuous"))
        dd_p->camera_continuous = method_number;

    else if (is_method(method_type, "camera_binning"))
        dd_p->camera_binning = method_number;

    else if (is_method(method_type, "camera_data_rate"))
        dd_p->camera_data_rate = method_number;

    else if (is_method(method_type, "pixelclock_speed")) /* alias */
        dd_p->camera_data_rate = method_number;

    else if (is_method(method_type, "camera_download"))
        dd_p->camera_download = method_number;

    else if (is_method(method_type, "get_gain"))
        dd_p->get_gain = method_number;

    else if (is_method(method_type, "get_offset"))
        dd_p->get_offset = method_number;

    else if (is_method(method_type, "set_gain"))
        dd_p->set_gain = method_number;

    else if (is_method(method_type, "set_offset"))
        dd_p->set_offset = method_number;

    else if (is_method(method_type, "first_open"))
        dd_p->first_open = method_number;

    else if (is_method(method_type, "last_close"))
        dd_p->last_close = method_number;

    else if (is_method(method_type, "interlace"))
    {
        if (method_number == PDV_PIRANHA_4CH_HWINTLV) /* special case hardware methods */
            dd_p->hwinterlace = method_number;
        else dd_p->swinterlace = method_number;
    }
    else if (is_method(method_type, "pingpong_varsize"))
        dd_p->pingpong_varsize = method_number;

    else if (is_method(method_type, "serial_format"))
        dd_p->serial_format = method_number;

    else if (is_method(method_type, "serial_mode"))
        dd_p->serial_mode = method_number;

    else if (is_method(method_type, "frame_timing"))
        dd_p->frame_timing = method_number;

    else if (is_method(method_type, "startdma"))
    {
        ei_p->startdma = method_number;
        dd_p->startdma = method_number;
    }
    else if (is_method(method_type, "enddma"))
    {
        ei_p->enddma = method_number;
        dd_p->enddma = method_number;
    }

    else if (is_method(method_type, "flushdma"))
    {
        ei_p->flushdma = method_number;
        dd_p->flushdma = method_number;
     }

    else if (is_method(method_type, "header_position"))
        dd_p->header_position = method_number;



    else
    {
        edt_msg(DEBUG0, "WARNING: unknown method direcive \"%s\" (ignored)\n", method_type);
        return 0;
    }
    return 1;
}

int
is_method(char *method_type, char *name)
{
    char    method_name[64];

    sprintf(method_name, "method_%s", name);
    if (COMPARE(method_name, method_type))
        return 1;
    return 0;
}

/*
 * clear dependent struct
 */
void
clear_dependent(Dependent * dd_p)
{
    memset(dd_p, 0, sizeof(Dependent));
}


/*
 * check_xx_method return 1 if found, 0 if not found, -1 (and print msg) if
 * error.
 */
int
check_int_method(char *line, char *label, int *arg, char *cfgfile)
{
    char    format[32];
    int     ret = 0;
    int     n;

    if (check_label(line, label))
    {
        sprintf(format, "%s: %%d", label);
        if ((n = sscanf(line, format, arg)) != 1)
        {
            edt_msg(DEBUG2,
                    "Error in parsing %s.\nExpected:\n\n\t%s: <parameter>\n",
                    cfgfile, label);
            edt_msg(DEBUG2, "\nGot:\n\n\t%s\n", line);
            ret = -1;
        }
        else
            ret = 1;
    }

    return ret;
}

int
check_ulong_method(char *line, char *label, u_long * arg, char *cfgfile)
{
    char    format[32];
    int     ret = 0;
    int     n;

    if (check_label(line, label))
    {
        sprintf(format, "%s: %%lu", label);
        if ((n = sscanf(line, format, arg)) != 1)
        {
            edt_msg(DEBUG2,
                    "Error in parsing %s.\nExpected:\n\n\t%s: <parameter>\n",
                    cfgfile, label);
            edt_msg(DEBUG2, "\nGot:\n\n\t%s\n", line);
            ret = -1;
        }
        else
            ret = 1;
    }

    return ret;
}

int
check_float_method(char *line, char *label, float * arg, char *cfgfile)
{
    char    format[32];
    int     ret = 0;
    int     n;

    if (check_label(line, label))
    {
        sprintf(format, "%s: %%f", label);
        if ((n = sscanf(line, format, arg)) != 1)
        {
            edt_msg(DEBUG2,
                    "Error in parsing %s.\nExpected:\n\n\t%s: <parameter>\n",
                    cfgfile, label);
            edt_msg(DEBUG2, "\nGot:\n\n\t%s\n", line);
            ret = -1;
        }
        else
            ret = 1;
    }

    return ret;
}

int
check_ushort_method(char *line, char *label, u_short * arg, char *cfgfile)
{
    char    format[32];
    int     ret = 0;
    int     n;
    int     v;

    if (check_label(line, label))
    {
        sprintf(format, "%s: %%u", label);
        if ((n = sscanf(line, format, &v)) != 1)
        {
            edt_msg(DEBUG2,
                    "Error in parsing %s.\nExpected:\n\n\t%s: <parameter>\n",
                    cfgfile, label);
            edt_msg(DEBUG2, "\nGot:\n\n\t%s\n", line);
            ret = -1;
        }
        else
        {
            *arg = v;
            ret = 1;
        }
    }

    return ret;
}

int
check_byte_method(char *line, char *label, u_short * arg, char *cfgfile)
{
    char    format[32];
    int     ret = 0;
    int     n;
    int     v;

    if (check_label(line, label))
    {
        sprintf(format, "%s: %%u", label);
        if ((n = sscanf(line, format, &v)) != 1)
        {
            edt_msg(DEBUG2,
                    "Error in parsing %s.\nExpected:\n\n\t%s: <parameter>\n",
                    cfgfile, label);
            edt_msg(DEBUG2, "\nGot:\n\n\t%s\n", line);
            ret = -1;
        }
        else
        {
            *arg = v;
            ret = 1;
        }
    }

    return ret;
}

/*
 * parse a hex string -- 2 digit bytes separated by spaces, put into
 * char buffer
 */
parse_hex_str(char *str, char *buf)
{
    int i = 0;
    u_int ibyte;
    char *sp = str;

    while ((*(sp+2) == ' ') || (*(sp+2) == '\0'))
    {
        sscanf(sp, "%02x ", &ibyte);
        buf[i++] = (char)ibyte;
        if (*(sp+2) == '\0')
            break;
        sp += 3;
    }
    buf[i] = '\0';
    return 1;
}

/*
 * check string method -- return 0 on failure, 1 on success
 */
check_str_method(char *line, char *label, char *arg, int max, char *cfgfile)
{
    int     ret = 1;
    char   *p = NULL;
    char   *sp = NULL;
    char   *ep;
    char    endchar;
    char    tmp_arg[MAXINIT];

    p = strchr(line, ':');
    if (!p)
        return (0);

    if ((sp = strchr(p, '"')) != NULL)
        endchar = '"';
    else if ((sp = strchr(p, '<')) != NULL)
        endchar = '>';
    else return 0;

    ep = strrchr(sp, endchar);

    if (!check_label(line, label))
        return 0;

    if ((int) strlen(sp) > max)
    {
        edt_msg(DEBUG0,
                "WARNING parsing %s: '%s' arg exceeds %d char max (truncating)\n",
                cfgfile, label, max - 3);
    }

    if ((p == NULL)
        || (sp == NULL)
        || (ep == NULL)
        || (ep == p))

    {
        edt_msg(DEBUG2,
                "Error in parsing %s.\nExpected:\n\n\t%s: \"command\" (up to %d chars);\n",
                cfgfile, label, max - 2);
        if (sp)
            edt_msg(DEBUG2, "\nGot:\n\n\t%s, %d chars\n", sp, strlen(sp));
        else
            edt_msg(DEBUG2, "\nGot: Nothing\n");
        return 0;
    }

    strcpy(tmp_arg, ++sp);
    if ((int) strlen(sp) > max)
        tmp_arg[max-1] = '\0';

    /*
     * find last double quote, get rid of it
     */
    if ((ep = strrchr(tmp_arg, endchar)) != NULL)
        *ep = '\0';

    if (endchar == '>')
        ret = parse_hex_str(tmp_arg, arg);
    else strncpy(arg, tmp_arg, max);

    return ret;
}


check_path_method(char *line, char *label, char *arg, char *cfgfile)
{
    int     ret = 0;
    int     n;
    char    format[32];

    if (check_label(line, label))
    {
        sprintf(format, "%s: %%s", label);
        if ((n = sscanf(line, format, arg)) != 1)
        {
            edt_msg(DEBUG2,
                    "Error in parsing %s.\nExpected:\n\n\t%s: <parameter>\n",
                    cfgfile, label);
            edt_msg(DEBUG2, "\nGot:\n\n\t%s\n", line);
            ret = -1;
        }
        else
            ret = 1;
    }

    return ret;
}


/* ALERT: check if this is same as check_foi_init -- hopefully so */
check_serial_init_method(char *line, char *label, char *cmd, char *cfgfile)
{
    int     ret = 0;
    char   *p = NULL;
    char   *sp = NULL;
    char   *ep;
    char    tmp_arg[128];

    p = strchr(line, ':');
    if (!p)
        return 0;
    sp = strchr(p, '"');
    if (!sp)
        return 0;
    if (!check_label(line, label))
        return 0;

    if ((p == NULL)
        || (*(p + 1) == '\0')
        || (sp == NULL)
        || (strlen(sp) > (MAXINIT - 2))
        || ((ep = strrchr(sp, '"')) == NULL))

    {
        edt_msg(DEBUG2,
                "Error in parsing %s.\nExpected:\n\n\t%s: \"command\" (up to %d chars);\n",
                cfgfile, label, MAXINIT - 2);
        if (sp)
            edt_msg(DEBUG2, "\nGot:\n\n\t%s, %d chars\n", sp, strlen(sp));
        else edt_msg(DEBUG2, "\nGot: Nothing\n");
        return 0;
    }

    strcpy(tmp_arg, ++sp);

    /* find last double quote, get rid of it  */
    /* also tack on trailing ':' if not there  */
    ep = strrchr(tmp_arg, '"');
    if ((*(ep - 1) != ':') || (*(ep - 2) == '\\'))
        *ep++ = ':';
    *ep = '\0';

    strncpy(cmd, tmp_arg, MAXINIT);
    return 1;
}

/*
 * return 1 on success, 0 on failure.
 */
check_hex_method(char *line, char *label, u_int * method, char *cfgfile)
{
    char    format[32];
    char    hexstr[32];

    if (!check_label(line, label))
        return 0;

    sprintf(format, "%s: %%s", label);
    if (sscanf(line, format, hexstr) != 1)
    {
        edt_msg(DEBUG2, "Error in parsing %s.  Expected:\n\n\t%s: <hex_parameter>\n", cfgfile, label);
        edt_msg(DEBUG2, "\nGot:\n\n\t%s\n", line);
        return 0;
    }
    *method = strtol(hexstr, NULL, 16);
    return 1;
}

/*
 * check int, long, hex, string methods
 * 
 * return 1 if found, 0 if not found, -1 if error
 */
check_other_param(char *s, Dependent * dd_p, char *cfgfile)
{
    int     ret;
    int     tr;
    char    tmpstr[256];

    /*
     * integer methods
     */
    if (ret = check_int_method(s, "width", &dd_p->width, cfgfile))
        return ret;
    if (ret = check_int_method(s, "height", &dd_p->height, cfgfile))
        return ret;
    if (ret = check_int_method(s, "cam_width", &dd_p->cam_width, cfgfile))
        return ret;
    if (ret = check_int_method(s, "cam_height", &dd_p->cam_height, cfgfile))
        return ret;
    if (ret = check_int_method(s, "depth", &dd_p->depth, cfgfile))
        return ret;
    if (ret = check_int_method(s, "extdepth", &dd_p->extdepth, cfgfile))
        return ret;
    if (ret = check_int_method(s, "slop", &dd_p->slop, cfgfile))
        return ret;
    if (ret = check_int_method(s, "hwpad", &dd_p->hwpad, cfgfile))
        return ret;
    /* rgb 30 bit overloaded on hwpad register bits if PIR */
    if (ret = check_int_method(s, "rgb30", &dd_p->hwpad, cfgfile))
        return ret;
    if (ret = check_int_method(s, "irris_strip", &dd_p->hwpad, cfgfile))
        return ret;
    if (ret = check_int_method(s, "byteswap", &dd_p->byteswap, cfgfile))
        return ret;
    if (ret = check_int_method(s, "shortswap", &dd_p->shortswap, cfgfile))
        return ret;
    if (ret = check_int_method(s, "skip", &dd_p->skip, cfgfile))
        return ret;
    if (ret = check_int_method(s, "gendata", &dd_p->gendata, cfgfile))
        return ret;
    if (ret = check_int_method(s, "skipfrm", &dd_p->gendata, cfgfile))
        return ret;
    if (ret = check_int_method(s, "fixedlen", &dd_p->fixedlen, cfgfile))
        return ret;
    if (ret = check_int_method(s, "interlace", &dd_p->interlace, cfgfile))
        return ret;
    if (ret = check_int_method(s, "pdv_type", &dd_p->pdv_type, cfgfile))
        return ret;
    if (ret = check_int_method(s, "simulator_speed", &dd_p->sim_speed, cfgfile))
        return ret;
    if (ret = check_int_method(s, "cameratest", &dd_p->cameratest, cfgfile))
        return ret;
    if (ret = check_int_method(s, "genericsim", &dd_p->genericsim, cfgfile))
        return ret;
    if (ret = check_int_method(s, "disable_mdout", &dd_p->disable_mdout, cfgfile))
        return ret;
    if (ret = check_int_method(s, "sim_width", &dd_p->sim_width, cfgfile))
        return ret;
    if (ret = check_int_method(s, "sim_height", &dd_p->sim_height, cfgfile))
        return ret;
    if (ret = check_int_method(s, "sim_ctl", (int *) (&dd_p->sim_ctl), cfgfile))
        return ret;
    if (ret = check_int_method(s, "line_delay", &dd_p->line_delay, cfgfile))
        return ret;
    if (ret = check_int_method(s, "frame_delay", &dd_p->frame_delay, cfgfile))
        return ret;
    if (ret = check_int_method(s, "frame_height", &dd_p->frame_height, cfgfile))
        return ret;
    if (ret = check_int_method(s, "fv_once", &dd_p->fv_once, cfgfile))
        return ret;
    if (ret = check_int_method(s, "fval_once", &dd_p->fv_once, cfgfile)) /* alias */
        return ret;
    if (ret = check_int_method(s, "fval_done", &dd_p->fval_done, cfgfile))
        return ret;
    if (ret = check_int_method(s, "fv_done", &dd_p->fval_done, cfgfile)) /* alias */
        return ret;
    if (ret = check_int_method(s, "pingpong_varsize", &dd_p->pingpong_varsize, cfgfile))
        return ret;
    if (ret = check_int_method(s, "continuous", &dd_p->continuous, cfgfile))
        return ret;
    if (ret = check_int_method(s, "clr_continuous_end", &dd_p->clr_cont_end, cfgfile))
        return ret;
    if (ret = check_int_method(s, "clr_continuous_start", &dd_p->clr_cont_start,
                               cfgfile))
        return ret;
    if (ret = check_int_method(s, "cnt_continuous", (int *) (&dd_p->cnt_continuous), cfgfile))
        return ret;

    if (ret = check_int_method(s, "shutter_speed_frontp", &dd_p->shutter_speed_frontp, cfgfile))
        return ret;
    if (ret = check_int_method(s, "shutter_speed", &dd_p->shutter_speed, cfgfile))
        return ret;
    if (ret = check_int_method(s, "shutter_speed_min", &dd_p->shutter_speed_min, cfgfile))
        return ret;
    if (ret = check_int_method(s, "shutter_speed_max", &dd_p->shutter_speed_max, cfgfile))
        return ret;

    if (ret = check_int_method(s, "aperture_min", &dd_p->aperture_min, cfgfile))
        return ret;
    if (ret = check_int_method(s, "aperture_max", &dd_p->aperture_max, cfgfile))
        return ret;
    if (ret = check_int_method(s, "default_shutter_speed", &dd_p->default_shutter_speed, cfgfile))
        return ret;
    if (ret = check_int_method(s, "default_exposure", &dd_p->default_shutter_speed, cfgfile))
        return ret;
    if (ret = check_int_method(s, "default_aperture", &dd_p->default_aperture, cfgfile))
        return ret;

    if (ret = check_int_method(s, "gain_min", &dd_p->gain_min, cfgfile))
        return ret;
    if (ret = check_int_method(s, "gain_max", &dd_p->gain_max, cfgfile))
        return ret;
    if (ret = check_int_method(s, "default_gain", &dd_p->default_gain, cfgfile))
        return ret;
    if (ret = check_int_method(s, "gain_frontp", &dd_p->gain_frontp, cfgfile))
        return ret;

    if (ret = check_int_method(s, "offset_min", &dd_p->offset_min, cfgfile))
        return ret;
    if (ret = check_int_method(s, "offset_max", &dd_p->offset_max, cfgfile))
        return ret;
    if (ret = check_int_method(s, "offset_frontp", &dd_p->offset_frontp, cfgfile))
        return ret;
    if (ret = check_int_method(s, "default_offset", &dd_p->default_offset, cfgfile))
        return ret;
    if (ret = check_int_method(s, "serial_baud", &dd_p->serial_baud, cfgfile))
        return ret;
    if (ret = check_int_method(s, "DUAL_CHANNEL", &dd_p->dual_channel, cfgfile))
        return ret;
    if (ret = check_int_method(s, "DOUBLE_RATE", &dd_p->double_rate, cfgfile))
        return ret;
    if (ret =