esdutil.c

一个通讯程序源码

	if(skip_cmd_break(tesd) || (*(tesd->pb + tesd->index) == ';') ||
			(*(tesd->pb + tesd->index) == '#'))
		return(1);
	return(0);
}	/* end of end_of_cmd */

/*+-------------------------------------------------------------------------
    erc = skip_cmd_char(tesd,skipchar)
--------------------------------------------------------------------------*/
int
skip_cmd_char(tesd,skipchar)
register ESD *tesd;
register char skipchar;
{
int erc;

	if(erc = skip_cmd_break(tesd))
		return(erc);

	if(tesd->pb[tesd->index] == skipchar)
	{
		++tesd->index;
		return(0);
	}

	return(eSyntaxError);

}   /* end of skip_cmd_char */

/*+-------------------------------------------------------------------------
    erc = skip_colon(tesd)
--------------------------------------------------------------------------*/
int
skip_colon(tesd)
register ESD *tesd;
{
	register erc;

	if(erc = skip_cmd_break(tesd))
		return(erc);

	if(tesd->pb[tesd->index] == ':')
	{
		++tesd->index;
		return(0);
	}

	return(eCommaExpected);

}   /* end of skip_colon */

/*+-------------------------------------------------------------------------
    erc = skip_comma(tesd)
--------------------------------------------------------------------------*/
int
skip_comma(tesd)
register ESD *tesd;
{
	register erc;

	if(erc = skip_cmd_break(tesd))
		return(erc);

	if(tesd->pb[tesd->index] == ',')
	{
		++tesd->index;
		return(0);
	}

	return(eCommaExpected);

}   /* end of skip_comma */

/*+-------------------------------------------------------------------------
    erc = skip_paren(fparam,LEFT or RIGHT)
--------------------------------------------------------------------------*/
int
skip_paren(tesd,fLeft)
register ESD *tesd;
int fLeft;
{
register erc;
register char search = (fLeft) ? '(' : ')';

	if(erc = skip_cmd_break(tesd))
		return(erc);

	if(tesd->pb[tesd->index] == search)
	{
		tesd->index++;
		return(0);
	}
	return((fLeft) ? eMissingLeftParen : eMissingRightParen);

}   /* end of skip_paren */

/*+-------------------------------------------------------------------------
	get_cmd_char(tesd,pchar)
--------------------------------------------------------------------------*/
int
get_cmd_char(tesd,pchar)
register ESD *tesd;
char *pchar;
{
int erc;

	if(erc = skip_cmd_break(tesd))
		return(erc);
	*pchar = tesd->pb[tesd->index++];
	return(0);

}	/* end of get_cmd_char */

/*+----------------------------------------------------------------
    get_alpha_zstr(&esd,&strbuf,strbuf_maxcb)

  places next alphabetic string token [A-Za-z_] into
  the null-terminated 'strbuf' string.  returns 0 or -1
  or skip_cmd_break error codes
-----------------------------------------------------------------*/
int
get_alpha_zstr(tesd,strbuf,strbuf_maxcb)
ESD *tesd;
register char *strbuf;
int strbuf_maxcb;
{
register izstr;
register schar;
register char *pb = tesd->pb;

	if(izstr = skip_cmd_break(tesd))
		return(izstr);
	izstr = 0;
	while( (izstr < strbuf_maxcb-1) && (tesd->index < tesd->cb) )
	{
		schar = pb[tesd->index];
		if((!isalpha(schar)) && (schar != '_'))
			break;
		strbuf[izstr++] = schar;
		tesd->index++;
	}

	strbuf[izstr] = 0;
	return(izstr ? 0 : eBadParameter);

}   /* end of get_alpha_zstr */

/*+----------------------------------------------------------------
    get_alphanum_zstr(&esd,&strbuf,strbuf_maxcb)

  places next alphanumeric string token [A-Za-z0-9_]
  into the null-terminated 'strbuf' string.  returns 0
  or -1 or skip_cmd_break error codes
-----------------------------------------------------------------*/
int
get_alphanum_zstr(tesd,strbuf,strbuf_maxcb)
register ESD *tesd;
register char *strbuf;
int strbuf_maxcb;
{
int izstr = 0;
int schar;
register cb = tesd->cb;
register index;

	if(izstr = skip_cmd_break(tesd))
		return(izstr);

	index = tesd->index;
	while( (izstr < strbuf_maxcb-1) && (index < cb))
	{
		schar = tesd->pb[index++];
		if(isalnum(schar) || (schar == '_'))
			strbuf[izstr++] = schar;
		else
		{
			--index;
			break;
		}
	}

	tesd->index = index;
	strbuf[izstr]=0;
	return(izstr ? 0 : eBadParameter);

}   /* end of get_alphanum_zstr */

/*+----------------------------------------------------------------
    get_numeric_zstr(&esd,&strbuf,strbuf_maxcb)
    gets next numeric string token places it
    into the null-terminated 'strbuf' string.  returns 0 or -1 
    or skip_cmd_break error codes
-----------------------------------------------------------------*/
int
get_numeric_zstr(tesd,strbuf,strbuf_maxcb)
register ESD *tesd;
register char *strbuf;
register strbuf_maxcb;
{
	register izstr;
	register schar;

	if(izstr = skip_cmd_break(tesd))
		return(izstr);

	while( (izstr < strbuf_maxcb-1) && (tesd->index < tesd->cb) )
	{
		schar = tesd->pb[tesd->index++];
		if( isdigit(schar) )
			strbuf[izstr++]=schar;
		else
		{
			--tesd->index;
			break;
		}
	}

	strbuf[izstr]=0;
	return(izstr ? 0 : eBadParameter);

}   /* end of get_numeric_zstr */

/*+-----------------------------------------------------------------------
	get_numeric_value(tesd,&long_var)
------------------------------------------------------------------------*/
get_numeric_value(tesd,value)
register ESD *tesd;
register long *value;
{
register erc;
char buf[32];

	if(erc = get_numeric_zstr(tesd,buf,sizeof(buf)))
		return(erc);
	sscanf(buf,"%ld",value);
	return(0);

}	/* end of get_numeric_value */

/*+----------------------------------------------------------------
    get_word_zstr(&esd,&strbuf,strbuf_maxcb)

  gets next word (continuous string of characters without spaces
  or tabs) returns 0 or -1 or skip_cmd_break error codes
-----------------------------------------------------------------*/
int
get_word_zstr(tesd,strbuf,strbuf_maxcb)
register ESD *tesd;
register char *strbuf;
register strbuf_maxcb;
{
	register izstr;
	register schar;

	if(izstr = skip_cmd_break(tesd))
		return(izstr);

	strbuf_maxcb--;
	while((izstr < strbuf_maxcb) && (tesd->index < tesd->cb))
	{
		schar = tesd->pb[tesd->index++];
		if( (schar > 0x20) && (schar <= 0x7e))
			strbuf[izstr++]=schar;
		else
		{
			--tesd->index;
			break;
		}
	}

	strbuf[izstr]=0;
	return(izstr ? 0 : eBadParameter);

}   /* end of get_word_zstr */

/*+-------------------------------------------------------------------------
    esd_strip_trail_break(tesd)
--------------------------------------------------------------------------*/
void
esd_strip_trail_break(ztext)
register ESD *ztext;
{
	while(ztext->cb &&
		((ztext->pb[ztext->cb-1] == 0x20) || (ztext->pb[ztext->cb-1] == 0x20)))
	{
		ztext->cb--;
	}
}   /* end of esd_strip_trail_break */

/*+-------------------------------------------------------------------------
	esdfgets(&esd,fileptr)

  stdio read from FILE *fileptr into esd
  returns tesd->cb set up not including trailing nl, tesd->index == 0
--------------------------------------------------------------------------*/
int
esdfgets(tesd,fileptr)
register ESD *tesd;
register FILE *fileptr;
{
register char *cptr;

	tesd->cb = 0;
	if(!fgets(tesd->pb,tesd->maxcb+1,fileptr))
		return(eEOF);
	if(!(cptr = strchr(tesd->pb,0x0A)))
		return(eBufferTooSmall);
	tesd->cb = (int)(cptr - tesd->pb);
	esd_null_terminate(tesd);
	tesd->index = 0;
	tesd->old_index = 0;
	return(0);

}	/* end of esdfgets */

/*+-------------------------------------------------------------------------
	esdfputs(&esd,fileptr,index_flag,nl_flag)

  write esd contents to stdio FILE *fileptr
  if index_flag is true, write from tesd->index thru end of esd
  otherwise, from start of esd
  if nl_flag is true, append nl to write, else just esd contents
--------------------------------------------------------------------------*/
int
esdfputs(tesd,fileptr,index_flag,nl_flag)
register ESD *tesd;
FILE *fileptr;
int index_flag;
int nl_flag;
{
register char *cptr;
register write_length;

	if(index_flag)
	{
		cptr = &tesd->pb[tesd->index];
		write_length = tesd->cb - tesd->index;
	}
	else
	{
		cptr = tesd->pb;
		write_length = tesd->cb;
	}

	if(write_length)
		fwrite(cptr,write_length,1,fileptr);

	if(nl_flag)
		fputc(0x0A,fileptr);

	return(0);
}	/* end of esdfputs */

/*+-------------------------------------------------------------------------
    get_switches(tesd,switches,switches_max)
--------------------------------------------------------------------------*/
int
get_switches(tesd,switches,switches_max)
ESD *tesd;
char *switches;
int switches_max;
{
register erc;
register index;
register char *pb = tesd->pb;
int cb = tesd->cb;
char schar;

	*switches = 0;

	if(erc = skip_cmd_break(tesd))
		return(erc);

	index = tesd->index;
	if(*(pb + index) != '-')
		return(eNoSwitches);

	if(switches_max < 3)
		return(eSwitchesTooLong);

	switches_max--;			/* for trailing null */
	*switches++ = '-';
	switches_max--;
	index++;
	while(index < cb)
	{
		schar = *(pb + index++);
		if(switches_max > 0)
			*switches++ = schar;
		switches_max--;
		if(isspace(schar))
			break;
	}

	tesd->index = index;
	*switches = 0;
	return((switches_max < 0) ? eSwitchesTooLong : 0);

}   /* end of get_switches() */

/* vi: set tabstop=4 shiftwidth=4: */
/* end of esdutil.c */