/* evaluate the value of the numeric literal constant in ES->TOK_BUF,
eval_err is set to a value other than ERR_NOERR if the constant cannot
be parsed and converted to an expression value */
static struct eval_value_t /* value of the literal constant */
constant(struct eval_state_t *es) /* expression evaluator */
{
struct eval_value_t val;
int int_val;
unsigned int uint_val;
double double_val;
char *endp;
#ifdef HOST_HAS_QWORD
sqword_t sqword_val;
qword_t qword_val;
#endif /* HOST_HAS_QWORD */
#if !defined(__CYGWIN32__)
extern int errno;
#endif
#if 0 /* no longer needed... */
#if defined(sparc) && !defined(__svr4__)
extern long strtol(char *, char **, int);
extern double strtod(char *, char **);
#endif /* sparc */
#endif
/*
* attempt multiple conversions, from least to most precise, using
* the value returned when the conversion is successful
*/
/* attempt integer conversion */
errno = 0;
int_val = strtol(es->tok_buf, &endp, /* parse base */0);
if (!errno && !*endp)
{
/* good conversion */
val.type = et_int;
val.value.as_int = int_val;
return val;
}
/* else, not an integer, attempt unsigned int conversion */
errno = 0;
uint_val = strtoul(es->tok_buf, &endp, /* parse base */0);
if (!errno && !*endp)
{
/* good conversion */
val.type = et_uint;
val.value.as_uint = uint_val;
return val;
}
#ifdef HOST_HAS_QWORD
/* else, not an int/uint, attempt sqword_t conversion */
errno = 0;
sqword_val = myatosq(es->tok_buf, &endp, /* parse base */0);
if (!errno && !*endp)
{
/* good conversion */
val.type = et_sqword;
val.value.as_sqword = sqword_val;
return val;
}
/* else, not an sqword_t, attempt qword_t conversion */
errno = 0;
qword_val = myatoq(es->tok_buf, &endp, /* parse base */0);
if (!errno && !*endp)
{
/* good conversion */
val.type = et_qword;
val.value.as_qword = qword_val;
return val;
}
#endif /* HOST_HAS_QWORD */
/* else, not any type of integer, attempt double conversion (NOTE: no
reliable float conversion is available on all machines) */
errno = 0;
double_val = strtod(es->tok_buf, &endp);
if (!errno && !*endp)
{
/* good conversion */
val.type = et_double;
val.value.as_double = double_val;
return val;
}
/* else, not a double value, therefore, could not convert constant,
declare an error */
eval_error = ERR_BADCONST;
return err_value;
}
/* read one EXO term from STREAM */
struct exo_term_t *
exo_read(FILE *stream)
{
int tok;
char tok_buf[1024], *endp;
struct exo_term_t *ent = NULL;
extern int errno;
extern void yy_setstream(FILE *);
/* make sure we have a valid stream */
if (!stream)
stream = stdin;
yy_setstream(stream);
/* make local copies of everything, allows arbitrary recursion */
tok = yylex();
strcpy(tok_buf, yytext);
switch (tok)
{
case lex_integer:
{
exo_integer_t int_val;
/* attempt integer conversion */
errno = 0;
#ifdef HOST_HAS_QUAD
int_val = myatoq(tok_buf, &endp, /* parse base */10);
#else /* !HOST_HAS_QUAD */
int_val = strtoul(tok_buf, &endp, /* parse base */10);
#endif /* HOST_HAS_QUAD */
if (!errno && !*endp)
{
/* good conversion */
ent = exo_new(ec_integer, int_val);
}
else
exo_err("cannot parse integer literal");
}
break;
case lex_address:
{
exo_address_t addr_val;
/* attempt address conversion */
errno = 0;
#ifdef HOST_HAS_QUAD
addr_val = myatoq(tok_buf, &endp, /* parse base */16);
#else /* !HOST_HAS_QUAD */
addr_val = strtoul(tok_buf, &endp, /* parse base */16);
#endif /* HOST_HAS_QUAD */
if (!errno && !*endp)
{
/* good conversion */
ent = exo_new(ec_address, addr_val);
}
else
exo_err("cannot parse address literal");
}
break;
case lex_float:
{
exo_float_t float_val;
/* attempt double conversion */
errno = 0;
float_val = strtod(tok_buf, &endp);
if (!errno && !*endp)
{
/* good conversion */
ent = exo_new(ec_float, float_val);
}
else
exo_err("cannot parse floating point literal");
}
break;
case lex_char:
{
int c;
c = intern_char(tok_buf, &endp);
if (!endp)
exo_err("cannot convert character literal");
ent = exo_new(ec_char, c);
}
break;
case lex_string:
{
char *s;
s = intern_string(tok_buf);
ent = exo_new(ec_string, s);
free(s);
}
break;
case lex_token:
ent = exo_new(ec_token, tok_buf);
break;
case lex_byte:
exo_err("unexpected blob byte encountered");
break;
case '(':
{
struct exo_term_t *elt;
ent = exo_new(ec_list, NULL);
if (yy_nextchar() != ')')
{
/* not an empty list */
do {
elt = exo_read(stream);
if (!elt)
exo_err("unexpected end-of-file");
ent->as_list.head =
exo_chain(ent->as_list.head, elt);
/* consume optional commas */
if (yy_nextchar() == ',')
yylex();
} while (yy_nextchar() != ')');
}
/* read tail delimiter */
tok = yylex();
if (tok != ')')
exo_err("expected ')'");
}
break;
case ')':
exo_err("unexpected ')' encountered");
break;
case '<':
exo_err("unexpected '<' encountered");
break;
case '>':
exo_err("unexpected '>' encountered");
break;
case '{':
{
int cnt, size;
struct exo_term_t *elt;
/* get the size */
elt = exo_read(stream);
if (!elt || elt->ec != ec_integer)
exo_err("badly formed array size");
/* record the size of the array/blob */
size = (int)elt->as_integer.val;
/* done with the EXO integer */
exo_delete(elt);
/* read the array delimiters */
tok = yylex();
if (tok != '}')
exo_err("expected '}'");
tok = yylex();
switch (tok)
{
case '[': /* array definition */
/* allocate an array definition */
ent = exo_new(ec_array, size, NULL);
/* read until array is full or tail delimiter encountered */
if (yy_nextchar() != ']')
{
/* not an empty array */
cnt = 0;
do {
if (cnt == ent->as_array.size)
exo_err("too many initializers for array");
/* NULL element? */
if (yy_nextchar() == ',')
{
elt = NULL;
}
else
{
elt = exo_read(stream);
if (!elt)
exo_err("unexpected end-of-file");
}
SET_EXO_ARR(ent, cnt, elt);
cnt++;
/* consume optional commas */
if (yy_nextchar() == ',')
yylex();
} while (yy_nextchar() != ']');
}
/* read tail delimiter */
tok = yylex();
if (tok != ']')
exo_err("expected ']'");
break;
case '<': /* blob definition */
/* allocate an array definition */
ent = exo_new(ec_blob, size, /* zero contents */NULL);
/* read until blob is full */
if (yy_nextchar() != '>')
{
unsigned int byte_val;
/* not an empty array */
cnt = 0;
for (;;) {
/* read next blob byte */
tok = yylex();
if (tok == lex_byte)
{
if (cnt == ent->as_blob.size)
exo_err("too many initializers for blob");
/* attempt hex conversion */
errno = 0;
byte_val = strtoul(yytext, &endp, /* parse base */16);
if (errno != 0 || *endp != '\0')
exo_err("cannot parse blob byte literal");
if (byte_val > 255)
panic("bogus byte value");
ent->as_blob.data[cnt] = byte_val;
cnt++;
}
else if (tok == '>')
break;
else
exo_err("unexpected character in blob");
}
}
#if 0 /* zero tail is OK... */
if (cnt != ent->as_blob.size)
exo_err("not enough initializers for blob");
#endif
break;
default:
exo_err("expected '[' or '<'");
}
}
break;
case '}':
exo_err("unexpected '}' encountered");
break;
case ',':
exo_err("unexpected ',' encountered");
break;
case '[':
{
int i, cnt;
struct exo_term_t *list, *elt, *next_elt;
/* compute the array size */
list = NULL;
if (yy_nextchar() == ']')
exo_err("unsized array has no initializers");
cnt = 0;
do {
/* NULL element? */
if (yy_nextchar() == ',')
{
elt = exo_new(ec_null);
}
else
{
elt = exo_read(stream);
if (!elt)
exo_err("unexpected end-of-file");
}
cnt++;
list = exo_chain(list, elt);
/* consume optional commas */
if (yy_nextchar() == ',')
yylex();
} while (yy_nextchar() != ']');
/* read tail delimiter */
tok = yylex();
if (tok != ']')
exo_err("expected ']'");
/* create the array */
assert(cnt > 0);
ent = exo_new(ec_array, cnt, NULL);
/* fill up the array */
for (i=0,elt=list; i<cnt; i++,elt=next_elt)
{
assert(elt != NULL);
next_elt = elt->next;
if (elt->ec == ec_null)
{
SET_EXO_ARR(ent, cnt, NULL);
exo_delete(ent);
}
else
{
SET_EXO_ARR(ent, cnt, elt);
elt->next = NULL;
}
}
}
break;
case ']':
exo_err("unexpected ']' encountered");
break;
case lex_eof:
/* nothing to read */
ent = NULL;
break;
default:
panic("bogus token");
}
return ent;
}
