/***********************************************************************
NAME
param
PURPOSE
This function is very useful and should be used by every program,
it does the dirty interface with the user, checking everything he
inputs, opening files, setting switches and so on.
SYNOPSIS
param(parmc,parmv,argc,argv)
struct parameter parmv[];
char ** argv;
int parmc,argc;
DESCRIPTION
The user places in parmv the name and type of all the switches
that the program is to recognize. For each of them he gives detailed
information about the values expected and where to place the value
read, which parameter is mandatory and which is optional. To know how
to set this information you should look to the structures defined in
param.h and also to some program already using this function.
COORDINATES
McGill University Electrical Engineering VLSI Lab MONTREAL CANADA
2 july 1984
AUTHOR
Michel DAGENAIS
***************************************************************************/
#include <stdio.h>
#include <malloc.h>
#include "param.h"
#define ASK 1
#define NOASK 0
#define TRUE 1
#define FALSE 0
double atof(); /* convert float string in float binary */
char *copy_and_alloc_string(); /* copy a string into new storage */
char *sfind_next_car(); /* finds a specified character in a string */
static char *types[] = /* description of the types */
{ "file name",
"name for two files",
"integer value",
"float value",
"character string",
"single character",
"logical value" };
static char *options[] = /* description of the options */
{ "is mandatory",
"was entered",
"is taken by default when no switch is present"};
static char *prerequisite[] = /* description of the different links */
{ "when present requires",
"when present excludes",
"when absent requires",
"when absent excludes"};
param(parmc,parmv,argc,argv)
struct parameter parmv[];
char **argv;
int parmc,argc;
/*
each possible parameter should be in the list sent to the function;
anything else will not be accepted.
Each switch has a name which can be more then one character long;
When we try to match the names, the list is scanned top to bottom
so the longest names should be placed in the list before the shorter
ones begining by the same letters. For example "slow" should be placed
in the list before "s" otherwise it will never be recognized. Beside
the name we have the type of parameter which tells what action is to be
taken. Also a flag tells if the parameter is needed and if it has some
prerequisites or allergy. It contains also the
information if the parameter was received or not. We check that all
needed parameters are received, that all parameters received that
having pre-requisite parameters get them satisfied. Also we check
that no two parameters which are mutually exclusive are received.
*/
{ int
flag, /* temp storage for the flag of the parameter */
reqa, /* logic value set if a is required */
reqb, /* logic value set if b is required */
reja, /* logic value set if a is rejected */
rejb, /* logic value set if b is rejected */
i, /* loop counter for the argv table */
j, /* loop for the parmv table */
k, /* loop for the options table */
indirect, /* index of a parameter referred by another one */
satisfied, /* logic value tells if all pre-requisite were satis*/
length; /* length of a character string */
char *cursor; /* pointer where we process in the command line */
/* This first loop is to process all the parameters entered directly on the
command line by the user. We scan the whole argv table */
for(i = 1 ; i < argc ; i++)
{ if(*(argv[i]) != '-')
{ for(j = 0 ; j < parmc ; j++)
{ if((parmv[j].flag & P_DEFAULT) && (parmv[j].flag & P_PRESENT) == 0)
break;
}
/* There is no - before the switch and no parameter 'by default' was expected */
if(j >= parmc)
{ fprintf(stderr,
"%s: switches should be preeceded by '-', unexpected %s\n",
argv[0],argv[i]);
exit(1);
}
/* It is a parameter taken 'by default' with no switch preeceding it */
parmv[j].flag |= P_PRESENT;
i--;
set_value(parmv + j,&i,argc,argv,NOASK);
}
/* We scan the list of options and try to match them with the options names
recognized that are in the parmv table */
else
{ cursor = argv[i] + 1;
for(; *cursor != NULL ;)
{ for(j = 0 ; j < parmc ; j++)
{ if((length = match_string(parmv[j].name,cursor)) > 0)
/* a switch was recognized it will be processed */
{ cursor += length;
if(parmv[j].flag & P_PRESENT)
{ fprintf(stderr,"%s: attempt to set twice switch -%s\n",
argv[0],parmv[j].name);
exit(1);
}
parmv[j].flag = parmv[j].flag | P_PRESENT;
/* the parameter value was on the command line so we call set_value with
the status noask. */
set_value(parmv + j,&i,argc,argv,NOASK);
break;
}
}
/* the switch was not found in the parmv table, we will print the
complete list of recognized switches. */
if(j == parmc)
{ fprintf(stderr,"%s: unknown switch -%s\n",argv[0],cursor);
fprintf(stderr,"\nThe switches recognized are :\n");
for(j = 0 ; j < parmc ; j++)
{ fprintf(stderr," -%s %s, %s\n",
parmv[j].name,parmv[j].descr,types[parmv[j].type - 1]);
k = 0;
for(i = 1 ; i <= P_DEFAULT ; i = i << 1)
{ if(parmv[j].flag & i)
fprintf(stderr," This parameter %s\n",options[k]);
k++;
}
k = 0;
for(; i <= P_ABSENT_A_EXCL ; i = i << 1)
{ if(parmv[j].flag & i)
fprintf(stderr," This parameter %s -%s\n",
prerequisite[k],parmv[parmv[j].a].name);
k++;
}
k = 0;
for(; i <= P_ABSENT_B_EXCL ; i = i << 1)
{ if(parmv[j].flag & i)
fprintf(stderr," This parameter %s -%s\n",
prerequisite[k],parmv[parmv[j].b].name);
k++;
}
}
exit(1);
}
}
}
}
/* All the options entered on the command line were processed. Now we will
scan the parmv table to see which parameters are mandatory and were not
entered. */
for(j = 0 ; j < parmc ; j++)
{ if((parmv[j].flag & P_NEEDED) && (parmv[j].flag & P_PRESENT) == 0)
{ set_value(parmv + j,&i,argc,argv,ASK);
parmv[j].flag = parmv[j].flag | P_PRESENT;
}
}
/* All the mandatory parameters were read from the keyboard, we will now
see if all the relations are satisfied. For each parameter we look if
it has some requirements on the state of other parameters and we try to
satisfy them. If it ask to a non-present parameter to be present, we simply
ask the user for a value, if a present parameter should not be present, we
are in big trouble and the program blows.
The table is scanned until all relations fulfilled.
The table may be scanned more than once because of prerequisite chains */
satisfied = 0;
for(; satisfied == 0 ;)
{ satisfied = 1;
for(j = 0; j < parmc ; j++)
{ flag = parmv[j].flag;
reqa = 0;
reqb = 0;
reja = 0;
rejb = 0;
if(flag & P_PRESENT)
{ if(flag & P_PRESENT_A_REQ)reqa = 1;
if(flag & P_PRESENT_A_EXCL)reja = 1;
if(flag & P_PRESENT_B_REQ)reqb = 1;
if(flag & P_PRESENT_B_EXCL)rejb = 1;
}
else
{ if(flag & P_ABSENT_A_REQ)reqa = 1;
if(flag & P_ABSENT_A_EXCL)reja = 1;
if(flag & P_ABSENT_B_REQ)reqb = 1;
if(flag & P_ABSENT_B_EXCL)rejb = 1;
}
indirect = parmv[j].a;
if(reqa && ((parmv[indirect].flag & P_PRESENT) == 0))
{ satisfied = 0;
parmv[indirect].flag |= P_PRESENT;
set_value(parmv + indirect,&i,argc,argv,ASK);
}
if(reja && (parmv[indirect].flag & P_PRESENT))
{ fprintf(stderr,"%s: -%s is set but -%s excludes it\n",
argv[0],parmv[indirect].name,parmv[j].name);
exit(1);
}
indirect = parmv[j].b;
if(reqb && ((parmv[indirect].flag & P_PRESENT) == 0))
{ satisfied = 0;
parmv[indirect].flag |= P_PRESENT;
set_value(parmv + indirect,&i,argc,argv,ASK);
}
if(rejb && (parmv[indirect].flag & P_PRESENT))
{ fprintf(stderr,"%s: -%s is set but -%s excludes it\n",
argv[0],parmv[indirect].name,parmv[j].name);
exit(1);
}
}
}
}
/***********************************************************************
NAME
set_value
PURPOSE
This function reads and checks values either from the argv table
or from the keybord.
SYNOPSIS
set_value(parm,ipnt,argc,argv,source)
struct parameter *parm;
int *ipnt,argc,source;
char **argv;
DESCRIPTION
The value received is checked for bounds imposed by the calling
program in the table and the proper action is taken depending
on the parameter type. If anything goes wrong, a message is issued
and a new value is requested to the user. When the source is ASK
the value is requested from the keyboard. When the source is NOASK
the value is taken from the array argv and the pointer ipnt is
incremented.
COORDINATES
McGill University Electrical Engineering VLSI Lab MONTREAL CANADA
2 july 1984
AUTHOR
Michel DAGENAIS
***************************************************************************/
set_value(parm,ipnt,argc,argv,source)
struct parameter *parm;
int *ipnt;
int argc;
char **argv;
int source;
{ int
length; /* length of a character string excluding the null */
struct p_file *p1; /* pointer for file parameters */
struct p_2file *p2; /* pointer for parameter of type file2 */
struct p_integer *p3; /* pointer for integer parameter */
struct p_float *p4; /* pointer for floating point parameter */
struct p_string *p5; /* pointer for string parameter */
struct p_character *p6; /* pointer for character argument */
struct p_logical *p7; /* pointer for logical parameter */
char
*begin_ext, /* address in buffer of the beginning of the ext */
buffer[132]; /* temp storage for strings to read, 132 car max */
/* if it is read from the argv table, we increment the pointer in the table
and check that at least one entry remains, otherwise a message is issued */
if(parm->type < P_LOGICAL && source == NOASK)
{ (*ipnt)++;
if(*ipnt >= argc)
{ fprintf(stderr,
"%s: switch -%s must be followed by an argument\n",argv[0],parm->name);
exit(1);
}
}
/* we branch to the program section corresponding to the parameter type */
switch (parm->type)
/* it is a file to open */
{ case P_FILE :
p1 = (struct p_file *)parm->def_pointer;
for(; ;)
{ if(source == ASK)
{ fprintf(stdout,"%s: enter %s file name : ",argv[0],parm->descr);
if(fscanf(stdin,"%s",buffer) == 0)
{ fprintf(stderr,"\n%s: illegal character at input\n",argv[0]);
exit(1);
}
putc('\n',stdout);
}
else copy_string(argv[(*ipnt)],buffer);
source = ASK;
if(sfind_next_car('.',buffer) == 0)
{ if(p1->access[0] != 'r' ||
(*(p1->fp) = fopen(buffer,p1->access)) == NULL)
{ append_string(".",buffer);
append_string(p1->default_ext,buffer);
if((*(p1->fp) = fopen(buffer,p1->access)) == NULL)
{ fprintf(stderr,"%s: cannot open %s file %s\n",
argv[0],parm->descr,buffer);
}
else break;
}
else break;
}
else if((*(p1->fp) = fopen(buffer,p1->access)) == NULL)
{ fprintf(stderr,"%s: cannot open %s file %s\n",
argv[0],parm->descr,buffer);
}
else break;
}
break;
/* we want to open two files with same name but different extensions */
case P_2FILE :
p2 = (struct p_2file *)parm->def_pointer;
for(; ;)
{ if(source == ASK)
{ fprintf(stdout,"%s: enter %s file name : ",argv[0],parm->descr);
if(fscanf(stdin,"%s",buffer) == 0)
{ fprintf(stderr,"\n%s: illegal character at input\n",argv[0]);
exit(1);
}
putc('\n',stdout);
}
else copy_string(argv[(*ipnt)],buffer);
source = ASK;
append_string(".",buffer);
append_string(p2->default_ext1,buffer);
if((*(p2->fp1) = fopen(buffer,p2->access1)) == NULL)
{ fprintf(stderr,
"%s: cannot open %s file %s\n",argv[0],parm->descr,buffer);
}
else
{ begin_ext = sfind_next_car('.',buffer);
*(begin_ext + 1) = NULL;
append_string(p2->default_ext2,buffer);
if((*(p2->fp2) = fopen(buffer,p2->access2)) == NULL)
{ fprintf(stderr,
"%s: cannot open %s file %s\n",argv[0],parm->descr,buffer);
}
else break;
}
}
break;
/* we want to input an integer value */
case P_INTEGER :
p3 = (struct p_integer *)parm->def_pointer;
for(; ;)
{ if(source == ASK)
{ fprintf(stdout,
"%s: enter %s integer value : ",argv[0],parm->descr);
if(fscanf(stdin,"%d",p3->intp) == 0)
{ putc('\n',stdout);
if(fscanf(stdin,"%s",buffer) == 0)
{ fprintf(stderr,"\n%s: illegal character at input\n",argv[0]);
exit(1);
}
continue;
}
putc('\n',stdout);
}
else *(p3->intp) = atoi(argv[(*ipnt)]);
source = ASK;
if(*(p3->intp) < p3->min || *(p3->intp) > p3->max)
{ fprintf(stderr,
"%s: %d value entered for %s not between %d and %d\n",
argv[0],*(p3->intp),parm->descr,p3->min,p3->max);
}
else break;
}
break;
case P_FLOAT :
p4 = (struct p_float *)parm->def_pointer;
for(; ;)
{ if(source == ASK)
{ fprintf(stdout,
"%s: enter %s float value : ",argv[0],parm->descr);
if(fscanf(stdin,"%f",p4->floatp) == 0)
{ putc('\n',stdout);
if(fscanf(stdin,"%s",buffer) == 0)
{ fprintf(stderr,"\n%s: illegal character at input\n",argv[0]);
exit(1);
}
continue;
}
putc('\n',stdout);
}
else *(p4->floatp) = atof(argv[(*ipnt)]);
source = ASK;
if(*(p4->floatp) < p4->min || *(p4->floatp) > p4->max)
{ fprintf(stderr,
"%s: %e value entered for %s not between %e and %e\n",
argv[0],*(p4->floatp),parm->descr,p4->min,p4->max);
}
else break;
}
break;
/* we want to input a string */
case P_STRING :
p5 = (struct p_string *)parm->def_pointer;
for(; ;)
{ if(source == ASK)
{ fprintf(stdout,
"%s: enter %s character string : ",argv[0],parm->descr);
if(fscanf(stdin,"%s",buffer) == 0)
{ fprintf(stderr,"\n%s: illegal character at input\n",argv[0]);
exit(1);
}
putc('\n',stdout);
}
else copy_string(argv[(*ipnt)],buffer);
source = ASK;
screen_backslash(buffer);
length = length_string(buffer);
if(length < p5->min || length > p5->max)
{ fprintf(stderr,
"%s: %d chars entered for %s not between %d and %d\n",
argv[0],length,parm->descr,p5->min,p5->max);
}
else
{ *(p5->charp) = copy_and_alloc_string(buffer);
break;
}
}
break;
/* we want to input a character */
case P_CHARACTER :
p6 = (struct p_character *)parm->def_pointer;
if(source == ASK)
{ fprintf(stdout,
"%s: enter %s single character : ",argv[0],parm->descr);
if(fscanf(stdin,"%s",buffer) == 0)
{ fprintf(stderr,"\n%s: illegal character at input\n",argv[0]);
exit(1);
}
putc('\n',stdout);
}
else copy_string(argv[(*ipnt)],buffer);
screen_backslash(buffer);
*(p6->car) = buffer[0];
break;
/* a logical value is to be set */
case P_LOGICAL :
p7 = (struct p_logical *)parm->def_pointer;
if(*(p7->logp)) *(p7->logp) = FALSE;
else *(p7->logp) = TRUE;
if(source == ASK)
{ fprintf(stdout,
"%s: %s is required and will be set\n",argv[0],parm->descr);
}
break;
}
}
/*************************************************************************
NAME
copy_string, copy_and_alloc_string, length_string
PURPOSE
Ease the string manipulation by the calling functions.
SYNOPSIS
copy_string(string_in,string_out)
char *string_in,*string_out;
char *copy_and_alloc_string(string)
char *string;
int length_string(string)
char *string;
DESCRIPTION
these subroutines copy all the characters from one string to the
other, the string end is marked by a NULL character. The copy and
allocate routine returns the pointer to the new string allocated.
The length string function returns the number of characters in the
string.
COORDINATES
McGill University Electrical Engineering MONTREAL CANADA
2 july 1984
AUTHOR
Michel DAGENAIS
*************************************************************************/
copy_string(string_in,string_out)
char *string_in,*string_out;
{
for(; (*(string_out++) = *(string_in++)) != NULL ;);
}
/***********************************************************************/
char *copy_and_alloc_string(string)
char *string;
{
char *pointer;
pointer = calloc((unsigned)(length_string(string) + 1),sizeof(char));
copy_string(string,pointer);
return(pointer);
}
/************************************************************************/
int length_string(string)
char *string;
{
int length;
for(length = 0 ; *(string++) != NULL ; length++);
return(length);
}
/*************************************************************************
NAME
match_string, sfind_next_car, append_string
PURPOSE
Ease the string manipulation by the calling functions.
SYNOPSIS
int match_string(string_searched,line)
char *string_searched,*line;
char *sfind_next_car(car,string)
char car,*string;
append_string(string,line)
char *string,*line;
DESCRIPTION
Match looks if the string is entirely present in the line and
if so it returns its length otherwise 0 is returned. Find car
returns the address of the byte containing the car to find or
0 if it is not found. Append simply put the string at the end
of the line.
COORDINATES
McGill University Electrical Engineering MONTREAL CANADA
2 july 1984
AUTHOR
Michel DAGENAIS
*************************************************************************/
int match_string(string_searched,line)
char *string_searched,*line;
{
int length;
for(length = 0 ; *string_searched != NULL && *line != NULL ; length++)
{ if(*(string_searched++) != *(line++)) return(0);
}
if(*string_searched == NULL) return(length);
return(0);
}
/*************************************************************************/
char *sfind_next_car(car,string)
char car,*string;
{
for(; *string != NULL && *string == car ; string++);
for(; *string != NULL && *string != car ; string++);
if(*string == car) return(string);
return(0);
}
/***********************************************************************/
append_string(string,line)
char *string,*line;
{
for(; *line != NULL ; line++);
for(; (*(line++) = *(string++)) != NULL ;);
}
/**********************************************************************
NAME
screen_backslash
PURPOSE
To help the user to enter some control characters in his strings
the standard backslash notation will be used. This function replaces
the occurence of \x by y where x is a character in the table and
y is the corresponding control character.
SYNOPSIS
screen_backslash(buffer)
char *buffer;
DESCRIPTION
The buffer is screened until the end ( null character ) and each time
a \ character is found we replace the following character by a the
corresponding character in a table.
COORDINATES
McGill University Electrical Engineering VLSI lab MONTREAL CANADA
16 august 1984
AUTHOR
Michel DAGENAIS
***************************************************************************/
screen_backslash(buffer)
char *buffer;
{
char *cursor; /* pointer in the buffer */
static char table[] = /* table of characters to replace */
{ 'n','r','\\','t'};
static char replace[] = /* table of replacing characters */
{ '\n','\r','\\','\t' };
static int table_size = sizeof(table) / sizeof(char); /* size of the table */
int i; /* index in the tables */
cursor = buffer;
for(; ;)
{ if(*buffer == '\\')
{ buffer++;
for(i = 0 ; i < table_size ; i++) if(*buffer == table[i]) break;
if(i == table_size) *cursor = *buffer;
else *cursor = replace[i];
}
else *cursor = *buffer;
if(*cursor == NULL) return;
cursor++;
buffer++;
}
}
������������������������������������������������������������������������������������������������������������