/* YACC grammar for Chill expressions, for GDB.
- Copyright (C) 1992 Free Software Foundation, Inc.
+ Copyright 1992, 1993 Free Software Foundation, Inc.
This file is part of GDB.
%token <voidval> FIXME_20
%token <voidval> FIXME_21
%token <voidval> FIXME_22
-%token <voidval> FIXME_23
%token <voidval> FIXME_24
%token <voidval> FIXME_25
%token <voidval> FIXME_26
%token <voidval> EMPTINESS_LITERAL
%token <sval> CHARACTER_STRING_LITERAL
%token <sval> BIT_STRING_LITERAL
+%token <tsym> TYPENAME
+%token <sval> FIELD_NAME
%token <voidval> '.'
%token <voidval> ';'
%token <voidval> SUCC
%token <voidval> ABS
%token <voidval> CARD
-%token <voidval> MAX
-%token <voidval> MIN
+%token <voidval> MAX_TOKEN
+%token <voidval> MIN_TOKEN
%token <voidval> SIZE
%token <voidval> UPPER
%token <voidval> LOWER
%type <voidval> lower_element
%type <voidval> upper_element
%type <voidval> first_element
-%type <voidval> structure_primitive_value
-%type <voidval> field_name
%type <voidval> mode_argument
%type <voidval> upper_lower_argument
%type <voidval> length_argument
-%type <voidval> mode_name
%type <voidval> array_mode_name
%type <voidval> string_mode_name
%type <voidval> variant_structure_mode_name
%type <voidval> subexpression
%type <voidval> case_label_specification
%type <voidval> buffer_location
-
%type <voidval> single_assignment_action
+%type <tsym> mode_name
%%
/* Z.200, 5.3.1 */
+start : value { }
+ | mode_name
+ { write_exp_elt_opcode(OP_TYPE);
+ write_exp_elt_type($1.type);
+ write_exp_elt_opcode(OP_TYPE);}
+ ;
+
value : expression
{
$$ = 0; /* FIXME */
/* Z.200, 4.2.1 */
location : access_name
+ | primitive_value POINTER
{
- $$ = 0; /* FIXME */
- }
- | FIXME_02
- {
- $$ = 0; /* FIXME */
+ write_exp_elt_opcode (UNOP_IND);
}
;
/* Z.200, 5.2.10 */
-value_structure_field: structure_primitive_value '.' field_name
- {
- $$ = 0; /* FIXME */
+value_structure_field: primitive_value FIELD_NAME
+ { write_exp_elt_opcode (STRUCTOP_STRUCT);
+ write_exp_string ($2);
+ write_exp_elt_opcode (STRUCTOP_STRUCT);
}
;
expression_conversion: mode_name parenthesised_expression
{
- $$ = 0; /* FIXME */
+ write_exp_elt_opcode (UNOP_CAST);
+ write_exp_elt_type ($1.type);
+ write_exp_elt_opcode (UNOP_CAST);
}
;
{
$$ = 0; /* FIXME */
}
+ | single_assignment_action
+ {
+ $$ = 0; /* FIXME */
+ }
| conditional_expression
{
$$ = 0; /* FIXME */
{
write_exp_elt_opcode (BINOP_BITWISE_XOR);
}
- | single_assignment_action
- {
- $$ = 0; /* FIXME */
- }
;
/* Z.200, 5.3.4 */
;
/* Z.200, 5.3.8 */
-/* Note that we accept any expression for BINOP_CONCAT, not just
- integer literal expressions. (FIXME?) */
operand_5 : operand_6
{
{
write_exp_elt_opcode (UNOP_LOGICAL_NOT);
}
- | parenthesised_expression operand_6
+ | parenthesised_expression literal
+/* We require the string operand to be a literal, to avoid some
+ nasty parsing ambiguities. */
{
write_exp_elt_opcode (BINOP_CONCAT);
}
operand_6 : POINTER location
{
- $$ = 0; /* FIXME */
+ write_exp_elt_opcode (UNOP_ADDR);
}
| RECEIVE buffer_location
{
{
$$ = 0; /* FIXME */
}
- | MAX '(' expression ')'
+ | MAX_TOKEN '(' expression ')'
{
$$ = 0; /* FIXME */
}
- | MIN '(' expression ')'
+ | MIN_TOKEN '(' expression ')'
{
$$ = 0; /* FIXME */
}
}
;
-upper_lower_argument : location
- {
- $$ = 0; /* FIXME */
- }
- | expression
+mode_name : TYPENAME
+ ;
+
+upper_lower_argument : expression
{
$$ = 0; /* FIXME */
}
}
;
-length_argument : location
- {
- $$ = 0; /* FIXME */
- }
- | expression
+length_argument : expression
{
$$ = 0; /* FIXME */
}
lower_element : FIXME_20 { $$ = 0; }
upper_element : FIXME_21 { $$ = 0; }
first_element : FIXME_22 { $$ = 0; }
-structure_primitive_value: FIXME_23 { $$ = 0; }
-field_name : FIXME_24 { $$ = 0; }
-mode_name : FIXME_25 { $$ = 0; }
boolean_expression : FIXME_26 { $$ = 0; }
case_selector_list : FIXME_27 { $$ = 0; }
subexpression : FIXME_28 { $$ = 0; }
if (isalpha (*tokptr))
{
+ char *result;
do {
tokptr++;
- } while (isalpha (*tokptr) || isdigit (*tokptr) || (*tokptr == '_'));
+ } while (isalnum (*tokptr) || (*tokptr == '_'));
yylval.sval.ptr = lexptr;
yylval.sval.length = tokptr - lexptr;
lexptr = tokptr;
- return (copy_name (yylval.sval));
+ result = copy_name (yylval.sval);
+ for (tokptr = result; *tokptr; tokptr++)
+ if (isupper (*tokptr))
+ *tokptr = tolower(*tokptr);
+ return result;
}
return (NULL);
}
int token;
};
-static const struct token tokentab6[] =
+static const struct token idtokentab[] =
{
- { "LENGTH", LENGTH }
-};
-
-static const struct token tokentab5[] =
-{
- { "LOWER", LOWER },
- { "UPPER", UPPER },
- { "ANDIF", ANDIF }
-};
-
-static const struct token tokentab4[] =
-{
- { "PRED", PRED },
- { "SUCC", SUCC },
- { "CARD", CARD },
- { "SIZE", SIZE },
- { "ORIF", ORIF }
-};
-
-static const struct token tokentab3[] =
-{
- { "NUM", NUM },
- { "ABS", ABS },
- { "MAX", MAX },
- { "MIN", MIN },
- { "MOD", MOD },
- { "REM", REM },
- { "NOT", NOT },
- { "XOR", LOGXOR },
- { "AND", LOGAND }
+ { "length", LENGTH },
+ { "lower", LOWER },
+ { "upper", UPPER },
+ { "andif", ANDIF },
+ { "pred", PRED },
+ { "succ", SUCC },
+ { "card", CARD },
+ { "size", SIZE },
+ { "orif", ORIF },
+ { "num", NUM },
+ { "abs", ABS },
+ { "max", MAX_TOKEN },
+ { "min", MIN_TOKEN },
+ { "mod", MOD },
+ { "rem", REM },
+ { "not", NOT },
+ { "xor", LOGXOR },
+ { "and", LOGAND },
+ { "in", IN },
+ { "or", LOGIOR }
};
static const struct token tokentab2[] =
{
{ ":=", GDB_ASSIGNMENT },
{ "//", SLASH_SLASH },
+ { "->", POINTER },
{ "/=", NOTEQUAL },
{ "<=", LEQ },
- { ">=", GTR },
- { "IN", IN },
- { "OR", LOGIOR }
+ { ">=", GTR }
};
/* Read one token, getting characters through lexptr. */
case ';':
case '!':
case '+':
- case '-':
case '*':
case '(':
case ')':
}
break;
}
- /* See if it is a special token of length 6. */
- for (i = 0; i < sizeof (tokentab6) / sizeof (tokentab6[0]); i++)
- {
- if (STREQN (lexptr, tokentab6[i].operator, 6))
- {
- lexptr += 6;
- return (tokentab6[i].token);
- }
- }
- /* See if it is a special token of length 5. */
- for (i = 0; i < sizeof (tokentab5) / sizeof (tokentab5[0]); i++)
- {
- if (STREQN (lexptr, tokentab5[i].operator, 5))
- {
- lexptr += 5;
- return (tokentab5[i].token);
- }
- }
- /* See if it is a special token of length 4. */
- for (i = 0; i < sizeof (tokentab4) / sizeof (tokentab4[0]); i++)
- {
- if (STREQN (lexptr, tokentab4[i].operator, 4))
- {
- lexptr += 4;
- return (tokentab4[i].token);
- }
- }
- /* See if it is a special token of length 3. */
- for (i = 0; i < sizeof (tokentab3) / sizeof (tokentab3[0]); i++)
- {
- if (STREQN (lexptr, tokentab3[i].operator, 3))
- {
- lexptr += 3;
- return (tokentab3[i].token);
- }
- }
/* See if it is a special token of length 2. */
for (i = 0; i < sizeof (tokentab2) / sizeof (tokentab2[0]); i++)
{
would already have found it. */
switch (*lexptr)
{
+ case '-':
case ':':
case '/':
case '<':
case '>':
return (*lexptr++);
}
- /* Look for other special tokens. */
- if (STREQN (lexptr, "TRUE", 4)) /* FIXME: What about lowercase? */
- {
- yylval.ulval = 1;
- lexptr += 4;
- return (BOOLEAN_LITERAL);
- }
- if (STREQN (lexptr, "FALSE", 5)) /* FIXME: What about lowercase? */
- {
- yylval.ulval = 0;
- lexptr += 5;
- return (BOOLEAN_LITERAL);
- }
/* Look for a float literal before looking for an integer literal, so
we match as much of the input stream as possible. */
token = match_float_literal ();
we can't classify what sort of name it is. */
simplename = match_simple_name_string ();
+
if (simplename != NULL)
{
+ /* See if it is a reserved identifier. */
+ for (i = 0; i < sizeof (idtokentab) / sizeof (idtokentab[0]); i++)
+ {
+ if (STREQ (simplename, idtokentab[i].operator))
+ {
+ return (idtokentab[i].token);
+ }
+ }
+
+ /* Look for other special tokens. */
+ if (STREQ (simplename, "true"))
+ {
+ yylval.ulval = 1;
+ return (BOOLEAN_LITERAL);
+ }
+ if (STREQ (simplename, "false"))
+ {
+ yylval.ulval = 0;
+ return (BOOLEAN_LITERAL);
+ }
+
sym = lookup_symbol (simplename, expression_context_block,
VAR_NAMESPACE, (int *) NULL,
(struct symtab **) NULL);
case LOC_LABEL:
return (LOCATION_NAME);
break;
- case LOC_UNDEF:
case LOC_TYPEDEF:
+ yylval.tsym.type = SYMBOL_TYPE (sym);
+ return TYPENAME;
+ case LOC_UNDEF:
case LOC_CONST_BYTES:
case LOC_OPTIMIZED_OUT:
error ("Symbol \"%s\" names no location.", simplename);
switch (*lexptr)
{
case '.': /* Not float for example. */
- return (*lexptr++);
+ lexptr++;
+ while (isspace (*lexptr)) lexptr++;
+ simplename = match_simple_name_string ();
+ if (!simplename)
+ return '.';
+ return FIELD_NAME;
}
return (ILLEGAL_TOKEN);
projects / deliverable / binutils-gdb.git / blobdiff