proc.c

一个通讯程序源码

/*+-------------------------------------------------------------------------
	proc.c - procedure command and control
	[e-mail]

  Defined functions:
	_cmd_gosub_common(param,type)
	_get_goto_label(param)
	do_proc(argc,argv)
	dump_proc(pcb)
	execute_esd(tesd)
	execute_goto(pcb,goto_type)
	execute_labelled_esd(tesd)
	execute_proc(pcb,use_goto_label)
	find_labelled_lcb(label,first,last)
	find_proc_cmd(cmd_list,cmd)
	find_procedure(name)
	free_lcb_chain(lcb)
	pcmd_do(param)
	pcmd_gosub(param)
	pcmd_gosubb(param)
	pcmd_goto(param)
	pcmd_gotob(param)
	pcmd_return(param)
	pcmd_upon(param)
	proc_dcdloss_handler(pcb)
	show_error_position(pcb)
	trace_proc_cmd(pcb)

--------------------------------------------------------------------------*/
/*+:EDITS:*/
/*:09-10-1992-14:00-wht@n4hgf-ECU release 3.20 */
/*:08-22-1992-15:39-wht@n4hgf-ECU release 3.20 BETA */
/*:11-16-1991-15:39-wht@n4hgf2-add pcmd_upon stub */
/*:11-16-1991-14:53-wht@n4hgf2-add proc_dcdloss_handler */
/*:11-16-1991-14:01-wht@n4hgf-calloc pcb instead of malloc */
/*:07-25-1991-12:59-wht@n4hgf-ECU release 3.10 */
/*:07-01-1991-01:53-wht@n4hgf-fix return with value */
/*:05-01-1991-04:18-wht@n4hgf-new find_procedure failed on home subdir match */
/*:04-30-1991-03:19-root@n4hgf-add search for .ep in ecu lib ep subdir */
/*:08-14-1990-20:40-wht@n4hgf-ecu3.00-flush old edit history */

#include "ecu.h"
#include "ecuerror.h"
#include "ecukey.h"
#include "esd.h"
#include "var.h"
#include "proc.h"

#define NEED_P_CMD
#include "ecucmd.h"

PCB *pcb_stack[PROC_STACK_MAX];

int proc_level = 0;
int proctrace = 0;

char goto_label[64];

/*+-------------------------------------------------------------------------
	_get_goto_label(param)
--------------------------------------------------------------------------*/
int
_get_goto_label(param)
ESD *param;
{
	register erc;
	register ESD *label_esd;

	goto_label[0] = 0;
	if(erc = get_alphanum_zstr(param,goto_label,sizeof(goto_label)))
	{
		if((label_esd = esdalloc(64)) == (ESD *)0)
			return(eNoMemory);
		if(!(erc = gstr(param,label_esd,0)))
			strcpy(goto_label,label_esd->pb);
		esdfree(label_esd);
	}

	return(erc);

}	/* end of _get_goto_label */

/*+-------------------------------------------------------------------------
	pcmd_goto(param)
--------------------------------------------------------------------------*/
int
pcmd_goto(param)
ESD *param;
{

	if(!proc_level)
		return(eNotExecutingProc);
	if(_get_goto_label(param))
		return(eInvalidLabel);
	return(eProcAttn_GOTO);

}	/* end of pcmd_goto */

/*+-------------------------------------------------------------------------
	pcmd_gotob(param)
--------------------------------------------------------------------------*/
int
pcmd_gotob(param)
ESD *param;
{

	if(!proc_level)
		return(eNotExecutingProc);
	if(_get_goto_label(param))
		return(eInvalidLabel);
	return(eProcAttn_GOTOB);

}	/* end of pcmd_gotob */

/*+-------------------------------------------------------------------------
	_cmd_gosub_common(param,type)
--------------------------------------------------------------------------*/
int
_cmd_gosub_common(param,type)
ESD *param;
int type;
{
	int erc;
	LCB *current_save;
	int index_save;

	if(_get_goto_label(param))
		return(eInvalidLabel);
	current_save = pcb_stack[proc_level - 1]->current;
	index_save = current_save->text->index;
	if(!(erc = execute_proc(pcb_stack[proc_level - 1],type)))
	{
		pcb_stack[proc_level - 1]->current = current_save;
		current_save->text->index = index_save;
	}
	return(erc);

}	/* end of _cmd_gosub_common */

/*+-------------------------------------------------------------------------
	pcmd_gosub(param)
--------------------------------------------------------------------------*/
int
pcmd_gosub(param)
ESD *param;
{
	if(!proc_level)
		return(eNotExecutingProc);
	return(_cmd_gosub_common(param,eProcAttn_GOTO));
}	/* end of pcmd_gosub */

/*+-------------------------------------------------------------------------
	pcmd_return(param)
--------------------------------------------------------------------------*/
int
pcmd_upon(param)
ESD *param;
{
	pprintf("'upon' not implimented\n");
	param->index = param->cb;
	return(0);
}	/* end of pcmd_return */

/*+-------------------------------------------------------------------------
	pcmd_gosubb(param)
--------------------------------------------------------------------------*/
int
pcmd_gosubb(param)
ESD *param;
{
	if(!proc_level)
		return(eNotExecutingProc);
	return(_cmd_gosub_common(param,eProcAttn_GOTO));
}	/* end of pcmd_gosubb */

/*+-------------------------------------------------------------------------
	pcmd_return(param)
--------------------------------------------------------------------------*/
int
pcmd_return(param)
ESD *param;
{
	long value = 0;
	if(!gint(param,&value))
	{
		if((value < 0) || (value > 255))
			value = 255;
		if(proctrace)
			pprintf("return value %ld\n",value);
		if(value)
			value += e_USER;
		return((int)value);
	}
	return(eProcAttn_RETURN);
}	/* end of pcmd_return */

/*+-------------------------------------------------------------------------
	find_labelled_lcb(label,first,last)
search for match between label
--------------------------------------------------------------------------*/
LCB *
find_labelled_lcb(label,first,last)
char *label;
register LCB *first;
LCB *last;
{
	register llen = strlen(label);
	ESD *text;

	while(first)
	{
		text = first->text;
		if((text->cb >= llen) && (!strncmp(text->pb,label,llen))
			&& (!text->pb[llen] || isspace(text->pb[llen])))
			return(first);

		if(first == last)
			return((LCB *)0);
		first = first->next;
	}
	pputs("find_labelled_lab logic error\n");
	return((LCB *)0);

}	/* end of find_labelled_lcb */

/*+-------------------------------------------------------------------------
	execute_goto(pcb,goto_type)
--------------------------------------------------------------------------*/
execute_goto(pcb,goto_type)
PCB *pcb;
int goto_type;
{
	LCB *next = (LCB *)0;	/* next lcb to execute */

	switch(goto_type)
	{
		case eProcAttn_GOTO:
			if(!(next = find_labelled_lcb(goto_label,pcb->current,pcb->last)))
				next = find_labelled_lcb(goto_label,pcb->first,pcb->current);
			break;
		case eProcAttn_GOTOB:
			if(!(next = find_labelled_lcb(goto_label,pcb->first,pcb->current)))
				next = find_labelled_lcb(goto_label,pcb->current,pcb->last);
			break;
	}
	if(next)
	{
		pcb->current = next;
		return(0);
	}
	pprintf("goto/gosub label not found: %s\n",goto_label);
	return(eFATAL_ALREADY);

}	/* end of execute_goto */

/*+-------------------------------------------------------------------------
	show_error_position(pcb)
cursor MUST be at left margin when this is called
--------------------------------------------------------------------------*/
void
show_error_position(pcb)
PCB *pcb;
{
	ESD *tesd = pcb->current->text;
	register itmp = tesd->old_index;
	char tag[64];

	sprintf(tag,"%s %u> ",pcb->argv[0],pcb->current->lineno);
	pputs(tag);
	pputs(tesd->pb);
	pputs("\n");
	itmp = strlen(tag) + tesd->old_index;
	while(itmp--)
		pputc(' ');
	pputs("^\n");

}	/* end of show_error_position */

/*+-------------------------------------------------------------------------
	find_proc_cmd(cmd_list,cmd)
--------------------------------------------------------------------------*/
P_CMD *
find_proc_cmd(cmd_list,cmd)
register P_CMD *cmd_list;
register char *cmd;
{
	while(cmd_list->token != -1)
	{
		if(!strcmp(cmd_list->cmd,cmd))
			break;
		cmd_list++;
	}
	return((cmd_list->token == -1) ? (P_CMD *)0 : cmd_list);

}	/* end of find_proc_cmd */

/*+-------------------------------------------------------------------------
	execute_esd(tesd)
--------------------------------------------------------------------------*/
int
execute_esd(tesd)
ESD *tesd;
{
	int erc;
	P_CMD *pcmd;
	static P_CMD *set_pcmd = (P_CMD *)0;	/* quick access to 'set' */
	char cmd[32];
	extern int proc_interrupt;

	/* if interrupt, exit */
	if(sigint | proc_interrupt)
		return(eCONINT);

	/* if blank, skip it */
	if(skip_cmd_break(tesd))
		return(0);

	/* if comment, skip it */
	if(!skip_cmd_char(tesd,'#'))
		return(0);

	if(*(tesd->pb + tesd->index) == '{')
	{
		pputs("invalid '{'\n");
		return(eFATAL_ALREADY);
	}

	while(1)
	{
		/* get command -- allow leading '$' to assume 'set' command */
		if(*(tesd->pb + tesd->index) == '$')
		{
			/* find 'set' in the list -- save for rapid access later */
			if(set_pcmd)
				pcmd = set_pcmd;
			else if((pcmd = find_proc_cmd(icmd_cmds,"set")) == (P_CMD *)0)
				return(eInternalLogicError);
			else
				set_pcmd = pcmd;
		}
		else
		{
			if(get_alphanum_zstr(tesd,cmd,sizeof(cmd)))
				return(eIllegalCommand);
			/* find it in the list */
			if((pcmd = find_proc_cmd(icmd_cmds,cmd)) == (P_CMD *)0)
				return(eIllegalCommand);
		}

		/* check to see if this command available for procedure */
		if(!pcmd->proc)
			return(eInteractiveCmd);

		/* execute the command */
		if(erc = (*pcmd->proc)(tesd))
			return(erc);

		/* look for comment */
		if(!skip_cmd_char(tesd,'#'))
			break;

		/* look for multiple commands on line */
		if(skip_cmd_char(tesd,';'))
			break;

		/* if blank after ';', skip it */
		if(skip_cmd_break(tesd))
			break;
	}
	return(0);
		
}	/* end of execute_esd */

/*+-------------------------------------------------------------------------
	execute_labelled_esd(tesd)
--------------------------------------------------------------------------*/
execute_labelled_esd(tesd)
ESD *tesd;
{
	register index = 0;
	register cb = tesd->cb;
	register char *pb = tesd->pb;

/* reset indices */
	tesd->index = index;
	tesd->old_index = index;

/* if comment, skip it */
	if(!skip_cmd_char(tesd,'#'))
		return(0);

/* skip over any label */
	while(!isspace(*(pb + index)) && (index < cb))
		index++;
	tesd->index = index;
	tesd->old_index = index;

	return(execute_esd(tesd));
}	/* end of execute_labelled_esd */

/*+-------------------------------------------------------------------------
	dump_proc(pcb)
--------------------------------------------------------------------------*/
#if 0
void
dump_proc(pcb)
PCB *pcb;
{
	int itmp;
	LCB *lcb;

	pprintf("------ pcb @ 0x%08lx -----------------\n",pcb);
	pprintf("argc=%d first=0x%08lx last=0x%08lx\n",pcb->argc,
		pcb->first,pcb->last);
	for(itmp = 0; itmp < pcb->argc; itmp++)
	{
		pprintf("argv(%d) @ 0x%lx: '%s'\n",itmp,pcb->argv[itmp],
			pcb->argv[itmp]);
	}
	pputs("\n");
	lcb = pcb->first;
	while(lcb)
	{
		pprintf("lcb @ 0x%08lx   lineno=%u\n",lcb,lcb->lineno);
		pputs("\n");
		lcb = lcb->next;
	}
	pflush();
}	/* end of dump_proc */
#endif

/*+-------------------------------------------------------------------------
	trace_proc_cmd(pcb) - if asked, show command
--------------------------------------------------------------------------*/
void
trace_proc_cmd(pcb)