view tools/options.c @ 0:5242703e91d3 tip

Initial checkin for AIM92 aimR8.2 (last updated May 1997).

#include <stdio.h>
#include <math.h>
#include "options.h"
#include "strmatch.h"
#include "units.h"


/*
Defaults for i/o parameters.
These are declared externally in options.h so they may be overridden by
option assignment.
*/

int LINE_LENGTH = 256 ; /* max length of line for ascii data.               */
int FIELDWIDTH  = 0   ; /* field width for printf.                          */
			/* (FIELDWIDTH=0 sets no extra fieldwidth.          */
			/* Positive integer fieldwidth sets right-justified */
			/* columns, negative integer fieldwidth sets left-  */
			/* justified columns).                              */
int PRECISION   = 3   ; /* precision (num decimal places) for printf,       */
			/* (PRECISION=0 sets integer output).               */



/*
Return a file pointer to a file `name' opened to read.
If `name' is `-' then return stdin.
If file `name' is not found return null pointer.
*/

FILE *fropen( name )
char *name ;
{
    FILE  *fopen() ;

    if ( isstr( name, "-" ) ) return stdin ;
    else  return ( fopen( name, "r" ) ) ;
}


/*
Generic options handler and file opener.
Return a file pointer to an opened file, either stdin (if no args remained on
command line after scanning) or the first name left on the command line.
*/

FILE *openopts( option, argc, argv )
Options *option ;
int      argc   ;
char    *argv[] ;
{
    FILE *fp ;
    int   i ;

    if ( ( i = getopts( option, argc, argv ) ) == 0 )
	return stdin ;
    if ( ( fp = fropen( argv[argc-i] ) ) == (FILE *)0 ) {
	fprintf(stderr, "%s: can't open %s\n", argv[0], argv[argc-i] ) ;
	exit( 1 ) ;
    }
    return ( fp ) ;
}


/*
Options handler and two file opener.
If one file is on command line after scanning options, then the first file
fp1 is assumed to be the stdin. Otherwise two files are expected.
Return 0 if incorrect number of files, otherwise return 1.
(Note: fp1 and fp2 are pts to file ptrs, so pass them as &fp1, &fp2 if
originally declared as file ptrs).
*/

open2opts( option, argc, argv, fp1, fp2 )
Options *option ;
int      argc   ;
char    *argv[] ;
FILE    **fp1   ;
FILE    **fp2   ;
{
    switch ( getopts( option, argc, argv ) ) {

	case 1 :
		*fp1 = stdin;
		if ( ( *fp2 = fropen( argv[argc-1] ) ) == (FILE *)0 ) {
		    fprintf( stderr,"%s: can't open %s\n", argv[0], argv[argc-1] ) ;
		    exit( 1 ) ;
		}
		break ;
	case 2 :
		if ( ( *fp1 = fropen( argv[argc-2] ) ) == (FILE *)0 ) {
		    fprintf( stderr,"%s: can't open %s\n", argv[0], argv[argc-2] ) ;
		    exit( 1 ) ;
		}
		if ( ( *fp2 = fropen( argv[argc-1] ) ) == (FILE *)0 ) {
		    fprintf( stderr,"%s: can't open %s\n", argv[0], argv[argc-1] ) ;
		    exit( 1 ) ;
		}
		break ;
	default :
		return ( 0 ) ;
    }
    return ( 1 ) ;
}



/*
  Build an options table.
  First assign all the option values with the defaults given in the table.
  Then scan the command line for arguments to overwrite corresponding vals.

  Argument syntax is one of the following three types (or combinations).
  Each syntax must contain either a leading '-' char or an embedded '=' char,
  to distinguish arguments from possible filenames.


  1)    -<name>                 FLAG_SYNTAX
  2)    -<name>[=]<value>       ARG_SYNTAX
  3)   [-]<name>=<value>        EQ_SYNTAX

  FLAG_SYNTAX takes no value. (The returned value is the empty string).

  ARG_SYNTAX takes a value after an optional '=' char.
  If the '=' char is not found, then the <value> is whatever follows the
  longest matching <name> string. Otherwise the <value> is whatever follows
  the '=' char. (The value is not allowed to be empty).

  EQ_SYNTAX takes a value which is whatever follows the '=' char.
  (The value is not allowed to be empty).

  It is assumed that all args remaining on the command line after an arg with
  invalid syntax must be filenames. These remain unscanned.
  Return argc, the number of args remaining unscanned on the command line,
  (argc=0 if no args left).
  To scan the remainder of the command line, and (eg) print the filenames:-

    if ( ( i = getopts( option, argc, argv, ) ) == 0 )
	printf("stdin\n" );
    else
	for ( ; i>0 ; i--)
	    printf("[%s]\n", argv[argc-i] );

*/


int getopts( option, argc, argv )
Options *option ;
int      argc   ;
char    *argv[] ;
{
    char *prog, *val ;
    int   i, n, index[64], span[64] ;

    /* Assign option vals using the defaults */

    for (i=0 ; option[i].name != (char *)0 ; i++)
	*(option[i].val) = option[i].dflt ;

    /* Overwrite option vals with corresponding vals found on command line */

    prog = *argv ;
    while ( --argc > 0 && ++argv ) {

	/* find list of options all with longest matching name span      */
	/* returning if none, with argc args remaining                   */
	if ( ( n = whichopt( option, *argv, index, span ) ) == 0 )
	    return ( argc ) ;

	/* check arg syntax, returning if invalid with argc args remaining */
	for ( i=0 ; i<n && ( val = checksyntax( *argv, span[i], option[index[i]].type ) ) == (char *)0  ; i++ )
	    ;
	if ( val == (char *)0 )
	    return ( argc ) ;

	/* if whichopt was ambiguous, yet an arg is valid, then its an     */
	/* ambiguous option, (and not a possible filename).                */
	if ( n > 1 ) {
	    fprintf(stderr,"%s: ambiguous option [%s]\n", prog, *argv ) ;
	    exit ( 1 ) ;
	}

	/* do operation */
	operate( option, *index, val ) ;
	side_effect( option, *index ) ;

    }
    return argc ;
}


/*
Find the default value of the first option whose name unambiguously matches
`s' (possibly abbreviated).
Return a ptr to the default value of the matching option.
Otherwise return the null ptr if a matching name is not found or is ambiguous.
*/

char *optdflt( option, s )
Options *option ;
char    *s      ;
{
    int  i ;

    if ( ( i = optindex( option, s ) ) < 0 )
	return ( (char *)0 ) ;
    return ( option[i].dflt ) ;
}

/*
Find the option whose name unambiguously matches `s' (possibly abbreviated).
Return the option list index of the matching option.
Otherwise return -1 if a matching name is not found, or -2 if the name is
ambiguous.
*/

int optindex( option, s )
Options *option ;
char    *s      ;
{
    int   i, n, index[64], span[64] ;

    if ( ( n = whichopt( option, s, index, span ) ) == 0 )
	return (-1) ;   /* option not found */
    if ( n > 1 )
	return (-2) ;   /* option name ambiguous */
    return ( *index ) ;
}


/*
Find the option whose name has the longest matching span with the head of `s'
(the argument string, possibly abbreviated or with trailing value parts).
Pass the option list index of the matching option back via arg `index'.
Pass the length of the matching span back via arg `span'.
Return the number of options found which have an equal longest matching span.
(Any `-' at the head of `s' is skipped before matching).
If there is an exact match (ie the longest matching span equals the length of
the option name) then return an unambiguous match.
*/

int whichopt( option, s, index, span )
Options *option ;
char    *s      ;
int     *index, *span ;
{
    int  i, j, n = 0, jmax = 0 ;

    if ( *s == '-' ) s++ ;  /* Skip leading hyphen  */

    for ( i = 0 ; option[i].name != (char *)0 ; i++ ) {

	if ( ( j = streqspn( s, option[i].name ) ) > jmax ) {
	    jmax = j ;                  /* a new longest matching span */
	    n = 0 ;
	    index[n]  = i ;
	    span[n++] = j ;
	}
	else if ( j > 0 && j == jmax ) {    /* ambiguous name with same matching span */
		index[n]  = i ;
		span[n++] = j ;
	}
    }

    for ( i = 0 ; i < n ; i++ )         /* check for an exact match */
	if ( span[i] == strlen( option[index[i]].name ) ) {
	    index[0] = index[i] ;
	    span[0]  = span[i] ;
	    return 1 ;
	}

    return n ;
}


/*
Check arg syntax and return a pointer to the value part, (or a pointer to the
terminating null if the value part is empty).
Return a NULL pointer if the syntax is invalid. It is assumed then that the
current arg (and all remaining) is a filename.
Print a warning if the syntax is an error rather than a possible filename,
(the filename will not be found in this case).

The check is arranged so that different option syntax types can be OR'd.
*/

char *checksyntax( s, span, type )
char *s ;
int   span, type ;
{
    int   i   ;
    char *v, *val = (char *)0 ;

    if ( bitset( type, FLAG_SYNTAX ) ) {        /*  -<name>             */
	if ( *s == '-' && *(v = s+1 + span) == '\0' )
	    val = v ;
    }

    if ( bitset( type, ARG_SYNTAX ) ) {         /*  -<name>[=]<value>   */
	if ( *s == '-' ) {
	    if ( *(v = s+1 + span) == '=' ) v++ ;
	    if ( *v != '\0' ) val = v ;
	}
    }

    if ( bitset( type, EQ_SYNTAX ) ) {          /* [-]<name>=<value>    */
	if ( *s == '-' ) s++ ;
	if ( *(v = s + span) == '=' && *++v != '\0' )
	    val = v ;
    }

    return ( val ) ;
}


/*
Return 1 if string s a possible option, (ie. a string which is not a <number>,
and contains either an embedded '=' or a leading '-').
Otherwise return 0.
*/

int isopt( s )
char  *s ;
{
    if ( isnumber( s ) ) return 0 ;
    if ( *s == '-' )     return 1 ;
    if ( strchr( s, '=' ) != (char *)0 ) return 1 ;
    return 0 ;
}


operate( option, i,  val )
Options *option ;
int      i ;
char    *val ;
{
    if ( bitset( option[i].type, LATCH ) )            /* LATCH  */
	*(option[i].val) = val ;

    else if ( bitset( option[i].type, AND ) )         /* AND    */
	*(option[i].val) = offstr ;

    else if ( bitset( option[i].type, OR  ) )         /* OR     */
	*(option[i].val) = onstr ;

    else if ( bitset( option[i].type, TOGGLE ) ) {    /* TOGGLE */
	if ( isempty( val ) ) {
	    if ( ison( *(option[i].val) ) )
		*(option[i].val) = offstr ;
	    else
		*(option[i].val) = onstr ;
	}
	else *(option[i].val) = val ;
    }
}


/*
Side-effects of options type specifiers.
*/

side_effect( option, j )
Options *option ;
int      j ;
{
    int   i ;
    char *exstr ;

    if ( bitset( option[j].type, EXCLUDE ) ) {  /* EXCLUDE */
	if ( ison( *(option[j].val) ) )
	    exstr = offstr ;
	else
	    exstr = onstr ;
	for ( i=0; option[i].name != (char *)0 ; i++)
	    if ( i != j && bitset( option[i].type, EXCLUDE ) )
		    *(option[i].val) = exstr  ;
    }
}



/*
Separate an option value string `optval' into two string tokens at the first
occurrence of a separator character `sep'. (Given as a string of one char).
Return the tokens via the pointers `val1' and `val2' (which could be passed
as the addresses of string pointers).
Return BADVAL if the option value string is bad (meaning that either `optval' was
null or empty, or the separator char was found but the 2nd token was missing).
Return 1 if the option value string is good (meaning that either two tokens
were found, or only the 1st token with no separator char, in which case `val2'
will be a ptr to an empty string). (See routine strpsep()).
*/

int getvals( optval, val1, val2, sep )
char  *optval ;
char **val1, **val2 ;
char  *sep ;
{
    *val1 = optval ;
    if ( isnull( *val2 = strsep( optval, sep ) ) )
	return BADVAL ;
    return 1 ;
}


/*
Parse a range selector of the form:  a[-b]
Return 0 if bad selectors, otherwise return 1.
Items are numbered 1,2,...,max, (where max is 0 by convention).
When either limit is "min", then set the respective value to 1.
When either limit is "max", then set the respective value to 0.
When `b' is missing, then set b=a.

If (a==0) then seek eof and process the final item.
Else seek past (a-1) items, and then process the next (b-a+1) items
(or all items until eof if (b==0)).
Eg:
    seekstart( a-1, bytes, fp ) ;
    for ( i = 0 ; ( b == 0  ||  i < b-a+1 ) ; i++ )
	do process

*/

int selector( s, a, b )
char *s ;
int  *a, *b ;
{
    char *val1, *val2 ;

    if ( getvals( s, &val1, &val2, "-" ) == BADVAL )
	return ( 0 ) ;
    if      ( ismin( val1 ) ) *a = 1 ;           /* first object         */
    else if ( ismax( val1 ) ) *a = 0 ;           /* last object          */
    else if ( ( *a = atoi( val1 ) ) <= 0 ) {     /* intermediate object  */
	if ( *a == 0 ) fprintf( stderr,"warning: selected items are numbered 1,...,max\n" ) ;
	return ( 0 ) ;
    }
    if ( isempty( val2 ) )    *b = *a ;          /* single object        */
    else if ( ismin( val2 ) ) *b = 1 ;
    else if ( ismax( val2 ) ) *b = 0 ;
    else if ( ( *b = atoi( val2 ) ) <= 0 ) {
	return ( 0 ) ;
    }
    if ( *b > 0  && ( *a == 0 || *a > *b ) )
	return ( 0 ) ;

    return ( 1 ) ;
}


/*
Parse a time range selector of the form:  a[-b]
The range is returned as limits meaning: start==a  duration==b-a+1.
(Note: when range=max or range=max-max then a==b==(-1) and duration==1).
Return 0 if bad selectors, otherwise return 1.
Time is numbered 0,2,...,max, (where max is (-1) by convention).
When either limit is "min", then set the respective value to 0.
When either limit is "max", then set the respective value to (-1).
When `b' is missing, then set b=a.
Time is specified as <number>[<units>], where <units> = {p, ms, s}.
Empty units are interpreted as `p' (ie sample points).
Convert `a' and `b' to sample points using the given samplerate.

(Note: this is like selector() but using to_p() instead of atoi(), and
numbering from 0 instead of 1).

If (a<0) then seek eof and process the final item.
Else seek past (a) items, and then process the next (b-a+1) items
(or all items until eof if (b==-1)).
Eg:
    seekstart( a, bytes, fp ) ;
    for ( i = 0 ; ( b < 0  ||  i < b-a+1 ) ; i++ )
	do process

*/

int range( s, a, b, samplerate )
char *s ;
int  *a, *b ;
int   samplerate ;
{
    char *val1, *val2 ;

    if ( getvals( s, &val1, &val2, "-" ) == BADVAL )
	return ( 0 ) ;
    if      ( ismin( val1 ) ) *a = 0    ;       /* first object         */
    else if ( ismax( val1 ) ) *a = (-1) ;       /* last object          */
    else if ( ( *a = to_p( val1, samplerate ) ) < 0 ) {
	return ( 0 ) ;
    }
    if ( isempty( val2 ) )    *b = *a   ;        /* single object        */
    else if ( ismin( val2 ) ) *b = 0    ;
    else if ( ismax( val2 ) ) *b = (-1) ;
    else if ( ( *b = to_p( val2, samplerate ) ) < 0 ) {
	return ( 0 ) ;
    }
    if ( *b >= 0  && ( *a < 0 || *a > *b ) )
	return ( 0 ) ;

    return ( 1 ) ;
}


/*
Seek n items of size bytes from current position in stream.
(Unlike fseek, this works even when fp is stdin).
Return the number of items actually read.
Example:  seekstart( n, sizeof(short), fp );
Datatype "ASCII" is a special case for which 0 is returned by the databytes
routine, so bytes==0 is taken to mean seek n ascii lines. In general use:
    seekstart( n, databytes( typestr ), fp )
*/

seekstart( n, bytes, fp )
int    n, bytes ;
FILE  *fp ;
{
    int   i    ;
    char *buf  ;
    char *line ;

    if ( bytes == 0 ) { /* special case meaning ascii lines */
	line = (char *)malloc( LINE_LENGTH ) ;
	for ( i = 0 ; i < n && fgets( line, LINE_LENGTH, fp ) != (char *)0 ; i++ )
	    ;
	free( line ) ;
	return ( i ) ;
    }

    if ( fp != stdin ) {
	if ( fseek( fp, (long)( n * bytes ), 1 ) == 0 )
	    return n ;          /* if improper, look for any input */
    }

    if ( ( buf = (char *)malloc( bytes ) ) == (char *)0 ) {
	fprintf( stderr, "seekstart: cannot allocate %d bytes\n", bytes ) ;
	exit( 1 ) ;
    }

    for ( i = 0 ; i < n && fread( buf, bytes, 1, fp ) ; i++ )
	;
    free( buf ) ;

    return ( i ) ;
}


/*
Seek n items of of given type from current position in stream.
This seekstart version takes a `type' arg instead of a size in `bytes'.
The `type' is an index to the datatype list in options.h, obtained for
example using: typeindex( typestr ).
*/

seektype( n, type, fp )
int    n, type ;
FILE  *fp ;
{
    return ( seekstart( n, typebytes( type ), fp ) ) ;
}


/*
Read the next n items of `type' from the given stream.
The `type' is an index to the datatype list in options.h, obtained for
example using: typeindex( typestr ).
Assign the item as a float in address `y', and return 1.
Return 0 if eof or error.
This can replace fread, eg:
	fread( &p, sizeof(short), 1, fp )               ( with short p )
becomes:
	readitem( &y, typeindex( "short" ), 1, fp )     ( with float y )
*/

readitem( y, type, n, fp )
float *y    ;
int    type ;
int    n    ;
FILE  *fp   ;
{
    char c ; short s ; int i ; float f ; double d ;
    int  j ;
    static char *line ;
    static int   first = 1 ;

    switch ( type ) {
	case   0  : for ( j = 0 ; j < n ; j++ ) {
			if ( fread( &c, sizeof(char),   1, fp ) == 0 ) return 0 ;
			*y++ = (float)c ;
		    }
		    break ;
	case   1  : for ( j = 0 ; j < n ; j++ ) {
			if ( fread( &s, sizeof(short),  1, fp ) == 0 ) return 0 ;
			*y++ = (float)s ;
		    }
		    break ;
	case   2  : for ( j = 0 ; j < n ; j++ ) {
			if ( fread( &i, sizeof(int),    1, fp ) == 0 ) return 0 ;
			*y++ = (float)i ;
		    }
		    break ;
	case   3  : for ( j = 0 ; j < n ; j++ ) {
			if ( fread( &f, sizeof(float),  1, fp ) == 0 ) return 0 ;
			*y++ = (float)f ;
		    }
		    break ;
	case   4  : for ( j = 0 ; j < n ; j++ ) {
			if ( fread( &d, sizeof(double), 1, fp ) == 0 ) return 0 ;
			*y++ = (float)d ;
		    }
		    break ;
	case   5  :
	case   6  : if ( first ) {
			line = (char *)malloc( LINE_LENGTH ) ;
			first = 0 ;
		    }
		    for ( j = 0 ; j < n ; j++ ) {
			if ( fgets( line, LINE_LENGTH, fp ) == (char *)0 )      return 0 ;
			*y++ = atof( line ) ;
		    }
		    break ;
    }
    return 1 ;
}


/*
Write the given n items of `type' onto the given stream.
The `type' is an index to the datatype list in options.h, (obtained for
example using: typeindex( typestr ) ).
*/

writeitem( y, type, n, fp )
float *y    ;
int    type ;
int    n    ;
FILE  *fp   ;
{
    char c ; short s ; int i ; float f ; double d ;
    int  j ;

    switch ( type ) {
	case   0  : for ( j = 0 ; j < n ; j++ ) {
			c = (char)   *y++ ;
			fwrite( &c, sizeof(char),   1, fp ) ;
		    }
		    break ;
	case   1  : for ( j = 0 ; j < n ; j++ ) {
			s = (short)  *y++ ;
			fwrite( &s, sizeof(short),  1, fp ) ;
		    }
		    break ;
	case   2  : for ( j = 0 ; j < n ; j++ ) {
			i = (int)    *y++ ;
			fwrite( &i, sizeof(int),    1, fp ) ;
		    }
		    break ;
	case   3  : for ( j = 0 ; j < n ; j++ ) {
			f = (float)  *y++ ;
			fwrite( &f, sizeof(float),  1, fp ) ;
		    }
		    break ;
	case   4  : for ( j = 0 ; j < n ; j++ ) {
			d = (double) *y++ ;
			fwrite( &d, sizeof(double), 1, fp ) ;
		    }
		    break ;
	case   5  :
	case   6  : for ( j = 0 ; j < n ; j++ )
			fprintf( fp, "%*.*f\n", FIELDWIDTH, PRECISION, *y++ ) ;
		    break ;
    }
}


/*
Read the next n items of `type' from the given stream within inclusive range
limits `a' and `b', (found using, eg: range( rangestr, &a, &b, samplerate ) ).
This is a version of readitem which incorporates the intial seek and handles
range=max correctly.
The `type' is an index to the datatype list in options.h, obtained for
example using: typeindex( typestr ).
Assign the item as a float in address `y', and return the number of items
read. Return 0 if eof or error.
*/

nextitem( y, type, n, fp, a, b )
float *y    ;
int    type ;
int    n    ;
FILE  *fp   ;
int    a, b ;
{
    static int count = 0 ;      /* total items read over all calls */
    int    num ;                /* number items read this call     */
    float  x   ;

    if ( count == 0 ) {

	if ( a == (-1) ) {      /* range=max or range=max-max */
	    if ( n == 1 && readitem( &x, type, 1, fp ) ) {
		*y = x ;
		while ( readitem( &x, type, 1, fp ) )
		    *y = x ;
		num = 1 ;
	    }
	    else num = 0 ;
	}

	else {
	    if ( seektype( a, type, fp ) < a )
		num = 0 ;
	    else {
		if ( b >= 0 && n > b-a+1 )  /* n restricted by upper limit */
		    n = b-a+1 ;
		for ( num = 0 ; num < n && readitem( &x, type, 1, fp ) ; num++ )
		    y[num] = x ;
	    }
	}

	count += num ;
    }

    else {
	if ( b >= 0 && count >= b-a+1 )
	    num = 0 ;
	else {
	    if ( b >= 0 && n > b-a+1 - count )  /* n restricted by upper limit */
		n = b-a+1 - count ;
	    for ( num = 0 ; num < n && readitem( &x, type, 1, fp ) ; num++ )
		y[num] = x ;
	}

	count += num ;
    }

    return num ;
}




/*
Return the type index (to the datatype list in options.h) of the given type
string. String matching allows for abbreviations.
If the given type string is in error then return an error code (less than 0):
    -1  type string not found in datatype list.
    -2  type string is ambiguous.
*/

int typeindex( typestr )
char   *typestr  ;
{
    return ( listindex( datatype, typestr ) ) ;
}


/*
Return a number of bytes for a given type index (to the datatype list in
options.h). Datatype "ASCII" is a special case for which 0 is returned.
*/

int typebytes( type )
int type ;
{
    int  bytes ;

    switch ( type ) {
	case   0  : bytes = sizeof( char   ) ;  break ;
	case   1  : bytes = sizeof( short  ) ;  break ;
	case   2  : bytes = sizeof( int    ) ;  break ;
	case   3  : bytes = sizeof( float  ) ;  break ;
	case   4  : bytes = sizeof( double ) ;  break ;
	case   5  :                                     /* ASCII */
	case   6  : bytes = 0 ;                 break ; /* ascii */
    }
    return ( bytes ) ;
}



/*
Return a number of bytes for a given type string.
The string can be a number (of bytes), or a token from the `datatype' list,
(see options.h) with which it is matched, allowing for abbreviations.
Datatype "ASCII" or "ascii" is a special case for which 0 is returned.
If the given type string is in error then return an error code (less than 0):
    -1  type string not found in datatype list.
    -2  type string is ambiguous.
    -3  type string is a negative number.
*/

int databytes( typestr )
char   *typestr  ;
{
    int  type, bytes ;

    if ( isnumber( typestr ) ) {        /* case of bytes number string */
	if ( ( bytes = atoi( typestr  ) ) < 0 )
	    return ( -3 ) ;
	else return bytes ;
    }

    if ( ( type = typeindex( typestr ) ) < 0 )
	return type ;

    return ( typebytes( type ) ) ;
}


/*
Check for over or underflow when the  given float is scaled and cast into the
given data type (an index to the datatype list in options.h).
Return a more appropriate scale factor, or a scale factor of 1 if no over
or underflow. The returned scale factor is the minimum scale factor over
a succession of calls to check_overflow.
*/

float check_overflow( p, scale, type )
float p, scale ;
int   type ;
{
    float  f, p1 = p * scale  ;
    static float first = 1 ;
    static float max, newscale ;

    if ( type >= 3 ) return ( 1. ) ;

    if ( first ) {

	switch ( type ) {
	    case   0  : max = pow( 2., 8.*sizeof(char)-1  ) - 1 ;  break ;
	    case   1  : max = pow( 2., 8.*sizeof(short)-1 ) - 1 ;  break ;
	    case   2  : max = pow( 2., 8.*sizeof(int)-1   ) - 1 ;  break ;
	}

	newscale = 1. ;
	first = 0 ;
    }

    if      ( p1 > max    ) f =    max / p   ;
    else if ( p1 < (-max) ) f = -( max / p ) ;
    else                    f = 1.           ;

    if ( f < newscale )
	newscale = f ;

    return ( newscale ) ;
}



/*
Some particular string tests.
*/


/*
Test for "on" or any <number> string other than "0".
*/

int ison( s )
char *s ;
{
    return ( strcmp( "on", s ) == 0 || ( isnumber( s ) && strcmp( "0", s ) != 0 ) ) ;
}

/*
Test for "off" or "0".
*/

int isoff( s )
char *s ;
{
    return ( strcmp( "off", s ) == 0 || strcmp( "0", s ) == 0 ) ;
}

/*
Test for "min".
*/

int ismin( s )
char *s ;
{
    return ( strcmp( "min", s ) == 0 ) ;
}

/*
Test for "max".
*/

int ismax( s )
char *s ;
{
    return ( strcmp( "max", s ) == 0 ) ;
}




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

/*
  Print help for user
  help=on or -help gets standard help for all except SILENT options.
  help=all gets standard help for all options.
  help=syntax gets help with syntax instead of comment for all except SILENT.
  help=<name> gets help for the named option (which can be abbreviated).
*/


/*
  types of helpopts (see defines in options.h)

helpopts   standard usage, exit when done
helpopts1  standard usage, supplied function for exit or additional help
helpopts2  supplied usage and function for exit or additional help
helpopts3  supplied usage, exit when done
*/


gethelp( helpstr, prog, applic, usage, option, tail )
char    *helpstr ;
char    *prog    ;
char    *applic  ;
char    *usage   ;
Options *option  ;
int    (*tail)() ;      /* function for exit or additional help */
{
    int  i, index[64], span[64] ;

    if ( isempty( helpstr ) || ison( helpstr ) || isstr( helpstr, "all" ) || isstr( helpstr, "syntax" ) )
	help( prog, applic, usage, option, isstr( helpstr, "all" ), isstr( helpstr, "syntax" ) ) ;
    else {
	i = whichopt( option, helpstr, index, span ) ;
	if ( i == 0 )
	    fprintf(stderr,"%s: unknown option [%s]\n", prog, helpstr ) ;
	else if ( i > 1 )
	    fprintf(stderr,"%s: ambiguous option [%s]\n", prog, helpstr ) ;
	else
	    helpshot( option[*index] ) ; /* single-line help i'th option */
    }
    (*tail)() ;
}



help( prog, applic, usage, option, all, syntax )
char    *prog, *applic, *usage ;
Options *option ;
int      all, syntax ;
{
    int  i ;
    char *which_syntax();

    if ( usage == (char *)0 )   /* a standard usage */
	printf( "%s:  %s\nUsage: %s  [arguments]  [file]\n", prog, applic, prog );
    else
	printf( "%s:  %s\nUsage: %s\n", prog, applic, usage );

    if ( num_printed_opts( option, all ) > 0 ) {
	printf("name        default     comment\n");
	printf("----------  ----------  --------.... \n");
    }
    for (i=0 ; option[i].name != (char *)0 ; i++) {
	if ( !bitset( option[i].type, SILENT ) || all ) {
	    if ( syntax )
		syntaxline( option[i] ) ;
	    else
		helpline( option[i] ) ;
	}
    }
}


helpline( option )
Options option ;
{
    printf("%-10s  ", option.name );
    printf("%-10s  ", option.dflt );
    printf("%s\n"   , option.help );
}

syntaxline( option )
Options option ;
{
    char *which_syntax();

    printf("%-10s  ", option.name );
    printf("%-10s  ", option.dflt );
    printf("%s\n"   , which_syntax( option.type ) );
}


helpshot( option )
Options option ;
{
    char *which_syntax();

    printf("name:    %s\n", option.name );
    printf("default: %s\n", option.dflt );
    printf("syntax:  %s\n", which_syntax( option.type ) );
    printf("comment: %s\n", option.help );
}


/*
Return the number of options which will get printed by help
*/

int num_printed_opts( option, all )
Options *option ;
int      all    ;
{
    int  i, j=0 ;

    for (i=0 ; option[i].name != (char *)0 ; i++)
	if ( !bitset( option[i].type, SILENT ) )
	    j++ ;
    if ( all ) return ( i ) ;   /* num all options        */
    else       return ( j ) ;   /* num non-SILENT options */
}


char *which_syntax( type )
int  type ;
{
    if ( bitsset( type, ALL_SYNTAX    ) ) return (char *)( All_Syntax    ) ;
    if ( bitsset( type, VAL_SYNTAX    ) ) return (char *)( Val_Syntax    ) ;
    if ( bitsset( type, TOGGLE_SYNTAX ) ) return (char *)( Toggle_Syntax ) ;
    if ( bitsset( type, ONOFF_SYNTAX  ) ) return (char *)( Onoff_Syntax  ) ;
    if ( bitsset( type, EQ_SYNTAX     ) ) return (char *)( Eq_Syntax     ) ;
    if ( bitsset( type, ARG_SYNTAX    ) ) return (char *)( Arg_Syntax    ) ;
    if ( bitsset( type, FLAG_SYNTAX   ) ) return (char *)( Flag_Syntax   ) ;
}