You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* Parse a Chill expression from text in a string,
and return the result as a struct expression pointer.
#define yylloc chill_lloc
#define yyreds chill_reds /* With YYDEBUG defined */
#define yytoks chill_toks /* With YYDEBUG defined */
+#define yylhs chill_yylhs
+#define yylen chill_yylen
+#define yydefred chill_yydefred
+#define yydgoto chill_yydgoto
+#define yysindex chill_yysindex
+#define yyrindex chill_yyrindex
+#define yygindex chill_yygindex
+#define yytable chill_yytable
+#define yycheck chill_yycheck
#ifndef YYDEBUG
#define YYDEBUG 0 /* Default to no yydebug support */
#endif
+static void
+write_lower_upper_value PARAMS ((enum exp_opcode, struct type *type));
+
int
yyparse PARAMS ((void));
int *ivec;
}
-%token <voidval> FIXME_01
-%token <voidval> FIXME_02
-%token <voidval> FIXME_03
-%token <voidval> FIXME_04
-%token <voidval> FIXME_05
-%token <voidval> FIXME_06
-%token <voidval> FIXME_07
-%token <voidval> FIXME_08
-%token <voidval> FIXME_09
-%token <voidval> FIXME_10
-%token <voidval> FIXME_11
-%token <voidval> FIXME_12
-%token <voidval> FIXME_13
-%token <voidval> FIXME_14
-%token <voidval> FIXME_15
-%token <voidval> FIXME_16
-%token <voidval> FIXME_17
-%token <voidval> FIXME_18
-%token <voidval> FIXME_19
-%token <voidval> FIXME_20
-%token <voidval> FIXME_21
-%token <voidval> FIXME_22
-%token <voidval> FIXME_24
-%token <voidval> FIXME_25
-%token <voidval> FIXME_26
-%token <voidval> FIXME_27
-%token <voidval> FIXME_28
-%token <voidval> FIXME_29
-%token <voidval> FIXME_30
-
%token <typed_val> INTEGER_LITERAL
%token <ulval> BOOLEAN_LITERAL
%token <typed_val> CHARACTER_LITERAL
%token <dval> FLOAT_LITERAL
%token <ssym> GENERAL_PROCEDURE_NAME
%token <ssym> LOCATION_NAME
-%token <voidval> SET_LITERAL
%token <voidval> EMPTINESS_LITERAL
%token <sval> CHARACTER_STRING_LITERAL
%token <sval> BIT_STRING_LITERAL
%token <voidval> CARD
%token <voidval> MAX_TOKEN
%token <voidval> MIN_TOKEN
+%token <voidval> ADDR_TOKEN
%token <voidval> SIZE
%token <voidval> UPPER
%token <voidval> LOWER
%token <voidval> LENGTH
+%token <voidval> ARRAY
/* Tokens which are not Chill tokens used in expressions, but rather GDB
specific things that we recognize in the same context as Chill tokens
(register names for example). */
-%token <lval> GDB_REGNAME /* Machine register name */
-%token <lval> GDB_LAST /* Value history */
-%token <ivar> GDB_VARIABLE /* Convenience variable */
+%token <voidval> GDB_VARIABLE /* Convenience variable */
%token <voidval> GDB_ASSIGNMENT /* Assign value to somewhere */
-%type <voidval> location
%type <voidval> access_name
%type <voidval> primitive_value
-%type <voidval> location_contents
%type <voidval> value_name
%type <voidval> literal
%type <voidval> tuple
-%type <voidval> value_string_element
-%type <voidval> value_string_slice
-%type <voidval> value_array_element
-%type <voidval> value_array_slice
-%type <voidval> value_structure_field
+%type <voidval> slice
%type <voidval> expression_conversion
-%type <voidval> value_procedure_call
%type <voidval> value_built_in_routine_call
-%type <voidval> chill_value_built_in_routine_call
-%type <voidval> start_expression
-%type <voidval> zero_adic_operator
%type <voidval> parenthesised_expression
%type <voidval> value
-%type <voidval> undefined_value
%type <voidval> expression
%type <voidval> conditional_expression
%type <voidval> then_alternative
%type <voidval> else_alternative
-%type <voidval> sub_expression
-%type <voidval> value_case_alternative
%type <voidval> operand_0
%type <voidval> operand_1
%type <voidval> operand_2
%type <voidval> operand_4
%type <voidval> operand_5
%type <voidval> operand_6
-%type <voidval> synonym_name
-%type <voidval> value_enumeration_name
-%type <voidval> value_do_with_name
-%type <voidval> value_receive_name
-%type <voidval> string_primitive_value
-%type <voidval> start_element
-%type <voidval> left_element
-%type <voidval> right_element
-%type <voidval> slice_size
-%type <voidval> array_primitive_value
%type <voidval> expression_list
-%type <voidval> lower_element
-%type <voidval> upper_element
-%type <voidval> first_element
%type <tval> mode_argument
-%type <voidval> upper_lower_argument
-%type <voidval> length_argument
+%type <voidval> single_assignment_action
+%type <tsym> mode_name
+%type <lval> rparen
+
+/* Not implemented:
+%type <voidval> undefined_value
%type <voidval> array_mode_name
%type <voidval> string_mode_name
%type <voidval> variant_structure_mode_name
-%type <voidval> boolean_expression
-%type <voidval> case_selector_list
-%type <voidval> subexpression
-%type <voidval> case_label_specification
-%type <voidval> buffer_location
-%type <voidval> single_assignment_action
-%type <tsym> mode_name
+*/
%%
;
value : expression
- {
- $$ = 0; /* FIXME */
- }
+/*
| undefined_value
- {
- $$ = 0; /* FIXME */
- }
- ;
-
-undefined_value : FIXME_01
- {
- $$ = 0; /* FIXME */
- }
- ;
-
-/* Z.200, 4.2.1 */
-
-location : access_name
- | primitive_value POINTER
- {
- write_exp_elt_opcode (UNOP_IND);
- }
+ { ??? }
+*/
;
/* Z.200, 4.2.2 */
write_exp_elt_sym ($1.sym);
write_exp_elt_opcode (OP_VAR_VALUE);
}
- | GDB_LAST /* gdb specific */
- {
- write_exp_elt_opcode (OP_LAST);
- write_exp_elt_longcst ($1);
- write_exp_elt_opcode (OP_LAST);
- }
- | GDB_REGNAME /* gdb specific */
- {
- write_exp_elt_opcode (OP_REGISTER);
- write_exp_elt_longcst ($1);
- write_exp_elt_opcode (OP_REGISTER);
- }
| GDB_VARIABLE /* gdb specific */
- {
- write_exp_elt_opcode (OP_INTERNALVAR);
- write_exp_elt_intern ($1);
- write_exp_elt_opcode (OP_INTERNALVAR);
- }
- | FIXME_03
- {
- $$ = 0; /* FIXME */
- }
;
/* Z.200, 4.2.8 */
{
arglist_len++;
}
+ ;
-/* Z.200, 5.2.1 */
-
-primitive_value : location_contents
- {
- $$ = 0; /* FIXME */
- }
- | value_name
+maybe_expression_list: /* EMPTY */
{
- $$ = 0; /* FIXME */
+ arglist_len = 0;
}
- | literal
- {
- $$ = 0; /* FIXME */
- }
- | tuple
- {
- $$ = 0; /* FIXME */
- }
- | value_string_element
- {
- $$ = 0; /* FIXME */
- }
- | value_string_slice
+ | expression_list
+ ;
+
+
+/* Z.200, 5.2.1 */
+
+primitive_value_lparen: primitive_value '('
+ /* This is to save the value of arglist_len
+ being accumulated for each dimension. */
+ { start_arglist (); }
+ ;
+
+rparen : ')'
+ { $$ = end_arglist (); }
+ ;
+
+primitive_value :
+ access_name
+ | primitive_value_lparen maybe_expression_list rparen
{
- $$ = 0; /* FIXME */
+ write_exp_elt_opcode (MULTI_SUBSCRIPT);
+ write_exp_elt_longcst ($3);
+ write_exp_elt_opcode (MULTI_SUBSCRIPT);
}
- | value_array_element
- {
- $$ = 0; /* FIXME */
+ | primitive_value FIELD_NAME
+ { write_exp_elt_opcode (STRUCTOP_STRUCT);
+ write_exp_string ($2);
+ write_exp_elt_opcode (STRUCTOP_STRUCT);
}
- | value_array_slice
+ | primitive_value POINTER
{
- $$ = 0; /* FIXME */
+ write_exp_elt_opcode (UNOP_IND);
}
- | value_structure_field
+ | primitive_value POINTER mode_name
{
- $$ = 0; /* FIXME */
+ write_exp_elt_opcode (UNOP_CAST);
+ write_exp_elt_type (lookup_pointer_type ($3.type));
+ write_exp_elt_opcode (UNOP_CAST);
+ write_exp_elt_opcode (UNOP_IND);
}
+ | value_name
+ | literal
+ | tuple
+ | slice
| expression_conversion
- {
- $$ = 0; /* FIXME */
- }
- | value_procedure_call
- {
- $$ = 0; /* FIXME */
- }
| value_built_in_routine_call
- {
- $$ = 0; /* FIXME */
- }
+/*
| start_expression
- {
- $$ = 0; /* FIXME */
- }
+ { ??? }
| zero_adic_operator
- {
- $$ = 0; /* FIXME */
- }
+ { ??? }
+*/
| parenthesised_expression
- {
- $$ = 0; /* FIXME */
- }
- ;
-
-/* Z.200, 5.2.2 */
-
-location_contents: location
- {
- $$ = 0; /* FIXME */
- }
;
/* Z.200, 5.2.3 */
-value_name : synonym_name
- {
- $$ = 0; /* FIXME */
- }
- | value_enumeration_name
- {
- $$ = 0; /* FIXME */
- }
- | value_do_with_name
- {
- $$ = 0; /* FIXME */
- }
- | value_receive_name
- {
- $$ = 0; /* FIXME */
- }
- | GENERAL_PROCEDURE_NAME
+value_name : GENERAL_PROCEDURE_NAME
{
write_exp_elt_opcode (OP_VAR_VALUE);
write_exp_elt_block (NULL);
write_exp_elt_dblcst ($1);
write_exp_elt_opcode (OP_DOUBLE);
}
- | SET_LITERAL
- {
- $$ = 0; /* FIXME */
- }
| EMPTINESS_LITERAL
{
- $$ = 0; /* FIXME */
+ struct type *void_ptr_type
+ = lookup_pointer_type (builtin_type_void);
+ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_type (void_ptr_type);
+ write_exp_elt_longcst (0);
+ write_exp_elt_opcode (OP_LONG);
}
| CHARACTER_STRING_LITERAL
{
/* Z.200, 5.2.5 */
-tuple : FIXME_04
- {
- $$ = 0; /* FIXME */
- }
+tuple_element : expression
+ | named_record_element
;
-
-/* Z.200, 5.2.6 */
-
-value_string_element: string_primitive_value '(' start_element ')'
- {
- $$ = 0; /* FIXME */
+named_record_element: FIELD_NAME ',' named_record_element
+ { write_exp_elt_opcode (OP_LABELED);
+ write_exp_string ($1);
+ write_exp_elt_opcode (OP_LABELED);
+ }
+ | FIELD_NAME ':' expression
+ { write_exp_elt_opcode (OP_LABELED);
+ write_exp_string ($1);
+ write_exp_elt_opcode (OP_LABELED);
}
;
-/* Z.200, 5.2.7 */
-
-value_string_slice: string_primitive_value '(' left_element ':' right_element ')'
+tuple_elements : tuple_element
{
- $$ = 0; /* FIXME */
+ arglist_len = 1;
}
- | string_primitive_value '(' start_element UP slice_size ')'
+ | tuple_elements ',' tuple_element
{
- $$ = 0; /* FIXME */
+ arglist_len++;
}
;
-/* Z.200, 5.2.8 */
-
-value_array_element: array_primitive_value '('
- /* This is to save the value of arglist_len
- being accumulated for each dimension. */
- { start_arglist (); }
- expression_list ')'
- {
- write_exp_elt_opcode (MULTI_SUBSCRIPT);
- write_exp_elt_longcst ((LONGEST) end_arglist ());
- write_exp_elt_opcode (MULTI_SUBSCRIPT);
- }
+maybe_tuple_elements : tuple_elements
+ | /* EMPTY */
;
-/* Z.200, 5.2.9 */
-
-value_array_slice: array_primitive_value '(' lower_element ':' upper_element ')'
+tuple : '['
+ { start_arglist (); }
+ maybe_tuple_elements ']'
{
- $$ = 0; /* FIXME */
+ write_exp_elt_opcode (OP_ARRAY);
+ write_exp_elt_longcst ((LONGEST) 0);
+ write_exp_elt_longcst ((LONGEST) end_arglist () - 1);
+ write_exp_elt_opcode (OP_ARRAY);
}
- | array_primitive_value '(' first_element UP slice_size ')'
+ |
+ mode_name '['
+ { start_arglist (); }
+ maybe_tuple_elements ']'
{
- $$ = 0; /* FIXME */
- }
- ;
-
-/* Z.200, 5.2.10 */
-
-value_structure_field: primitive_value FIELD_NAME
- { write_exp_elt_opcode (STRUCTOP_STRUCT);
- write_exp_string ($2);
- write_exp_elt_opcode (STRUCTOP_STRUCT);
- }
- ;
+ write_exp_elt_opcode (OP_ARRAY);
+ write_exp_elt_longcst ((LONGEST) 0);
+ write_exp_elt_longcst ((LONGEST) end_arglist () - 1);
+ write_exp_elt_opcode (OP_ARRAY);
-/* Z.200, 5.2.11 */
-
-expression_conversion: mode_name parenthesised_expression
- {
write_exp_elt_opcode (UNOP_CAST);
write_exp_elt_type ($1.type);
write_exp_elt_opcode (UNOP_CAST);
}
;
-/* Z.200, 5.2.12 */
-value_procedure_call: FIXME_05
- {
- $$ = 0; /* FIXME */
- }
- ;
+/* Z.200, 5.2.6 */
-/* Z.200, 5.2.13 */
-value_built_in_routine_call: chill_value_built_in_routine_call
+slice: primitive_value_lparen expression ':' expression rparen
{
- $$ = 0; /* FIXME */
+ write_exp_elt_opcode (TERNOP_SLICE);
}
- ;
-
-/* Z.200, 5.2.14 */
-
-start_expression: FIXME_06
+ | primitive_value_lparen expression UP expression rparen
{
- $$ = 0; /* FIXME */
- } /* Not in GNU-Chill */
+ write_exp_elt_opcode (TERNOP_SLICE_COUNT);
+ }
;
-/* Z.200, 5.2.15 */
+/* Z.200, 5.2.11 */
-zero_adic_operator: FIXME_07
+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);
+ }
+ | ARRAY '(' ')' mode_name parenthesised_expression
+ /* This is pseudo-Chill, similar to C's '(TYPE[])EXPR'
+ which casts to an artificial array. */
+ {
+ struct type *range_type
+ = create_range_type ((struct type *) NULL,
+ builtin_type_int, 0, 0);
+ struct type *array_type
+ = create_array_type ((struct type *) NULL,
+ $4.type, range_type);
+ TYPE_ARRAY_UPPER_BOUND_TYPE(array_type)
+ = BOUND_CANNOT_BE_DETERMINED;
+ write_exp_elt_opcode (UNOP_CAST);
+ write_exp_elt_type (array_type);
+ write_exp_elt_opcode (UNOP_CAST);
}
;
/* Z.200, 5.2.16 */
parenthesised_expression: '(' expression ')'
- {
- $$ = 0; /* FIXME */
- }
;
/* Z.200, 5.3.2 */
expression : operand_0
- {
- $$ = 0; /* FIXME */
- }
| single_assignment_action
- {
- $$ = 0; /* FIXME */
- }
| conditional_expression
- {
- $$ = 0; /* FIXME */
- }
- ;
-
-conditional_expression : IF boolean_expression then_alternative else_alternative FI
- {
- $$ = 0; /* FIXME */
- }
- | CASE case_selector_list OF value_case_alternative '[' ELSE sub_expression ']' ESAC
- {
- $$ = 0; /* FIXME */
- }
;
-then_alternative: THEN subexpression
- {
- $$ = 0; /* FIXME */
- }
+conditional_expression : IF expression then_alternative else_alternative FI
+ { write_exp_elt_opcode (TERNOP_COND); }
+/*
+ | CASE case_selector_list OF value_case_alternative ELSE expression ESAC
+ { error ("not implemented: CASE expression" }
+*/
;
-else_alternative: ELSE subexpression
- {
- $$ = 0; /* FIXME */
- }
- | ELSIF boolean_expression then_alternative else_alternative
- {
- $$ = 0; /* FIXME */
- }
+then_alternative: THEN expression
;
-sub_expression : expression
- {
- $$ = 0; /* FIXME */
- }
- ;
-
-value_case_alternative: case_label_specification ':' sub_expression ';'
- {
- $$ = 0; /* FIXME */
- }
+else_alternative: ELSE expression
+ | ELSIF expression then_alternative else_alternative
+ { write_exp_elt_opcode (TERNOP_COND); }
;
/* Z.200, 5.3.3 */
operand_0 : operand_1
- {
- $$ = 0; /* FIXME */
- }
| operand_0 LOGIOR operand_1
{
write_exp_elt_opcode (BINOP_BITWISE_IOR);
}
| operand_0 ORIF operand_1
{
- $$ = 0; /* FIXME */
+ write_exp_elt_opcode (BINOP_LOGICAL_OR);
}
| operand_0 LOGXOR operand_1
{
/* Z.200, 5.3.4 */
operand_1 : operand_2
- {
- $$ = 0; /* FIXME */
- }
| operand_1 LOGAND operand_2
{
write_exp_elt_opcode (BINOP_BITWISE_AND);
}
| operand_1 ANDIF operand_2
{
- $$ = 0; /* FIXME */
+ write_exp_elt_opcode (BINOP_LOGICAL_AND);
}
;
/* Z.200, 5.3.5 */
operand_2 : operand_3
- {
- $$ = 0; /* FIXME */
- }
| operand_2 '=' operand_3
{
write_exp_elt_opcode (BINOP_EQUAL);
/* Z.200, 5.3.6 */
operand_3 : operand_4
- {
- $$ = 0; /* FIXME */
- }
| operand_3 '+' operand_4
{
write_exp_elt_opcode (BINOP_ADD);
/* Z.200, 5.3.7 */
operand_4 : operand_5
- {
- $$ = 0; /* FIXME */
- }
| operand_4 '*' operand_5
{
write_exp_elt_opcode (BINOP_MUL);
/* Z.200, 5.3.8 */
operand_5 : operand_6
- {
- $$ = 0; /* FIXME */
- }
| '-' operand_6
{
write_exp_elt_opcode (UNOP_NEG);
/* Z.200, 5.3.9 */
-operand_6 : POINTER location
+operand_6 : POINTER primitive_value
{
write_exp_elt_opcode (UNOP_ADDR);
}
- | RECEIVE buffer_location
- {
- $$ = 0; /* FIXME */
- }
+ | RECEIVE expression
+ { error ("not implemented: RECEIVE expression"); }
| primitive_value
- {
- $$ = 0; /* FIXME */
- }
;
/* Z.200, 6.2 */
single_assignment_action :
- location GDB_ASSIGNMENT value
+ primitive_value GDB_ASSIGNMENT value
{
write_exp_elt_opcode (BINOP_ASSIGN);
}
/* Z.200, 6.20.3 */
-chill_value_built_in_routine_call :
+value_built_in_routine_call :
NUM '(' expression ')'
{
- $$ = 0; /* FIXME */
+ write_exp_elt_opcode (UNOP_CAST);
+ write_exp_elt_type (builtin_type_int);
+ write_exp_elt_opcode (UNOP_CAST);
}
| PRED '(' expression ')'
- {
- $$ = 0; /* FIXME */
- }
+ { error ("not implemented: PRED builtin function"); }
| SUCC '(' expression ')'
- {
- $$ = 0; /* FIXME */
- }
+ { error ("not implemented: SUCC builtin function"); }
+ | ADDR_TOKEN '(' expression ')'
+ { write_exp_elt_opcode (UNOP_ADDR); }
| ABS '(' expression ')'
- {
- $$ = 0; /* FIXME */
- }
+ { error ("not implemented: ABS builtin function"); }
| CARD '(' expression ')'
- {
- $$ = 0; /* FIXME */
- }
+ { error ("not implemented: CARD builtin function"); }
| MAX_TOKEN '(' expression ')'
- {
- $$ = 0; /* FIXME */
- }
+ { error ("not implemented: MAX builtin function"); }
| MIN_TOKEN '(' expression ')'
- {
- $$ = 0; /* FIXME */
- }
+ { error ("not implemented: MIN builtin function"); }
| SIZE '(' expression ')'
{ write_exp_elt_opcode (UNOP_SIZEOF); }
| SIZE '(' mode_argument ')'
write_exp_elt_type (builtin_type_int);
write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3));
write_exp_elt_opcode (OP_LONG); }
- | UPPER '(' upper_lower_argument ')'
- {
- $$ = 0; /* FIXME */
- }
- | LOWER '(' upper_lower_argument ')'
- {
- $$ = 0; /* FIXME */
- }
- | LENGTH '(' length_argument ')'
- {
- $$ = 0; /* FIXME */
- }
+ | LOWER '(' mode_argument ')'
+ { write_lower_upper_value (UNOP_LOWER, $3); }
+ | UPPER '(' mode_argument ')'
+ { write_lower_upper_value (UNOP_UPPER, $3); }
+ | LOWER '(' expression ')'
+ { write_exp_elt_opcode (UNOP_LOWER); }
+ | UPPER '(' expression ')'
+ { write_exp_elt_opcode (UNOP_UPPER); }
+ | LENGTH '(' expression ')'
+ { write_exp_elt_opcode (UNOP_LENGTH); }
;
mode_argument : mode_name
{
$$ = $1.type;
}
+/*
| array_mode_name '(' expression ')'
- {
- $$ = 0; /* FIXME */
- }
+ { ??? }
| string_mode_name '(' expression ')'
- {
- $$ = 0; /* FIXME */
- }
+ { ??? }
| variant_structure_mode_name '(' expression_list ')'
- {
- $$ = 0; /* FIXME */
- }
+ { ??? }
+*/
;
mode_name : TYPENAME
;
-upper_lower_argument : expression
- {
- $$ = 0; /* FIXME */
- }
- | mode_name
- {
- $$ = 0; /* FIXME */
- }
- ;
-
-length_argument : expression
- {
- $$ = 0; /* FIXME */
- }
- ;
-
-/* Z.200, 12.4.3 */
-
-array_primitive_value : primitive_value
- {
- $$ = 0;
- }
- ;
-
-
-/* Things which still need productions... */
-
-array_mode_name : FIXME_08 { $$ = 0; }
-string_mode_name : FIXME_09 { $$ = 0; }
-variant_structure_mode_name: FIXME_10 { $$ = 0; }
-synonym_name : FIXME_11 { $$ = 0; }
-value_enumeration_name : FIXME_12 { $$ = 0; }
-value_do_with_name : FIXME_13 { $$ = 0; }
-value_receive_name : FIXME_14 { $$ = 0; }
-string_primitive_value : FIXME_15 { $$ = 0; }
-start_element : FIXME_16 { $$ = 0; }
-left_element : FIXME_17 { $$ = 0; }
-right_element : FIXME_18 { $$ = 0; }
-slice_size : FIXME_19 { $$ = 0; }
-lower_element : FIXME_20 { $$ = 0; }
-upper_element : FIXME_21 { $$ = 0; }
-first_element : FIXME_22 { $$ = 0; }
-boolean_expression : FIXME_26 { $$ = 0; }
-case_selector_list : FIXME_27 { $$ = 0; }
-subexpression : FIXME_28 { $$ = 0; }
-case_label_specification: FIXME_29 { $$ = 0; }
-buffer_location : FIXME_30 { $$ = 0; }
-
%%
/* Implementation of a dynamically expandable buffer for processing input
yylval.sval.length = tokptr - lexptr;
lexptr = tokptr;
result = copy_name (yylval.sval);
- for (tokptr = result; *tokptr; tokptr++)
- if (isupper (*tokptr))
- *tokptr = tolower(*tokptr);
return result;
}
return (NULL);
while (*tokptr != '\0')
{
- temp = tolower (*tokptr);
+ temp = *tokptr;
+ if (isupper (temp))
+ temp = tolower (temp);
tokptr++;
switch (temp)
{
char *tokptr = lexptr;
int ival = 0;
- if ((tolower (*tokptr) == 'c') && (*(tokptr + 1) == '\''))
+ if ((*tokptr == 'c' || *tokptr == 'C') && (*(tokptr + 1) == '\''))
{
/* We have a GNU chill extension form, so skip the leading "C'",
decode the hex value, and then ensure that we have a trailing
static int
match_bitstring_literal ()
{
- char *tokptr = lexptr;
- int mask;
+ register char *tokptr = lexptr;
int bitoffset = 0;
int bitcount = 0;
- int base;
+ int bits_per_char;
int digit;
tempbufindex = 0;
+ CHECKBUF (1);
+ tempbuf[0] = 0;
/* Look for the required explicit base specifier. */
{
case 'b':
case 'B':
- base = 2;
+ bits_per_char = 1;
break;
case 'o':
case 'O':
- base = 8;
+ bits_per_char = 3;
break;
case 'h':
case 'H':
- base = 16;
+ bits_per_char = 4;
break;
default:
return (0);
break;
}
-
+
/* Ensure that the character after the explicit base is a single quote. */
if (*tokptr++ != '\'')
while (*tokptr != '\0' && *tokptr != '\'')
{
- digit = tolower (*tokptr);
+ digit = *tokptr;
+ if (isupper (digit))
+ digit = tolower (digit);
tokptr++;
switch (digit)
{
return (0);
break;
}
- if (digit >= base)
+ if (digit >= 1 << bits_per_char)
{
/* Found something not in domain for current base. */
return (0);
}
else
{
- /* Extract bits from digit, starting with the msbit appropriate for
- the current base, and packing them into the bitstring byte,
- starting at the lsbit. */
- for (mask = (base >> 1); mask > 0; mask >>= 1)
+ /* Extract bits from digit, packing them into the bitstring byte. */
+ int k = TARGET_BYTE_ORDER == BIG_ENDIAN ? bits_per_char - 1 : 0;
+ for (; TARGET_BYTE_ORDER == BIG_ENDIAN ? k >= 0 : k < bits_per_char;
+ TARGET_BYTE_ORDER == BIG_ENDIAN ? k-- : k++)
{
bitcount++;
- CHECKBUF (1);
- if (digit & mask)
+ if (digit & (1 << k))
{
- tempbuf[tempbufindex] |= (1 << bitoffset);
+ tempbuf[tempbufindex] |=
+ (TARGET_BYTE_ORDER == BIG_ENDIAN)
+ ? (1 << (HOST_CHAR_BIT - 1 - bitoffset))
+ : (1 << bitoffset);
}
bitoffset++;
if (bitoffset == HOST_CHAR_BIT)
{
bitoffset = 0;
tempbufindex++;
+ CHECKBUF(1);
+ tempbuf[tempbufindex] = 0;
}
}
}
}
}
-/* Recognize tokens that start with '$'. These include:
-
- $regname A native register name or a "standard
- register name".
- Return token GDB_REGNAME.
-
- $variable A convenience variable with a name chosen
- by the user.
- Return token GDB_VARIABLE.
-
- $digits Value history with index <digits>, starting
- from the first value which has index 1.
- Return GDB_LAST.
-
- $$digits Value history with index <digits> relative
- to the last value. I.E. $$0 is the last
- value, $$1 is the one previous to that, $$2
- is the one previous to $$1, etc.
- Return token GDB_LAST.
-
- $ | $0 | $$0 The last value in the value history.
- Return token GDB_LAST.
-
- $$ An abbreviation for the second to the last
- value in the value history, I.E. $$1
- Return token GDB_LAST.
-
- Note that we currently assume that register names and convenience
- variables follow the convention of starting with a letter or '_'.
-
- */
-
-static int
-match_dollar_tokens ()
-{
- char *tokptr;
- int regno;
- int namelength;
- int negate;
- int ival;
-
- /* We will always have a successful match, even if it is just for
- a single '$', the abbreviation for $$0. So advance lexptr. */
-
- tokptr = ++lexptr;
-
- if (*tokptr == '_' || isalpha (*tokptr))
- {
- /* Look for a match with a native register name, usually something
- like "r0" for example. */
-
- for (regno = 0; regno < NUM_REGS; regno++)
- {
- namelength = strlen (reg_names[regno]);
- if (STREQN (tokptr, reg_names[regno], namelength)
- && !isalnum (tokptr[namelength]))
- {
- yylval.lval = regno;
- lexptr += namelength;
- return (GDB_REGNAME);
- }
- }
-
- /* Look for a match with a standard register name, usually something
- like "pc", which gdb always recognizes as the program counter
- regardless of what the native register name is. */
-
- for (regno = 0; regno < num_std_regs; regno++)
- {
- namelength = strlen (std_regs[regno].name);
- if (STREQN (tokptr, std_regs[regno].name, namelength)
- && !isalnum (tokptr[namelength]))
- {
- yylval.lval = std_regs[regno].regnum;
- lexptr += namelength;
- return (GDB_REGNAME);
- }
- }
-
- /* Attempt to match against a convenience variable. Note that
- this will always succeed, because if no variable of that name
- already exists, the lookup_internalvar will create one for us.
- Also note that both lexptr and tokptr currently point to the
- start of the input string we are trying to match, and that we
- have already tested the first character for non-numeric, so we
- don't have to treat it specially. */
-
- while (*tokptr == '_' || isalnum (*tokptr))
- {
- tokptr++;
- }
- yylval.sval.ptr = lexptr;
- yylval.sval.length = tokptr - lexptr;
- yylval.ivar = lookup_internalvar (copy_name (yylval.sval));
- lexptr = tokptr;
- return (GDB_VARIABLE);
- }
-
- /* Since we didn't match against a register name or convenience
- variable, our only choice left is a history value. */
-
- if (*tokptr == '$')
- {
- negate = 1;
- ival = 1;
- tokptr++;
- }
- else
- {
- negate = 0;
- ival = 0;
- }
-
- /* Attempt to decode more characters as an integer value giving
- the index in the history list. If successful, the value will
- overwrite ival (currently 0 or 1), and if not, ival will be
- left alone, which is good since it is currently correct for
- the '$' or '$$' case. */
-
- decode_integer_literal (&ival, &tokptr);
- yylval.lval = negate ? -ival : ival;
- lexptr = tokptr;
- return (GDB_LAST);
-}
-
struct token
{
char *operator;
static const struct token idtokentab[] =
{
+ { "array", ARRAY },
{ "length", LENGTH },
{ "lower", LOWER },
{ "upper", UPPER },
{ "xor", LOGXOR },
{ "and", LOGAND },
{ "in", IN },
- { "or", LOGIOR }
+ { "or", LOGIOR },
+ { "up", UP },
+ { "addr", ADDR_TOKEN },
+ { "null", EMPTINESS_LITERAL }
};
static const struct token tokentab2[] =
{
unsigned int i;
int token;
- char *simplename;
+ char *inputname;
struct symbol *sym;
/* Skip over any leading whitespace. */
}
break;
case '$':
- token = match_dollar_tokens ();
- if (token != 0)
- {
- return (token);
- }
+ yylval.sval.ptr = lexptr;
+ do {
+ lexptr++;
+ } while (isalnum (*lexptr) || *lexptr == '_' || *lexptr == '$');
+ yylval.sval.length = lexptr - yylval.sval.ptr;
+ write_dollar_variable (yylval.sval);
+ return GDB_VARIABLE;
break;
}
/* See if it is a special token of length 2. */
the token from lexptr, so we can't back out if we later find that
we can't classify what sort of name it is. */
- simplename = match_simple_name_string ();
+ inputname = match_simple_name_string ();
- if (simplename != NULL)
+ if (inputname != NULL)
{
+ char *simplename = (char*) alloca (strlen (inputname) + 1);
+
+ char *dptr = simplename, *sptr = inputname;
+ for (; *sptr; sptr++)
+ *dptr++ = isupper (*sptr) ? tolower(*sptr) : *sptr;
+ *dptr = '\0';
+
/* See if it is a reserved identifier. */
for (i = 0; i < sizeof (idtokentab) / sizeof (idtokentab[0]); i++)
{
return (BOOLEAN_LITERAL);
}
- sym = lookup_symbol (simplename, expression_context_block,
+ sym = lookup_symbol (inputname, expression_context_block,
VAR_NAMESPACE, (int *) NULL,
(struct symtab **) NULL);
+ if (sym == NULL && strcmp (inputname, simplename) != 0)
+ {
+ sym = lookup_symbol (simplename, expression_context_block,
+ VAR_NAMESPACE, (int *) NULL,
+ (struct symtab **) NULL);
+ }
if (sym != NULL)
{
yylval.ssym.stoken.ptr = NULL;
case LOC_UNDEF:
case LOC_CONST_BYTES:
case LOC_OPTIMIZED_OUT:
- error ("Symbol \"%s\" names no location.", simplename);
+ error ("Symbol \"%s\" names no location.", inputname);
break;
}
}
}
else
{
- error ("No symbol \"%s\" in current context.", simplename);
+ error ("No symbol \"%s\" in current context.", inputname);
}
}
case '.': /* Not float for example. */
lexptr++;
while (isspace (*lexptr)) lexptr++;
- simplename = match_simple_name_string ();
- if (!simplename)
+ inputname = match_simple_name_string ();
+ if (!inputname)
return '.';
return FIELD_NAME;
}
return (ILLEGAL_TOKEN);
}
+static void
+write_lower_upper_value (opcode, type)
+ enum exp_opcode opcode; /* Either UNOP_LOWER or UNOP_UPPER */
+ struct type *type;
+{
+ extern LONGEST type_lower_upper ();
+ struct type *result_type;
+ LONGEST val = type_lower_upper (opcode, type, &result_type);
+ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_type (result_type);
+ write_exp_elt_longcst (val);
+ write_exp_elt_opcode (OP_LONG);
+}
+
void
yyerror (msg)
- char *msg; /* unused */
+ char *msg;
{
- printf_unfiltered ("Parsing: %s\n", lexptr);
- if (yychar < 256)
- {
- error ("Invalid syntax in expression near character '%c'.", yychar);
- }
- else
- {
- error ("Invalid syntax in expression");
- }
+ error ("A %s in expression, near `%s'.", (msg ? msg : "error"), lexptr);
}
projects / deliverable / binutils-gdb.git / blobdiff