shell.yacc

VXWORKS源代码

LOCAL void printSym (val, prefix, suffix)
    FAST int val;
    char *prefix;
    char *suffix;

    {
    void *    symVal;  /* symbol value      */
    SYMBOL_ID symId;   /* symbol identifier */
    char *    name;    /* symbol name       */
    char      demangled [MAX_SYS_SYM_LEN + 1];
    char *    nameToPrint;

    /* Only search for symbol value and print symbol name if value is not -1 */
    
        if ((val != -1) && 
	    (symFindSymbol (sysSymTbl, NULL, (void *)val, 
		   	    SYM_MASK_NONE, SYM_MASK_NONE, &symId) == OK) &&
	    (symNameGet (symId, &name) == OK) &&
	    (symValueGet (symId, &symVal) == OK) &&
	    (symVal != 0) && ((val - (int)symVal) < 0x1000))
	    {
	    printf (prefix);

	    nameToPrint = cplusDemangle(name, demangled, sizeof (demangled));

	    if (val == (int) symVal)
	        printf ("%s", nameToPrint);
	    else
	        printf ("%s + 0x%x", nameToPrint, val - (int) symVal);

	    printf (suffix);
	    }
    
    }
/*******************************************************************************
*
* newArgList - start a new argument list
*/

LOCAL VALUE newArgList ()
    {
    VALUE value;

    value.side	   = RHS;
    value.type	   = T_INT;
    value.value.rv = nArgs;

    return (value);
    }
/*******************************************************************************
*
* addArg - add an argument to an argument list
*/

LOCAL void addArg (pArgList, pNewArg)
    VALUE *pArgList;
    FAST VALUE *pNewArg;

    {
    VALUE val;
    int partA;
    int partB;
#if CPU_FAMILY==I960
    int nArgsSave;
#endif
#ifndef	_WRS_NO_TGT_SHELL_FP
    BOOL isfloat = pNewArg->type == T_FLOAT || pNewArg->type == T_DOUBLE;
#endif	/* _WRS_NO_TGT_SHELL_FP */
    SYMBOL_ID   symId;  /* symbol identifier           */
    SYM_TYPE    sType;  /* place to return symbol type */

#ifndef	_WRS_NO_TGT_SHELL_FP
    if (isfloat)
# if CPU_FAMILY!=I960
	nArgs++;	/* will need an extra arg slot */
# else /* CPU_FAMILY!=I960 */
	{
	nArgsSave = nArgs;
	if (spawnFlag)
	    {
	    if ((nArgs %2) == 0)
	  	nArgs++;
	    }
	else
	    {
	    nArgs += nArgs % 2;	/* conditionally borrow slot to double align */
	    nArgs++;		/* borrow second slot for double-word value  */
	    }
	}
# endif /* CPU_FAMILY!=I960 */
#endif	/* _WRS_NO_TGT_SHELL_FP */

    if (nArgs == MAX_SHELL_ARGS || 
        (nArgs - pArgList->value.rv) == MAX_FUNC_ARGS)
	{
#ifndef	_WRS_NO_TGT_SHELL_FP
	if (isfloat)
# if CPU_FAMILY!=I960
	    nArgs--;		/* return borrowed slot */
# else  /* CPU_FAMILY!=I960 */
	    nArgs = nArgsSave;	/* return borrowed slot(s) */
# endif /* CPU_FAMILY!=I960 */
#endif	/* _WRS_NO_TGT_SHELL_FP */
	printf ("too many arguments to functions.\n");
	SET_ERROR;
	}
    else
	{
	/* push arg value on top of arg stack */

	(void)getRv (pNewArg, &val);

#ifndef	_WRS_NO_TGT_SHELL_FP
	if (isfloat)
	    {
# if CPU_FAMILY==I960
	    if (spawnFlag == FALSE)
# endif /* CPU_FAMILY==I960 */
		nArgs--;	/* return borrowed slot */
	    
	    /* put float as integers on argStack */

	    doubleToInts (pNewArg->type == T_FLOAT ?
			  val.value.fp : val.value.dp,
			  &partA, &partB);

	    argStack[nArgs++] = partA;
	    argStack[nArgs++] = partB;
	    }
	else if (checkRv (&val))
#else	/* _WRS_NO_TGT_SHELL_FP */
	if (checkRv (&val))
#endif	/* _WRS_NO_TGT_SHELL_FP */
	    {
	    int rv;

	    switch (val.type)
		{
		case T_BYTE:
		    rv = val.value.byte;
		    break;

		case T_WORD:
		    rv = val.value.word;
		    break;

		case T_INT:
		    rv = val.value.rv;
		
		    /* 
		     * new symLib api - symbol name lengths are no
		     * longer limited 
		     */

		    if (symFindSymbol (sysSymTbl, NULL, (void *)rv, 
			   	       SYM_MASK_NONE, SYM_MASK_NONE, 
				       &symId) == OK)
		 	symTypeGet (symId, &sType);

		    if ((nArgs == 0) && (sType == (N_TEXT + N_EXT)))
			spawnFlag = TRUE;
		    break;

		default:
		    rv = 0;
		    printf ("addArg: bad type.\n");
		    SET_ERROR;
		}

	    argStack[nArgs++] = rv;
	    }
	}
    }
#ifndef	_WRS_NO_TGT_SHELL_FP
/*******************************************************************************
*
* doubleToInts - separate double into two integer parts
*/

LOCAL void doubleToInts (d, partA, partB)
    double d;
    int *partA;
    int *partB;

    {
    union 
	{
	struct
	    {
	    int a;
	    int b;
	    } part;
	double d;
	} val;

    val.d = d;

    *partA = val.part.a;
    *partB = val.part.b;
    }
#endif	/* _WRS_NO_TGT_SHELL_FP */
/*******************************************************************************
*
* funcCall - call a function
*/

LOCAL VALUE funcCall (pV, pArgList)
    VALUE *pV;
    VALUE *pArgList;

    {
    static int funcStatus;	/* status from function calls */
    int a [MAX_FUNC_ARGS];
    VALUE value;
    FAST int i;
    FAST int argNum;
    int oldInFd	 = ioGlobalStdGet (STD_IN);
    int oldOutFd = ioGlobalStdGet (STD_OUT);
    FUNCPTR pFunc = (pV->side == LHS) ? (FUNCPTR) (int)getLv (pV)
				      : (FUNCPTR) pV->value.rv;

#if ((CPU_FAMILY == ARM) && ARM_THUMB)
    pFunc = (FUNCPTR)((UINT32)pFunc | 1);	/* make it a Thumb call */
#endif

    /* get any specified args off stack, or pre-set all args to 0 */

    for (argNum = pArgList->value.rv, i = 0; i < MAX_FUNC_ARGS; argNum++, i++)
	{
	a [i] = (argNum < nArgs) ? argStack[argNum] : 0;
	}

    /* set standard in/out to redirection fds */

    if (redirInFd >= 0)
	ioGlobalStdSet (STD_IN, redirInFd);

    if (redirOutFd >= 0)
	ioGlobalStdSet (STD_OUT, redirOutFd);

    /* call function and save resulting status */

    errnoSet (funcStatus);

    value.side = RHS;
    value.type = pV->type;

    switch (pV->type)
	{
	case T_BYTE:
	case T_WORD:
	case T_INT:
	    {
	    /* NOTE: THE FOLLOWING ARRAY REFERENCES MUST AGREE WITH THE
	     *       MAX_FUNC_ARGS COUNT DEFINED ABOVE IN THIS FILE!
	     */
	    int rv = (* pFunc) (a[0], a[1], a[2], a[3], a[4], a[5], a[6],
				a[7], a[8], a[9], a[10], a[11]);

	    switch (pV->type)
		{
		case T_BYTE:
		    value.value.byte = (char) rv;
		    break;

		case T_WORD:
		    value.value.word = (short) rv;
		    break;

		case T_INT:
		    value.value.rv = rv;
		    break;
		default:
		    break;
		}

	    break;
	    }

#ifndef	_WRS_NO_TGT_SHELL_FP
	case T_FLOAT:
	    value.value.fp = (* (float (*)())pFunc) (a[0], a[1], a[2], a[3],
			a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11]);
	    break;

	case T_DOUBLE:
	    value.value.dp = (* (double (*)())pFunc) (a[0], a[1], a[2], a[3],
			a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11]);
	    break;
#endif	/* _WRS_NO_TGT_SHELL_FP */

	default:
	    printf ("funcCall: bad function type.\n");
	    SET_ERROR;
	}

    funcStatus = errnoGet ();

    /* restore original in/out fds */

    if (redirInFd >= 0)
	ioGlobalStdSet (STD_IN, oldInFd);

    if (redirOutFd >= 0)
	ioGlobalStdSet (STD_OUT, oldOutFd);

    /* arg stack back to previous level */

    nArgs = pArgList->value.rv;

    return (value);
    }
/*******************************************************************************
*
* checkLv - check that a value can be used as left value
*/

LOCAL BOOL checkLv (pValue)
    VALUE *pValue;

    {
    if (pValue->side != LHS)
	{
	printf ("invalid application of 'address of' operator.\n");
	SET_ERROR;
	return (FALSE);
	}

    return (TRUE);
    }
/*******************************************************************************
*
* checkRv - check that a value can be used as right value
*/

LOCAL BOOL checkRv (pValue)
    VALUE *pValue;

    {
    if (pValue->side == LHS)
	return (checkLv (pValue));

    return (TRUE);
    }
/*******************************************************************************
*
* getRv - get a value's right value 
*/

LOCAL VALUE *getRv (pValue, pRv)
    FAST VALUE *pValue;
    FAST VALUE *pRv;			/* where to put value */

    {
    if (pValue->side == RHS)
	*pRv = *pValue;
    else
	{
	pRv->side = RHS;
	pRv->type = pValue->type;

	switch (pValue->type)
	    {
	    case T_BYTE:
		pRv->value.byte = *(char *)pValue->value.lv;
		break;

	    case T_WORD:
		pRv->value.word = *(short *)pValue->value.lv;
		break;

	    case T_INT:
		pRv->value.rv = *pValue->value.lv;
		break;

#ifndef	_WRS_NO_TGT_SHELL_FP
	    case T_FLOAT:
		pRv->value.fp = *(float *)pValue->value.lv;
		break;

	    case T_DOUBLE:
		pRv->value.dp = *(double *)pValue->value.lv;
		break;
#endif	/* _WRS_NO_TGT_SHELL_FP */

	    default:
		printf ("getRv: invalid rhs.");
		SET_ERROR;
	    }
	}

    return (pRv);
    }
/*******************************************************************************
*
* getLv - get a value's left value (address)
*/

LOCAL int *getLv (pValue)
    VALUE *pValue;

    {
    return (checkLv (pValue) ? pValue->value.lv : 0);
    }
/*******************************************************************************
*
* setLv - set a lv
*/

LOCAL void setLv (pVal1, pVal2)
    FAST VALUE *pVal1;
    FAST VALUE *pVal2;

    {
    if (pVal2->side == LHS)
	{
	printf ("setLv: invalid lhs.\n");
	SET_ERROR;
	}

    if ((int)pVal2->type != (int)T_INT)
	{
	printf ("setLv: type conflict.\n");
	SET_ERROR;
	}

    pVal1->side     = LHS;
    pVal1->type     = pVal2->type;
    pVal1->value.lv = (int *)pVal2->value.rv;
    }
/*******************************************************************************
*
* setRv - set the rv
*/

LOCAL void setRv (pVal1, pVal2)
    FAST VALUE *pVal1;
    FAST VALUE *pVal2;

    {
    pVal1->side = RHS;
    pVal1->type = pVal2->type;

    switch (pVal2->type)
	{
	case T_BYTE:
	    pVal1->value.byte = (pVal2->side == LHS) ?
			    *(char *)pVal2->value.lv : pVal2->value.byte;
	case T_WORD:
	    pVal1->value.word = (pVal2->side == LHS) ?
			    *(short *)pVal2->value.lv : pVal2->value.word;

	case T_INT:
	    pVal1->value.rv = (pVal2->side == LHS) ?
			    *pVal2->value.lv : pVal2->value.rv;
	    break;

#ifndef	_WRS_NO_TGT_SHELL_FP
	case T_FLOAT:
	    pVal1->value.fp = (pVal2->side == LHS) ?
			    *(float *)pVal2->value.lv : pVal2->value.fp;
	    break;

	case T_DOUBLE:
	    pVal1->value.dp = (pVal2->side == LHS) ?
			    *(double *)pVal2->value.lv : pVal2->value.dp;
	    break;
#endif	/* _WRS_NO_TGT_SHELL_FP */

	default:
	    printf ("setRv: bad type.\n");
	    SET_ERROR;
	}
    }
/*******************************************************************************
*
* printLv - print left-hand side value
*
* "ssss + xxx = xxxx"
*/

LOCAL void printLv (pValue)
    VALUE *pValue;

    {
    FAST int *lv = getLv (pValue);

    printSym ((int) lv, "", " = ");

    printf ("0x%x", (UINT) lv);
    }
/*******************************************************************************
*
* printRv - print right-hand side value
*
* The format for integers is:
*
* "nnnn = xxxx = 'c' = ssss + nnn"
*                           ^ only if nn < LIMIT for some ssss
*                 ^ only if value is printable
*/

LOCAL void printRv (pValue)
    VALUE *pValue;

    {
    VALUE val;
    int rv;

    (void)getRv (pValue, &val);

    switch (pValue->type)
	{
	case T_BYTE:
	    rv = val.value.byte;
	    goto caseT_INT;

	case T_WORD:
	    rv = val.value.word;
	    goto caseT_INT;

	case T_INT:
	    rv = val.value.rv;
	    /* drop through */

	caseT_INT:
	    printf ("%d = 0x%x", rv, rv);
	    if (isascii (rv) && isprint (rv))
		printf (" = '%c'", rv);

	    printSym (rv, " = ", "");
	    break;

#ifndef	_WRS_NO_TGT_SHELL_FP
	case T_FLOAT:
	    printf ("%g", val.value.fp);
	    break;

	case T_DOUBLE:
	    printf ("%g", val.value.dp);
	    break;
#endif	/* _WRS_NO_TGT_SHELL_FP */

	default:
	    printf ("printRv: bad type.\n");
	    SET_ERROR;
	}