getcmd.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

		&ueis,&udis,&usds,&ucds,&uads,&usis) != ES$SUCC)
        return(UE$ERR_S_OPEN);
    }
/***************** PROCESS "b" FLAG *****************************/

in_st.out_file = FALSE;

if (( tree = get_tree(UE$FLG_b)) != UE$NULL)
    {
    if (( parm = tree->parm_list) == UE$NULL)
        return(UE$ERR_INVPAR);
    (void)strcpy(pstring, parm->parm_string);
    if (parm->next_parm != UE$NULL)
	return(UE$ERR_INVPAR);
    if (es$open(NULL,ES$EVENT,ES$APPEND,pstring,
		UE$NULL,UE$NULL,UE$NULL,UE$NULL,UE$NULL) != ES$SUCC)
        return(UE$ERR_S_OPEN);
    in_st.out_file = TRUE;
    }

/***************** PROCESS "o" FLAG *****************************/

in_st.out_form = UE$OUT_BRIEF;		/* default = brief	*/
					/* go get "o" tree	*/
if (( tree = get_tree(UE$FLG_o)) != UE$NULL)
    {
    if (( parm = tree->parm_list) == UE$NULL)
	return(UE$ERR_INVPAR);
    if      ((strncmp(parm->parm_string,"ful",3)) == 0)
        in_st.out_form = UE$OUT_FULL;
    else if ((strncmp(parm->parm_string,"ter",3)) == 0)
        in_st.out_form = UE$OUT_TERSE;
    else if ((strncmp(parm->parm_string,"bri",3)) == 0)
        in_st.out_form = UE$OUT_BRIEF;
    else
	return(UE$ERR_INVPAR);
    if (parm->next_parm != UE$NULL)
	return(UE$ERR_INVPAR);
    }
/***************** PROCESS "Z" FLAG *****************************/

if (( tree = get_tree(UE$FLG_Z)) != UE$NULL)
    in_st.dump_rec = TRUE;
else
    in_st.dump_rec = FALSE;

/***************** PROCESS "S" FLAG *****************************/

if (( tree = get_tree(UE$FLG_S)) != UE$NULL)
    in_st.summary = TRUE;
else
    in_st.summary = FALSE;

/****************************************************************/
return(UE$SUCC);
}
/*...	ENDFUNCTION valid_tool					*/


/*
*	.SBTTL	valid_gen - Function to validate generic input.
*++
* FUNCTIONAL DESCRIPTION:		
*
*	-  Validates all input which is generic to all tools.
*	-  Builds a selection tree,
*	-  Calls erm_select who validates selection criteria and
*	   sets up for later selection.
*	-  Returns valid generic info or error code.
*
* FORMAL PARAMETERS:		
*
* IMPLICIT INPUTS:		none
*
* IMPLICIT OUTPUTS:		validated generic input
*
* COMPLETION STATUS:		UE$SUCC = successful
*				UE$FAIL = failure
*
* SIDE EFFECTS:			NONE
*
*--
*/

/**********************  NODE BUILDING MACRO *********************/

#define BLD_NODE(new_node,op,old_node) \
	if (old_node == UE$NULL) \
	    old_node = new_node; \
	else \
	    old_node = es$mkselectnode(op,new_node,old_node,UE$NULL);

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

/*...	FUNCTION valid_gen ()					*/
long  valid_gen ()
{
unsigned long   asctotime();
struct parse_tree *get_tree();
SELNODE *es$mkselectnode();
SELNODE *es$parse();
SELNODE *get_devtype();

SELNODE *sel_tree;		/* selection tree  	*/
SELNODE *flag_node;		/* node of option flag	*/
SELNODE *pars_node;		/* node from parse	*/
SELNODE *temp_node;		/* node for temp use	*/

struct parse_tree *tree;
struct parm_struc *parm;
char   pstring[UE$XFF];
char   tstring[UE$XFF];
long   stat;
long   status;
long   pcode;
unsigned long   datetime;
short  i;
short  j;
short  len;

sel_tree = UE$NULL;

/*  OR ********* PROCESS "c" FLAG *******************************/

if ((tree = get_tree(UE$FLG_c)) != UE$NULL)
    {
    flag_node = UE$NULL;
    if ((parm = tree->parm_list) != UE$NULL)
	{
	do
	    {
	    if      ((strncmp((parm->parm_string),"err",3)) == 0)
		pcode = ec$error;
	    else if ((strncmp((parm->parm_string),"ope",3)) == 0)
		pcode = ec$operator;
	    else if ((strncmp((parm->parm_string),"mai",3)) == 0)
		pcode = ec$maintenance;
	    else
		return(UE$ERR_INVPAR);
            pars_node = es$parse(&status,DD$eventclass,"eq %d", pcode);
	    if (status != ES$SUCC)
		return(UE$ERR_INVPAR);
	    BLD_NODE (pars_node,ES$OR,flag_node);
	    }
        while ((parm = parm->next_parm) != UE$NULL);
	BLD_NODE (flag_node,ES$OR,sel_tree);
	}
    else
	return(UE$ERR_INVPAR);
    }

/*  OR ********* PROCESS "T" FLAG *******************************/

if ((tree = get_tree(UE$FLG_T)) != UE$NULL)
    {
    flag_node = UE$NULL;
    if ((parm = tree->parm_list) != UE$NULL)
	{
	do
	    {
	    pars_node = get_devtype(parm->parm_string,&status);
	    if (status != UE$SUCC)
		return(UE$ERR_INVPAR);
	    BLD_NODE (pars_node,ES$OR,flag_node);
	    }
        while ((parm = parm->next_parm) != UE$NULL);
	}
    pars_node = es$parse(&status, DD$devclass, "eq %d, %d, %d,%d",
                dc$dstape,dc$mbtape,dc$ubtape,dc$sctape);
    if (status != ES$SUCC)		/* status from es$parse	*/
	return(UE$ERR_INVPAR);
    BLD_NODE (pars_node,ES$AND,flag_node);
    BLD_NODE (flag_node,ES$OR,sel_tree);
    }

/*  OR ********* PROCESS "D" FLAG *******************************/

if ((tree = get_tree(UE$FLG_D)) != UE$NULL)
    {
    flag_node = UE$NULL;
    if ((parm = tree->parm_list) != UE$NULL)
	{
	do
	    {
	    pars_node = get_devtype(parm->parm_string,&status);
	    if (status != UE$SUCC)
		return(UE$ERR_INVPAR);
	    BLD_NODE (pars_node,ES$OR,flag_node);
	    }
        while ((parm = parm->next_parm) != UE$NULL);
	}
    pars_node = es$parse(&status, DD$devclass, "eq %d, %d, %d, %d",
                dc$scdisk,dc$dsdisk,dc$mbdisk,dc$ubdisk);
    if (status != ES$SUCC)		/* status from es$parse	*/
	return(UE$ERR_INVPAR);
    BLD_NODE (pars_node,ES$AND,flag_node);
    BLD_NODE (flag_node,ES$OR,sel_tree);
    }

/*  OR *************** PROCESS "u" FLAG *************************/

if ((tree = get_tree(UE$FLG_u)) != UE$NULL)
    {
    if ((parm = tree->parm_list) != UE$NULL)
        {
        flag_node = UE$NULL;
	do
	    {
            strcpy(tstring,parm->parm_string);
            temp_node = UE$NULL;
            i = 0;
            while (tstring[i] != '\0')
                {
                (void)strcpy(pstring,"eq ");
                j = 3;
                while (isalpha(tstring[i]) != 0)
                    pstring[j++] = tstring[i++];
                pstring[j] = '\0';
                pars_node = es$parse(&status, DD$sum_dev_pre, pstring);
                if (status != ES$SUCC)	/* status from es$parse */
                    return(UE$ERR_INVPAR);
                BLD_NODE (pars_node,ES$AND,temp_node);

                (void)strcpy(pstring,"eq ");
                j = 3;
                while (isdigit(tstring[i]) != 0)
                    pstring[j++] = tstring[i++];
                pstring[j] = '\0';
                pars_node = es$parse(&status, DD$sum_unum, pstring);
                if (status != ES$SUCC)	/* status from es$parse */
                    return(UE$ERR_INVPAR);
                BLD_NODE (pars_node,ES$AND,temp_node);
                BLD_NODE (temp_node,ES$OR,flag_node);
                }
	    }
        while ((parm = parm->next_parm) != UE$NULL);
        BLD_NODE (flag_node,ES$OR,sel_tree);
	}
    else
	return(UE$ERR_INVPAR);
    }

/*  OR ********* PROCESS "A" FLAG *******************************/

if ((tree = get_tree(UE$FLG_A)) != UE$NULL)
    {
    flag_node = UE$NULL;
    if ((parm = tree->parm_list) != UE$NULL)
	{
	do
	    {
	    pars_node = get_devtype(parm->parm_string,&status);
	    if (status != UE$SUCC)
		return(UE$ERR_INVPAR);
	    BLD_NODE (pars_node,ES$OR,flag_node);
	    }
        while ((parm = parm->next_parm) != UE$NULL);
	}
    pars_node = es$parse(&status, DD$devclass, "eq %d",dc$adapter);
    if (status != ES$SUCC)		/* status from es$parse	*/
	return(UE$ERR_INVPAR);
    BLD_NODE (pars_node,ES$AND,flag_node);
    BLD_NODE (flag_node,ES$OR,sel_tree);
    }

/*  OR ********* PROCESS "M" FLAG *******************************/

if ((tree = get_tree(UE$FLG_M)) != UE$NULL)
    {
    flag_node = UE$NULL;
    if ((parm = tree->parm_list) != UE$NULL)
	{
	do
	    {
	    if      ((strncmp((parm->parm_string),"cpu",3)) == 0)
		pcode = dc$cpu;
	    else if ((strncmp((parm->parm_string),"mem",3)) == 0)
		pcode = dc$memory;
	    else
		return(UE$ERR_INVPAR);
	    pars_node = es$parse(&status, DD$devclass, "eq %d",pcode);
	    if (status != ES$SUCC)
		return(UE$ERR_INVPAR);
	    BLD_NODE (pars_node,ES$OR,flag_node);
	    }
        while ((parm = parm->next_parm) != UE$NULL);
	}
    else
	{
	pars_node = es$parse(&status, DD$devclass, 
                    "eq %d, %d",dc$cpu, dc$memory);
	if (status != ES$SUCC)
	    return(UE$ERR_INVPAR);
	BLD_NODE (pars_node,ES$OR,flag_node);
	}
    BLD_NODE (flag_node,ES$OR,sel_tree);
    }

/*************** PROCESS "O" FLAG *******************************/

if ((tree = get_tree(UE$FLG_O)) != UE$NULL)
    {
    flag_node = UE$NULL;
    if ((parm = tree->parm_list) != UE$NULL)
	{
	do
	    {
	    if      ((strncmp((parm->parm_string),"aef",3)) == 0)
		pcode = atflt;
	    else if ((strncmp((parm->parm_string),"ast",3)) == 0)
		pcode = astflt;
	    else if ((strncmp((parm->parm_string),"bpt",3)) == 0)
		pcode = bpt;
	    else if ((strncmp((parm->parm_string),"cmp",3)) == 0)
		pcode = cmpflt;
	    else if ((strncmp((parm->parm_string),"pag",3)) == 0)
		pcode = pgflt;
	    else if ((strncmp((parm->parm_string),"pif",3)) == 0)
		pcode = pif;
	    else if ((strncmp((parm->parm_string),"pro",3)) == 0)
		pcode = protect;
	    else if ((strncmp((parm->parm_string),"ptf",3)) == 0)
		pcode = pgtflt;
	    else if ((strncmp((parm->parm_string),"raf",3)) == 0)
		pcode = raf;
	    else if ((strncmp((parm->parm_string),"rof",3)) == 0)
		pcode = rof;
	    else if ((strncmp((parm->parm_string),"scf",3)) == 0)
		pcode = syscall;
	    else if ((strncmp((parm->parm_string),"seg",3)) == 0)
		pcode = segflt;
	    else if ((strncmp((parm->parm_string),"tra",3)) == 0)
		pcode = trace;
	    else if ((strncmp((parm->parm_string),"xfc",3)) == 0)
		pcode = xfc;
	    else
		return(UE$ERR_INVPAR);
	    pars_node = es$parse(&status, DD$coarsesyndrome, "eq %d",pcode);
	    if (status != ES$SUCC)
		return(UE$ERR_INVPAR);
	    BLD_NODE (pars_node,ES$OR,flag_node);
	    }
        while ((parm = parm->next_parm) != UE$NULL);
	}
    else
	{
	pars_node = es$parse(&status, DD$eventtype, "eq 109,200");
	if (status != ES$SUCC)
	    return(UE$ERR_INVPAR);
	BLD_NODE (pars_node,ES$OR,flag_node);
	}
    BLD_NODE (flag_node,ES$OR,sel_tree);
    }

/*  OR ********* PROCESS "s" FLAG *******************************/

if ((tree = get_tree(UE$FLG_s)) != UE$NULL)
    {
    if (get_tree(UE$FLG_r) != UE$NULL)
	return(UE$ERR_INCPAR);
    if (get_tree(UE$FLG_c) != UE$NULL)
	return(UE$ERR_INCPAR);
    (void)strcpy(pstring,"eq    ");
    flag_node = UE$NULL;
    if ((parm = tree->parm_list) != UE$NULL)
        {
	do
	    {
            (void)strcat(pstring,parm->parm_string);
            i = strcspn(pstring,"-");
            if ((i == 0) || (i == strlen(pstring)-1))
	        return(UE$ERR_INVPAR);
            if (i != strlen(pstring))
	        {
	        strncpy(pstring+i,",",1);
	        strncpy(pstring,"range",5);
	        }
            pars_node = es$parse(&status, DD$recordnumber, pstring);
            if (status != ES$SUCC)	/* status from es$parse */
	        return(UE$ERR_INVPAR);
	    BLD_NODE (pars_node,ES$OR,flag_node);
	    (void)strcpy(pstring,"eq   ");
	    }
        while ((parm = parm->next_parm) != UE$NULL);
        BLD_NODE (flag_node,ES$OR,sel_tree);
	}
    else
	return(UE$ERR_INVPAR);
    }

/*  OR ********* PROCESS "r" FLAG *******************************/

if ((tree = get_tree(UE$FLG_r)) != UE$NULL)
    {
    if (get_tree(UE$FLG_s) != UE$NULL)
	return(UE$ERR_INCPAR);
    if (get_tree(UE$FLG_c) != UE$NULL)
	return(UE$ERR_INCPAR);
    (void)strcpy(pstring,"eq    ");
    flag_node = UE$NULL;
    if ((parm = tree->parm_list) != UE$NULL)
        {
	do
	    {
            (void)strcat(pstring,parm->parm_string);
            i = strcspn(pstring,"-");
            if ((i == 0) || (i == strlen(pstring)-1))
	        return(UE$ERR_INVPAR);
            if (i != strlen(pstring))
	        {
	        strncpy(pstring+i,",",1);
	        strncpy(pstring,"range",5);
	        }
            pars_node = es$parse(&status, DD$eventtype, pstring);
            if (status != ES$SUCC)	/* status from es$parse */
	        return(UE$ERR_INVPAR);
	    BLD_NODE (pars_node,ES$OR,flag_node);
	    (void)strcpy(pstring,"eq   ");
	    }
        while ((parm = parm->next_parm) != UE$NULL);
        BLD_NODE (flag_node,ES$OR,sel_tree);
	}
    else
	return(UE$ERR_INVPAR);
    }

/* NOT ********* PROCESS "x" FLAG *******************************/

if ((tree = get_tree(UE$FLG_x)) != UE$NULL)
    {
    if (tree->parm_list != UE$NULL)
	return(UE$ERR_INVPAR);
    if (sel_tree != UE$NULL)
        sel_tree = es$mkselectnode(ES$NOT,sel_tree,UE$NULL,UE$NULL);
    }

/* AND ********* PROCESS "H" FLAG *******************************/

if ((tree = get_tree(UE$FLG_H)) != UE$NULL)
    {
    flag_node = UE$NULL;
    if ((parm = tree->parm_list) != UE$NULL)
        {
	do
	    {
            (void)strcpy(pstring,"eq ");
            (void)strcat(pstring,parm->parm_string);
            pars_node = es$parse(&status, DD$hostname, pstring);
            if (status != ES$SUCC)
	        return(UE$ERR_INVPAR);
	    BLD_NODE (pars_node,ES$OR,flag_node);
	    }
        while ((parm = parm->next_parm) != UE$NULL);
        BLD_NODE (flag_node,ES$AND,sel_tree);
	}
    else
	return(UE$ERR_INVPAR);
    }

/*************** PROCESS "t" FLAG *******************************/

if ((tree = get_tree(UE$FLG_t)) != UE$NULL)
    {
    flag_node = UE$NULL;
    if ((parm = tree->parm_list) != UE$NULL)
	{
        do
	    {
	    (void)strcpy(pstring,parm->parm_string);

				/* check for date,time combo */

	    if ((parm->next_parm != UE$NULL) &&