binutils-gdb/gdb/ada-lex.l

597 lines
14 KiB
Plaintext
Raw Normal View History

2002-06-04 17:28:49 +02:00
/* FLEX lexer for Ada expressions, for GDB.
2007-01-09 18:59:20 +01:00
Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003, 2007
2002-06-04 17:28:49 +02:00
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
* breakpoint.c: * arm-tdep.c: * ia64-tdep.c: * i386-tdep.c: * hpread.c: * hppa-tdep.c: * hppa-hpux-tdep.c: * gnu-nat.c: * gdbtypes.c: * gdbarch.h: * gdbarch.c: * eval.c: * dwarf2read.c: * dbxread.c: * copying: * symfile.c: * stabsread.c: * sh64-tdep.c: * sh-tdep.c: * s390-tdep.c: * rs6000-tdep.c: * remote.c: * remote-mips.c: * mips-tdep.c: * mdebugread.c: * linux-nat.c: * infrun.c: * xcoffread.c: * win32-nat.c: * valops.c: * utils.c: * tracepoint.c: * target.c: * symtab.c: * c-exp.y: * ada-valprint.c: * ada-typeprint.c: * ada-lex.l: * ada-lang.h: * ada-lang.c: * ada-exp.y: * alphafbsd-tdep.c: * alphabsd-tdep.h: * alphabsd-tdep.c: * alphabsd-nat.c: * alpha-tdep.h: * alpha-tdep.c: * alpha-osf1-tdep.c: * alpha-nat.c: * alpha-mdebug-tdep.c: * alpha-linux-tdep.c: * alpha-linux-nat.c: * aix-thread.c: * abug-rom.c: * arch-utils.c: * annotate.h: * annotate.c: * amd64obsd-tdep.c: * amd64obsd-nat.c: * amd64nbsd-tdep.c: * amd64nbsd-nat.c: * amd64fbsd-tdep.c: * amd64fbsd-nat.c: * amd64bsd-nat.c: * amd64-tdep.h: * amd64-tdep.c: * amd64-sol2-tdep.c: * amd64-nat.h: * amd64-nat.c: * amd64-linux-tdep.c: * amd64-linux-nat.c: * alphanbsd-tdep.c: * block.h: * block.c: * bfd-target.h: * bfd-target.c: * bcache.h: * bcache.c: * ax.h: * ax-general.c: * ax-gdb.h: * ax-gdb.c: * avr-tdep.c: * auxv.h: * auxv.c: * armnbsd-tdep.c: * armnbsd-nat.c: * arm-tdep.h: * arm-linux-nat.c: * arch-utils.h: * charset.c: * call-cmds.h: * c-valprint.c: * c-typeprint.c: * c-lang.h: * c-lang.c: * buildsym.h: * buildsym.c: * bsd-uthread.h: * bsd-uthread.c: * bsd-kvm.h: * bsd-kvm.c: * breakpoint.h: * core-regset.c: * core-aout.c: * completer.h: * completer.c: * complaints.h: * complaints.c: * command.h: * coffread.c: * coff-solib.h: * coff-solib.c: * coff-pe-read.h: * coff-pe-read.c: * cli-out.h: * cli-out.c: * charset.h: * dink32-rom.c: * dictionary.h: * dictionary.c: * demangle.c: * defs.h: * dcache.h: * dcache.c: * d10v-tdep.c: * cpu32bug-rom.c: * cp-valprint.c: * cp-support.h: * cp-support.c: * cp-namespace.c: * cp-abi.h: * cp-abi.c: * corelow.c: * corefile.c: * environ.c: * elfread.c: * dwarfread.c: * dwarf2loc.c: * dwarf2expr.h: * dwarf2expr.c: * dwarf2-frame.h: * dwarf2-frame.c: * dve3900-rom.c: * dummy-frame.h: * dummy-frame.c: * dsrec.c: * doublest.h: * doublest.c: * disasm.h: * disasm.c: * fork-child.c: * findvar.c: * fbsd-nat.h: * fbsd-nat.c: * f-valprint.c: * f-typeprint.c: * f-lang.h: * f-lang.c: * expression.h: * expprint.c: * exec.h: * exec.c: * exceptions.h: * exceptions.c: * event-top.h: * event-top.c: * event-loop.h: * event-loop.c: * gdb.c: * gdb-stabs.h: * gdb-events.h: * gdb-events.c: * gcore.c: * frv-tdep.h: * frv-tdep.c: * frv-linux-tdep.c: * frame.h: * frame.c: * frame-unwind.h: * frame-unwind.c: * frame-base.h: * frame-base.c: * gdb_vfork.h: * gdb_thread_db.h: * gdb_string.h: * gdb_stat.h: * gdb_regex.h: * gdb_ptrace.h: * gdb_proc_service.h: * gdb_obstack.h: * gdb_locale.h: * gdb_dirent.h: * gdb_curses.h: * gdb_assert.h: * gdbarch.sh: * gdb.h: * hpux-thread.c: * hppabsd-nat.c: * hppa-tdep.h: * hpacc-abi.c: * h8300-tdep.c: * gregset.h: * go32-nat.c: * gnu-v3-abi.c: * gnu-v2-abi.h: * gnu-v2-abi.c: * gnu-nat.h: * glibc-tdep.c: * gdbtypes.h: * gdbcore.h: * gdbcmd.h: * i386nbsd-tdep.c: * i386nbsd-nat.c: * i386gnu-tdep.c: * i386gnu-nat.c: * i386fbsd-tdep.c: * i386fbsd-nat.c: * i386bsd-tdep.c: * i386bsd-nat.h: * i386bsd-nat.c: * i386-tdep.h: * i386-sol2-nat.c: * i386-nto-tdep.c: * i386-nat.c: * i386-linux-tdep.h: * i386-linux-tdep.c: * i386-linux-nat.c: * i386-cygwin-tdep.c: * inf-ttrace.c: * inf-ptrace.h: * inf-ptrace.c: * inf-loop.h: * inf-loop.c: * inf-child.h: * inf-child.c: * ia64-tdep.h: * ia64-linux-nat.c: * i387-tdep.h: * i387-tdep.c: * i386v4-nat.c: * i386v-nat.c: * i386obsd-tdep.c: * i386obsd-nat.c: * kod.c: * jv-valprint.c: * jv-typeprint.c: * jv-lang.h: * jv-lang.c: * irix5-nat.c: * iq2000-tdep.c: * interps.h: * interps.c: * inftarg.c: * inflow.h: * inflow.c: * inferior.h: * infcmd.c: * infcall.h: * infcall.c: * inf-ttrace.h: * m32r-tdep.h: * m32r-tdep.c: * m32r-rom.c: * m32r-linux-tdep.c: * m32r-linux-nat.c: * m2-valprint.c: * m2-typeprint.c: * m2-lang.h: * m2-lang.c: * lynx-nat.c: * linux-thread-db.c: * linux-nat.h: * linespec.c: * libunwind-frame.h: * libunwind-frame.c: * language.h: * language.c: * macroexp.c: * macrocmd.c: * m88kbsd-nat.c: * m88k-tdep.h: * m88k-tdep.c: * m68klinux-tdep.c: * m68klinux-nat.c: * m68kbsd-tdep.c: * m68kbsd-nat.c: * m68k-tdep.h: * m68k-tdep.c: * mips-linux-nat.c: * mips-irix-tdep.c: * minsyms.c: * memattr.h: * memattr.c: * mem-break.c: * mdebugread.h: * main.h: * main.c: * macrotab.h: * macrotab.c: * macroscope.h: * macroscope.c: * macroexp.h: * nbsd-tdep.c: * mt-tdep.c: * monitor.h: * monitor.c: * mn10300-tdep.h: * mn10300-tdep.c: * mn10300-linux-tdep.c: * mipsv4-nat.c: * mipsread.c: * mipsnbsd-tdep.h: * mipsnbsd-tdep.c: * mipsnbsd-nat.c: * mips64obsd-tdep.c: * mips64obsd-nat.c: * mips-tdep.h: * mips-mdebug-tdep.c: * mips-linux-tdep.c: * osabi.h: * osabi.c: * ocd.h: * ocd.c: * observer.c: * objfiles.h: * objfiles.c: * objc-lang.h: * objc-lang.c: * objc-exp.y: * nto-tdep.h: * nto-tdep.c: * nto-procfs.c: * nlmread.c: * nbsd-tdep.h: * ppcobsd-tdep.c: * ppcobsd-nat.c: * ppcnbsd-tdep.h: * ppcnbsd-tdep.c: * ppcnbsd-nat.c: * ppcbug-rom.c: * ppc-tdep.h: * ppc-sysv-tdep.c: * ppc-linux-tdep.c: * ppc-linux-nat.c: * ppc-bdm.c: * parser-defs.h: * parse.c: * p-valprint.c: * p-typeprint.c: * p-lang.h: * p-lang.c: * remote-fileio.h: * remote-fileio.c: * remote-est.c: * remote-e7000.c: * regset.h: * regset.c: * reggroups.h: * reggroups.c: * regcache.h: * regcache.c: * proc-why.c: * proc-service.c: * proc-events.c: * printcmd.c: * ppcobsd-tdep.h: * sentinel-frame.h: * sentinel-frame.c: * scm-valprint.c: * scm-tags.h: * scm-lang.h: * scm-lang.c: * scm-exp.c: * s390-tdep.h: * rom68k-rom.c: * remote.h: * remote-utils.c: * remote-st.c: * remote-sim.c: * remote-sds.c: * remote-rdp.c: * remote-rdi.c: * remote-hms.c: * sim-regno.h: * shnbsd-tdep.h: * shnbsd-tdep.c: * shnbsd-nat.c: * sh-tdep.h: * serial.h: * serial.c: * ser-unix.h: * ser-unix.c: * ser-tcp.c: * ser-pipe.c: * ser-go32.c: * ser-e7kpc.c: * ser-base.h: * ser-base.c: * solib.c: * solib-svr4.h: * solib-svr4.c: * solib-sunos.c: * solib-som.h: * solib-som.c: * solib-pa64.h: * solib-pa64.c: * solib-osf.c: * solib-null.c: * solib-legacy.c: * solib-irix.c: * solib-frv.c: * solib-aix5.c: * sol-thread.c: * sparc64-linux-tdep.c: * sparc64-linux-nat.c: * sparc-tdep.h: * sparc-tdep.c: * sparc-sol2-tdep.c: * sparc-sol2-nat.c: * sparc-nat.h: * sparc-nat.c: * sparc-linux-tdep.c: * sparc-linux-nat.c: * source.h: * source.c: * somread.c: * solist.h: * solib.h: * std-regs.c: * stack.h: * stack.c: * stabsread.h: * sparcobsd-tdep.c: * sparcnbsd-tdep.c: * sparcnbsd-nat.c: * sparc64obsd-tdep.c: * sparc64nbsd-tdep.c: * sparc64nbsd-nat.c: * sparc64fbsd-tdep.c: * sparc64fbsd-nat.c: * sparc64-tdep.h: * sparc64-tdep.c: * sparc64-sol2-tdep.c: * sparc64-nat.c: * ui-file.c: * typeprint.h: * typeprint.c: * tramp-frame.h: * tramp-frame.c: * trad-frame.h: * trad-frame.c: * tracepoint.h: * top.c: * tobs.inc: * thread.c: * terminal.h: * target.h: * symfile.h: * stop-gdb.c: * vaxbsd-nat.c: * vax-tdep.h: * vax-tdep.c: * vax-nat.c: * varobj.h: * varobj.c: * value.h: * value.c: * valprint.h: * valprint.c: * v850-tdep.c: * uw-thread.c: * user-regs.c: * ui-out.h: * ui-out.c: * ui-file.h: * xcoffsolib.h: * xcoffsolib.c: * wrapper.c: * wince.c: * wince-stub.h: * wince-stub.c: * vaxobsd-tdep.c: * vaxnbsd-tdep.c: * gdb_gcore.sh: * copying.c: * configure.ac: * aclocal.m4: * acinclude.m4: * reply_mig_hack.awk: * observer.sh: * gdb_mbuild.sh: * arm-linux-tdep.c: * blockframe.c: * dbug-rom.c: * environ.h: * dwarf2loc.h: * gdb-events.sh: * glibc-tdep.h: * gdb_wait.h: * gdbthread.h: * i386-sol2-tdep.c: * hppabsd-tdep.c: * hppa-linux-nat.c: * hppa-hpux-nat.c: * ia64-linux-tdep.c: * infptrace.c: * linespec.h: * maint.c: * mips-mdebug-tdep.h: * remote-m32r-sdi.c: * s390-nat.c: * rs6000-nat.c: * remote-utils.h: * sh3-rom.c: * sh-linux-tdep.c: * top.h: * symtab.h: * symmisc.c: * symfile-mem.c: * srec.h: * user-regs.h: * version.h: * valarith.c: * xstormy16-tdep.c: * wrapper.h: * Makefile.in: * f-exp.y: * cris-tdep.c: * cp-name-parser.y: * procfs.c: * proc-utils.h: * proc-flags.c: * proc-api.c: * p-exp.y: * m68hc11-tdep.c: * m2-exp.y: * kod.h: * kod-cisco.c: * jv-exp.y: * hppa-linux-tdep.c: Add (c) after Copyright. Update the FSF address.
2005-12-17 23:34:03 +01:00
Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA. */
2002-06-04 17:28:49 +02:00
/*----------------------------------------------------------------------*/
/* The converted version of this file is to be included in ada-exp.y, */
/* the Ada parser for gdb. The function yylex obtains characters from */
/* the global pointer lexptr. It returns a syntactic category for */
/* each successive token and places a semantic value into yylval */
/* (ada-lval), defined by the parser. */
DIG [0-9]
NUM10 ({DIG}({DIG}|_)*)
HEXDIG [0-9a-f]
NUM16 ({HEXDIG}({HEXDIG}|_)*)
OCTDIG [0-7]
LETTER [a-z_]
ID ({LETTER}({LETTER}|{DIG})*|"<"{LETTER}({LETTER}|{DIG})*">")
WHITE [ \t\n]
TICK ("'"{WHITE}*)
GRAPHIC [a-z0-9 #&'()*+,-./:;<>=_|!$%?@\[\]\\^`{}~]
OPER ([-+*/=<>&]|"<="|">="|"**"|"/="|"and"|"or"|"xor"|"not"|"mod"|"rem"|"abs")
EXP (e[+-]{NUM10})
POSEXP (e"+"?{NUM10})
%{
2002-06-04 17:28:49 +02:00
#define NUMERAL_WIDTH 256
#define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
/* Temporary staging for numeric literals. */
static char numbuf[NUMERAL_WIDTH];
static void canonicalizeNumeral (char *s1, const char *);
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
static struct stoken processString (const char*, int);
static int processInt (const char *, const char *, const char *);
static int processReal (const char *);
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
static struct stoken processId (const char *, int);
static int processAttribute (const char *);
static int find_dot_all (const char *);
2002-06-04 17:28:49 +02:00
#undef YY_DECL
#define YY_DECL static int yylex ( void )
2002-06-04 17:28:49 +02:00
#undef YY_INPUT
#define YY_INPUT(BUF, RESULT, MAX_SIZE) \
if ( *lexptr == '\000' ) \
(RESULT) = YY_NULL; \
else \
{ \
*(BUF) = *lexptr; \
(RESULT) = 1; \
lexptr += 1; \
}
static int find_dot_all (const char *);
2002-06-04 17:28:49 +02:00
%}
%option case-insensitive interactive nodefault
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
%s BEFORE_QUAL_QUOTE
2002-06-04 17:28:49 +02:00
%%
{WHITE} { }
"--".* { yyterminate(); }
{NUM10}{POSEXP} {
canonicalizeNumeral (numbuf, yytext);
2002-06-04 17:28:49 +02:00
return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
}
{NUM10} {
canonicalizeNumeral (numbuf, yytext);
2002-06-04 17:28:49 +02:00
return processInt (NULL, numbuf, NULL);
}
{NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
canonicalizeNumeral (numbuf, yytext);
return processInt (numbuf,
strchr (numbuf, '#') + 1,
2002-06-04 17:28:49 +02:00
strrchr(numbuf, '#') + 1);
}
{NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" {
canonicalizeNumeral (numbuf, yytext);
return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
}
"0x"{HEXDIG}+ {
canonicalizeNumeral (numbuf, yytext+2);
return processInt ("16#", numbuf, NULL);
}
{NUM10}"."{NUM10}{EXP} {
canonicalizeNumeral (numbuf, yytext);
2002-06-04 17:28:49 +02:00
return processReal (numbuf);
}
{NUM10}"."{NUM10} {
canonicalizeNumeral (numbuf, yytext);
2002-06-04 17:28:49 +02:00
return processReal (numbuf);
}
{NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
error (_("Based real literals not implemented yet."));
2002-06-04 17:28:49 +02:00
}
{NUM10}"#"{NUM16}"."{NUM16}"#" {
error (_("Based real literals not implemented yet."));
2002-06-04 17:28:49 +02:00
}
<INITIAL>"'"({GRAPHIC}|\")"'" {
* ada-exp.y (type_int): New function to add layer of abstraction around references to expression types. (type_long): Ditto. (type_long_long): Ditto. (type_float): Ditto. (type_double): Ditto. (type_long_double): Ditto. (type_char): Ditto. (type_system_address): Ditto. (simple_exp): Use type_* functions in place of builtin_* variables. (exp): Ditto. (write_var_from_name): Ditto. (write_object_renaming): Ditto. * ada-lang.c (ada_create_fundamental_type): Remove redundant declaration. (build_ada_types): Remove, replacing with... (ada_language_arch_info): New function to initialize primitive type vector in language_arch_info. (ada_array_length): Remove use of builtin_type_ada_int. (value_pos_atr): Ditto. (ada_evaluate_subexp): Ditto. (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long, builtin_type_ada_long_long, builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. (ada_builtin_types): Remove. (ada_language_defn): Remove entries for la_builtin_type_vector and string_char_type and use ada_language_arch_info. (_initialize_ada_language): Do type-vector initialization along the lines of c-lang.c. (ada_create_fundamental_type): Break up line. (ada_dump_symtab): Remove unused function. (enum ada_primitive_types): Define. * ada-lang.h (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long,builtin_type_ada_long_long,builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. * ada-lex.l: Use type_* functions in place of builtin_* variables. (processInt): Ditto. (processReal): Ditto. (name_lookup): Ditto. * ada-typeprint.c (print_range): Use builtin_type_int, not builtin_type_ada_int.
2004-09-19 00:23:23 +02:00
yylval.typed_val.type = type_char ();
2002-06-04 17:28:49 +02:00
yylval.typed_val.val = yytext[1];
return CHARLIT;
}
<INITIAL>"'[\""{HEXDIG}{2}"\"]'" {
int v;
* ada-exp.y (type_int): New function to add layer of abstraction around references to expression types. (type_long): Ditto. (type_long_long): Ditto. (type_float): Ditto. (type_double): Ditto. (type_long_double): Ditto. (type_char): Ditto. (type_system_address): Ditto. (simple_exp): Use type_* functions in place of builtin_* variables. (exp): Ditto. (write_var_from_name): Ditto. (write_object_renaming): Ditto. * ada-lang.c (ada_create_fundamental_type): Remove redundant declaration. (build_ada_types): Remove, replacing with... (ada_language_arch_info): New function to initialize primitive type vector in language_arch_info. (ada_array_length): Remove use of builtin_type_ada_int. (value_pos_atr): Ditto. (ada_evaluate_subexp): Ditto. (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long, builtin_type_ada_long_long, builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. (ada_builtin_types): Remove. (ada_language_defn): Remove entries for la_builtin_type_vector and string_char_type and use ada_language_arch_info. (_initialize_ada_language): Do type-vector initialization along the lines of c-lang.c. (ada_create_fundamental_type): Break up line. (ada_dump_symtab): Remove unused function. (enum ada_primitive_types): Define. * ada-lang.h (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long,builtin_type_ada_long_long,builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. * ada-lex.l: Use type_* functions in place of builtin_* variables. (processInt): Ditto. (processReal): Ditto. (name_lookup): Ditto. * ada-typeprint.c (print_range): Use builtin_type_int, not builtin_type_ada_int.
2004-09-19 00:23:23 +02:00
yylval.typed_val.type = type_char ();
2002-06-04 17:28:49 +02:00
sscanf (yytext+3, "%2x", &v);
yylval.typed_val.val = v;
return CHARLIT;
}
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
\"({GRAPHIC}|"[\""({HEXDIG}{2}|\")"\"]")*\" {
yylval.sval = processString (yytext+1, yyleng-2);
2002-06-04 17:28:49 +02:00
return STRING;
}
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
\" {
error (_("ill-formed or non-terminated string literal"));
2002-06-04 17:28:49 +02:00
}
if {
while (*lexptr != 'i' && *lexptr != 'I')
lexptr -= 1;
yyrestart(NULL);
2002-06-04 17:28:49 +02:00
return 0;
}
/* ADA KEYWORDS */
abs { return ABS; }
and { return _AND_; }
else { return ELSE; }
in { return IN; }
mod { return MOD; }
new { return NEW; }
not { return NOT; }
null { return NULL_PTR; }
or { return OR; }
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
others { return OTHERS; }
2002-06-04 17:28:49 +02:00
rem { return REM; }
then { return THEN; }
xor { return XOR; }
/* ATTRIBUTES */
{TICK}[a-zA-Z][a-zA-Z]+ { return processAttribute (yytext+1); }
/* PUNCTUATION */
"=>" { return ARROW; }
".." { return DOTDOT; }
"**" { return STARSTAR; }
":=" { return ASSIGN; }
"/=" { return NOTEQUAL; }
"<=" { return LEQ; }
">=" { return GEQ; }
<BEFORE_QUAL_QUOTE>"'" { BEGIN INITIAL; return '\''; }
[-&*+./:<>=|;\[\]] { return yytext[0]; }
"," { if (paren_depth == 0 && comma_terminates)
{
lexptr -= 1;
yyrestart(NULL);
return 0;
}
else
2002-06-04 17:28:49 +02:00
return ',';
}
"(" { paren_depth += 1; return '('; }
")" { if (paren_depth == 0)
2002-06-04 17:28:49 +02:00
{
lexptr -= 1;
yyrestart(NULL);
return 0;
}
else
2002-06-04 17:28:49 +02:00
{
paren_depth -= 1;
2002-06-04 17:28:49 +02:00
return ')';
}
}
"."{WHITE}*all { return DOT_ALL; }
"."{WHITE}*{ID} {
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
yylval.sval = processId (yytext+1, yyleng-1);
return DOT_ID;
2002-06-04 17:28:49 +02:00
}
{ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'")? {
2002-06-04 17:28:49 +02:00
int all_posn = find_dot_all (yytext);
if (all_posn == -1 && yytext[yyleng-1] == '\'')
2002-06-04 17:28:49 +02:00
{
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
BEGIN BEFORE_QUAL_QUOTE;
yyless (yyleng-1);
2002-06-04 17:28:49 +02:00
}
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
else if (all_posn >= 0)
2002-06-04 17:28:49 +02:00
yyless (all_posn);
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
yylval.sval = processId (yytext, yyleng);
return NAME;
}
2002-06-04 17:28:49 +02:00
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
/* GDB EXPRESSION CONSTRUCTS */
2002-06-04 17:28:49 +02:00
"'"[^']+"'"{WHITE}*:: {
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
yyless (yyleng - 2);
yylval.sval = processId (yytext, yyleng);
return NAME;
2002-06-04 17:28:49 +02:00
}
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
"::" { return COLONCOLON; }
2002-06-04 17:28:49 +02:00
[{}@] { return yytext[0]; }
/* REGISTERS AND GDB CONVENIENCE VARIABLES */
"$"({LETTER}|{DIG}|"$")* {
2002-06-04 17:28:49 +02:00
yylval.sval.ptr = yytext;
yylval.sval.length = yyleng;
return SPECIAL_VARIABLE;
2002-06-04 17:28:49 +02:00
}
/* CATCH-ALL ERROR CASE */
. { error (_("Invalid character '%s' in expression."), yytext); }
2002-06-04 17:28:49 +02:00
%%
#include <ctype.h>
#include "gdb_string.h"
2002-06-04 17:28:49 +02:00
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
/* Initialize the lexer for processing new expression. */
2002-06-04 17:28:49 +02:00
void
lexer_init (FILE *inp)
2002-06-04 17:28:49 +02:00
{
BEGIN INITIAL;
yyrestart (inp);
}
/* Copy S2 to S1, removing all underscores, and downcasing all letters. */
2002-06-04 17:28:49 +02:00
static void
canonicalizeNumeral (char *s1, const char *s2)
2002-06-04 17:28:49 +02:00
{
for (; *s2 != '\000'; s2 += 1)
2002-06-04 17:28:49 +02:00
{
if (*s2 != '_')
{
*s1 = tolower(*s2);
s1 += 1;
}
}
s1[0] = '\000';
}
/* Interprets the prefix of NUM that consists of digits of the given BASE
as an integer of that BASE, with the string EXP as an exponent.
Puts value in yylval, and returns INT, if the string is valid. Causes
an error if the number is improperly formated. BASE, if NULL, defaults
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'.
*/
2002-06-04 17:28:49 +02:00
static int
processInt (const char *base0, const char *num0, const char *exp0)
2002-06-04 17:28:49 +02:00
{
ULONGEST result;
long exp;
int base;
char *trailer;
2002-06-04 17:28:49 +02:00
if (base0 == NULL)
base = 10;
else
{
base = strtol (base0, (char **) NULL, 10);
2002-06-04 17:28:49 +02:00
if (base < 2 || base > 16)
error (_("Invalid base: %d."), base);
2002-06-04 17:28:49 +02:00
}
if (exp0 == NULL)
exp = 0;
else
exp = strtol(exp0, (char **) NULL, 10);
2002-06-04 17:28:49 +02:00
errno = 0;
result = strtoulst (num0, (const char **) &trailer, base);
2002-06-04 17:28:49 +02:00
if (errno == ERANGE)
error (_("Integer literal out of range"));
2002-06-04 17:28:49 +02:00
if (isxdigit(*trailer))
error (_("Invalid digit `%c' in based literal"), *trailer);
2002-06-04 17:28:49 +02:00
while (exp > 0)
2002-06-04 17:28:49 +02:00
{
if (result > (ULONG_MAX / base))
error (_("Integer literal out of range"));
2002-06-04 17:28:49 +02:00
result *= base;
exp -= 1;
}
2002-06-04 17:28:49 +02:00
if ((result >> (TARGET_INT_BIT-1)) == 0)
* ada-exp.y (type_int): New function to add layer of abstraction around references to expression types. (type_long): Ditto. (type_long_long): Ditto. (type_float): Ditto. (type_double): Ditto. (type_long_double): Ditto. (type_char): Ditto. (type_system_address): Ditto. (simple_exp): Use type_* functions in place of builtin_* variables. (exp): Ditto. (write_var_from_name): Ditto. (write_object_renaming): Ditto. * ada-lang.c (ada_create_fundamental_type): Remove redundant declaration. (build_ada_types): Remove, replacing with... (ada_language_arch_info): New function to initialize primitive type vector in language_arch_info. (ada_array_length): Remove use of builtin_type_ada_int. (value_pos_atr): Ditto. (ada_evaluate_subexp): Ditto. (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long, builtin_type_ada_long_long, builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. (ada_builtin_types): Remove. (ada_language_defn): Remove entries for la_builtin_type_vector and string_char_type and use ada_language_arch_info. (_initialize_ada_language): Do type-vector initialization along the lines of c-lang.c. (ada_create_fundamental_type): Break up line. (ada_dump_symtab): Remove unused function. (enum ada_primitive_types): Define. * ada-lang.h (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long,builtin_type_ada_long_long,builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. * ada-lex.l: Use type_* functions in place of builtin_* variables. (processInt): Ditto. (processReal): Ditto. (name_lookup): Ditto. * ada-typeprint.c (print_range): Use builtin_type_int, not builtin_type_ada_int.
2004-09-19 00:23:23 +02:00
yylval.typed_val.type = type_int ();
2002-06-04 17:28:49 +02:00
else if ((result >> (TARGET_LONG_BIT-1)) == 0)
* ada-exp.y (type_int): New function to add layer of abstraction around references to expression types. (type_long): Ditto. (type_long_long): Ditto. (type_float): Ditto. (type_double): Ditto. (type_long_double): Ditto. (type_char): Ditto. (type_system_address): Ditto. (simple_exp): Use type_* functions in place of builtin_* variables. (exp): Ditto. (write_var_from_name): Ditto. (write_object_renaming): Ditto. * ada-lang.c (ada_create_fundamental_type): Remove redundant declaration. (build_ada_types): Remove, replacing with... (ada_language_arch_info): New function to initialize primitive type vector in language_arch_info. (ada_array_length): Remove use of builtin_type_ada_int. (value_pos_atr): Ditto. (ada_evaluate_subexp): Ditto. (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long, builtin_type_ada_long_long, builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. (ada_builtin_types): Remove. (ada_language_defn): Remove entries for la_builtin_type_vector and string_char_type and use ada_language_arch_info. (_initialize_ada_language): Do type-vector initialization along the lines of c-lang.c. (ada_create_fundamental_type): Break up line. (ada_dump_symtab): Remove unused function. (enum ada_primitive_types): Define. * ada-lang.h (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long,builtin_type_ada_long_long,builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. * ada-lex.l: Use type_* functions in place of builtin_* variables. (processInt): Ditto. (processReal): Ditto. (name_lookup): Ditto. * ada-typeprint.c (print_range): Use builtin_type_int, not builtin_type_ada_int.
2004-09-19 00:23:23 +02:00
yylval.typed_val.type = type_long ();
2002-06-04 17:28:49 +02:00
else if (((result >> (TARGET_LONG_BIT-1)) >> 1) == 0)
{
/* We have a number representable as an unsigned integer quantity.
For consistency with the C treatment, we will treat it as an
2002-06-04 17:28:49 +02:00
anonymous modular (unsigned) quantity. Alas, the types are such
that we need to store .val as a signed quantity. Sorry
2002-06-04 17:28:49 +02:00
for the mess, but C doesn't officially guarantee that a simple
assignment does the trick (no, it doesn't; read the reference manual).
*/
yylval.typed_val.type = builtin_type_unsigned_long;
if (result & LONGEST_SIGN)
yylval.typed_val.val =
(LONGEST) (result & ~LONGEST_SIGN)
2002-06-04 17:28:49 +02:00
- (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
else
yylval.typed_val.val = (LONGEST) result;
return INT;
}
else
* ada-exp.y (type_int): New function to add layer of abstraction around references to expression types. (type_long): Ditto. (type_long_long): Ditto. (type_float): Ditto. (type_double): Ditto. (type_long_double): Ditto. (type_char): Ditto. (type_system_address): Ditto. (simple_exp): Use type_* functions in place of builtin_* variables. (exp): Ditto. (write_var_from_name): Ditto. (write_object_renaming): Ditto. * ada-lang.c (ada_create_fundamental_type): Remove redundant declaration. (build_ada_types): Remove, replacing with... (ada_language_arch_info): New function to initialize primitive type vector in language_arch_info. (ada_array_length): Remove use of builtin_type_ada_int. (value_pos_atr): Ditto. (ada_evaluate_subexp): Ditto. (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long, builtin_type_ada_long_long, builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. (ada_builtin_types): Remove. (ada_language_defn): Remove entries for la_builtin_type_vector and string_char_type and use ada_language_arch_info. (_initialize_ada_language): Do type-vector initialization along the lines of c-lang.c. (ada_create_fundamental_type): Break up line. (ada_dump_symtab): Remove unused function. (enum ada_primitive_types): Define. * ada-lang.h (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long,builtin_type_ada_long_long,builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. * ada-lex.l: Use type_* functions in place of builtin_* variables. (processInt): Ditto. (processReal): Ditto. (name_lookup): Ditto. * ada-typeprint.c (print_range): Use builtin_type_int, not builtin_type_ada_int.
2004-09-19 00:23:23 +02:00
yylval.typed_val.type = type_long_long ();
2002-06-04 17:28:49 +02:00
yylval.typed_val.val = (LONGEST) result;
return INT;
}
static int
processReal (const char *num0)
2002-06-04 17:28:49 +02:00
{
sscanf (num0, DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);
2002-06-04 17:28:49 +02:00
* ada-exp.y (type_int): New function to add layer of abstraction around references to expression types. (type_long): Ditto. (type_long_long): Ditto. (type_float): Ditto. (type_double): Ditto. (type_long_double): Ditto. (type_char): Ditto. (type_system_address): Ditto. (simple_exp): Use type_* functions in place of builtin_* variables. (exp): Ditto. (write_var_from_name): Ditto. (write_object_renaming): Ditto. * ada-lang.c (ada_create_fundamental_type): Remove redundant declaration. (build_ada_types): Remove, replacing with... (ada_language_arch_info): New function to initialize primitive type vector in language_arch_info. (ada_array_length): Remove use of builtin_type_ada_int. (value_pos_atr): Ditto. (ada_evaluate_subexp): Ditto. (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long, builtin_type_ada_long_long, builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. (ada_builtin_types): Remove. (ada_language_defn): Remove entries for la_builtin_type_vector and string_char_type and use ada_language_arch_info. (_initialize_ada_language): Do type-vector initialization along the lines of c-lang.c. (ada_create_fundamental_type): Break up line. (ada_dump_symtab): Remove unused function. (enum ada_primitive_types): Define. * ada-lang.h (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long,builtin_type_ada_long_long,builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. * ada-lex.l: Use type_* functions in place of builtin_* variables. (processInt): Ditto. (processReal): Ditto. (name_lookup): Ditto. * ada-typeprint.c (print_range): Use builtin_type_int, not builtin_type_ada_int.
2004-09-19 00:23:23 +02:00
yylval.typed_val_float.type = type_float ();
2002-06-04 17:28:49 +02:00
if (sizeof(DOUBLEST) >= TARGET_DOUBLE_BIT / TARGET_CHAR_BIT)
* ada-exp.y (type_int): New function to add layer of abstraction around references to expression types. (type_long): Ditto. (type_long_long): Ditto. (type_float): Ditto. (type_double): Ditto. (type_long_double): Ditto. (type_char): Ditto. (type_system_address): Ditto. (simple_exp): Use type_* functions in place of builtin_* variables. (exp): Ditto. (write_var_from_name): Ditto. (write_object_renaming): Ditto. * ada-lang.c (ada_create_fundamental_type): Remove redundant declaration. (build_ada_types): Remove, replacing with... (ada_language_arch_info): New function to initialize primitive type vector in language_arch_info. (ada_array_length): Remove use of builtin_type_ada_int. (value_pos_atr): Ditto. (ada_evaluate_subexp): Ditto. (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long, builtin_type_ada_long_long, builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. (ada_builtin_types): Remove. (ada_language_defn): Remove entries for la_builtin_type_vector and string_char_type and use ada_language_arch_info. (_initialize_ada_language): Do type-vector initialization along the lines of c-lang.c. (ada_create_fundamental_type): Break up line. (ada_dump_symtab): Remove unused function. (enum ada_primitive_types): Define. * ada-lang.h (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long,builtin_type_ada_long_long,builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. * ada-lex.l: Use type_* functions in place of builtin_* variables. (processInt): Ditto. (processReal): Ditto. (name_lookup): Ditto. * ada-typeprint.c (print_range): Use builtin_type_int, not builtin_type_ada_int.
2004-09-19 00:23:23 +02:00
yylval.typed_val_float.type = type_double ();
2002-06-04 17:28:49 +02:00
if (sizeof(DOUBLEST) >= TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT)
* ada-exp.y (type_int): New function to add layer of abstraction around references to expression types. (type_long): Ditto. (type_long_long): Ditto. (type_float): Ditto. (type_double): Ditto. (type_long_double): Ditto. (type_char): Ditto. (type_system_address): Ditto. (simple_exp): Use type_* functions in place of builtin_* variables. (exp): Ditto. (write_var_from_name): Ditto. (write_object_renaming): Ditto. * ada-lang.c (ada_create_fundamental_type): Remove redundant declaration. (build_ada_types): Remove, replacing with... (ada_language_arch_info): New function to initialize primitive type vector in language_arch_info. (ada_array_length): Remove use of builtin_type_ada_int. (value_pos_atr): Ditto. (ada_evaluate_subexp): Ditto. (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long, builtin_type_ada_long_long, builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. (ada_builtin_types): Remove. (ada_language_defn): Remove entries for la_builtin_type_vector and string_char_type and use ada_language_arch_info. (_initialize_ada_language): Do type-vector initialization along the lines of c-lang.c. (ada_create_fundamental_type): Break up line. (ada_dump_symtab): Remove unused function. (enum ada_primitive_types): Define. * ada-lang.h (builtin_type_ada_int, builtin_type_ada_short, builtin_type_ada_long,builtin_type_ada_long_long,builtin_type_ada_char, builtin_type_ada_float, builtin_type_ada_double, builtin_type_ada_long_double, builtin_type_ada_natural, builtin_type_ada_positive, builtin_type_ada_system_address): Remove. * ada-lex.l: Use type_* functions in place of builtin_* variables. (processInt): Ditto. (processReal): Ditto. (name_lookup): Ditto. * ada-typeprint.c (print_range): Use builtin_type_int, not builtin_type_ada_int.
2004-09-19 00:23:23 +02:00
yylval.typed_val_float.type = type_long_double ();
2002-06-04 17:28:49 +02:00
return FLOAT;
}
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
/* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym. The
resulting string is valid until the next call to ada_parse. It differs
from NAME0 in that:
+ Characters between '...' or <...> are transfered verbatim to
yylval.ssym.
+ <, >, and trailing "'" characters in quoted sequences are removed
(a leading quote is preserved to indicate that the name is not to be
GNAT-encoded).
+ Unquoted whitespace is removed.
+ Unquoted alphabetic characters are mapped to lower case.
Result is returned as a struct stoken, but for convenience, the string
is also null-terminated. Result string valid until the next call of
ada_parse.
*/
static struct stoken
processId (const char *name0, int len)
2002-06-04 17:28:49 +02:00
{
char *name = obstack_alloc (&temp_parse_space, len + 11);
2002-06-04 17:28:49 +02:00
int i0, i;
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
struct stoken result;
2002-06-04 17:28:49 +02:00
while (len > 0 && isspace (name0[len-1]))
len -= 1;
i = i0 = 0;
while (i0 < len)
2002-06-04 17:28:49 +02:00
{
if (isalnum (name0[i0]))
{
name[i] = tolower (name0[i0]);
i += 1; i0 += 1;
}
else switch (name0[i0])
2002-06-04 17:28:49 +02:00
{
default:
name[i] = name0[i0];
i += 1; i0 += 1;
break;
case ' ': case '\t':
i0 += 1;
break;
case '\'':
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
do
2002-06-04 17:28:49 +02:00
{
name[i] = name0[i0];
i += 1; i0 += 1;
}
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
while (i0 < len && name0[i0] != '\'');
2002-06-04 17:28:49 +02:00
i0 += 1;
break;
case '<':
i0 += 1;
while (i0 < len && name0[i0] != '>')
{
name[i] = name0[i0];
i += 1; i0 += 1;
}
i0 += 1;
break;
}
}
name[i] = '\000';
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
result.ptr = name;
result.length = i;
return result;
2002-06-04 17:28:49 +02:00
}
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
/* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
with special hex character notations replaced with characters.
Result valid until the next call to ada_parse. */
2002-06-04 17:28:49 +02:00
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
static struct stoken
processString (const char *text, int len)
2002-06-04 17:28:49 +02:00
{
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
const char *p;
char *q;
const char *lim = text + len;
struct stoken result;
q = result.ptr = obstack_alloc (&temp_parse_space, len);
p = text;
while (p < lim)
2002-06-04 17:28:49 +02:00
{
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
if (p[0] == '[' && p[1] == '"' && p+2 < lim)
{
if (p[2] == '"') /* "...["""]... */
{
*q = '"';
p += 4;
}
else
{
int chr;
sscanf (p+2, "%2x", &chr);
*q = (char) chr;
p += 5;
}
}
else
*q = *p;
q += 1;
p += 1;
}
result.length = q - result.ptr;
return result;
2002-06-04 17:28:49 +02:00
}
/* Returns the position within STR of the '.' in a
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
'.{WHITE}*all' component of a dotted name, or -1 if there is none.
Note: we actually don't need this routine, since 'all' can never be an
Ada identifier. Thus, looking up foo.all or foo.all.x as a name
must fail, and will eventually be interpreted as (foo).all or
(foo).all.x. However, this does avoid an extraneous lookup. */
2002-06-04 17:28:49 +02:00
static int
find_dot_all (const char *str)
2002-06-04 17:28:49 +02:00
{
int i;
for (i = 0; str[i] != '\000'; i += 1)
{
if (str[i] == '.')
{
int i0 = i;
do
2002-06-04 17:28:49 +02:00
i += 1;
while (isspace (str[i]));
* ada-exp.y: Considerable reorganization to move functionality from ada-lex.l to here, where it is logically more appropriate. The original reason, however, was to prevent premature name lookups for selector names in record aggregates. (BLOCKNAME, TYPENAME, OBJECT_RENAMING): Remove; lexer now returns NAME for all of these. (VAR): New artificial token to clarify precedence rules. (OTHERS): New lexeme. (empty_stoken): New symbol. (%union): Remove ssym, voidval. (%type): Remove <voidval> type declarations. (syntax definitions): Add aggregates. Remove distinction between NAME, TYPENAME, BLOCKNAME, OBJECT_RENAMING. Rename some non-terminals to be closer to reference manual usage. Tighten up expression syntax to disallow certain non-Ada constructions such as X and then Y or else Z. (ada_parse): Remove initialization of left_block_context. (write_var_from_name): Remove. (write_var_or_type): New function, containing previous code from defunct write_var_from_name and name_lookup. (block_lookup): New function, moved from ada-lex.l (select_possible_type_sym): New function, factored out of name_lookup, which used to be in ada-lex.l. (find_primitive_type): Ditto. (chop_selector): Ditto. (write_ambiguous_var): New function, factored out of defunct write_var_from_name. (write_selectors): New function. (write_name_assoc): New function. (write_exp_op_with_string): New function. * ada-lex.l (processId): Change interface to return stoken. (tempbuf, resize_tempbuf, tempbuf_size, tempbuf_len): Remove. (block_lookup, name_lookup): Remove. Functionality moved to ada-exp.y. (state IN_STRING): Remove. (rules): Handle string escapes in processString. Add 'others' token. Return all NAMEs, BLOCKNAMEs, OBJECT_RENAMINGs, TYPENAMEs in yylval.sval (as simple strings). All name look-ups now handled in ada-exp.y. Introduce "::" (COLONCOLON) token and return as separate token. (processId): Change return convention. Comment. Leave leading "'" in place. (processString): New function. (find_dot_all): Add note to comment. Fix problem that allowed match only at the end. * ada-lang.c: Introduce aggregates. (find_struct_field): Add new parameter to count fields skipped, and allow other output parameters to be NULL. (value_tag_from_contents_and_address, ada_value_struct_elt): Use new find_struct_field. (ada_index_struct_field, assign_aggregate, ada_is_array_type) (num_visible_fields, ada_index_struct_field_1, ada_index_struct_field) (num_component_specs, assign_component, assign_aggregate): (aggregate_assign_from_choices,aggregate_assign_positional) (aggregate_assign_others,add_component_interval): New functions. (ada_evaluate_subexp): Declare. Add aggregate-related operators. (ada_forward_operator_length): Declare. (resolve_subexp): Add cases for new aggregate operators and OP_NAME. Consolidate Ada operators, using ada_forward_operator_length. (ada_search_struct_field): Search in forward order. (ADA_OPERATORS): Add new aggregate operators. (ada_operator_length, ada_op_name, ada_forward_operator_length) (ada_dump_subexp_body, ada_print_subexp): Handle new aggregate operators and OP_NAME. (ada_type_of_array): Use longest_to_int. (value_assign_to_component): New function. (ada_forward_operator_length, ada_op_name, ada_dump_subexp_body): Add OP_NAME case. (ada_forward_operator_length, ada_dump_subexp_body): Add OP_STRING case. * ada-lang.h (enum ada_operator): Add OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_DISCRETE_RANGE, OP_POSITIONAL.
2006-01-02 10:46:34 +01:00
if (strncmp (str+i, "all", 3) == 0
2002-06-04 17:28:49 +02:00
&& ! isalnum (str[i+3]) && str[i+3] != '_')
return i0;
}
}
return -1;
}
2002-06-04 17:28:49 +02:00
/* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
case. */
2002-06-04 17:28:49 +02:00
static int
subseqMatch (const char *subseq, const char *str)
2002-06-04 17:28:49 +02:00
{
if (subseq[0] == '\0')
return 1;
else if (str[0] == '\0')
return 0;
else if (tolower (subseq[0]) == tolower (str[0]))
return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
else
return subseqMatch (subseq, str+1);
}
static struct { const char *name; int code; }
2002-06-04 17:28:49 +02:00
attributes[] = {
{ "address", TICK_ADDRESS },
{ "unchecked_access", TICK_ACCESS },
{ "unrestricted_access", TICK_ACCESS },
{ "access", TICK_ACCESS },
{ "first", TICK_FIRST },
{ "last", TICK_LAST },
{ "length", TICK_LENGTH },
{ "max", TICK_MAX },
{ "min", TICK_MIN },
{ "modulus", TICK_MODULUS },
{ "pos", TICK_POS },
{ "range", TICK_RANGE },
{ "size", TICK_SIZE },
{ "tag", TICK_TAG },
{ "val", TICK_VAL },
{ NULL, -1 }
};
/* Return the syntactic code corresponding to the attribute name or
abbreviation STR. */
static int
processAttribute (const char *str)
2002-06-04 17:28:49 +02:00
{
int i, k;
for (i = 0; attributes[i].code != -1; i += 1)
if (strcasecmp (str, attributes[i].name) == 0)
return attributes[i].code;
for (i = 0, k = -1; attributes[i].code != -1; i += 1)
if (subseqMatch (str, attributes[i].name))
2002-06-04 17:28:49 +02:00
{
if (k == -1)
k = i;
else
error (_("ambiguous attribute name: `%s'"), str);
2002-06-04 17:28:49 +02:00
}
if (k == -1)
error (_("unrecognized attribute: `%s'"), str);
2002-06-04 17:28:49 +02:00
return attributes[k].code;
}
int
yywrap(void)
2002-06-04 17:28:49 +02:00
{
return 1;
}
/* Dummy definition to suppress warnings about unused static definitions. */
typedef void (*dummy_function) ();
dummy_function ada_flex_use[] =
{
(dummy_function) yyunput
};