proc.c

一个通讯程序源码

PCB *pcb;
{
	if(proctrace)
	{
		pprintf("%s %u> ",pcb->argv[0],pcb->current->lineno);
		pputs(pcb->current->text->pb);
		pputc('\n');
	}

}	/* end of trace_proc_cmd */

/*+-------------------------------------------------------------------------
	proc_dcdloss_handler(pcb) - a statement execution found DCD loss
--------------------------------------------------------------------------*/
int
proc_dcdloss_handler(pcb)
PCB *pcb;
{
	int erc = 0;
	int itmp;
	ESD esdcopy;
	ESD *tesd;

	if(pcb->upon_dcdloss.pb)
	{
		esdcopy = pcb->upon_dcdloss;	/* a copy to preserve pcb->index */	
		tesd = &esdcopy;
		if(proctrace)
		{
			pprintf("%s DCDLOSS> ",pcb->argv[0]);
			pputs(tesd->pb + tesd->index);
			pputc('\n');
		}
		if(erc = execute_esd(tesd))
		{
			if(erc != eFATAL_ALREADY)
				proc_error(erc);
			pprintf("error in 'upon dcdloss' statement\n");
			pputs(tesd->pb + pcb->upon_dcdloss.index);
			pputs("\n");
			itmp = tesd->old_index - pcb->upon_dcdloss.index;;
			while(itmp--)
				pputc(' ');
			pputs("^\ninvoked while executing:\n");
			erc = eFATAL_ALREADY;
		}
	}
	else	/* DCD watch enabled but no 'upon dcdloss' in effect */
	{
		pprintf("Connection terminated during procedure execution\n");
		pputs("while executing:\n");
		erc = eFATAL_ALREADY;
	}
	return(erc);
}	/* end of proc_dcdloss_handler */

/*+-------------------------------------------------------------------------
	execute_proc(pcb,use_goto_label) - execute a memory-resident procedure
--------------------------------------------------------------------------*/
execute_proc(pcb,use_goto_label)
PCB *pcb;
int use_goto_label;
{
	int erc = 0;
	extern int proc_interrupt;

	if(proc_level == PROC_STACK_MAX)
		return(eProcStackTooDeep);

	pcb_stack[proc_level++] = pcb;
	if(use_goto_label)
	{
		if(erc = execute_goto(pcb,use_goto_label))
			return(erc);
	}
	else
		pcb->current = pcb->first;

	mkv_proc_starting(pcb);

	while(pcb->current)
	{
		/* execute the command */
		trace_proc_cmd(pcb);
		if(erc = execute_labelled_esd(pcb->current->text))
		{
			/* handle other classes of errors */
			switch(erc & 0xF000)
			{
				case e_WARNING:		/* warning */
					erc = 0;
					break;

				case e_FATAL:		/* fatal */
					goto PROC_RETURN;

				case e_ProcAttn:	/* proc attention */
					switch(erc)
					{
						case eProcAttn_GOTO:
						case eProcAttn_GOTOB:
							if(erc = execute_goto(pcb,erc))
								break;	/* didn't find it */
							continue;	/* pcb->current is now goto target */

						case eProcAttn_RETURN:
							erc = 0;
							break;

						case eProcAttn_Interrupt:
						case eProcAttn_ESCAPE:
							pprintf(
								"procedure %s interrupted.\n",pcb->argv[0]);
							erc = eFATAL_ALREADY;
							break;

						case eProcAttn_DCDloss:
							erc = proc_dcdloss_handler(pcb);
							break;

						default:
							pprintf("procedure error 0x%x\n",erc);
							erc = eFATAL_ALREADY;
							break;
					}
					goto PROC_RETURN;

				default:	/* must be proc return error code */
					goto PROC_RETURN;
			}
		}

		if(sigint || proc_interrupt)
		{
			proc_interrupt = 0;
			sigint = 0;
			pprintf("procedure %s interrupted\n",pcb->argv[0]);
			erc = eFATAL_ALREADY;
		}

		if(erc)
			break;
		pcb->current = pcb->current->next;
	}

PROC_RETURN:
	mkv_proc_terminating(pcb);
	if(erc)
	{
		if((erc > 0) && (erc < e_USER))
		{
			pprintf(">>procedure %s returned %d\n",pcb->argv[0],erc);
			erc |= e_USER;
		}
		else if((erc > e_USER) && (erc <= 0x1FFF))
		{
			;	/* already said it */
		}
		else
		{
			if(erc != eFATAL_ALREADY)
			{
				proc_error(erc);
				erc = eFATAL_ALREADY;
			}
			show_error_position(pcb);
		}
	}
	pcb_stack[--proc_level] = (PCB *)0;
#if 0
	if(erc && !proc_level)
		plog_control((char *)0);
#endif
	return(erc);
}	/* end of execute_proc */

/*+-------------------------------------------------------------------------
	free_lcb_chain(lcb)
--------------------------------------------------------------------------*/
void
free_lcb_chain(lcb)
register LCB *lcb;
{
	LCB *plcb;

	while(lcb)
	{
		if(lcb->text)
			esdfree(lcb->text);
		plcb  = lcb;
		lcb = lcb->next;
		free((char *)plcb);
	}

}	/* end of free_lcb_chain */

/*+-------------------------------------------------------------------------
	find_procedure(name) - find procedure if it exists
--------------------------------------------------------------------------*/
char *
find_procedure(name)
char *name;
{
	static char procpath[256];

/*
 * try to find proc file in current directory
 */
	strcpy(procpath,name);
	strcat(procpath,".ep");
	if(!access(procpath,4))
		return(procpath);
	if(proctrace && (errno != ENOENT))
		pperror(procpath);

/*
 * try to find proc file in home .ecu subdirectory
 */
	get_home_dir(procpath);
	strcat(procpath,"/.ecu/");
	strcat(procpath,name);
	strcat(procpath,".ep");
	if(!access(procpath,4))
		return(procpath);
	if(proctrace && (errno != ENOENT))
		pperror(procpath);

/*
 * try to find proc file in library ep subdirectory
 */
	strcpy(procpath,ECULIBDIR);
	strcat(procpath,"/ep/");
	strcat(procpath,name);
	strcat(procpath,".ep");
	if(!access(procpath,4))
		return(procpath);
	if(proctrace && (errno != ENOENT) && (errno != ENOTDIR))
		pperror(procpath);

/*
 * no luck
 */
	return((char *)0);

}	/* end of find_procedure */

/*+-------------------------------------------------------------------------
	do_proc(argc,argv) - read in a disk-based procedure and execute it
--------------------------------------------------------------------------*/
do_proc(argc,argv)
int argc;
char **argv;
{
	register itmp;
	int itmp2;
	int erc;
	int iargv;
	char *pargv[MAX_PARGV];
	int ipargv = 0;
	char s256[256];
	char *procpath;
	FILE *fp;
	PCB *pcb = (PCB *)0;
	LCB *lcb = (LCB *)0;
	LCB *plcb;
	ushort line_count = 0;
	extern ulong colors_current;
	ulong colors_at_entry = colors_current;
	extern int proc_interrupt;

	proc_interrupt = 0;		/* ok to reset here because no one ... */
	sigint = 0;				/* ... would call here if interrupted */

	for(iargv = 0; iargv < argc; iargv++)
	{
		if(ipargv == MAX_PARGV)
		{
			pputs("\nMax arguments to procedure invocation exceeded\n");
			erc = eFATAL_ALREADY;
			goto RETURN;
		}
		pargv[ipargv++] = argv[iargv];
	}

	if(!ipargv)
	{
		pputs("\nno procedure name given\n");
		erc = eFATAL_ALREADY;
		goto RETURN;
	}

	if(!(procpath = find_procedure(pargv[0])))
	{
		pprintf("\nprocedure %s not found\n",pargv[0]);
		erc = eFATAL_ALREADY;
		goto RETURN;
	}
	fp = fopen(procpath,"r");
	if(!fp)
	{
		pperror(procpath);
		erc = eFATAL_ALREADY;
		goto RETURN;
	}
	if(proctrace)
		pprintf("DO: %s\n",procpath);

	if(!(pcb = (PCB *)calloc(1,sizeof(PCB))))
	{
		erc = eNoMemory;
		goto RETURN;
	}

	pcb->argv = pargv;
	pcb->argc = ipargv;

	plcb = (LCB *)0;
	line_count = 0;
	while(1)
	{
		if(fgets(s256,sizeof(s256),fp) == NULL)
			break;
		line_count++;

		itmp = strlen(s256) - 1;	/* skip blank lines */
		if(!itmp)
			continue;
		s256[itmp] = 0;				/* kill trailing NL */
		for(itmp2 = 0; itmp2 < itmp; itmp2++)
		{	/* convert tabs to spaces so we don't have to scan for each */
			if(s256[itmp2] == TAB)
				s256[itmp2] = SPACE;
		}
		if(s256[0] == '#')	 		/* skip comments */
			continue;

		if(!(lcb = (LCB *)malloc(sizeof(LCB))))
		{
			fclose(fp);
			erc = eNoMemory;
			goto RETURN;
		}

		lcb->prev = plcb;
		lcb->next = (LCB *)0;
		lcb->lineno = line_count;

		if(plcb)
			plcb->next = lcb;
		else
			pcb->first = lcb;

		if((lcb->text = esdalloc(itmp)) == (ESD *)0)
		{
			fclose(fp);
			erc = eNoMemory;
			goto RETURN;
		}
		strcpy(lcb->text->pb,s256);
		lcb->text->cb = itmp;
		esd_null_terminate(lcb->text);
		plcb = lcb;
	}
	fclose(fp);
	pcb->last = lcb;
	if(line_count)
		erc = execute_proc(pcb,0);
	else
		erc = eProcEmpty;

RETURN:
	if(pcb)
	{
		if(pcb->first)
			free_lcb_chain(pcb->first);
		free((char *)pcb);
	}
	if((erc > e_USER) && (erc <= 0x1FFF))
		erc -= e_USER;
	if(erc > e_USER)
		setcolor(colors_at_entry);
	return(erc);

}	/* end of do_proc */

/*+-------------------------------------------------------------------------
	pcmd_do(param)
--------------------------------------------------------------------------*/
pcmd_do(param)
ESD *param;
{
	int erc;
	register ipargv;
	char *cmd_copy;
	char *pargv[MAX_PARGV];
	ESD *pargv_esd[MAX_PARGV];
	int pargc = 0;

	if(!(cmd_copy = (char *)malloc(param->cb)))
		return(eNoMemory);
	strcpy(cmd_copy,param->pb + param->old_index);
	while(pargc != MAX_PARGV)
	{
		if(end_of_cmd(param))
			break;
		if((pargv_esd[pargc] = esdalloc(256)) == (ESD *)0)
		{
			erc = eNoMemory;
			goto RETURN;
		}
		if(erc = gstr(param,pargv_esd[pargc],1))
			goto RETURN;
		pargv[pargc] = pargv_esd[pargc]->pb;
		pargc++;
	}

	if(pargc < MAX_PARGV)
		erc = do_proc(pargc,pargv);
	else
	{
		pprintf("too many arguments to procedure\n");
		erc = eFATAL_ALREADY;
	}

RETURN:
	free(cmd_copy);
	for(ipargv = 0; ipargv < pargc; ipargv++)
		esdfree(pargv_esd[ipargv]);
	return(erc);

}	/* end of pcmd_do */

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