= eval(MULT)) > 15)
                                                                {
                                                                    evalerr = TRUE;
                                                                    markerr('E');
                                                                    break;
                                                                }
                                                                valu1 = valu1 >> valu2;
                                                                break;

                                                    case ')':   if (prec == LPREN) return valu1;
                                                                else
                                                                {
                                                                    evalerr = TRUE;
                                                                    markerr('(');
                                                                    break;
                                                                }
                                                }
                              }
                          }
        }
    }
}

/*
Function to get the precedence of a binary operator.
Function returns the precedence value.
*/

getprec(operator)
char operator;
{
	switch (operator)
	{
		case '*':
		case '/':
		case MOD:
		case SHL:
		case SHR:	return MULT;

		case '+':
		case '-':	return ADDIT;

		case '>':
		case '=':
		case '<':
		case GRTEQ:
		case NOTEQ:
		case LESEQ:	return RELAT;

		case AND:	return LOG1;

		case OR:
		case XOR:	return LOG2;

		case HIGH:
		case LOW:	return UOP3;

		case ')':	return RPREN;
	}
}

/*
Function to mark up an error in the line if one isn't
already marked up.  The error code letter comes in
through letter.
*/

markerr(letter)
char letter;
{
	if (errcode == ' ')
	{
		errcode = letter;
		errcount++;
	}
}
,NOSKIP),c1) != '\n' &&  c1 != c)
					if (++attrib <= 2) *tmpptr++ = c1;
				if (c1 == '\n' || attrib > 2)
				{
					if (c1 == '\n') backchr;
					evalerr = TRUE;
					markerr('"');
					return VALUE;
				}
				tmpptr = temp;
				for (*value = 0; attrib != 0; attrib--) *value = (*value << 8) + *tmpptr++;
				return VALUE;

		case ALPHA:	backchr;
				getname(temp);
				if (strcmp(temp,"$") == 0)
				{
					*value = pc;
					return VALUE;
				}
				if ((*value = chkoprat(temp) & 0xff) != NO_OPR) return OPERATR;
				strcat(temp,PADDING);
				if (slookup(temp) == 0)
				{
					*value = sympoint -> symvalu;
					if (sympoint -> symname[0] > 0x7f) directok = FALSE;
				}
				else
				{
					evalerr = TRUE;
					markerr('U');
				}
				return VALUE;
	}
}

/*
Function to get a symbol name, opcode, or label from the present source
line.  The name is returned (null terminated) in buffer.  Names are
terminated by any non-alphanumeric character.
*/

getname(buffer)
char *buffer;
{
	char c, d, count;
	count = 0;
	while ((c = getchr(&d,NOSKIP)) == ALPHA || c == NUMERIC)
		if (++count <= SYMLEN) *buffer++ = d;
	backchr;
	*buffer = '\0';
}

/*
Function to check a string against the list of operators that get spelled out.
This list consists of GE, GT, LE, LT, EQ, NE, AND, OR, XOR, NOT, MOD, SHL,
SHR, HIGH, LOW.  The function returns the token for the operator if the
string is an operator, the token NO_OPR otherwise.
*/

chkoprat(string)
char *string;
{
	char s, t, getopr();
	return (bsearch(string,&s,&t,0,numoprs(),getopr)) ? t : NO_OPR;
}

/*
Function to get an Intel format number from the present input line.
value points to the number to be returned, and base points to an
unsigned where the base of the number will be saved during internal
computations.  The function returns a fixed value of 1 and flags errors
as it goes along.
*/

getnum(number,base)
unsigned *number, *base;
{
	char c1, c2, toupper();
	unsigned b;
	if ((c1 = getchr(&c2,NOSKIP)) != ALPHA && c1 != NUMERIC)
	{
		backchr;
		return 0xffff;
	}
	if ((b = getnum(number,base)) == 0xffff)
	{
		*number = 0;
		switch (toupper(c2))
		{
			case 'H':	*base = 16;	return 1;
			case 'D':	*base = 10;	return 1;
			case 'O':
			case 'Q':	*base = 8;	return 1;
			case 'B':	*base = 2;	return 1;
			default:	*base = 10;	b = 1;
		}
	}
	*number += b * _aton(toupper(c2),*base);
	return b * *base;
}

/*
Internal function in getnum to convert a character to a digit.  The base
is passed so that this routine can check for digits larger than the base.
*/

_aton(letter,base)
char letter;
unsigned base;
{
	unsigned n;
	if (letter >= '0' && letter <= '9') n = letter - '0';
	else if (letter >= 'A' && letter <= 'F') n = letter - ('A' - 10);
	else
	{
		markerr('E');
		evalerr = TRUE;
		return 0;
	}
	if (n < base) return n;
	markerr('D');
	evalerr = TRUE;
	return 0;
}

/*
Function to get a character from the present source line.  The function
returns the attribute of the charac