opt.c

ecg心电信号产生程序

	}
	
    else
	if (*s == DELIM )
	{
		++s;
		if (*s=='\0')
		{
			short_usage();
			doc_usage();
			long_usage();
			return;
		}
		if (*s==DELIM)
		{
			opt_doc();
			return;
		}
		
	}
}
static void
short_usage()
{
    if(Title != NULL)
		sprintf(gstr,"%s\n",Title), opt_message(gstr);
    if(Usage != NULL)
		sprintf(gstr,"[%s] %s\n",opt_program_name,Usage), opt_message(gstr);
    sprintf(gstr,"To invoke the menu, type:\n\t%s %c\n",
			opt_program_name,INTERACT), 
	opt_message(gstr);
}	
static void
long_usage()
{
	sprintf(gstr,"The options are:\n"), opt_message(gstr);
	opt_usage();

}
static void
doc_usage()
{
		if(doc_fcn != NULL)
		{
			sprintf(gstr,"For fuller documentation, type:\n\t"), 
			opt_message(gstr);
			sprintf(gstr,"%s %c%c%c\n",opt_program_name,
					DELIM,DELIM,DELIM), 
			opt_message(gstr);
		}

}

	/* --------------------------------- */
	/* put current options in named file */
	/* --------------------------------- */

int
opt_tofname(fname)
char	*fname;
{
    FILE	*fp;
    
    if( *fname != OPTTOFILE )
    {
	free((char *)optfile_name);
	optfile_name = append_string(fname,"");
    }
    if( access(optfile_name,0)==0 )
    {
	sprintf(gstr,"Options file [%s] has been overwritten\n",
		optfile_name), opt_message(gstr);
	backup_file(optfile_name);
    }
    fp = fopen(optfile_name,"w");

    if(fp==NULL)
    {
	sprintf(gstr,"cant open file %s\n",fname), opt_message(gstr);
	return(0);
    }
    opt_tofile(fp);
    fclose(fp);
    return(1);
}
#ifdef __TURBOC__
backup_file(fname)
char *fname;
{}
#else
backup_file(fname)
char *fname;
{
    char fname_backup[80];
    sprintf(fname_backup,"%s%s",fname,"~");
    sprintf(gstr,"%s %s %s","cp",fname,fname_backup);
    system(gstr);
    sprintf(gstr,"File [%s] is backup file\n",fname_backup);
    opt_message(gstr);
}
#endif
	/* ----------------------------------------- */
	/* get and process options from a named file */
	/* ----------------------------------------- */

#define	MAXOPLINE	256
int
opt_fromfname(fname)
char	*fname;
{
    FILE	*fp;
    char	line[MAXOPLINE+2];	/* leave room for termination */

    if( *fname != OPTFROMFILE )		/* if not default file */
    {
	if( access(fname,0)!=0 )	/* if file doesn't exist */
	{
	    sprintf(gstr,"File [%s] does not exist\n",fname);
	    opt_message(gstr);
	    return(0);
	}
	else
	{
	    free((char *)optfile_name);
	    optfile_name = append_string(fname,"");
	}
    }
    fp = fopen(optfile_name,"r");
    
    if(fp==NULL)
    {
	sprintf(gstr,"Cannot open options file [%s]\n",optfile_name);
	opt_warning(gstr);
	return(0);
    }
    
    while( opt_getline(line,fp) > 0 )
    	opt_lineprocess(line);
    
    fclose(fp);
    return(1);
}
int
opt_getline(line,fp)
char	*line;
FILE	*fp;
{
    int	c;
    int	count=0;
	
    while( (c=getc(fp)) != '\n' && c!=EOF )
    {
		*line = (char)c;
		++line;
		if( ++count > MAXOPLINE-3 )
		{
			opt_warning("Options line too long");
			break;
        }
    }
    *line++ = '\0';		/* double terminate line !! */
    *line++ = '\0';
    
    return(count);
}/*opt_getline*/

/* ------------------- */
/* basic help function */
/* ------------------- */

void
opt_help(s)
char	*s;
{
    if(s==NULL || *s=='\0')
    {
	sprintf(gstr,"\t%c %-20s\n",DELIM,"Options delimiter"), 
	opt_message(gstr); 
	sprintf(gstr,"\t%c %-20s\n",HELPCH,"Help"), 
	opt_message(gstr);
	sprintf(gstr,"\t%c %-20s\n",RUN,"Run program and return to menu"), 
	opt_message(gstr);
	sprintf(gstr,"\t%c %-20s\n",BANG,"Shell to Operating System"), 
	opt_message(gstr); 
	if (menuflag)
		sprintf(gstr,"\t%c %-20s\n",INTERACT,"Exit menu"), 
		opt_message(gstr); 
	else
		sprintf(gstr,"\t%c %-20s\n",INTERACT,"Invoke menu"), 
		opt_message(gstr); 
	sprintf(gstr,"\t%c %-20s\n",ADDITIONAL_OPTS,"Additional options"), 
	opt_message(gstr);
	sprintf(gstr,"\t%c<filename> %-20s\n",OPTFROMFILE,
		"Get options from file",optfile_name), 
	opt_message(gstr);
	sprintf(gstr,"\t%c%c %-2s [%s]\n",OPTFROMFILE,OPTFROMFILE,
		"Get options from file",optfile_name), 
	opt_message(gstr);
	sprintf(gstr,"\t%c<filename> %-20s\n",OPTTOFILE,
		"Put options in file"), 
	opt_message(gstr);
	sprintf(gstr,"\t%c%c %-2s [%s]\n",OPTTOFILE,OPTTOFILE,
		"Put options in file",optfile_name), 
	opt_message(gstr);
	sprintf(gstr,"\t%c %-20s\n",QUITCH,"Quit"), 
	opt_message(gstr);
    }
	else
	{
		/* first check if help is available for single character delimiter */
		if( s[1]=='\0' && opt_number(s[0]) >=0 )
			opt_get_help(s[0]); 
		else
		{
			if( help_fcn==NULL )
				sprintf(gstr,"Help unavailable for: [%s]\n",s), 
				opt_message(gstr);
			else
				(*help_fcn)(s);
		}
	}
}
/* ------ */
/* quit() */ 
/* ------ */
void
opt_quit()
{
    if( quit_fcn == NULL )
		opt_abort_run();
    else
	{
		(*quit_fcn)();
		opt_abort_run();
	}
}
/* ---------- */
/* document() */
/* ---------- */
void
opt_doc()
{
    if( doc_fcn == NULL )
	return;
    else
	(*doc_fcn)();
}
/* opt_menu.c */


#ifndef	SINGLEFILE
#include <stdio.h>
#include <ctype.h>
#ifdef convex
#include <strings.h>
#else
#include <string.h>
#endif
#ifdef __TURBOC__
#include <alloc.h>
#endif
#include "opt_p.h"
#endif /* SINGLEFILE */

/* --------------------- menu flag ------------------- */

flag menuflag=False;

static char mgstring[160];	/* global menu string */

#define menu_wr_string(str)       opt_message(str)
#define menu_getresponse(respond) opt_getline(respond,stdin)

static void write_the_menu();
static int auto_prefix_delim();


/* ----------------------------------------------------	*/
/*  opt_menu:	Get options from an interactive menu	*/
/* ----------------------------------------------------	*/

#define	MAXRESPONDLINE	280
#ifndef	MAXOPTSINMENU
#define	MAXOPTSINMENU	20
#endif

void
opt_menu()
{
    char respond[MAXRESPONDLINE+2];
    static int maxoptsinmenu=MAXOPTSINMENU;
	flag fullmenu;
    int	iop,iopfrom,iopto;

    menuflag=True;	/* turn on MENUFLAG in case it is not set already */
    
    iopfrom = 0;
    iopto = ( nregopts < maxoptsinmenu ? nregopts : maxoptsinmenu );
    
	respond[0]='\0';

	opt_wr_title();
	write_the_menu(iopfrom,iopto);

    while( menuflag )
    {
	    menu_wr_string("-> ");
		menu_getresponse(respond);
		
		switch(*respond)
		{
		case ADDITIONAL_OPTS:
			if( respond[1] != '\0' && respond[1] != ' ' )
			{
				maxoptsinmenu = atoi(respond+1);
				if(maxoptsinmenu < 1)
					maxoptsinmenu = nregopts;
				sprintf(mgstring,"Scroll %d options\n",maxoptsinmenu);
				menu_wr_string(mgstring);
				iopfrom = 0;
				iopto = 
					( nregopts < maxoptsinmenu ? nregopts : maxoptsinmenu );
			}
			else
			{
				iopfrom += maxoptsinmenu;
				if( iopfrom > nregopts)
					iopfrom = 0;
				iopto = iopfrom + maxoptsinmenu;
				if( iopto > nregopts )
					iopto = nregopts;
			}
			write_the_menu(iopfrom,iopto);
			break;
		case INTERACT:
			menuflag=False;
			break;
	    case BANG:
			system( respond+1 );
			break;
		case '\0':
			write_the_menu(iopfrom,iopto);
			break;
		case QUITCH:
			/* only quit if the QUITCH is followed by whitespace */
			if ( respond[1]=='\0' || respond[1]==' ' )
				opt_abort_run(0);
			break;
		case DELIM:
		case ALTDELIM:
			opt_lineprocess(respond);
			break;
		default:
			auto_prefix_delim(respond);
			opt_lineprocess(respond);
			break;
		}
	}
}/* opt_menu */


/**********
 * write_the_menu:
 *	write the menu including options from iopfrom to iopto.
 */
static void
write_the_menu(iopfrom,iopto)
int iopfrom,iopto;
{
	int iop;
	flag fullmenu;

	fullmenu = ((iopfrom==0 && iopto==nregopts) ? True : False );

	if( !fullmenu )
	{
		sprintf(mgstring,"menu: %d->%d [%d]\n",iopfrom,iopto,nregopts);
		menu_wr_string(mgstring);
	}

	for(iop=iopfrom; iop<iopto; ++iop)
	{
		char *s;
		s = opt_mstring(iop);
		if (s!=NULL)
		{
			strcpy( mgstring, s );
			menu_wr_string(mgstring);
			menu_wr_string("\n");
		}
	}
	if (!fullmenu)
	{
		sprintf(mgstring,"%c Additional options\n",ADDITIONAL_OPTS);
		menu_wr_string(mgstring);
	}
	sprintf(mgstring,"(Type %c for Help)\n",HELPCH);
	menu_wr_string(mgstring);
}

/*	auto_prefix_delim:	
 *		this is a fru-fru piece of code that automatically
 *		sticks a DELIM character onto the front of a string
 *		in cases where it imagines that that is what the user
 *		really meant.  Thus
 *		-> m4
 *		gives the same effect as
 *		-> -m4
 *		But be warned that this only applies in limited cases.
 *		Eg.,
 *		-> m4 b3
 *		is not the same as
 *		-> -m4 -b3
 *
 *		a '-' will be prepended in the case that 
 *		the first character is a registered name
 */
static int
auto_prefix_delim(r)
char *r;
{
    if( opt_number( *r ) != -1 )
    {
		int len;
		len = strlen(r)+1;	/* +1 since double terminated */
		while(len>=0)
		{
			r[len+1]=r[len];
			--len;
		}
		r[0]=DELIM;
		return(1);
    }
    else
		return(0);
}/* auto_prefix_delim */


/**************************
 *  some useful utilities *
 **************************/
/*
 *  1) Variable argument lists: for error messages
 *     opt_errmess(), gives message and then aborts run
 *  2) Long Jump: for aborting run() without losing the entire job
 *     opt_begin_run()
 *     opt_abort_run()
 *  3) Signal: trapping ^C so that it aborts run()
 *     
 */
/*  Can be disabled by setting constants
 *                        DISABLE_VARARG, 
 *                        DISABLE_LONGJUMP, 
 *                        DISABLE_SIGNAL
 */
#ifndef SINGLEFILE
#include <stdio.h>
#include "opt_p.h"
#endif

static void   set_signal(/* void */);
static void unset_signal(/* void */);
static void catch_signal(/* void */);


void
opt_message(s)
char *s;
{
	if (s != NULL)
		fputs(s,stderr);
}
void
opt_warning(s)
char *s;
{
	fputs(opt_program_name,stderr);
	fputs(":: ",stderr);
    fputs("OPT Warning: ",stderr);
    fputs(s,stderr);
	fputs("\n",stderr);
}
void
opt_fatal(s)
char *s;
{
	fputs(opt_program_name,stderr);
	fputs(":: ",stderr);
    fputs("OPT Fatal error: ",stderr);
    fputs(s,stderr);
    exit(1);
}

/**********
 * VARARG *
 **********/

#if DISABLE_VARARG

void
opt_errmess(s)
char *s;
{
	fputs(opt_program_name,stderr);
	fputs(":: ",stderr);
    fputs(s,stderr);
    opt_abort_run();
}

#else /* if not DISABLE_VARARGS */

#ifdef __TURBOC__
/* Turbo-C implements variable argument lists differently than SUN */

#ifndef SINGLEFILE
#include <stdarg.h>
#endif

void
opt_errmess(char *format, ...)
{
    va_list argptr;
    
    va_start(argptr,format);
    vfprintf(stderr,format,argptr);
    va_end(argptr);
    opt_abort_run();
}
#else /* if not __TURBOC__ but default instead */
#ifndef SINGLEFILE
#include <stdarg.h>
#endif
#endif /* if __TURBOC__ */
#endif /* end VARARGS */

/************
 * LONGJUMP *
 ************/

#if DISABLE_LONGJUMP

int
opt_begin_run(run)
int	(*run)();
{    return( (*run)() );
}
void
opt_abort_run()
{    exit(1);
}

#else /* if not DISABLE_LONGJUMP */

#ifndef SINGLEFILE
#include <setjmp.h>
#endif

static jmp_buf	opt_jumpstart;
static int		opt_jump_set=FALSE;

void
opt_abort_run()
{
    if(opt_jump_set)
		longjmp(opt_jumpstart,1);
    else
		exit(1);
}
int
opt_begin_run(run)
int	(*run)();
{
    int value;

    opt_jump_set=TRUE;
	set_signal();

    value = setjmp(opt_jumpstart);
    if(value!=0)
		opt_message("Run aborted...try again\n");
    else
		value = (*run)();
	
	unset_signal();
	opt_jump_set=FALSE;

    return value;
}
#endif /* end LONGJUMP */

/**********
 * SIGNAL *
 **********/

#if DISABLE_SIGNAL

static void
set_signal()
{}
static void
unset_signal()
{}
#else

#ifndef SINGLEFILE
#include <signal.h>
#endif

static	void (*old_catcher)();

static void
set_signal()
{
    old_catcher = signal(SIGINT,catch_signal);
}
static void
unset_signal()
{
	signal(SIGINT,old_catcher);
}
#ifdef __TURBOC__
   static void catch_signal(sig)
   int sig;
#else
#ifdef convex
   static void catch_signal(sig,code,scp)
   int sig, code; 
   struct sigcontext *scp;
#else /* default */
   static void catch_signal(sig,code,scp,addr)
   int sig, code;
   struct sigcontext *scp;
   char *addr;
#endif
#endif
{
    opt_message("\nOPT Interrupted:\n");
    longjmp(opt_jumpstart,1);
    perror("Did not long-jump");
    exit(0);
}
#endif /* end SIGNAL */