* Makefile.in (YYFILES): Add ch-exp.tab.c.
* Makefile.in (YYOBJ): Add ch-exp.tab.o.
* Makefile.in (saber_gdb): Add unload of ch-exp.y and load
of ch-exp.tab.c.
* Makefile.in (distclean): Add target ch-exp.tab.c.
* Makefile.in (realclean): Add rm of ch-exp.tab.c.
* Makefile.in (c-exp.tab.c, m2-exp.tab.c): Add dependency on
Makefile since it contains sed patterns used in generation.
Add sed pattern to also delete #include of any malloc.h.
* Makefile.in (ch-exp.tab.o, ch-exp.tab.c): New targets.
* ch-exp.y: New expression parser, for GNU-Chill.
* c-exp.y, expr.c, expression.h, language.c, m2-exp.y,
parser-defs.h, valarith.c, valops.c, value.h: Remap macros and
function names to conform to K&R terminology with respect to
logical and bitwise operators:
UNOP_ZEROP => UNOP_LOGICAL_NOT
UNOP_LOGNOT => UNOP_COMPLEMENT
BINOP_LOGAND => BINOP_BITWISE_AND
BINOP_LOGXOR => BINOP_BITWISE_XOR
BINOP_LOGIOR => BINOP_BITWISE_IOR
BINOP_AND => BINOP_LOGICAL_AND
BINOP_OR => BINOP_LOGICAL_OR
PREC_OR => PREC_LOGICAL_OR
PREC_AND => PREC_LOGICAL_AND
PREC_LOGIOR => PREC_BITWISE_IOR
PREC_LOGXOR => PREC_BITWISE_XOR
PREC_LOGAND => PREC_BITWISE_AND
value_zerop() => value_logical_not()
value_lognot() => value_complement()
* c-exp.y (c_op_print_tab): Add explicit empty terminator.
* m2-exp.y (m2_op_print_tab): Add explicit empty terminator.
* defs.h (enum language): Add language_chill.
* dwarfread.c (set_cu_language): Add LANG_CHILL case and make
LANG_MODULA2 a recognized language.
* eval.c (evaluate_subexp): Add OP_BOOL case.
* expprint.c (print_subexp): Add OP_BOOL case.
* gdbtypes.h (enum_typecode): Note TYPE_CODE_BOOL used for
Chill as well as Modula-2.
* gdbtypes.y (builtin_type_chill_bool, builtin_type_chill_long,
builtin_type_chill_ulong, builtin_type_chill_real): Add.
* i387-tdep.c (sys/dir.h): Remove, appears to be unnecessary
and is nonexistant in some SVR4 based systems.
* language.c (DEFAULT_ALLOCSIZE): Change from 3 => 4.
* language.c (set_language_command): Add chill.
* language.c (binop_result_type, integral_type, character_type,
boolean_type, structured_type, value_true, binop_type_check):
Add language_chill cases.
* language.h (_LANG_chill): Define.
* m2-exp.y (number_sign, modblock): Make static, #ifdef out
unused modblock.
* m2-exp.y (ANDAND): Rename to LOGICAL_AND.
* source.c (source_info): Fix minor nits, print "1 line" rather
than "1 lines", and "language is <lang>".
* symfile.c (deduce_language_from_filename): Recognize the
filename extensions ".chill", ".c186", and ".c286" for Chill.
* valarith.c (value_binop): Handle TYPE_CODE_BOOL as well
as TYPE_CODE_INT and TYPE_CODE_FLOAT.
* valprint.c (val_print): Print TYPE_CODE_BOOL type values as
"TRUE" or "FALSE".
* valprint.c (typedef_print): Add case for language_chill.
* values.c (value_from_longest): Handle TYPE_CODE_BOOL.
buildsym.h
c-exp.y
call-cmds.h
+ch-exp.y
coffread.c
command.c
command.h
+Sun Nov 15 09:22:09 1992 Fred Fish (fnf@cygnus.com)
+
+ * Makefile.in (SFILES_MAINDIR): Add ch-exp.y.
+ * Makefile.in (YYFILES): Add ch-exp.tab.c.
+ * Makefile.in (YYOBJ): Add ch-exp.tab.o.
+ * Makefile.in (saber_gdb): Add unload of ch-exp.y and load
+ of ch-exp.tab.c.
+ * Makefile.in (distclean): Add target ch-exp.tab.c.
+ * Makefile.in (realclean): Add rm of ch-exp.tab.c.
+ * Makefile.in (c-exp.tab.c, m2-exp.tab.c): Add dependency on
+ Makefile since it contains sed patterns used in generation.
+ Add sed pattern to also delete #include of any malloc.h.
+ * Makefile.in (ch-exp.tab.o, ch-exp.tab.c): New targets.
+ * ch-exp.y: New expression parser, for GNU-Chill.
+ * c-exp.y, expr.c, expression.h, language.c, m2-exp.y,
+ parser-defs.h, valarith.c, valops.c, value.h: Remap macros and
+ function names to conform to K&R terminology with respect to
+ logical and bitwise operators:
+ UNOP_ZEROP => UNOP_LOGICAL_NOT
+ UNOP_LOGNOT => UNOP_COMPLEMENT
+ BINOP_LOGAND => BINOP_BITWISE_AND
+ BINOP_LOGXOR => BINOP_BITWISE_XOR
+ BINOP_LOGIOR => BINOP_BITWISE_IOR
+ BINOP_AND => BINOP_LOGICAL_AND
+ BINOP_OR => BINOP_LOGICAL_OR
+ PREC_OR => PREC_LOGICAL_OR
+ PREC_AND => PREC_LOGICAL_AND
+ PREC_LOGIOR => PREC_BITWISE_IOR
+ PREC_LOGXOR => PREC_BITWISE_XOR
+ PREC_LOGAND => PREC_BITWISE_AND
+ value_zerop() => value_logical_not()
+ value_lognot() => value_complement()
+ * c-exp.y (c_op_print_tab): Add explicit empty terminator.
+ * m2-exp.y (m2_op_print_tab): Add explicit empty terminator.
+ * defs.h (enum language): Add language_chill.
+ * dwarfread.c (set_cu_language): Add LANG_CHILL case and make
+ LANG_MODULA2 a recognized language.
+ * eval.c (evaluate_subexp): Add OP_BOOL case.
+ * expprint.c (print_subexp): Add OP_BOOL case.
+ * gdbtypes.h (enum_typecode): Note TYPE_CODE_BOOL used for
+ Chill as well as Modula-2.
+ * gdbtypes.y (builtin_type_chill_bool, builtin_type_chill_long,
+ builtin_type_chill_ulong, builtin_type_chill_real): Add.
+ * i387-tdep.c (sys/dir.h): Remove, appears to be unnecessary
+ and is nonexistant in some SVR4 based systems.
+ * language.c (DEFAULT_ALLOCSIZE): Change from 3 => 4.
+ * language.c (set_language_command): Add chill.
+ * language.c (binop_result_type, integral_type, character_type,
+ boolean_type, structured_type, value_true, binop_type_check):
+ Add language_chill cases.
+ * language.h (_LANG_chill): Define.
+ * m2-exp.y (number_sign, modblock): Make static, #ifdef out
+ unused modblock.
+ * m2-exp.y (ANDAND): Rename to LOGICAL_AND.
+ * source.c (source_info): Fix minor nits, print "1 line" rather
+ than "1 lines", and "language is <lang>".
+ * symfile.c (deduce_language_from_filename): Recognize the
+ filename extensions ".chill", ".c186", and ".c286" for Chill.
+ * valarith.c (value_binop): Handle TYPE_CODE_BOOL as well
+ as TYPE_CODE_INT and TYPE_CODE_FLOAT.
+ * valprint.c (val_print): Print TYPE_CODE_BOOL type values as
+ "TRUE" or "FALSE".
+ * valprint.c (typedef_print): Add case for language_chill.
+ * values.c (value_from_longest): Handle TYPE_CODE_BOOL.
+
Fri Nov 13 20:24:10 1992 Stu Grossman (grossman at cygnus.com)
* infcmd.c (step_over_calls): Improve comments.
mem-break.c target.c \
dbxread.c coffread.c elfread.c dwarfread.c xcoffread.c stabsread.c \
ieee-float.c language.c parse.c buildsym.c objfiles.c \
- minsyms.c mipsread.c maint.c
+ minsyms.c mipsread.c maint.c ch-exp.y
# Source files in subdirectories (which will be handled separately by
# 'make gdb.tar.Z').
SUBDIRS = doc
# For now, shortcut the "configure GDB for fewer languages" stuff.
-YYFILES = c-exp.tab.c m2-exp.tab.c
-YYOBJ = c-exp.tab.o m2-exp.tab.o
+YYFILES = c-exp.tab.c m2-exp.tab.c ch-exp.tab.c
+YYOBJ = c-exp.tab.o m2-exp.tab.o ch-exp.tab.o
# Prevent Sun make from putting in the machine type. Setting
# TARGET_ARCH to nothing works for SunOS 3, 4.0, but not for 4.1.
#setopt load_flags $(CFLAGS) -I$(BFD_DIR) -DHOST_SYS=SUN4_SYS
#load ./init.c $(SFILES)
#unload ${srcdir}/c-exp.y ${srcdir}/m2-exp.y ${srcdir}/vx-share/*.h
+ #unload ${srcdir}/ch-exp.y
#unload ${srcdir}/nindy-share/[A-Z]*
- #load c-exp.tab.c m2-exp.tab.c
+ #load c-exp.tab.c m2-exp.tab.c ch-exp.tab.c
#load copying.c version.c
#load ../opcodes/libopcodes.a
#load ../libiberty/libiberty.a
rm -f gdb[0-9]
@$(MAKE) subdir_do DO=clean "DODIRS=$(SUBDIRS)" $(FLAGS_TO_PASS)
-distclean: clean c-exp.tab.c m2-exp.tab.c TAGS
+distclean: clean c-exp.tab.c m2-exp.tab.c ch-exp.tab.c TAGS
rm -f tm.h xm.h config.status
rm -f y.output yacc.acts yacc.tmp
rm -f ${TESTS} Makefile depend
@$(MAKE) subdir_do DO=distclean "DODIRS=$(SUBDIRS)" $(FLAGS_TO_PASS)
realclean: clean
- rm -f c-exp.tab.c m2-exp.tab.c TAGS
+ rm -f c-exp.tab.c m2-exp.tab.c ch-exp.tab.c TAGS
rm -f tm.h xm.h config.status
rm -f Makefile depend
@$(MAKE) subdir_do DO=realclean "DODIRS=$(SUBDIRS)" $(FLAGS_TO_PASS)
# Remove bogus decls for malloc/realloc/free which conflict with everything
# else.
c-exp.tab.o: c-exp.tab.c
-c-exp.tab.c: $(srcdir)/c-exp.y
+c-exp.tab.c: $(srcdir)/c-exp.y Makefile
@echo 'Expect 4 shift/reduce conflicts.'
${YACC} $(srcdir)/c-exp.y
-sed -e '/extern.*malloc/d' \
-e '/extern.*realloc/d' \
-e '/extern.*free/d' \
+ -e '/include.*malloc.h/d' \
-e 's/malloc/xmalloc/g' \
-e 's/realloc/xrealloc/g' \
< y.tab.c > c-exp.tab.c
-rm y.tab.c
+# ch-exp.tab.c is generated in target dir from ch-exp.y if it doesn't exist
+# in srcdir, then compiled in target dir to ch-exp.tab.o.
+# Remove bogus decls for malloc/realloc/free which conflict with everything
+# else.
+ch-exp.tab.o: ch-exp.tab.c
+ch-exp.tab.c: $(srcdir)/ch-exp.y Makefile
+ @echo 'Expect 4 shift/reduce conflicts.'
+ ${YACC} $(srcdir)/ch-exp.y
+ -sed -e '/extern.*malloc/d' \
+ -e '/extern.*realloc/d' \
+ -e '/extern.*free/d' \
+ -e '/include.*malloc.h/d' \
+ -e 's/malloc/xmalloc/g' \
+ -e 's/realloc/xrealloc/g' \
+ < y.tab.c > ch-exp.tab.c
+ -rm y.tab.c
+
# m2-exp.tab.c is generated in target dir from m2-exp.y if it doesn't exist
# in srcdir, then compiled in target dir to m2-exp.tab.o.
+# Remove bogus decls for malloc/realloc/free which conflict with everything
+# else.
m2-exp.tab.o: m2-exp.tab.c
-m2-exp.tab.c: $(srcdir)/m2-exp.y
+m2-exp.tab.c: $(srcdir)/m2-exp.y Makefile
${YACC} $(srcdir)/m2-exp.y
-sed -e '/extern.*malloc/d' \
-e '/extern.*realloc/d' \
-e '/extern.*free/d' \
+ -e '/include.*malloc.h/d' \
-e 's/malloc/xmalloc/g' \
-e 's/realloc/xrealloc/g' \
< y.tab.c > m2-exp.tab.c
;
exp : '!' exp %prec UNARY
- { write_exp_elt_opcode (UNOP_ZEROP); }
+ { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
;
exp : '~' exp %prec UNARY
- { write_exp_elt_opcode (UNOP_LOGNOT); }
+ { write_exp_elt_opcode (UNOP_COMPLEMENT); }
;
exp : INCREMENT exp %prec UNARY
;
exp : exp '&' exp
- { write_exp_elt_opcode (BINOP_LOGAND); }
+ { write_exp_elt_opcode (BINOP_BITWISE_AND); }
;
exp : exp '^' exp
- { write_exp_elt_opcode (BINOP_LOGXOR); }
+ { write_exp_elt_opcode (BINOP_BITWISE_XOR); }
;
exp : exp '|' exp
- { write_exp_elt_opcode (BINOP_LOGIOR); }
+ { write_exp_elt_opcode (BINOP_BITWISE_IOR); }
;
exp : exp ANDAND exp
- { write_exp_elt_opcode (BINOP_AND); }
+ { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
;
exp : exp OROR exp
- { write_exp_elt_opcode (BINOP_OR); }
+ { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
;
exp : exp '?' exp ':' exp %prec '?'
{"*=", ASSIGN_MODIFY, BINOP_MUL},
{"/=", ASSIGN_MODIFY, BINOP_DIV},
{"%=", ASSIGN_MODIFY, BINOP_REM},
- {"|=", ASSIGN_MODIFY, BINOP_LOGIOR},
- {"&=", ASSIGN_MODIFY, BINOP_LOGAND},
- {"^=", ASSIGN_MODIFY, BINOP_LOGXOR},
+ {"|=", ASSIGN_MODIFY, BINOP_BITWISE_IOR},
+ {"&=", ASSIGN_MODIFY, BINOP_BITWISE_AND},
+ {"^=", ASSIGN_MODIFY, BINOP_BITWISE_XOR},
{"++", INCREMENT, BINOP_END},
{"--", DECREMENT, BINOP_END},
{"->", ARROW, BINOP_END},
{
{",", BINOP_COMMA, PREC_COMMA, 0},
{"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
- {"||", BINOP_OR, PREC_OR, 0},
- {"&&", BINOP_AND, PREC_AND, 0},
- {"|", BINOP_LOGIOR, PREC_LOGIOR, 0},
- {"&", BINOP_LOGAND, PREC_LOGAND, 0},
- {"^", BINOP_LOGXOR, PREC_LOGXOR, 0},
+ {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
+ {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
+ {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
+ {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
+ {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
{"==", BINOP_EQUAL, PREC_EQUAL, 0},
{"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
{"<=", BINOP_LEQ, PREC_ORDER, 0},
{"%", BINOP_REM, PREC_MUL, 0},
{"@", BINOP_REPEAT, PREC_REPEAT, 0},
{"-", UNOP_NEG, PREC_PREFIX, 0},
- {"!", UNOP_ZEROP, PREC_PREFIX, 0},
- {"~", UNOP_LOGNOT, PREC_PREFIX, 0},
+ {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
+ {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
{"*", UNOP_IND, PREC_PREFIX, 0},
{"&", UNOP_ADDR, PREC_PREFIX, 0},
{"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
{"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
/* C++ */
{"::", BINOP_SCOPE, PREC_PREFIX, 0},
+ {NULL, 0, 0, 0}
};
\f
/* These variables point to the objects
--- /dev/null
+/* YACC grammar for Chill expressions, for GDB.
+ Copyright (C) 1992 Free Software Foundation, Inc.
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+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. */
+
+/* Parse a Chill expression from text in a string,
+ and return the result as a struct expression pointer.
+ That structure contains arithmetic operations in reverse polish,
+ with constants represented by operations that are followed by special data.
+ See expression.h for the details of the format.
+ What is important here is that it can be built up sequentially
+ during the process of parsing; the lower levels of the tree always
+ come first in the result.
+
+ Note that malloc's and realloc's in this file are transformed to
+ xmalloc and xrealloc respectively by the same sed command in the
+ makefile that remaps any other malloc/realloc inserted by the parser
+ generator. Doing this with #defines and trying to control the interaction
+ with include files (<malloc.h> and <stdlib.h> for example) just became
+ too messy, particularly when such includes can be inserted at random
+ times by the parser generator.
+
+ Also note that the language accepted by this parser is more liberal
+ than the one accepted by an actual Chill compiler. For example, the
+ language rule that a simple name string can not be one of the reserved
+ simple name strings is not enforced (e.g "case" is not treated as a
+ reserved name). Another example is that Chill is a strongly typed
+ language, and certain expressions that violate the type constraints
+ may still be evaluated if gdb can do so in a meaningful manner, while
+ such expressions would be rejected by the compiler. The reason for
+ this more liberal behavior is the philosophy that the debugger
+ is intended to be a tool that is used by the programmer when things
+ go wrong, and as such, it should provide as few artificial barriers
+ to it's use as possible. If it can do something meaningful, even
+ something that violates language contraints that are enforced by the
+ compiler, it should do so without complaint.
+
+ */
+
+%{
+
+#include <stdio.h>
+#include <string.h>
+#include "defs.h"
+#include "symtab.h"
+#include "gdbtypes.h"
+#include "frame.h"
+#include "expression.h"
+#include "language.h"
+#include "value.h"
+#include "parser-defs.h"
+#include "bfd.h"
+#include "symfile.h"
+#include "objfiles.h"
+
+/* These MUST be included in any grammar file!!!! Please choose unique names!
+ Note that this are a combined list of variables that can be produced
+ by any one of bison, byacc, or yacc. */
+#define yymaxdepth chill_maxdepth
+#define yyparse chill_parse
+#define yylex chill_lex
+#define yyerror chill_error
+#define yylval chill_lval
+#define yychar chill_char
+#define yydebug chill_debug
+#define yypact chill_pact
+#define yyr1 chill_r1
+#define yyr2 chill_r2
+#define yydef chill_def
+#define yychk chill_chk
+#define yypgo chill_pgo
+#define yyact chill_act
+#define yyexca chill_exca
+#define yyerrflag chill_errflag
+#define yynerrs chill_nerrs
+#define yyps chill_ps
+#define yypv chill_pv
+#define yys chill_s
+#define yy_yys chill_yys
+#define yystate chill_state
+#define yytmp chill_tmp
+#define yyv chill_v
+#define yy_yyv chill_yyv
+#define yyval chill_val
+#define yylloc chill_lloc
+#define yyss chill_yyss /* byacc */
+#define yyssp chill_yysp /* byacc */
+#define yyvs chill_yyvs /* byacc */
+#define yyvsp chill_yyvsp /* byacc */
+
+static int
+yylex PARAMS ((void));
+
+static void
+yyerror PARAMS ((char *));
+
+int
+yyparse PARAMS ((void));
+
+/* #define YYDEBUG 1 */
+
+%}
+
+/* Although the yacc "value" of an expression is not used,
+ since the result is stored in the structure being created,
+ other node types do have values. */
+
+%union
+ {
+ LONGEST lval;
+ unsigned LONGEST ulval;
+ struct {
+ LONGEST val;
+ struct type *type;
+ } typed_val;
+ double dval;
+ struct symbol *sym;
+ struct type *tval;
+ struct stoken sval;
+ struct ttype tsym;
+ struct symtoken ssym;
+ int voidval;
+ struct block *bval;
+ enum exp_opcode opcode;
+ struct internalvar *ivar;
+
+ struct type **tvec;
+ int *ivec;
+ }
+
+%{
+static int parse_number PARAMS ((void));
+%}
+
+%token <voidval> FIXME
+
+%token <typed_val> INTEGER_LITERAL
+%token <ulval> BOOLEAN_LITERAL
+%token <voidval> CHARACTER_LITERAL
+%token <voidval> SET_LITERAL
+%token <voidval> EMPTINESS_LITERAL
+%token <voidval> CHARACTER_STRING_LITERAL
+%token <voidval> BIT_STRING_LITERAL
+
+%token <voidval> STRING
+%token <voidval> CONSTANT
+%token <voidval> '.'
+%token <voidval> ';'
+%token <voidval> ':'
+%token <voidval> CASE
+%token <voidval> OF
+%token <voidval> ESAC
+%token <voidval> LOGIOR
+%token <voidval> ORIF
+%token <voidval> LOGXOR
+%token <voidval> LOGAND
+%token <voidval> ANDIF
+%token <voidval> '='
+%token <voidval> NOTEQUAL
+%token <voidval> '>'
+%token <voidval> GTR
+%token <voidval> '<'
+%token <voidval> LEQ
+%token <voidval> IN
+%token <voidval> '+'
+%token <voidval> '-'
+%token <voidval> '*'
+%token <voidval> '/'
+%token <voidval> SLASH_SLASH
+%token <voidval> MOD
+%token <voidval> REM
+%token <voidval> NOT
+%token <voidval> POINTER
+%token <voidval> RECEIVE
+%token <voidval> SC
+%token <voidval> '['
+%token <voidval> ']'
+%token <voidval> '('
+%token <voidval> ')'
+%token <voidval> UP
+%token <voidval> IF
+%token <voidval> THEN
+%token <voidval> ELSE
+%token <voidval> FI
+%token <voidval> ELSIF
+%token <voidval> ILLEGAL_TOKEN
+
+%type <voidval> location
+%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> expression_conversion
+%type <voidval> value_procedure_call
+%type <voidval> 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_3
+%type <voidval> operand_4
+%type <voidval> operand_5
+%type <voidval> operand_6
+%type <voidval> integer_literal_expression
+%type <voidval> synonym_name
+%type <voidval> value_enumeration_name
+%type <voidval> value_do_with_name
+%type <voidval> value_receive_name
+%type <voidval> general_procedure_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 <voidval> structure_primitive_value
+%type <voidval> field_name
+%type <voidval> mode_name
+%type <voidval> boolean_expression
+%type <voidval> case_selector_list
+%type <voidval> subexpression
+%type <voidval> case_label_specification
+%type <voidval> buffer_location
+
+%%
+
+/* Z.200, 5.3.1 */
+
+value : expression
+ {
+ $$ = 0; /* FIXME */
+ }
+ | undefined_value
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+undefined_value : FIXME
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 4.2.1 */
+
+location : FIXME
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.1 */
+
+primitive_value : location_contents
+ {
+ $$ = 0; /* FIXME */
+ }
+ | value_name
+ {
+ $$ = 0; /* FIXME */
+ }
+ | literal
+ {
+ $$ = 0; /* FIXME */
+ }
+ | tuple
+ {
+ $$ = 0; /* FIXME */
+ }
+ | value_string_element
+ {
+ $$ = 0; /* FIXME */
+ }
+ | value_string_slice
+ {
+ $$ = 0; /* FIXME */
+ }
+ | value_array_element
+ {
+ $$ = 0; /* FIXME */
+ }
+ | value_array_slice
+ {
+ $$ = 0; /* FIXME */
+ }
+ | value_structure_field
+ {
+ $$ = 0; /* FIXME */
+ }
+ | 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
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.4.1 */
+
+literal : INTEGER_LITERAL
+ {
+ write_exp_elt_opcode (OP_LONG);
+ write_exp_elt_type ($1.type);
+ write_exp_elt_longcst ((LONGEST) ($1.val));
+ write_exp_elt_opcode (OP_LONG);
+ }
+ | BOOLEAN_LITERAL
+ {
+ write_exp_elt_opcode (OP_BOOL);
+ write_exp_elt_longcst ((LONGEST) $1);
+ write_exp_elt_opcode (OP_BOOL);
+ }
+ | CHARACTER_LITERAL
+ {
+ $$ = 0; /* FIXME */
+ }
+ | SET_LITERAL
+ {
+ $$ = 0; /* FIXME */
+ }
+ | EMPTINESS_LITERAL
+ {
+ $$ = 0; /* FIXME */
+ }
+ | CHARACTER_STRING_LITERAL
+ {
+ $$ = 0; /* FIXME */
+ }
+ | BIT_STRING_LITERAL
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.5 */
+
+tuple : FIXME
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+
+/* Z.200, 5.2.6 */
+
+value_string_element: string_primitive_value '(' start_element ')'
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.7 */
+
+value_string_slice: string_primitive_value '(' left_element ':' right_element ')'
+ {
+ $$ = 0; /* FIXME */
+ }
+ | string_primitive_value '(' start_element UP slice_size ')'
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.8 */
+
+value_array_element: array_primitive_value '(' expression_list ')'
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.9 */
+
+value_array_slice: array_primitive_value '(' lower_element ':' upper_element ')'
+ {
+ $$ = 0; /* FIXME */
+ }
+ | array_primitive_value '(' first_element UP slice_size '('
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.10 */
+
+value_structure_field: structure_primitive_value '.' field_name
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.11 */
+
+expression_conversion: mode_name '(' expression ')'
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.12 */
+
+value_procedure_call: FIXME
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.13 */
+
+value_built_in_routine_call: FIXME
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.14 */
+
+start_expression: FIXME
+ {
+ $$ = 0; /* FIXME */
+ } /* Not in GNU-Chill */
+ ;
+
+/* Z.200, 5.2.15 */
+
+zero_adic_operator: FIXME
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.2.16 */
+
+parenthesised_expression: '(' expression ')'
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.3.2 */
+
+expression : operand_0
+ {
+ $$ = 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 */
+ }
+ ;
+
+else_alternative: ELSE subexpression
+ {
+ $$ = 0; /* FIXME */
+ }
+ | ELSIF boolean_expression then_alternative else_alternative
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+sub_expression : expression
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+value_case_alternative: case_label_specification ':' sub_expression ';'
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* 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 */
+ }
+ | operand_0 LOGXOR operand_1
+ {
+ write_exp_elt_opcode (BINOP_BITWISE_XOR);
+ }
+ ;
+
+/* 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 */
+ }
+ ;
+
+/* Z.200, 5.3.5 */
+
+operand_2 : operand_3
+ {
+ $$ = 0; /* FIXME */
+ }
+ | operand_2 '=' operand_3
+ {
+ write_exp_elt_opcode (BINOP_EQUAL);
+ }
+ | operand_2 NOTEQUAL operand_3
+ {
+ write_exp_elt_opcode (BINOP_NOTEQUAL);
+ }
+ | operand_2 '>' operand_3
+ {
+ write_exp_elt_opcode (BINOP_GTR);
+ }
+ | operand_2 GTR operand_3
+ {
+ write_exp_elt_opcode (BINOP_GEQ);
+ }
+ | operand_2 '<' operand_3
+ {
+ write_exp_elt_opcode (BINOP_LESS);
+ }
+ | operand_2 LEQ operand_3
+ {
+ write_exp_elt_opcode (BINOP_LEQ);
+ }
+ | operand_2 IN operand_3
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+
+/* Z.200, 5.3.6 */
+
+operand_3 : operand_4
+ {
+ $$ = 0; /* FIXME */
+ }
+ | operand_3 '+' operand_4
+ {
+ write_exp_elt_opcode (BINOP_ADD);
+ }
+ | operand_3 '-' operand_4
+ {
+ write_exp_elt_opcode (BINOP_SUB);
+ }
+ | operand_3 SLASH_SLASH operand_4
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.3.7 */
+
+operand_4 : operand_5
+ {
+ $$ = 0; /* FIXME */
+ }
+ | operand_4 '*' operand_5
+ {
+ write_exp_elt_opcode (BINOP_MUL);
+ }
+ | operand_4 '/' operand_5
+ {
+ write_exp_elt_opcode (BINOP_DIV);
+ }
+ | operand_4 MOD operand_5
+ {
+ $$ = 0; /* FIXME */
+ }
+ | operand_4 REM operand_5
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.3.8 */
+
+operand_5 : operand_6
+ {
+ $$ = 0; /* FIXME */
+ }
+ | '-' operand_6
+ {
+ write_exp_elt_opcode (UNOP_NEG);
+ }
+ | NOT operand_6
+ {
+ write_exp_elt_opcode (UNOP_LOGICAL_NOT);
+ }
+ | '(' integer_literal_expression ')' operand_6
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+/* Z.200, 5.3.9 */
+
+operand_6 : POINTER location
+ {
+ $$ = 0; /* FIXME */
+ }
+ | RECEIVE buffer_location
+ {
+ $$ = 0; /* FIXME */
+ }
+ | primitive_value
+ {
+ $$ = 0; /* FIXME */
+ }
+ ;
+
+
+/* Z.200, 12.4.3 */
+/* FIXME: For now we just accept only a single integer literal. */
+
+integer_literal_expression:
+ INTEGER_LITERAL
+ {
+ $$ = 0;
+ }
+
+/* Things which still need productions... */
+synonym_name : FIXME { $$ = 0; }
+value_enumeration_name : FIXME { $$ = 0; }
+value_do_with_name : FIXME { $$ = 0; }
+value_receive_name : FIXME { $$ = 0; }
+general_procedure_name : FIXME { $$ = 0; }
+string_primitive_value : FIXME { $$ = 0; }
+start_element : FIXME { $$ = 0; }
+left_element : FIXME { $$ = 0; }
+right_element : FIXME { $$ = 0; }
+slice_size : FIXME { $$ = 0; }
+array_primitive_value : FIXME { $$ = 0; }
+expression_list : FIXME { $$ = 0; }
+lower_element : FIXME { $$ = 0; }
+upper_element : FIXME { $$ = 0; }
+first_element : FIXME { $$ = 0; }
+structure_primitive_value: FIXME { $$ = 0; }
+field_name : FIXME { $$ = 0; }
+mode_name : FIXME { $$ = 0; }
+boolean_expression : FIXME { $$ = 0; }
+case_selector_list : FIXME { $$ = 0; }
+subexpression : FIXME { $$ = 0; }
+case_label_specification: FIXME { $$ = 0; }
+buffer_location : FIXME { $$ = 0; }
+
+%%
+
+/* Recognize a character literal. */
+
+static int
+decode_character_literal ()
+{
+ char *tokptr = lexptr;
+ int ival = 0;
+
+ if (*tokptr++ != '\'')
+ {
+ return (0);
+ }
+
+ if (*tokptr != '\\')
+ {
+ ival = *++tokptr;
+ tokptr++;
+ }
+ else
+ {
+
+ }
+ if (*++tokptr != '\'')
+ {
+ return (0);
+ }
+ yylval.typed_val.val = ival;
+ yylval.typed_val.type = builtin_type_int;
+ lexptr = tokptr;
+ return (CHARACTER_LITERAL);
+}
+
+/* Recognize an integer literal, as specified in Z.200 sec 5.2.4.2.
+ Note that according to 5.2.4.2, a single "_" is also a valid integer
+ literal, however GNU-chill requires there to be at least one "digit"
+ in any integer literal. */
+
+static int
+decode_integer_literal ()
+{
+ char *tokptr = lexptr;
+ int ival = 0;
+ int base = 0;
+ int digits = 0;
+ int temp;
+
+ /* Look for an explicit base specifier, which is optional. */
+
+ switch (*tokptr)
+ {
+ case 'd':
+ case 'D':
+ base = 10;
+ tokptr++;
+ break;
+ case 'b':
+ case 'B':
+ base = 2;
+ tokptr++;
+ break;
+ case 'h':
+ case 'H':
+ base = 16;
+ tokptr++;
+ break;
+ case 'o':
+ case 'O':
+ base = 8;
+ tokptr++;
+ break;
+ }
+
+ /* If we found no explicit base then default to 10, otherwise ensure
+ that the character after the explicit base is a single quote. */
+
+ if (base == 0)
+ {
+ base = 10;
+ }
+ else
+ {
+ if (*tokptr++ != '\'')
+ {
+ return (0);
+ }
+ }
+
+ /* Start looking for a value composed of valid digits as set by the base
+ in use. Note that '_' characters are valid anywhere, in any quantity,
+ and are simply ignored. Since we must find at least one valid digit,
+ or reject this token as an integer literal, we keep track of how many
+ digits we have encountered. */
+
+ while (*tokptr != '\0')
+ {
+ temp = tolower (*tokptr);
+ tokptr++;
+ switch (temp)
+ {
+ case '_':
+ continue;
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ temp -= '0';
+ break;
+ case 'a': case 'b': case 'c': case 'd': case 'e':
+ case 'f':
+ temp -= 'a';
+ temp += 10;
+ break;
+ default:
+ temp = base;
+ break;
+ }
+ if (temp < base)
+ {
+ digits++;
+ ival *= base;
+ ival += temp;
+ }
+ else
+ {
+ /* Found something not in domain for current base. */
+ tokptr--; /* Unconsume what gave us indigestion. */
+ break;
+ }
+ }
+
+ /* If we didn't find any digits, then we don't have a valid integer
+ literal, so reject the entire token. Otherwise, set up the parser
+ variables, advance the current lexical scan pointer, and return the
+ INTEGER_LITERAL token. */
+
+ if (digits == 0)
+ {
+ return (0);
+ }
+ else
+ {
+ yylval.typed_val.val = ival;
+ yylval.typed_val.type = builtin_type_int;
+ lexptr = tokptr;
+ return (INTEGER_LITERAL);
+ }
+}
+
+static void convert_float ()
+{
+#if 0
+ extern double strtod ();
+ double d;
+ char tmp[256];
+ char *p = yytext, *p1 = tmp;
+ char c;
+
+ while (c = *p++)
+ {
+ switch (c)
+ {
+ case '_':
+ break;
+ case 'E':
+ case 'd':
+ case 'D':
+ *p1++ = 'e';
+ break;
+ default:
+ *p1++ = c;
+ break;
+ }
+ }
+ *p1 = '\0';
+ d = strtod (tmp, &p1);
+ if (*p1)
+ {
+ /* add error handling here */
+ ;
+ }
+ yylval.dval = d;
+#endif
+}
+
+/* Take care of parsing a number (anything that starts with a digit).
+ Set yylval and return the token type; update lexptr.
+ LEN is the number of characters in it. */
+
+/*** Needs some error checking for the float case ***/
+
+static int
+parse_number ()
+{
+}
+
+struct token
+{
+ char *operator;
+ int token;
+};
+
+const static struct token tokentab5[] =
+{
+ { "ANDIF", ANDIF }
+};
+
+const static struct token tokentab4[] =
+{
+ { "ORIF", ORIF }
+};
+
+const static struct token tokentab3[] =
+{
+ { "NOT", NOT },
+ { "XOR", LOGXOR },
+ { "AND", LOGAND }
+};
+
+const static struct token tokentab2[] =
+{
+ { "//", SLASH_SLASH },
+ { "/=", NOTEQUAL },
+ { "<=", LEQ },
+ { ">=", GTR },
+ { "IN", IN },
+ { "OR", LOGIOR }
+};
+
+/* Read one token, getting characters through lexptr. */
+/* This is where we will check to make sure that the language and the
+ operators used are compatible. */
+
+static int
+yylex ()
+{
+ unsigned int i;
+ int token;
+
+ /* Skip over any leading whitespace. */
+ while (isspace (*lexptr))
+ {
+ lexptr++;
+ }
+ /* Look for special single character cases which can't be the first
+ character of some other multicharacter token. */
+ switch (*lexptr)
+ {
+ case '\0':
+ return (0);
+ case '.':
+ case '=':
+ case ':':
+ case ';':
+ case '!':
+ case '+':
+ case '-':
+ case '*':
+ case '/':
+ case '(':
+ case ')':
+ case '[':
+ case ']':
+ return (*lexptr++);
+ }
+ /* Look for characters which start a particular kind of multicharacter
+ token, such as a character literal. */
+ switch (*lexptr)
+ {
+ case '\'':
+ if ((token = decode_character_literal ()) != 0)
+ {
+ return (token);
+ }
+ break;
+ }
+ /* See if it is a special token of length 5. */
+ for (i = 0; i < sizeof (tokentab5) / sizeof (tokentab5[0]); i++)
+ {
+ if (strncmp (lexptr, tokentab5[i].operator, 5) == 0)
+ {
+ 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 (strncmp (lexptr, tokentab4[i].operator, 4) == 0)
+ {
+ 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 (strncmp (lexptr, tokentab3[i].operator, 3) == 0)
+ {
+ 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++)
+ {
+ if (strncmp (lexptr, tokentab2[i].operator, 2) == 0)
+ {
+ lexptr += 2;
+ return (tokentab2[i].token);
+ }
+ }
+ /* Look for single character cases which which could be the first
+ character of some other multicharacter token, but aren't, or we
+ would already have found it. */
+ switch (*lexptr)
+ {
+ case '/':
+ case '<':
+ case '>':
+ return (*lexptr++);
+ }
+ /* Look for other special tokens. */
+ if (strncmp (lexptr, "TRUE", 4) == 0) /* FIXME: What about lowercase? */
+ {
+ yylval.ulval = 1;
+ lexptr += 4;
+ return (BOOLEAN_LITERAL);
+ }
+ if (strncmp (lexptr, "FALSE", 5) == 0) /* FIXME: What about lowercase? */
+ {
+ yylval.ulval = 0;
+ lexptr += 5;
+ return (BOOLEAN_LITERAL);
+ }
+ if ((token = decode_integer_literal ()) != 0)
+ {
+ return (token);
+ }
+ return (ILLEGAL_TOKEN);
+}
+
+static void
+yyerror (msg)
+ char *msg; /* unused */
+{
+ printf ("Parsing: %s\n", lexptr);
+ if (yychar < 256)
+ {
+ error ("Invalid syntax in expression near character '%c'.", yychar);
+ }
+ else
+ {
+ error ("Invalid syntax in expression");
+ }
+}
+
+\f
+/* Table of operators and their precedences for printing expressions. */
+
+const static struct op_print chill_op_print_tab[] = {
+ {"AND", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
+ {"OR", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
+ {"NOT", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
+ {"MOD", BINOP_REM, PREC_MUL, 0},
+ {":=", BINOP_ASSIGN, PREC_ASSIGN, 1},
+ {"=", BINOP_EQUAL, PREC_EQUAL, 0},
+ {"/=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
+ {"<=", BINOP_LEQ, PREC_ORDER, 0},
+ {">=", BINOP_GEQ, PREC_ORDER, 0},
+ {">", BINOP_GTR, PREC_ORDER, 0},
+ {"<", BINOP_LESS, PREC_ORDER, 0},
+ {"+", BINOP_ADD, PREC_ADD, 0},
+ {"-", BINOP_SUB, PREC_ADD, 0},
+ {"*", BINOP_MUL, PREC_MUL, 0},
+ {"/", BINOP_DIV, PREC_MUL, 0},
+ {"-", UNOP_NEG, PREC_PREFIX, 0},
+ {NULL, 0, 0, 0}
+};
+
+\f
+/* The built-in types of Chill. */
+
+struct type *builtin_type_chill_bool;
+struct type *builtin_type_chill_long;
+struct type *builtin_type_chill_ulong;
+struct type *builtin_type_chill_real;
+
+struct type ** const (chill_builtin_types[]) =
+{
+ &builtin_type_chill_bool,
+ &builtin_type_chill_long,
+ &builtin_type_chill_ulong,
+ &builtin_type_chill_real,
+ 0
+};
+
+const struct language_defn chill_language_defn = {
+ "chill",
+ language_chill,
+ chill_builtin_types,
+ range_check_on,
+ type_check_on,
+ chill_parse, /* parser */
+ chill_error, /* parser error function */
+ &BUILTIN_TYPE_LONGEST, /* longest signed integral type */
+ &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
+ &builtin_type_chill_real, /* longest floating point type */
+ "0x%x", "0x%", "x", /* Hex format, prefix, suffix */
+ "0%o", "0%", "o", /* Octal format, prefix, suffix */
+ chill_op_print_tab, /* expression operators for printing */
+ LANG_MAGIC
+};
+
+/* Initialization for Chill */
+
+void
+_initialize_chill_exp ()
+{
+ builtin_type_chill_bool =
+ init_type (TYPE_CODE_BOOL, TARGET_INT_BIT / TARGET_CHAR_BIT,
+ TYPE_FLAG_UNSIGNED,
+ "BOOL", (struct objfile *) NULL);
+ builtin_type_chill_long =
+ init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
+ 0,
+ "LONG", (struct objfile *) NULL);
+ builtin_type_chill_ulong =
+ init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
+ TYPE_FLAG_UNSIGNED,
+ "ULONG", (struct objfile *) NULL);
+ builtin_type_chill_real =
+ init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
+ 0,
+ "LONG_REAL", (struct objfile *) NULL);
+
+ add_language (&chill_language_defn);
+}
#define QUIT { if (quit_flag) quit (); }
-/* Notes on classes: class_alias is for alias commands which are not
- abbreviations of the original command. */
+/* Command classes are top-level categories into which commands are broken
+ down for "help" purposes.
+ Notes on classes: class_alias is for alias commands which are not
+ abbreviations of the original command. class-pseudo is for commands
+ which are not really commands nor help topics ("stop"). */
enum command_class
{
/* Classes of commands */
no_class = -1, class_run = 0, class_vars, class_stack,
class_files, class_support, class_info, class_breakpoint,
- class_alias, class_obscure, class_user, class_maintenance
+ class_alias, class_obscure, class_user, class_maintenance,
+ class_pseudo
};
/* the cleanup list records things that have to be undone
language_auto, /* Placeholder for automatic setting */
language_c, /* C */
language_cplus, /* C++ */
+ language_chill, /* Chill */
language_m2 /* Modula-2 */
};
#include "xm.h"
+/* Native machine support. This will be a symlink to one of the
+ nm-*.h files, built by the `configure' script. */
+
+#include "nm.h"
+
/* If the xm.h file did not define the mode string used to open the
files, assume that binary files are opened the same way as text
files */
#define MAINTENANCE_CMDS 1
#endif
-#include "energize.h"
-
#endif /* !defined (DEFS_H) */
case LANG_C_PLUS_PLUS:
cu_language = language_cplus;
break;
+ case LANG_CHILL:
+ cu_language = language_chill;
+ break;
+ case LANG_MODULA2:
+ cu_language = language_m2;
+ break;
case LANG_ADA83:
case LANG_COBOL74:
case LANG_COBOL85:
case LANG_FORTRAN77:
case LANG_FORTRAN90:
case LANG_PASCAL83:
- case LANG_MODULA2:
default:
cu_language = language_unknown;
break;
(*pos) += 2;
return value_of_register (longest_to_int (exp->elts[pc + 1].longconst));
+ case OP_BOOL:
+ (*pos) += 2;
+ return value_from_longest (builtin_type_chill_bool,
+ exp->elts[pc + 1].longconst);
+
case OP_INTERNALVAR:
(*pos) += 2;
return value_of_internalvar (exp->elts[pc + 1].internalvar);
case TERNOP_COND:
/* Skip third and second args to evaluate the first one. */
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (value_zerop (arg1))
+ if (value_logical_not (arg1))
{
evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
return evaluate_subexp (NULL_TYPE, exp, pos, noside);
nargs = longest_to_int (exp->elts[pc + 1].longconst) + 1;
/* First, evaluate the structure into arg2 */
pc2 = (*pos)++;
- /* type = exp->elts[pc2 + 1].type; */
- tem2 = strlen (&exp->elts[pc2 + 2].string);
- *pos += 3 + (tem2 + sizeof (union exp_element)) / sizeof (union exp_element);
+ tem2 = strlen (&exp->elts[pc2 + 1].string);
+ *pos += 2 + (tem2 + sizeof (union exp_element)) / sizeof (union exp_element);
if (noside == EVAL_SKIP)
goto nosideret;
int static_memfuncp;
value temp = arg2;
- /* argvec[0] gets the method;
- argvec[1] gets the 'this' pointer (unless static) (from arg2);
- the remaining args go into the rest of argvec. */
-
argvec[1] = arg2;
argvec[0] =
- value_struct_elt (&temp, argvec+1, &exp->elts[pc2 + 2].string,
+ value_struct_elt (&temp, argvec+1, &exp->elts[pc2 + 1].string,
&static_memfuncp,
op == STRUCTOP_STRUCT
? "structure" : "structure pointer");
return call_function_by_hand (argvec[0], nargs, argvec + 1);
case STRUCTOP_STRUCT:
- tem = strlen (&exp->elts[pc + 2].string);
- (*pos) += 3 + ((tem + sizeof (union exp_element))
+ tem = strlen (&exp->elts[pc + 1].string);
+ (*pos) += 2 + ((tem + sizeof (union exp_element))
/ sizeof (union exp_element));
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
- goto handle_structop_ptr;
- type = exp->elts[pc + 1].type;
- if (type)
- arg1 = value_ind (value_cast (lookup_pointer_type (type),
- value_addr (arg1)));
if (noside == EVAL_SKIP)
goto nosideret;
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1),
- &exp->elts[pc + 2].string,
+ &exp->elts[pc + 1].string,
0),
lval_memory);
else
{
value temp = arg1;
- return value_struct_elt (&temp, (value *)0, &exp->elts[pc + 2].string,
+ return value_struct_elt (&temp, (value *)0, &exp->elts[pc + 1].string,
(int *) 0, "structure");
}
case STRUCTOP_PTR:
- tem = strlen (&exp->elts[pc + 2].string);
- (*pos) += 3 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
+ tem = strlen (&exp->elts[pc + 1].string);
+ (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
- handle_structop_ptr:
- type = exp->elts[pc + 1].type;
- if (type)
- arg1 = value_cast (lookup_pointer_type (type), arg1);
if (noside == EVAL_SKIP)
goto nosideret;
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return value_zero (lookup_struct_elt_type (TYPE_TARGET_TYPE
(VALUE_TYPE (arg1)),
- &exp->elts[pc + 2].string,
+ &exp->elts[pc + 1].string,
0),
lval_memory);
else
{
value temp = arg1;
- return value_struct_elt (&temp, (value *)0, &exp->elts[pc + 2].string,
+ return value_struct_elt (&temp, (value *)0, &exp->elts[pc + 1].string,
(int *) 0, "structure pointer");
}
case BINOP_REM:
case BINOP_LSH:
case BINOP_RSH:
- case BINOP_LOGAND:
- case BINOP_LOGIOR:
- case BINOP_LOGXOR:
+ case BINOP_BITWISE_AND:
+ case BINOP_BITWISE_IOR:
+ case BINOP_BITWISE_XOR:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
else
return value_subscript (arg1, arg2);
- case BINOP_AND:
+ case BINOP_LOGICAL_AND:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
{
}
else
{
- tem = value_zerop (arg1);
+ tem = value_logical_not (arg1);
arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
(tem ? EVAL_SKIP : noside));
return value_from_longest (builtin_type_int,
- (LONGEST) (!tem && !value_zerop (arg2)));
+ (LONGEST) (!tem && !value_logical_not (arg2)));
}
- case BINOP_OR:
+ case BINOP_LOGICAL_OR:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
{
}
else
{
- tem = value_zerop (arg1);
+ tem = value_logical_not (arg1);
arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
(!tem ? EVAL_SKIP : noside));
return value_from_longest (builtin_type_int,
- (LONGEST) (!tem || !value_zerop (arg2)));
+ (LONGEST) (!tem || !value_logical_not (arg2)));
}
case BINOP_EQUAL:
else
return value_neg (arg1);
- case UNOP_LOGNOT:
+ case UNOP_COMPLEMENT:
/* C++: check for and handle destructor names. */
op = exp->elts[*pos].opcode;
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
- if (unop_user_defined_p (UNOP_LOGNOT, arg1))
- return value_x_unop (arg1, UNOP_LOGNOT);
+ if (unop_user_defined_p (UNOP_COMPLEMENT, arg1))
+ return value_x_unop (arg1, UNOP_COMPLEMENT);
else
- return value_lognot (arg1);
+ return value_complement (arg1);
- case UNOP_ZEROP:
+ case UNOP_LOGICAL_NOT:
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
return value_x_unop (arg1, op);
else
return value_from_longest (builtin_type_int,
- (LONGEST) value_zerop (arg1));
+ (LONGEST) value_logical_not (arg1));
case UNOP_IND:
if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
/* Modula-2 */
TYPE_CODE_CHAR, /* *real* character type */
- TYPE_CODE_BOOL /* Builtin Modula-2 BOOLEAN */
+ TYPE_CODE_BOOL /* Builtin Modula-2/Chill BOOLEAN */
};
/* For now allow source to use TYPE_CODE_CLASS for C++ classes, as an
extern struct type *builtin_type_m2_real;
extern struct type *builtin_type_m2_bool;
+/* Chill types */
+
+extern struct type *builtin_type_chill_bool;
+extern struct type *builtin_type_chill_long;
+extern struct type *builtin_type_chill_ulong;
+extern struct type *builtin_type_chill_real;
+
/* LONG_LONG is defined if the host has "long long". */
#ifdef LONG_LONG
#endif
#include <sys/param.h>
-#include <sys/dir.h>
#include <signal.h>
#include <sys/user.h>
#include <sys/ioctl.h>
static const struct language_defn **languages;
static unsigned languages_size;
static unsigned languages_allocsize;
-#define DEFAULT_ALLOCSIZE 3
+#define DEFAULT_ALLOCSIZE 4
/* The "set language/type/range" commands all put stuff in these
buffers. This is to make them work as set/show commands. The
local or auto Automatic setting based on source file\n\
c Use the C language\n\
c++ Use the C++ language\n\
+chill Use the Chill language\n\
modula-2 Use the Modula-2 language\n");
/* Restore the silly string. */
set_language(current_language->la_language);
not needed. */
return l1 > l2 ? VALUE_TYPE(v1) : VALUE_TYPE(v2);
break;
+ case language_chill:
+ error ("Missing Chill support in function binop_result_check.");/*FIXME*/
}
abort();
return (struct type *)0; /* For lint */
(TYPE_CODE(type) != TYPE_CODE_ENUM) ? 0 : 1;
case language_m2:
return TYPE_CODE(type) != TYPE_CODE_INT ? 0 : 1;
+ case language_chill:
+ error ("Missing Chill support in function integral_type."); /*FIXME*/
default:
error ("Language not supported.");
}
return (TYPE_CODE(type) == TYPE_CODE_INT) &&
TYPE_LENGTH(type) == sizeof(char)
? 1 : 0;
+ case language_chill:
+ error ("Missing Chill support in function character_type."); /*FIXME*/
default:
return (0);
}
{
switch(current_language->la_language)
{
+ case language_chill:
case language_m2:
return TYPE_CODE(type) != TYPE_CODE_BOOL ? 0 : 1;
return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
(TYPE_CODE(type) == TYPE_CODE_SET) ||
(TYPE_CODE(type) == TYPE_CODE_ARRAY);
+ case language_chill:
+ error ("Missing Chill support in function structured_type."); /*FIXME*/
default:
return (0);
}
case language_c:
case language_cplus:
- return !value_zerop (val);
+ return !value_logical_not (val);
case language_m2:
type = VALUE_TYPE(val);
return 0; /* BOOLEAN with value FALSE */
break;
+ case language_chill:
+ error ("Missing Chill support in function value_type."); /*FIXME*/
+
default:
error ("Language not supported.");
}
type_op_error ("Arguments to %s must be of the same type.",op);
break;
- case BINOP_AND:
- case BINOP_OR:
+ case BINOP_LOGICAL_AND:
+ case BINOP_LOGICAL_OR:
if (!boolean_type(t1) || !boolean_type(t2))
type_op_error ("Arguments to %s must be of boolean type.",op);
break;
/* Unary checks -- arg2 is null */
- case UNOP_ZEROP:
+ case UNOP_LOGICAL_NOT:
if (!boolean_type(t1))
type_op_error ("Argument to %s must be of boolean type.",op);
break;
break;
}
#endif
+
+#ifdef _LANG_chill
+ case language_chill:
+ error ("Missing Chill support in function binop_type_check.");/*FIXME*/
+#endif
+
}
}
}
/* #include "lang_def.h" */
#define _LANG_c
#define _LANG_m2
+#define _LANG_chill
/* range_mode ==
range_mode_auto: range_check set automatically to default of language.
yyparse PARAMS ((void));
/* The sign of the number being parsed. */
-int number_sign = 1;
+static int number_sign = 1;
/* The block that the module specified by the qualifer on an identifer is
contained in, */
-struct block *modblock=0;
+#if 0
+static struct block *modblock=0;
+#endif
/* #define YYDEBUG 1 */
%}
%nonassoc ASSIGN
%left '<' '>' LEQ GEQ '=' NOTEQUAL '#' IN
%left OROR
-%left ANDAND '&'
+%left LOGICAL_AND '&'
%left '@'
%left '+' '-'
%left '*' '/' DIV MOD
;
exp : not_exp exp %prec UNARY
- { write_exp_elt_opcode (UNOP_ZEROP); }
+ { write_exp_elt_opcode (UNOP_LOGICAL_NOT); }
;
not_exp : NOT
{ write_exp_elt_opcode (BINOP_GTR); }
;
-exp : exp ANDAND exp
- { write_exp_elt_opcode (BINOP_AND); }
- ;
-
-exp : exp '&' exp
- { write_exp_elt_opcode (BINOP_AND); }
+exp : exp LOGICAL_AND exp
+ { write_exp_elt_opcode (BINOP_LOGICAL_AND); }
;
exp : exp OROR exp
- { write_exp_elt_opcode (BINOP_OR); }
+ { write_exp_elt_opcode (BINOP_LOGICAL_OR); }
;
exp : exp ASSIGN exp
{
{"OR" , OROR },
{"IN", IN },/* Note space after IN */
- {"AND", ANDAND },
+ {"AND", LOGICAL_AND},
{"ABS", ABS },
{"CHR", CHR },
{"DEC", DEC },
{"DIV", BINOP_INTDIV, PREC_MUL, 0},
{"MOD", BINOP_REM, PREC_MUL, 0},
{":=", BINOP_ASSIGN, PREC_ASSIGN, 1},
- {"OR", BINOP_OR, PREC_OR, 0},
- {"AND", BINOP_AND, PREC_AND, 0},
- {"NOT", UNOP_ZEROP, PREC_PREFIX, 0},
+ {"OR", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
+ {"AND", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
+ {"NOT", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
{"=", BINOP_EQUAL, PREC_EQUAL, 0},
{"<>", BINOP_NOTEQUAL, PREC_EQUAL, 0},
{"<=", BINOP_LEQ, PREC_ORDER, 0},
{"<", BINOP_LESS, PREC_ORDER, 0},
{"^", UNOP_IND, PREC_PREFIX, 0},
{"@", BINOP_REPEAT, PREC_REPEAT, 0},
+ {NULL, 0, 0, 0}
};
\f
/* The built-in types of Modula-2. */
they are used as the "surrounding precedence" to force
various kinds of things to be parenthesized. */
enum precedence
-{ PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_OR, PREC_AND,
- PREC_LOGIOR, PREC_LOGAND, PREC_LOGXOR, PREC_EQUAL, PREC_ORDER,
- PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT,
+{ PREC_NULL, PREC_COMMA, PREC_ABOVE_COMMA, PREC_ASSIGN, PREC_LOGICAL_OR,
+ PREC_LOGICAL_AND, PREC_BITWISE_IOR, PREC_BITWISE_AND, PREC_BITWISE_XOR,
+ PREC_EQUAL, PREC_ORDER, PREC_SHIFT, PREC_ADD, PREC_MUL, PREC_REPEAT,
PREC_HYPER, PREC_PREFIX, PREC_SUFFIX };
/* Table mapping opcodes into strings for printing operators
#include "objfiles.h"
#include "gdbcmd.h"
#include "breakpoint.h"
+#include "language.h"
#include <obstack.h>
#include <assert.h>
/* Functions this file defines */
+static void
+set_initial_language PARAMS ((void));
+
static void
load_command PARAMS ((char *, int));
current_source_line = 0;
if (from_tty)
{
- printf_filtered ("No symbol file now.\n");
+ printf ("No symbol file now.\n");
}
}
else
else
{
symbol_file_add (name, from_tty, (CORE_ADDR)0, 1, mapped, readnow);
+ set_initial_language ();
}
do_cleanups (cleanups);
}
}
+/* Set the initial language.
+
+ A better solution would be to record the language in the psymtab when reading
+ partial symbols, and then use it (if known) to set the language. This would
+ be a win for formats that encode the language in an easily discoverable place,
+ such as DWARF. For stabs, we can jump through hoops looking for specially
+ named symbols or try to intuit the language from the specific type of stabs
+ we find, but we can't do that until later when we read in full symbols.
+ FIXME. */
+
+static void
+set_initial_language ()
+{
+ struct partial_symtab *pst;
+ enum language lang = language_unknown;
+
+ pst = find_main_psymtab ();
+ if (pst != NULL)
+ {
+ if (pst -> filename != NULL)
+ {
+ lang = deduce_language_from_filename (pst -> filename);
+ }
+ if (lang == language_unknown)
+ {
+ /* Make C the default language */
+ lang = language_c;
+ }
+ set_language (lang);
+ expected_language = current_language; /* Don't warn the user */
+ }
+}
+
/* Open file specified by NAME and hand it off to BFD for preliminary
analysis. Result is a newly initialized bfd *, which includes a newly
malloc'd` copy of NAME (tilde-expanded and made absolute).
error ("\"%s\": can't open to read symbols: %s.", name,
bfd_errmsg (bfd_error));
}
+ sym_bfd->cacheable = true;
if (!bfd_check_format (sym_bfd, bfd_object))
{
return language_c;
else if(!strcmp(c,".cc") || !strcmp(c,".C"))
return language_cplus;
+ else if(!strcmp(c,".chill") || !strcmp(c,".c186") || !strcmp(c,".c286"))
+ return language_chill;
return language_unknown; /* default */
}
return;
clear_symtab_users_done = clear_symtab_users_queued;
- printf_filtered ("Resetting debugger state after updating old symbol tables\n");
+ printf ("Resetting debugger state after updating old symbol tables\n");
/* Someday, we should do better than this, by only blowing away
the things that really need to be blown. */
error ("no such vector element");
v = allocate_value (elt_type);
- (void) memcpy (VALUE_CONTENTS (v), VALUE_CONTENTS (array) + elt_offs,
- elt_size);
+ memcpy (VALUE_CONTENTS (v), VALUE_CONTENTS (array) + elt_offs, elt_size);
if (VALUE_LVAL (array) == lval_internalvar)
VALUE_LVAL (v) = lval_internalvar_component;
ptr = tstr+8;
switch (op)
{
- case BINOP_ADD: strcpy(ptr,"+"); break;
- case BINOP_SUB: strcpy(ptr,"-"); break;
- case BINOP_MUL: strcpy(ptr,"*"); break;
- case BINOP_DIV: strcpy(ptr,"/"); break;
- case BINOP_REM: strcpy(ptr,"%"); break;
- case BINOP_LSH: strcpy(ptr,"<<"); break;
- case BINOP_RSH: strcpy(ptr,">>"); break;
- case BINOP_LOGAND: strcpy(ptr,"&"); break;
- case BINOP_LOGIOR: strcpy(ptr,"|"); break;
- case BINOP_LOGXOR: strcpy(ptr,"^"); break;
- case BINOP_AND: strcpy(ptr,"&&"); break;
- case BINOP_OR: strcpy(ptr,"||"); break;
- case BINOP_MIN: strcpy(ptr,"<?"); break;
- case BINOP_MAX: strcpy(ptr,">?"); break;
- case BINOP_ASSIGN: strcpy(ptr,"="); break;
+ case BINOP_ADD: strcpy(ptr,"+"); break;
+ case BINOP_SUB: strcpy(ptr,"-"); break;
+ case BINOP_MUL: strcpy(ptr,"*"); break;
+ case BINOP_DIV: strcpy(ptr,"/"); break;
+ case BINOP_REM: strcpy(ptr,"%"); break;
+ case BINOP_LSH: strcpy(ptr,"<<"); break;
+ case BINOP_RSH: strcpy(ptr,">>"); break;
+ case BINOP_BITWISE_AND: strcpy(ptr,"&"); break;
+ case BINOP_BITWISE_IOR: strcpy(ptr,"|"); break;
+ case BINOP_BITWISE_XOR: strcpy(ptr,"^"); break;
+ case BINOP_LOGICAL_AND: strcpy(ptr,"&&"); break;
+ case BINOP_LOGICAL_OR: strcpy(ptr,"||"); break;
+ case BINOP_MIN: strcpy(ptr,"<?"); break;
+ case BINOP_MAX: strcpy(ptr,">?"); break;
+ case BINOP_ASSIGN: strcpy(ptr,"="); break;
case BINOP_ASSIGN_MODIFY:
switch (otherop)
{
- case BINOP_ADD: strcpy(ptr,"+="); break;
- case BINOP_SUB: strcpy(ptr,"-="); break;
- case BINOP_MUL: strcpy(ptr,"*="); break;
- case BINOP_DIV: strcpy(ptr,"/="); break;
- case BINOP_REM: strcpy(ptr,"%="); break;
- case BINOP_LOGAND: strcpy(ptr,"&="); break;
- case BINOP_LOGIOR: strcpy(ptr,"|="); break;
- case BINOP_LOGXOR: strcpy(ptr,"^="); break;
+ case BINOP_ADD: strcpy(ptr,"+="); break;
+ case BINOP_SUB: strcpy(ptr,"-="); break;
+ case BINOP_MUL: strcpy(ptr,"*="); break;
+ case BINOP_DIV: strcpy(ptr,"/="); break;
+ case BINOP_REM: strcpy(ptr,"%="); break;
+ case BINOP_BITWISE_AND: strcpy(ptr,"&="); break;
+ case BINOP_BITWISE_IOR: strcpy(ptr,"|="); break;
+ case BINOP_BITWISE_XOR: strcpy(ptr,"^="); break;
default:
error ("Invalid binary operation specified.");
}
case UNOP_PREDECREMENT: strcpy(ptr,"++"); break;
case UNOP_POSTINCREMENT: strcpy(ptr,"++"); break;
case UNOP_POSTDECREMENT: strcpy(ptr,"++"); break;
- case UNOP_ZEROP: strcpy(ptr,"!"); break;
- case UNOP_LOGNOT: strcpy(ptr,"~"); break;
- case UNOP_NEG: strcpy(ptr,"-"); break;
+ case UNOP_LOGICAL_NOT: strcpy(ptr,"!"); break;
+ case UNOP_COMPLEMENT: strcpy(ptr,"~"); break;
+ case UNOP_NEG: strcpy(ptr,"-"); break;
default:
error ("Invalid binary operation specified.");
}
if ((TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_FLT
&&
- TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
+ TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT
+ &&
+ TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_BOOL)
||
(TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_FLT
&&
- TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT))
- error ("Argument to arithmetic operation not a number.");
+ TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT
+ &&
+ TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_BOOL))
+ error ("Argument to arithmetic operation not a number or boolean.");
if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FLT
||
SWAP_TARGET_AND_HOST (&v, sizeof (v));
*(double *) VALUE_CONTENTS_RAW (val) = v;
}
+ else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_BOOL
+ &&
+ TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_BOOL)
+ {
+ LONGEST v1, v2, v;
+ v1 = value_as_long (arg1);
+ v2 = value_as_long (arg2);
+
+ switch (op)
+ {
+ case BINOP_BITWISE_AND:
+ v = v1 & v2;
+ break;
+
+ case BINOP_BITWISE_IOR:
+ v = v1 | v2;
+ break;
+
+ case BINOP_BITWISE_XOR:
+ v = v1 ^ v2;
+ break;
+
+ default:
+ error ("Invalid operation on booleans.");
+ }
+
+ val = allocate_value (builtin_type_chill_bool);
+ SWAP_TARGET_AND_HOST (&v, sizeof (v));
+ *(LONGEST *) VALUE_CONTENTS_RAW (val) = v;
+ }
else
/* Integral operations here. */
+ /* FIXME: Also mixed integral/booleans, with result an integer. */
{
/* Should we promote to unsigned longest? */
if ((TYPE_UNSIGNED (VALUE_TYPE (arg1))
v = v1 >> v2;
break;
- case BINOP_LOGAND:
+ case BINOP_BITWISE_AND:
v = v1 & v2;
break;
- case BINOP_LOGIOR:
+ case BINOP_BITWISE_IOR:
v = v1 | v2;
break;
- case BINOP_LOGXOR:
+ case BINOP_BITWISE_XOR:
v = v1 ^ v2;
break;
- case BINOP_AND:
+ case BINOP_LOGICAL_AND:
v = v1 && v2;
break;
- case BINOP_OR:
+ case BINOP_LOGICAL_OR:
v = v1 || v2;
break;
v = v1 >> v2;
break;
- case BINOP_LOGAND:
+ case BINOP_BITWISE_AND:
v = v1 & v2;
break;
- case BINOP_LOGIOR:
+ case BINOP_BITWISE_IOR:
v = v1 | v2;
break;
- case BINOP_LOGXOR:
+ case BINOP_BITWISE_XOR:
v = v1 ^ v2;
break;
- case BINOP_AND:
+ case BINOP_LOGICAL_AND:
v = v1 && v2;
break;
- case BINOP_OR:
+ case BINOP_LOGICAL_OR:
v = v1 || v2;
break;
/* Simulate the C operator ! -- return 1 if ARG1 contains zero. */
int
-value_zerop (arg1)
+value_logical_not (arg1)
value arg1;
{
register int len;
}
value
-value_lognot (arg1)
+value_complement (arg1)
register value arg1;
{
COERCE_ENUM (arg1);
obstack_ptr_grow (&dont_print_obstack, TYPE_BASECLASS (type, i));
}
+ /* Fix to use baseclass_offset instead. FIXME */
baddr = baseclass_addr (type, i, valaddr, 0, &err);
if (err == 0 && baddr == 0)
error ("could not find virtual baseclass `%s'\n",
addr = unpack_pointer (lookup_pointer_type (builtin_type_void),
valaddr);
- if (addr < 128) /* FIXME! What is this 128? */
+ if (METHOD_PTR_IS_VIRTUAL(addr))
{
+ int offset = METHOD_PTR_TO_VOFFSET(addr);
len = TYPE_NFN_FIELDS (domain);
for (i = 0; i < len; i++)
{
for (j = 0; j < len2; j++)
{
QUIT;
- if (TYPE_FN_FIELD_VOFFSET (f, j) == addr)
+ if (TYPE_FN_FIELD_VOFFSET (f, j) == offset)
{
- kind = "virtual";
+ kind = "virtual ";
goto common;
}
}
fprintf_filtered (stream, "<range type>");
break;
+ case TYPE_CODE_BOOL:
+ val = unpack_long (builtin_type_chill_bool, valaddr);
+ fprintf_filtered (stream, val ? "TRUE" : "FALSE");
+ break;
+
default:
error ("Invalid type code in symbol table.");
}
fprintf_filtered(stream, "<builtin> = ");
type_print(type,"",stream,0);
break;
+#endif
+#ifdef _LANG_chill
+ case language_chill:
+ error("Missing Chill support in function typedef_print."); /*FIXME*/
#endif
default:
error("Language not supported.");
fprintf_filtered (stream, ";\n");
}
- /* C++: print out the methods */
+ /* If there are both fields and methods, put a space between. */
len = TYPE_NFN_FIELDS (type);
+ if (len && section_type != s_none)
+ fprintf_filtered (stream, "\n");
+
+ /* C++: print out the methods */
+
for (i = 0; i < len; i++)
{
struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
integers, and that all pointers have the same form. */
if (code == TYPE_CODE_INT || code == TYPE_CODE_ENUM ||
code == TYPE_CODE_CHAR || code == TYPE_CODE_PTR ||
- code == TYPE_CODE_REF)
+ code == TYPE_CODE_REF || code == TYPE_CODE_BOOL)
{
if (len == sizeof (char))
* (char *) VALUE_CONTENTS_RAW (val) = num;
projects / binutils-gdb.git / commitdiff