From 68d0ed486f267c168b420f9ab8da26b45db84401 Mon Sep 17 00:00:00 2001 From: Simon Schubert Date: Sun, 11 Sep 2005 12:56:08 +0000 Subject: [PATCH] Import stripped gcc-4.0.1 sources. --- contrib/gcc-4.0/BUGS | 36 +- contrib/gcc-4.0/LAST_UPDATED | 2 +- contrib/gcc-4.0/MAINTAINERS | 1 + contrib/gcc-4.0/README.SCO | 2 +- contrib/gcc-4.0/gcc/builtins.c | 105 +- contrib/gcc-4.0/gcc/c-common.c | 42 +- contrib/gcc-4.0/gcc/c-common.h | 11 + contrib/gcc-4.0/gcc/c-decl.c | 285 +- contrib/gcc-4.0/gcc/c-errors.c | 12 +- contrib/gcc-4.0/gcc/c-format.c | 77 +- contrib/gcc-4.0/gcc/c-opts.c | 4 + contrib/gcc-4.0/gcc/c-parse.c | 11243 ++++++++++--------- contrib/gcc-4.0/gcc/c-pragma.c | 5 +- contrib/gcc-4.0/gcc/c-tree.h | 53 +- contrib/gcc-4.0/gcc/c-typeck.c | 286 +- contrib/gcc-4.0/gcc/c.opt | 4 + contrib/gcc-4.0/gcc/cfgcleanup.c | 2 + contrib/gcc-4.0/gcc/cgraph.h | 4 + contrib/gcc-4.0/gcc/collect2.c | 27 +- contrib/gcc-4.0/gcc/combine.c | 2 +- contrib/gcc-4.0/gcc/config/i386/emmintrin.h | 35 +- contrib/gcc-4.0/gcc/config/i386/i386-protos.h | 2 + contrib/gcc-4.0/gcc/config/i386/i386.c | 70 +- contrib/gcc-4.0/gcc/config/i386/i386.h | 35 +- contrib/gcc-4.0/gcc/config/i386/i386.md | 2 +- contrib/gcc-4.0/gcc/config/i386/mmx.md | 2 +- contrib/gcc-4.0/gcc/config/i386/xmmintrin.h | 10 +- contrib/gcc-4.0/gcc/cp/call.c | 5 +- contrib/gcc-4.0/gcc/cp/class.c | 3 + contrib/gcc-4.0/gcc/cp/cp-tree.h | 19 +- contrib/gcc-4.0/gcc/cp/decl.c | 164 +- contrib/gcc-4.0/gcc/cp/decl2.c | 20 +- contrib/gcc-4.0/gcc/cp/error.c | 36 +- contrib/gcc-4.0/gcc/cp/init.c | 2 +- contrib/gcc-4.0/gcc/cp/lex.c | 5 - contrib/gcc-4.0/gcc/cp/method.c | 37 +- contrib/gcc-4.0/gcc/cp/name-lookup.c | 118 +- contrib/gcc-4.0/gcc/cp/name-lookup.h | 1 + contrib/gcc-4.0/gcc/cp/parser.c | 45 +- contrib/gcc-4.0/gcc/cp/pt.c | 290 +- contrib/gcc-4.0/gcc/cp/rtti.c | 8 +- contrib/gcc-4.0/gcc/cp/semantics.c | 10 +- contrib/gcc-4.0/gcc/cp/tree.c | 4 +- contrib/gcc-4.0/gcc/cp/typeck.c | 49 +- contrib/gcc-4.0/gcc/dbxout.c | 6 +- contrib/gcc-4.0/gcc/diagnostic.c | 58 +- contrib/gcc-4.0/gcc/doc/contrib.texi | 6 + contrib/gcc-4.0/gcc/doc/cpp.1 | 4 +- contrib/gcc-4.0/gcc/doc/cpp.info | 158 +- contrib/gcc-4.0/gcc/doc/cppinternals.info | 4 +- contrib/gcc-4.0/gcc/doc/extend.texi | 46 +- contrib/gcc-4.0/gcc/doc/fsf-funding.7 | 4 +- contrib/gcc-4.0/gcc/doc/g++.1 | 162 +- contrib/gcc-4.0/gcc/doc/gcc.1 | 162 +- contrib/gcc-4.0/gcc/doc/gcc.info | 957 +- contrib/gcc-4.0/gcc/doc/gccinstall.info | 220 +- contrib/gcc-4.0/gcc/doc/gccint.info | 530 +- contrib/gcc-4.0/gcc/doc/gcj-dbtool.1 | 4 +- contrib/gcc-4.0/gcc/doc/gcj.1 | 6 +- contrib/gcc-4.0/gcc/doc/gcj.info | 305 +- contrib/gcc-4.0/gcc/doc/gcjh.1 | 20 +- contrib/gcc-4.0/gcc/doc/gcov.1 | 4 +- contrib/gcc-4.0/gcc/doc/gfdl.7 | 4 +- contrib/gcc-4.0/gcc/doc/gij.1 | 12 +- contrib/gcc-4.0/gcc/doc/gpl.7 | 4 +- contrib/gcc-4.0/gcc/doc/grmic.1 | 4 +- contrib/gcc-4.0/gcc/doc/grmiregistry.1 | 4 +- contrib/gcc-4.0/gcc/doc/include/gcc-common.texi | 2 +- contrib/gcc-4.0/gcc/doc/install.texi | 91 +- contrib/gcc-4.0/gcc/doc/invoke.texi | 83 +- contrib/gcc-4.0/gcc/doc/jcf-dump.1 | 4 +- contrib/gcc-4.0/gcc/doc/jv-convert.1 | 4 +- contrib/gcc-4.0/gcc/doc/jv-scan.1 | 4 +- contrib/gcc-4.0/gcc/doc/md.texi | 96 + contrib/gcc-4.0/gcc/doc/passes.texi | 13 + contrib/gcc-4.0/gcc/dojump.c | 14 +- contrib/gcc-4.0/gcc/dwarf2out.c | 15 +- contrib/gcc-4.0/gcc/expr.c | 31 +- contrib/gcc-4.0/gcc/expr.h | 6 +- contrib/gcc-4.0/gcc/final.c | 6 +- contrib/gcc-4.0/gcc/fold-const.c | 16 +- contrib/gcc-4.0/gcc/gcc.c | 27 +- contrib/gcc-4.0/gcc/gcov-dump.c | 3 + contrib/gcc-4.0/gcc/gcov-io.h | 69 +- contrib/gcc-4.0/gcc/gcov.c | 9 +- contrib/gcc-4.0/gcc/gengtype-lex.c | 1554 +-- contrib/gcc-4.0/gcc/gengtype-yacc.c | 3264 +++--- contrib/gcc-4.0/gcc/gengtype-yacc.h | 131 +- contrib/gcc-4.0/gcc/gensupport.c | 3 + contrib/gcc-4.0/gcc/gimplify.c | 63 +- contrib/gcc-4.0/gcc/gthr-posix.h | 1 + contrib/gcc-4.0/gcc/intl.h | 4 + contrib/gcc-4.0/gcc/loop-unswitch.c | 5 +- contrib/gcc-4.0/gcc/params.def | 5 + contrib/gcc-4.0/gcc/postreload.c | 3 +- contrib/gcc-4.0/gcc/reg-stack.c | 14 +- contrib/gcc-4.0/gcc/reload.c | 19 +- contrib/gcc-4.0/gcc/reload1.c | 39 +- contrib/gcc-4.0/gcc/rtl-error.c | 12 +- contrib/gcc-4.0/gcc/rtlanal.c | 14 +- contrib/gcc-4.0/gcc/simplify-rtx.c | 84 +- contrib/gcc-4.0/gcc/system.h | 75 +- contrib/gcc-4.0/gcc/toplev.c | 3 + contrib/gcc-4.0/gcc/tree-cfg.c | 15 +- contrib/gcc-4.0/gcc/tree-chrec.c | 38 +- contrib/gcc-4.0/gcc/tree-chrec.h | 4 +- contrib/gcc-4.0/gcc/tree-gimple.c | 2 +- contrib/gcc-4.0/gcc/tree-inline.c | 18 +- contrib/gcc-4.0/gcc/tree-scalar-evolution.c | 2 +- contrib/gcc-4.0/gcc/tree-ssa-ccp.c | 12 - contrib/gcc-4.0/gcc/tree-ssa-dce.c | 9 + contrib/gcc-4.0/gcc/tree-ssa-dom.c | 22 + contrib/gcc-4.0/gcc/tree-ssa-loop-im.c | 1 + contrib/gcc-4.0/gcc/tree-ssa-loop-ivopts.c | 5 + contrib/gcc-4.0/gcc/tree-ssa-operands.c | 8 +- contrib/gcc-4.0/gcc/tree-ssa-pre.c | 17 +- contrib/gcc-4.0/gcc/tree-ssa-threadupdate.c | 3 +- contrib/gcc-4.0/gcc/tree-ssa.c | 4 +- contrib/gcc-4.0/gcc/tree.c | 15 +- contrib/gcc-4.0/gcc/varasm.c | 52 +- contrib/gcc-4.0/gcc/version.c | 2 +- contrib/gcc-4.0/include/libiberty.h | 24 +- contrib/gcc-4.0/libcpp/line-map.c | 6 +- contrib/gcc-4.0/libcpp/system.h | 75 +- contrib/gcc-4.0/libiberty/configure | 141 +- contrib/gcc-4.0/libiberty/fopen_unlocked.c | 136 + .../libstdc++-v3/config/abi/compatibility.h | 214 + contrib/gcc-4.0/libstdc++-v3/config/linker-map.gnu | 310 +- .../libstdc++-v3/include/bits/basic_string.h | 66 +- .../gcc-4.0/libstdc++-v3/include/bits/c++config | 2 +- .../libstdc++-v3/include/bits/char_traits.h | 2 +- .../libstdc++-v3/include/bits/cpp_type_traits.h | 4 +- .../gcc-4.0/libstdc++-v3/include/bits/deque.tcc | 12 +- .../gcc-4.0/libstdc++-v3/include/bits/fstream.tcc | 36 +- .../libstdc++-v3/include/bits/locale_facets.tcc | 404 +- .../gcc-4.0/libstdc++-v3/include/bits/stl_algo.h | 33 +- .../libstdc++-v3/include/bits/stl_algobase.h | 4 +- .../libstdc++-v3/include/bits/stl_bvector.h | 54 +- .../gcc-4.0/libstdc++-v3/include/bits/stl_deque.h | 42 +- .../libstdc++-v3/include/bits/stl_function.h | 6 +- .../gcc-4.0/libstdc++-v3/include/bits/stl_list.h | 32 +- .../gcc-4.0/libstdc++-v3/include/bits/stl_map.h | 16 +- .../libstdc++-v3/include/bits/stl_multimap.h | 14 +- .../libstdc++-v3/include/bits/stl_multiset.h | 10 +- .../gcc-4.0/libstdc++-v3/include/bits/stl_set.h | 17 +- .../gcc-4.0/libstdc++-v3/include/bits/stl_tree.h | 9 +- .../gcc-4.0/libstdc++-v3/include/bits/stl_vector.h | 26 +- .../gcc-4.0/libstdc++-v3/include/bits/vector.tcc | 10 +- contrib/gcc-4.0/libstdc++-v3/include/debug/bitset | 24 +- contrib/gcc-4.0/libstdc++-v3/include/debug/debug.h | 2 +- .../gcc-4.0/libstdc++-v3/include/debug/formatter.h | 11 +- contrib/gcc-4.0/libstdc++-v3/include/debug/string | 21 +- .../libstdc++-v3/include/ext/mt_allocator.h | 4 +- .../libstdc++-v3/include/ext/pod_char_traits.h | 76 +- .../libstdc++-v3/include/ext/pool_allocator.h | 2 +- contrib/gcc-4.0/libstdc++-v3/include/ext/rope | 6 +- .../gcc-4.0/libstdc++-v3/include/ext/ropeimpl.h | 40 +- .../gcc-4.0/libstdc++-v3/include/std/std_bitset.h | 65 +- .../gcc-4.0/libstdc++-v3/include/tr1/type_traits | 21 +- contrib/gcc-4.0/libstdc++-v3/libmath/stubs.c | 17 + contrib/gcc-4.0/libstdc++-v3/src/compatibility.cc | 363 + contrib/gcc-4.0/libstdc++-v3/src/istream.cc | 129 - 162 files changed, 14235 insertions(+), 10125 deletions(-) rewrite contrib/gcc-4.0/gcc/c-parse.c (70%) rewrite contrib/gcc-4.0/gcc/gengtype-yacc.c (60%) rewrite contrib/gcc-4.0/gcc/gengtype-yacc.h (83%) create mode 100644 contrib/gcc-4.0/libiberty/fopen_unlocked.c create mode 100644 contrib/gcc-4.0/libstdc++-v3/config/abi/compatibility.h create mode 100644 contrib/gcc-4.0/libstdc++-v3/src/compatibility.cc diff --git a/contrib/gcc-4.0/BUGS b/contrib/gcc-4.0/BUGS index 9570e7ada0..37252d8077 100644 --- a/contrib/gcc-4.0/BUGS +++ b/contrib/gcc-4.0/BUGS @@ -31,12 +31,12 @@ Table of Contents The main purpose of a bug report is to enable us to fix the bug. The most important prerequisite for this is that the report must be - complete and self-contained, which we explain in detail below. + complete and self-contained. Before you report a bug, please check the [19]list of well-known bugs - and, if possible in any way, try a current development snapshot. If - you want to report a bug with versions of GCC before 3.1 we strongly - recommend upgrading to the current release first. + and, if possible, try a current development snapshot. If you want to + report a bug with versions of GCC before 3.4 we strongly recommend + upgrading to the current release first. Before reporting that GCC compiles your code incorrectly, please compile it with gcc -Wall and see whether this shows anything wrong @@ -81,9 +81,6 @@ Summarized bug reporting instructions compiled, such that retrying a sufficient number of times results in a successful compilation; this is a symptom of a hardware problem, not of a compiler bug (sorry) - * E-mail messages that complement previous, incomplete bug reports. - Post a new, self-contained, full bug report instead, if possible - as a follow-up to the original bug report * Assembly files (*.s) produced by the compiler, or any binary files, such as object files, executables, core files, or precompiled header files @@ -119,15 +116,6 @@ Detailed bug reporting instructions gcc -v -save-temps all-your-options source-file - Typically the preprocessed file (extension .i for C or .ii for C++, - and .f if the preprocessor is used on Fortran files) will be large, so - please compress the resulting file with one of the popular compression - programs such as bzip2, gzip, zip or compress (in decreasing order of - preference). Use maximum compression (-9) if available. Please include - the compressed preprocessor output in your bug report, even if the - source code is freely available elsewhere; it makes the job of our - volunteer testers much easier. - The only excuses to not send us the preprocessed sources are (i) if you've found a bug in the preprocessor, (ii) if you've reduced the testcase to a small file that doesn't include any other file or (iii) @@ -140,12 +128,6 @@ Detailed bug reporting instructions although you may want to post parts of it to point out assembly code you consider to be wrong. - Whether to use MIME attachments or uuencode is up to you. In any case, - make sure the compiler command line, version and error output are in - plain text, so that we don't have to decode the bug report in order to - tell who should take care of it. A meaningful subject indicating - language and platform also helps. - Please avoid posting an archive (.tar, .shar or .zip); we generally need just a single file to reproduce the bug (the .i/.ii/.f preprocessed file), and, by storing it in an archive, you're just @@ -158,16 +140,6 @@ Detailed bug reporting instructions included in the body of your bug report as plain text, even if needlessly duplicated as part of an archive. - If you fail to supply enough information for a bug report to be - reproduced, someone will probably ask you to post additional - information (or just ignore your bug report, if they're in a bad day, - so try to get it right on the first posting :-). In this case, please - post the additional information to the bug reporting mailing list, not - just to the person who requested it, unless explicitly told so. If - possible, please include in this follow-up all the information you had - supplied in the incomplete bug report (including the preprocessor - output), so that the new bug report is self-contained. - Detailed bug reporting instructions for GNAT See the [24]previous section for bug reporting instructions for GCC diff --git a/contrib/gcc-4.0/LAST_UPDATED b/contrib/gcc-4.0/LAST_UPDATED index 51e9e516b1..34bc9923a9 100644 --- a/contrib/gcc-4.0/LAST_UPDATED +++ b/contrib/gcc-4.0/LAST_UPDATED @@ -1 +1 @@ -Obtained from CVS: -rgcc_4_0_0_release +Obtained from CVS: -rgcc_4_0_1_release diff --git a/contrib/gcc-4.0/MAINTAINERS b/contrib/gcc-4.0/MAINTAINERS index 2872a49a06..7e5258fd84 100644 --- a/contrib/gcc-4.0/MAINTAINERS +++ b/contrib/gcc-4.0/MAINTAINERS @@ -42,6 +42,7 @@ arm port Richard Earnshaw rearnsha@arm.com arm port Paul Brook paul@codesourcery.com avr port Denis Chertykov denisc@overta.ru avr port Marek Michalkiewicz marekm@amelek.gda.pl +bfin port Bernd Schmidt bernd.schmidt@analog.com c4x port Michael Hayes m.hayes@elec.canterbury.ac.nz cris port Hans-Peter Nilsson hp@axis.com fr30 port Nick Clifton nickc@redhat.com diff --git a/contrib/gcc-4.0/README.SCO b/contrib/gcc-4.0/README.SCO index fb2c0f81ea..1c32590274 100644 --- a/contrib/gcc-4.0/README.SCO +++ b/contrib/gcc-4.0/README.SCO @@ -6,4 +6,4 @@ no longer believe that SCO is a serious threat. For more on the FSF's position regarding SCO's attacks on free software, please read: - http://www.gnu.org/philosophy/sco/sco.html + http://www.fsf.org/licensing/sco/ diff --git a/contrib/gcc-4.0/gcc/builtins.c b/contrib/gcc-4.0/gcc/builtins.c index 9e7ccaa914..988661e36b 100644 --- a/contrib/gcc-4.0/gcc/builtins.c +++ b/contrib/gcc-4.0/gcc/builtins.c @@ -113,15 +113,15 @@ static rtx expand_builtin_strspn (tree, rtx, enum machine_mode); static rtx expand_builtin_strcspn (tree, rtx, enum machine_mode); static rtx expand_builtin_memcpy (tree, rtx, enum machine_mode); static rtx expand_builtin_mempcpy (tree, tree, rtx, enum machine_mode, int); -static rtx expand_builtin_memmove (tree, tree, rtx, enum machine_mode); -static rtx expand_builtin_bcopy (tree, tree); +static rtx expand_builtin_memmove (tree, tree, rtx, enum machine_mode, tree); +static rtx expand_builtin_bcopy (tree); static rtx expand_builtin_strcpy (tree, rtx, enum machine_mode); static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode); static rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, enum machine_mode); static rtx expand_builtin_strncpy (tree, rtx, enum machine_mode); static rtx builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode); static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode); -static rtx expand_builtin_memset (tree, rtx, enum machine_mode); +static rtx expand_builtin_memset (tree, rtx, enum machine_mode, tree); static rtx expand_builtin_bzero (tree); static rtx expand_builtin_strlen (tree, rtx, enum machine_mode); static rtx expand_builtin_strstr (tree, tree, rtx, enum machine_mode); @@ -2675,7 +2675,8 @@ expand_builtin_memcpy (tree exp, rtx target, enum machine_mode mode) /* Copy word part most expediently. */ dest_addr = emit_block_move (dest_mem, src_mem, len_rtx, - BLOCK_OP_NORMAL); + CALL_EXPR_TAILCALL (exp) + ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL); if (dest_addr == 0) { @@ -2782,7 +2783,7 @@ expand_builtin_mempcpy (tree arglist, tree type, rtx target, enum machine_mode m static rtx expand_builtin_memmove (tree arglist, tree type, rtx target, - enum machine_mode mode) + enum machine_mode mode, tree orig_exp) { if (!validate_arglist (arglist, POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) @@ -2814,11 +2815,13 @@ expand_builtin_memmove (tree arglist, tree type, rtx target, normal memcpy. */ if (readonly_data_expr (src)) { - tree const fn = implicit_built_in_decls[BUILT_IN_MEMCPY]; + tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY]; if (!fn) return 0; - return expand_expr (build_function_call_expr (fn, arglist), - target, mode, EXPAND_NORMAL); + fn = build_function_call_expr (fn, arglist); + if (TREE_CODE (fn) == CALL_EXPR) + CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp); + return expand_expr (fn, target, mode, EXPAND_NORMAL); } /* If length is 1 and we can expand memcpy call inline, @@ -2840,8 +2843,10 @@ expand_builtin_memmove (tree arglist, tree type, rtx target, if we failed the caller should emit a normal call. */ static rtx -expand_builtin_bcopy (tree arglist, tree type) +expand_builtin_bcopy (tree exp) { + tree arglist = TREE_OPERAND (exp, 1); + tree type = TREE_TYPE (exp); tree src, dest, size, newarglist; if (!validate_arglist (arglist, @@ -2861,7 +2866,7 @@ expand_builtin_bcopy (tree arglist, tree type) newarglist = tree_cons (NULL_TREE, src, newarglist); newarglist = tree_cons (NULL_TREE, dest, newarglist); - return expand_builtin_memmove (newarglist, type, const0_rtx, VOIDmode); + return expand_builtin_memmove (newarglist, type, const0_rtx, VOIDmode, exp); } #ifndef HAVE_movstr @@ -3153,7 +3158,8 @@ builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED, convenient). */ static rtx -expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode) +expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode, + tree orig_exp) { if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE)) @@ -3239,7 +3245,9 @@ expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode) dest_mem = get_memory_rtx (dest); set_mem_align (dest_mem, dest_align); - dest_addr = clear_storage (dest_mem, len_rtx); + dest_addr = clear_storage (dest_mem, len_rtx, + CALL_EXPR_TAILCALL (orig_exp) + ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL); if (dest_addr == 0) { @@ -3255,8 +3263,9 @@ expand_builtin_memset (tree arglist, rtx target, enum machine_mode mode) if we failed the caller should emit a normal call. */ static rtx -expand_builtin_bzero (tree arglist) +expand_builtin_bzero (tree exp) { + tree arglist = TREE_OPERAND (exp, 1); tree dest, size, newarglist; if (!validate_arglist (arglist, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) @@ -3274,7 +3283,7 @@ expand_builtin_bzero (tree arglist) newarglist = tree_cons (NULL_TREE, integer_zero_node, newarglist); newarglist = tree_cons (NULL_TREE, dest, newarglist); - return expand_builtin_memset (newarglist, const0_rtx, VOIDmode); + return expand_builtin_memset (newarglist, const0_rtx, VOIDmode, exp); } /* Expand expression EXP, which is a call to the memcmp built-in function. @@ -3413,7 +3422,7 @@ expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode) tree len, len1, len2; rtx arg1_rtx, arg2_rtx, arg3_rtx; rtx result, insn; - tree fndecl; + tree fndecl, fn; int arg1_align = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT; @@ -3497,8 +3506,10 @@ expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode) arglist = build_tree_list (NULL_TREE, arg2); arglist = tree_cons (NULL_TREE, arg1, arglist); fndecl = get_callee_fndecl (exp); - exp = build_function_call_expr (fndecl, arglist); - return expand_call (exp, target, target == const0_rtx); + fn = build_function_call_expr (fndecl, arglist); + if (TREE_CODE (fn) == CALL_EXPR) + CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp); + return expand_call (fn, target, target == const0_rtx); } #endif return 0; @@ -3535,7 +3546,7 @@ expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode) tree len, len1, len2; rtx arg1_rtx, arg2_rtx, arg3_rtx; rtx result, insn; - tree fndecl; + tree fndecl, fn; int arg1_align = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT; @@ -3625,8 +3636,10 @@ expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode) arglist = tree_cons (NULL_TREE, arg2, arglist); arglist = tree_cons (NULL_TREE, arg1, arglist); fndecl = get_callee_fndecl (exp); - exp = build_function_call_expr (fndecl, arglist); - return expand_call (exp, target, target == const0_rtx); + fn = build_function_call_expr (fndecl, arglist); + if (TREE_CODE (fn) == CALL_EXPR) + CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp); + return expand_call (fn, target, target == const0_rtx); } #endif return 0; @@ -4556,15 +4569,16 @@ build_string_literal (int len, const char *str) return t; } -/* Expand a call to printf or printf_unlocked with argument list ARGLIST. +/* Expand EXP, a call to printf or printf_unlocked. Return 0 if a normal call should be emitted rather than transforming the function inline. If convenient, the result should be placed in TARGET with mode MODE. UNLOCKED indicates this is a printf_unlocked call. */ static rtx -expand_builtin_printf (tree arglist, rtx target, enum machine_mode mode, +expand_builtin_printf (tree exp, rtx target, enum machine_mode mode, bool unlocked) { + tree arglist = TREE_OPERAND (exp, 1); tree fn_putchar = unlocked ? implicit_built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : implicit_built_in_decls[BUILT_IN_PUTCHAR]; @@ -4655,19 +4669,22 @@ expand_builtin_printf (tree arglist, rtx target, enum machine_mode mode, if (!fn) return 0; - return expand_expr (build_function_call_expr (fn, arglist), - target, mode, EXPAND_NORMAL); + fn = build_function_call_expr (fn, arglist); + if (TREE_CODE (fn) == CALL_EXPR) + CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp); + return expand_expr (fn, target, mode, EXPAND_NORMAL); } -/* Expand a call to fprintf or fprintf_unlocked with argument list ARGLIST. +/* Expand EXP, a call to fprintf or fprintf_unlocked. Return 0 if a normal call should be emitted rather than transforming the function inline. If convenient, the result should be placed in TARGET with mode MODE. UNLOCKED indicates this is a fprintf_unlocked call. */ static rtx -expand_builtin_fprintf (tree arglist, rtx target, enum machine_mode mode, +expand_builtin_fprintf (tree exp, rtx target, enum machine_mode mode, bool unlocked) { + tree arglist = TREE_OPERAND (exp, 1); tree fn_fputc = unlocked ? implicit_built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : implicit_built_in_decls[BUILT_IN_FPUTC]; tree fn_fputs = unlocked ? implicit_built_in_decls[BUILT_IN_FPUTS_UNLOCKED] @@ -4749,8 +4766,10 @@ expand_builtin_fprintf (tree arglist, rtx target, enum machine_mode mode, if (!fn) return 0; - return expand_expr (build_function_call_expr (fn, arglist), - target, mode, EXPAND_NORMAL); + fn = build_function_call_expr (fn, arglist); + if (TREE_CODE (fn) == CALL_EXPR) + CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp); + return expand_expr (fn, target, mode, EXPAND_NORMAL); } /* Expand a call to sprintf with argument list ARGLIST. Return 0 if @@ -5520,25 +5539,26 @@ expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode, break; case BUILT_IN_MEMMOVE: - target = expand_builtin_memmove (arglist, TREE_TYPE (exp), target, mode); + target = expand_builtin_memmove (arglist, TREE_TYPE (exp), target, + mode, exp); if (target) return target; break; case BUILT_IN_BCOPY: - target = expand_builtin_bcopy (arglist, TREE_TYPE (exp)); + target = expand_builtin_bcopy (exp); if (target) return target; break; case BUILT_IN_MEMSET: - target = expand_builtin_memset (arglist, target, mode); + target = expand_builtin_memset (arglist, target, mode, exp); if (target) return target; break; case BUILT_IN_BZERO: - target = expand_builtin_bzero (arglist); + target = expand_builtin_bzero (exp); if (target) return target; break; @@ -5615,13 +5635,13 @@ expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode, return const0_rtx; case BUILT_IN_PRINTF: - target = expand_builtin_printf (arglist, target, mode, false); + target = expand_builtin_printf (exp, target, mode, false); if (target) return target; break; case BUILT_IN_PRINTF_UNLOCKED: - target = expand_builtin_printf (arglist, target, mode, true); + target = expand_builtin_printf (exp, target, mode, true); if (target) return target; break; @@ -5638,13 +5658,13 @@ expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode, break; case BUILT_IN_FPRINTF: - target = expand_builtin_fprintf (arglist, target, mode, false); + target = expand_builtin_fprintf (exp, target, mode, false); if (target) return target; break; case BUILT_IN_FPRINTF_UNLOCKED: - target = expand_builtin_fprintf (arglist, target, mode, true); + target = expand_builtin_fprintf (exp, target, mode, true); if (target) return target; break; @@ -5826,10 +5846,17 @@ fold_builtin_constant_p (tree arglist) /* If we know this is a constant, emit the constant of one. */ if (CONSTANT_CLASS_P (arglist) || (TREE_CODE (arglist) == CONSTRUCTOR - && TREE_CONSTANT (arglist)) - || (TREE_CODE (arglist) == ADDR_EXPR - && TREE_CODE (TREE_OPERAND (arglist, 0)) == STRING_CST)) + && TREE_CONSTANT (arglist))) return integer_one_node; + if (TREE_CODE (arglist) == ADDR_EXPR) + { + tree op = TREE_OPERAND (arglist, 0); + if (TREE_CODE (op) == STRING_CST + || (TREE_CODE (op) == ARRAY_REF + && integer_zerop (TREE_OPERAND (op, 1)) + && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST)) + return integer_one_node; + } /* If this expression has side effects, show we don't know it to be a constant. Likewise if it's a pointer or aggregate type since in diff --git a/contrib/gcc-4.0/gcc/c-common.c b/contrib/gcc-4.0/gcc/c-common.c index f5b82d294b..0c2a676b80 100644 --- a/contrib/gcc-4.0/gcc/c-common.c +++ b/contrib/gcc-4.0/gcc/c-common.c @@ -284,6 +284,12 @@ int warn_unknown_pragmas; /* Tri state variable. */ int warn_format; +/* Warn about using __null (as NULL in C++) as sentinel. For code compiled + with GCC this doesn't matter as __null is guaranteed to have the right + size. */ + +int warn_strict_null_sentinel; + /* Zero means that faster, ...NonNil variants of objc_msgSend... calls will be used in ObjC; passing nil receivers to such calls will most likely result in crashes. */ @@ -3269,6 +3275,11 @@ c_common_nodes_and_builtins (void) mudflap_init (); main_identifier_node = get_identifier ("main"); + + /* Create the built-in __null node. It is important that this is + not shared. */ + null_node = make_node (INTEGER_CST); + TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0); } /* Look up the function in built_in_decls that corresponds to DECL @@ -5115,8 +5126,15 @@ check_function_sentinel (tree attrs, tree params) } /* Validate the sentinel. */ - if (!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel))) - || !integer_zerop (TREE_VALUE (sentinel))) + if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel))) + || !integer_zerop (TREE_VALUE (sentinel))) + /* Although __null (in C++) is only an integer we allow it + nevertheless, as we are guaranteed that it's exactly + as wide as a pointer, and we don't want to force + users to cast the NULL they have written there. + We warn with -Wstrict-null-sentinel, though. */ + && (warn_strict_null_sentinel + || null_node != TREE_VALUE (sentinel))) warning ("missing sentinel in function call"); } } @@ -5501,51 +5519,51 @@ catenate_strings (const char *lhs, const char *rhs_start, int rhs_size) return result; } -/* Issue the error given by MSGID, indicating that it occurred before +/* Issue the error given by GMSGID, indicating that it occurred before TOKEN, which had the associated VALUE. */ void -c_parse_error (const char *msgid, enum cpp_ttype token, tree value) +c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value) { #define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2)) char *message = NULL; if (token == CPP_EOF) - message = catenate_messages (msgid, " at end of input"); + message = catenate_messages (gmsgid, " at end of input"); else if (token == CPP_CHAR || token == CPP_WCHAR) { unsigned int val = TREE_INT_CST_LOW (value); const char *const ell = (token == CPP_CHAR) ? "" : "L"; if (val <= UCHAR_MAX && ISGRAPH (val)) - message = catenate_messages (msgid, " before %s'%c'"); + message = catenate_messages (gmsgid, " before %s'%c'"); else - message = catenate_messages (msgid, " before %s'\\x%x'"); + message = catenate_messages (gmsgid, " before %s'\\x%x'"); error (message, ell, val); free (message); message = NULL; } else if (token == CPP_STRING || token == CPP_WSTRING) - message = catenate_messages (msgid, " before string constant"); + message = catenate_messages (gmsgid, " before string constant"); else if (token == CPP_NUMBER) - message = catenate_messages (msgid, " before numeric constant"); + message = catenate_messages (gmsgid, " before numeric constant"); else if (token == CPP_NAME) { - message = catenate_messages (msgid, " before %qs"); + message = catenate_messages (gmsgid, " before %qs"); error (message, IDENTIFIER_POINTER (value)); free (message); message = NULL; } else if (token < N_TTYPES) { - message = catenate_messages (msgid, " before %qs token"); + message = catenate_messages (gmsgid, " before %qs token"); error (message, cpp_type2name (token)); free (message); message = NULL; } else - error (msgid); + error (gmsgid); if (message) { diff --git a/contrib/gcc-4.0/gcc/c-common.h b/contrib/gcc-4.0/gcc/c-common.h index 502c03dd21..bad4586351 100644 --- a/contrib/gcc-4.0/gcc/c-common.h +++ b/contrib/gcc-4.0/gcc/c-common.h @@ -160,6 +160,8 @@ enum c_tree_index CTI_VOID_ZERO, + CTI_NULL, + CTI_MAX }; @@ -204,6 +206,9 @@ struct c_common_identifier GTY(()) /* A node for `((void) 0)'. */ #define void_zero_node c_global_trees[CTI_VOID_ZERO] +/* The node for C++ `__null'. */ +#define null_node c_global_trees[CTI_NULL] + extern GTY(()) tree c_global_trees[CTI_MAX]; /* In a RECORD_TYPE, a sorted array of the fields of the type, not a @@ -575,6 +580,12 @@ extern int flag_threadsafe_statics; extern int warn_implicit; +/* Warn about using __null (as NULL in C++) as sentinel. For code compiled + with GCC this doesn't matter as __null is guaranteed to have the right + size. */ + +extern int warn_strict_null_sentinel; + /* Maximum template instantiation depth. This limit is rather arbitrary, but it exists to limit the time it takes to notice infinite template instantiations. */ diff --git a/contrib/gcc-4.0/gcc/c-decl.c b/contrib/gcc-4.0/gcc/c-decl.c index 2dba38ba70..dabd1c145b 100644 --- a/contrib/gcc-4.0/gcc/c-decl.c +++ b/contrib/gcc-4.0/gcc/c-decl.c @@ -98,6 +98,14 @@ static int enum_overflow; static location_t current_function_prototype_locus; +/* Whether this prototype was built-in. */ + +static bool current_function_prototype_built_in; + +/* The argument type information of this prototype. */ + +static tree current_function_prototype_arg_types; + /* The argument information structure for the function currently being defined. */ @@ -673,6 +681,8 @@ pop_scope (void) bool functionbody = scope->function_body; bool keep = functionbody || scope->keep || scope->bindings; + c_end_vm_scope (scope->depth); + /* If appropriate, create a BLOCK to record the decls for the life of this function. */ block = 0; @@ -1104,11 +1114,11 @@ locate_old_decl (tree decl, void (*diag)(const char *, ...)) if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl)) ; else if (DECL_INITIAL (decl)) - diag (N_("%Jprevious definition of %qD was here"), decl, decl); + diag (G_("%Jprevious definition of %qD was here"), decl, decl); else if (C_DECL_IMPLICIT (decl)) - diag (N_("%Jprevious implicit declaration of %qD was here"), decl, decl); + diag (G_("%Jprevious implicit declaration of %qD was here"), decl, decl); else - diag (N_("%Jprevious declaration of %qD was here"), decl, decl); + diag (G_("%Jprevious declaration of %qD was here"), decl, decl); } /* Subroutine of duplicate_decls. Compare NEWDECL to OLDDECL. @@ -1572,6 +1582,10 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype) { int new_is_definition = (TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0); + int new_is_prototype = (TREE_CODE (newdecl) == FUNCTION_DECL + && TYPE_ARG_TYPES (TREE_TYPE (newdecl)) != 0); + int old_is_prototype = (TREE_CODE (olddecl) == FUNCTION_DECL + && TYPE_ARG_TYPES (TREE_TYPE (olddecl)) != 0); /* For real parm decl following a forward decl, rechain the old decl in its new location and clear TREE_ASM_WRITTEN (it's not a @@ -1645,8 +1659,12 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype) if (TREE_DEPRECATED (newdecl)) TREE_DEPRECATED (olddecl) = 1; - /* Keep source location of definition rather than declaration. */ - if (DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0) + /* Keep source location of definition rather than declaration and of + prototype rather than non-prototype unless that prototype is + built-in. */ + if ((DECL_INITIAL (newdecl) == 0 && DECL_INITIAL (olddecl) != 0) + || (old_is_prototype && !new_is_prototype + && !C_DECL_BUILTIN_PROTOTYPE (olddecl))) DECL_SOURCE_LOCATION (newdecl) = DECL_SOURCE_LOCATION (olddecl); /* Merge the unused-warning information. */ @@ -1761,6 +1779,11 @@ merge_decls (tree newdecl, tree olddecl, tree newtype, tree oldtype) DECL_BUILT_IN_CLASS (newdecl) = DECL_BUILT_IN_CLASS (olddecl); DECL_FUNCTION_CODE (newdecl) = DECL_FUNCTION_CODE (olddecl); C_DECL_DECLARED_BUILTIN (newdecl) = 1; + if (new_is_prototype) + C_DECL_BUILTIN_PROTOTYPE (newdecl) = 0; + else + C_DECL_BUILTIN_PROTOTYPE (newdecl) + = C_DECL_BUILTIN_PROTOTYPE (olddecl); } /* Also preserve various other info from the definition. */ @@ -1982,6 +2005,12 @@ pushdecl (tree x) || DECL_INITIAL (x) || !DECL_EXTERNAL (x))) DECL_CONTEXT (x) = current_function_decl; + /* If this is of variably modified type, prevent jumping into its + scope. */ + if ((TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == TYPE_DECL) + && variably_modified_type_p (TREE_TYPE (x), NULL_TREE)) + c_begin_vm_scope (scope->depth); + /* Anonymous decls are just inserted in the scope. */ if (!name) { @@ -1999,11 +2028,52 @@ pushdecl (tree x) b = I_SYMBOL_BINDING (name); if (b && B_IN_SCOPE (b, scope)) { + struct c_binding *b_ext, *b_use; + tree type = TREE_TYPE (x); + tree visdecl = b->decl; + tree vistype = TREE_TYPE (visdecl); if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE && COMPLETE_TYPE_P (TREE_TYPE (x))) b->inner_comp = false; - if (duplicate_decls (x, b->decl)) - return b->decl; + b_use = b; + b_ext = b; + /* If this is an external linkage declaration, we should check + for compatibility with the type in the external scope before + setting the type at this scope based on the visible + information only. */ + if (TREE_PUBLIC (x) && TREE_PUBLIC (visdecl)) + { + while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext)) + b_ext = b_ext->shadowed; + if (b_ext) + { + b_use = b_ext; + if (b_use->type) + TREE_TYPE (b_use->decl) = b_use->type; + } + } + if (duplicate_decls (x, b_use->decl)) + { + if (b_use != b) + { + /* Save the updated type in the external scope and + restore the proper type for this scope. */ + tree thistype; + if (comptypes (vistype, type)) + thistype = composite_type (vistype, type); + else + thistype = TREE_TYPE (b_use->decl); + b_use->type = TREE_TYPE (b_use->decl); + if (TREE_CODE (b_use->decl) == FUNCTION_DECL + && DECL_BUILT_IN (b_use->decl)) + thistype + = build_type_attribute_variant (thistype, + TYPE_ATTRIBUTES + (b_use->type)); + TREE_TYPE (b_use->decl) = thistype; + } + return b_use->decl; + } else goto skip_external_and_shadow_checks; } @@ -2090,7 +2160,15 @@ pushdecl (tree x) && duplicate_decls (x, b->decl)) { tree thistype; - thistype = (vistype ? composite_type (vistype, type) : type); + if (vistype) + { + if (comptypes (vistype, type)) + thistype = composite_type (vistype, type); + else + thistype = TREE_TYPE (b->decl); + } + else + thistype = type; b->type = TREE_TYPE (b->decl); if (TREE_CODE (b->decl) == FUNCTION_DECL && DECL_BUILT_IN (b->decl)) thistype @@ -2197,7 +2275,7 @@ implicit_decl_warning (tree id, tree olddecl) default: gcc_unreachable (); } - diag (N_("implicit declaration of function %qE"), id); + diag (G_("implicit declaration of function %qE"), id); if (olddecl) locate_old_decl (olddecl, diag); } @@ -2439,7 +2517,7 @@ define_label (location_t location, tree name) if there is a containing function with a declared label with the same name. */ tree label = I_LABEL_DECL (name); - struct c_label_list *nlist; + struct c_label_list *nlist_se, *nlist_vm; if (label && ((DECL_CONTEXT (label) == current_function_decl @@ -2458,6 +2536,9 @@ define_label (location_t location, tree name) definition. */ if (C_DECL_UNDEFINABLE_STMT_EXPR (label)) error ("%Jjump into statement expression", label); + if (C_DECL_UNDEFINABLE_VM (label)) + error ("%Jjump into scope of identifier with variably modified type", + label); DECL_SOURCE_LOCATION (label) = location; } else @@ -2475,10 +2556,15 @@ define_label (location_t location, tree name) "identifier %qs conflicts", &location, IDENTIFIER_POINTER (name)); - nlist = XOBNEW (&parser_obstack, struct c_label_list); - nlist->next = label_context_stack->labels_def; - nlist->label = label; - label_context_stack->labels_def = nlist; + nlist_se = XOBNEW (&parser_obstack, struct c_label_list); + nlist_se->next = label_context_stack_se->labels_def; + nlist_se->label = label; + label_context_stack_se->labels_def = nlist_se; + + nlist_vm = XOBNEW (&parser_obstack, struct c_label_list); + nlist_vm->next = label_context_stack_vm->labels_def; + nlist_vm->label = label; + label_context_stack_vm->labels_def = nlist_vm; /* Mark label as having been defined. */ DECL_INITIAL (label) = error_mark_node; @@ -2700,6 +2786,7 @@ builtin_function (const char *name, tree type, int function_code, DECL_LANG_SPECIFIC (decl) = GGC_CNEW (struct lang_decl); DECL_BUILT_IN_CLASS (decl) = cl; DECL_FUNCTION_CODE (decl) = function_code; + C_DECL_BUILTIN_PROTOTYPE (decl) = (TYPE_ARG_TYPES (type) != 0); if (library_name) SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name)); @@ -3198,11 +3285,13 @@ finish_decl (tree decl, tree init, tree asmspec_tree) /* Get the completed type made by complete_array_type. */ type = TREE_TYPE (decl); - if (failure == 1) - error ("%Jinitializer fails to determine size of %qD", decl, decl); - - else if (failure == 2) + switch (failure) { + case 1: + error ("%Jinitializer fails to determine size of %qD", decl, decl); + break; + + case 2: if (do_default) error ("%Jarray size missing in %qD", decl, decl); /* If a `static' var's size isn't known, @@ -3213,9 +3302,33 @@ finish_decl (tree decl, tree init, tree asmspec_tree) and it will get allocated. */ else if (!pedantic && TREE_STATIC (decl) && !TREE_PUBLIC (decl)) DECL_EXTERNAL (decl) = 1; + break; + + case 3: + error ("%Jzero or negative size array %qD", decl, decl); + break; + + case 0: + /* For global variables, update the copy of the type that + exists in the binding. */ + if (TREE_PUBLIC (decl)) + { + struct c_binding *b_ext = I_SYMBOL_BINDING (DECL_NAME (decl)); + while (b_ext && !B_IN_EXTERNAL_SCOPE (b_ext)) + b_ext = b_ext->shadowed; + if (b_ext) + { + if (b_ext->type) + b_ext->type = composite_type (b_ext->type, type); + else + b_ext->type = type; + } + } + break; + + default: + gcc_unreachable (); } - else if (failure == 3) - error ("%Jzero or negative size array %qD", decl, decl); if (DECL_INITIAL (decl)) TREE_TYPE (DECL_INITIAL (decl)) = type; @@ -5327,7 +5440,7 @@ finish_struct (tree t, tree fieldlist, tree attributes) make it one, warn and turn off the flag. */ if (TREE_CODE (t) == UNION_TYPE && TYPE_TRANSPARENT_UNION (t) - && TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t))) + && (!TYPE_FIELDS (t) || TYPE_MODE (t) != DECL_MODE (TYPE_FIELDS (t)))) { TYPE_TRANSPARENT_UNION (t) = 0; warning ("union cannot be made transparent"); @@ -5655,7 +5768,8 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator, { tree decl1, old_decl; tree restype, resdecl; - struct c_label_context *nstack; + struct c_label_context_se *nstack_se; + struct c_label_context_vm *nstack_vm; current_function_returns_value = 0; /* Assume, until we see it does. */ current_function_returns_null = 0; @@ -5664,11 +5778,18 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator, current_extern_inline = 0; c_switch_stack = NULL; - nstack = XOBNEW (&parser_obstack, struct c_label_context); - nstack->labels_def = NULL; - nstack->labels_used = NULL; - nstack->next = label_context_stack; - label_context_stack = nstack; + nstack_se = XOBNEW (&parser_obstack, struct c_label_context_se); + nstack_se->labels_def = NULL; + nstack_se->labels_used = NULL; + nstack_se->next = label_context_stack_se; + label_context_stack_se = nstack_se; + + nstack_vm = XOBNEW (&parser_obstack, struct c_label_context_vm); + nstack_vm->labels_def = NULL; + nstack_vm->labels_used = NULL; + nstack_vm->scope = 0; + nstack_vm->next = label_context_stack_vm; + label_context_stack_vm = nstack_vm; /* Indicate no valid break/continue context by setting these variables to some non-null, non-label value. We'll notice and emit the proper @@ -5680,7 +5801,11 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator, /* If the declarator is not suitable for a function definition, cause a syntax error. */ if (decl1 == 0) - return 0; + { + label_context_stack_se = label_context_stack_se->next; + label_context_stack_vm = label_context_stack_vm->next; + return 0; + } decl_attributes (&decl1, attributes, 0); @@ -5710,14 +5835,53 @@ start_function (struct c_declspecs *declspecs, struct c_declarator *declarator, /* If this definition isn't a prototype and we had a prototype declaration before, copy the arg type info from that prototype. */ old_decl = lookup_name_in_scope (DECL_NAME (decl1), current_scope); - if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE - && comptypes (TREE_TYPE (TREE_TYPE (decl1)), - TREE_TYPE (TREE_TYPE (old_decl))) - && TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0) - { - TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl), - TREE_TYPE (decl1)); - current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl); + current_function_prototype_locus = UNKNOWN_LOCATION; + current_function_prototype_built_in = false; + current_function_prototype_arg_types = NULL_TREE; + if (TYPE_ARG_TYPES (TREE_TYPE (decl1)) == 0) + { + if (old_decl != 0 && TREE_CODE (TREE_TYPE (old_decl)) == FUNCTION_TYPE + && comptypes (TREE_TYPE (TREE_TYPE (decl1)), + TREE_TYPE (TREE_TYPE (old_decl)))) + { + TREE_TYPE (decl1) = composite_type (TREE_TYPE (old_decl), + TREE_TYPE (decl1)); + current_function_prototype_locus = DECL_SOURCE_LOCATION (old_decl); + current_function_prototype_built_in + = C_DECL_BUILTIN_PROTOTYPE (old_decl); + current_function_prototype_arg_types + = TYPE_ARG_TYPES (TREE_TYPE (decl1)); + } + if (TREE_PUBLIC (decl1)) + { + /* If there is an external prototype declaration of this + function, record its location but do not copy information + to this decl. This may be an invisible declaration + (built-in or in a scope which has finished) or simply + have more refined argument types than any declaration + found above. */ + struct c_binding *b; + for (b = I_SYMBOL_BINDING (DECL_NAME (decl1)); b; b = b->shadowed) + if (B_IN_SCOPE (b, external_scope)) + break; + if (b) + { + tree ext_decl, ext_type; + ext_decl = b->decl; + ext_type = b->type ? b->type : TREE_TYPE (ext_decl); + if (TREE_CODE (ext_type) == FUNCTION_TYPE + && comptypes (TREE_TYPE (TREE_TYPE (decl1)), + TREE_TYPE (ext_type))) + { + current_function_prototype_locus + = DECL_SOURCE_LOCATION (ext_decl); + current_function_prototype_built_in + = C_DECL_BUILTIN_PROTOTYPE (ext_decl); + current_function_prototype_arg_types + = TYPE_ARG_TYPES (ext_type); + } + } + } } /* Optionally warn of old-fashioned def with no previous prototype. */ @@ -6057,11 +6221,11 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info) set the DECL_ARG_TYPE of each argument according to the type previously specified, and report any mismatches. */ - if (TYPE_ARG_TYPES (TREE_TYPE (fndecl))) + if (current_function_prototype_arg_types) { tree type; for (parm = DECL_ARGUMENTS (fndecl), - type = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); + type = current_function_prototype_arg_types; parm || (type && (TYPE_MAIN_VARIANT (TREE_VALUE (type)) != void_type_node)); parm = TREE_CHAIN (parm), type = TREE_CHAIN (type)) @@ -6069,9 +6233,15 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info) if (parm == 0 || type == 0 || TYPE_MAIN_VARIANT (TREE_VALUE (type)) == void_type_node) { - error ("number of arguments doesn%'t match prototype"); - error ("%Hprototype declaration", - ¤t_function_prototype_locus); + if (current_function_prototype_built_in) + warning ("number of arguments doesn%'t match " + "built-in prototype"); + else + { + error ("number of arguments doesn%'t match prototype"); + error ("%Hprototype declaration", + ¤t_function_prototype_locus); + } break; } /* Type for passing arg must be consistent with that @@ -6098,17 +6268,33 @@ store_parm_decls_oldstyle (tree fndecl, const struct c_arg_info *arg_info) if (pedantic) { - pedwarn ("promoted argument %qD " - "doesn%'t match prototype", parm); - pedwarn ("%Hprototype declaration", - ¤t_function_prototype_locus); + /* ??? Is it possible to get here with a + built-in prototype or will it always have + been diagnosed as conflicting with an + old-style definition and discarded? */ + if (current_function_prototype_built_in) + warning ("promoted argument %qD " + "doesn%'t match built-in prototype", parm); + else + { + pedwarn ("promoted argument %qD " + "doesn%'t match prototype", parm); + pedwarn ("%Hprototype declaration", + ¤t_function_prototype_locus); + } } } else { - error ("argument %qD doesn%'t match prototype", parm); - error ("%Hprototype declaration", - ¤t_function_prototype_locus); + if (current_function_prototype_built_in) + warning ("argument %qD doesn%'t match " + "built-in prototype", parm); + else + { + error ("argument %qD doesn%'t match prototype", parm); + error ("%Hprototype declaration", + ¤t_function_prototype_locus); + } } } } @@ -6251,7 +6437,8 @@ finish_function (void) { tree fndecl = current_function_decl; - label_context_stack = label_context_stack->next; + label_context_stack_se = label_context_stack_se->next; + label_context_stack_vm = label_context_stack_vm->next; if (TREE_CODE (fndecl) == FUNCTION_DECL && targetm.calls.promote_prototypes (TREE_TYPE (fndecl))) diff --git a/contrib/gcc-4.0/gcc/c-errors.c b/contrib/gcc-4.0/gcc/c-errors.c index fa71b8cfa9..ccdbf7ef7c 100644 --- a/contrib/gcc-4.0/gcc/c-errors.c +++ b/contrib/gcc-4.0/gcc/c-errors.c @@ -32,13 +32,13 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA /* Issue an ISO C99 pedantic warning MSGID. */ void -pedwarn_c99 (const char *msgid, ...) +pedwarn_c99 (const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, input_location, + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, flag_isoc99 ? pedantic_error_kind () : DK_WARNING); report_diagnostic (&diagnostic); va_end (ap); @@ -50,13 +50,13 @@ pedwarn_c99 (const char *msgid, ...) (There is no flag_c90.) */ void -pedwarn_c90 (const char *msgid, ...) +pedwarn_c90 (const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, input_location, + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, flag_isoc99 ? DK_WARNING : pedantic_error_kind ()); report_diagnostic (&diagnostic); va_end (ap); diff --git a/contrib/gcc-4.0/gcc/c-format.c b/contrib/gcc-4.0/gcc/c-format.c index a0ae154ab4..1bb9f3aebb 100644 --- a/contrib/gcc-4.0/gcc/c-format.c +++ b/contrib/gcc-4.0/gcc/c-format.c @@ -2289,9 +2289,25 @@ init_dynamic_asm_fprintf_info (void) HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code prior to using that modifier. */ hwi = maybe_get_identifier ("__gcc_host_wide_int__"); + if (!hwi) + { + error ("%<__gcc_host_wide_int__%> is not defined as a type"); + return; + } + hwi = identifier_global_value (hwi); + if (!hwi || TREE_CODE (hwi) != TYPE_DECL) + { + error ("%<__gcc_host_wide_int__%> is not defined as a type"); + return; + } + hwi = DECL_ORIGINAL_TYPE (hwi); gcc_assert (hwi); - hwi = DECL_ORIGINAL_TYPE (identifier_global_value (hwi)); - gcc_assert (hwi); + if (hwi != long_integer_type_node && hwi != long_long_integer_type_node) + { + error ("%<__gcc_host_wide_int__%> is not defined as %" + " or %"); + return; + } /* Create a new (writable) copy of asm_fprintf_length_specs. */ new_asm_fprintf_length_specs = (format_length_info *) @@ -2335,19 +2351,70 @@ init_dynamic_diag_info (void) However we don't force a hard ICE because we may see only one or the other type. */ if ((loc = maybe_get_identifier ("location_t"))) - loc = TREE_TYPE (identifier_global_value (loc)); + { + loc = identifier_global_value (loc); + if (loc) + { + if (TREE_CODE (loc) != TYPE_DECL) + { + error ("% is not defined as a type"); + loc = 0; + } + else + loc = TREE_TYPE (loc); + } + } /* We need to grab the underlying 'union tree_node' so peek into an extra type level. */ if ((t = maybe_get_identifier ("tree"))) - t = TREE_TYPE (TREE_TYPE (identifier_global_value (t))); + { + t = identifier_global_value (t); + if (t) + { + if (TREE_CODE (t) != TYPE_DECL) + { + error ("% is not defined as a type"); + t = 0; + } + else if (TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE) + { + error ("% is not defined as a pointer type"); + t = 0; + } + else + t = TREE_TYPE (TREE_TYPE (t)); + } + } /* Find the underlying type for HOST_WIDE_INT. For the %w length modifier to work, one must have issued: "typedef HOST_WIDE_INT __gcc_host_wide_int__;" in one's source code prior to using that modifier. */ if ((hwi = maybe_get_identifier ("__gcc_host_wide_int__"))) - hwi = DECL_ORIGINAL_TYPE (identifier_global_value (hwi)); + { + hwi = identifier_global_value (hwi); + if (hwi) + { + if (TREE_CODE (hwi) != TYPE_DECL) + { + error ("%<__gcc_host_wide_int__%> is not defined as a type"); + hwi = 0; + } + else + { + hwi = DECL_ORIGINAL_TYPE (hwi); + gcc_assert (hwi); + if (hwi != long_integer_type_node + && hwi != long_long_integer_type_node) + { + error ("%<__gcc_host_wide_int__%> is not defined" + " as % or %"); + hwi = 0; + } + } + } + } /* Assign the new data for use. */ diff --git a/contrib/gcc-4.0/gcc/c-opts.c b/contrib/gcc-4.0/gcc/c-opts.c index b1a08621ca..04085b7a8f 100644 --- a/contrib/gcc-4.0/gcc/c-opts.c +++ b/contrib/gcc-4.0/gcc/c-opts.c @@ -464,6 +464,10 @@ c_common_handle_option (size_t scode, const char *arg, int value) warn_return_type = value; break; + case OPT_Wstrict_null_sentinel: + warn_strict_null_sentinel = value; + break; + case OPT_Wsystem_headers: cpp_opts->warn_system_headers = value; break; diff --git a/contrib/gcc-4.0/gcc/c-parse.c b/contrib/gcc-4.0/gcc/c-parse.c dissimilarity index 70% index cf0e906f39..bf346a1d2a 100644 --- a/contrib/gcc-4.0/gcc/c-parse.c +++ b/contrib/gcc-4.0/gcc/c-parse.c @@ -1,5249 +1,5994 @@ -/* A Bison parser, made from c-parse.y - by GNU bison 1.35. */ - -#define YYBISON 1 /* Identify Bison output. */ - -# define IDENTIFIER 257 -# define TYPENAME 258 -# define SCSPEC 259 -# define STATIC 260 -# define TYPESPEC 261 -# define TYPE_QUAL 262 -# define OBJC_TYPE_QUAL 263 -# define CONSTANT 264 -# define STRING 265 -# define ELLIPSIS 266 -# define SIZEOF 267 -# define ENUM 268 -# define STRUCT 269 -# define UNION 270 -# define IF 271 -# define ELSE 272 -# define WHILE 273 -# define DO 274 -# define FOR 275 -# define SWITCH 276 -# define CASE 277 -# define DEFAULT 278 -# define BREAK 279 -# define CONTINUE 280 -# define RETURN 281 -# define GOTO 282 -# define ASM_KEYWORD 283 -# define TYPEOF 284 -# define ALIGNOF 285 -# define ATTRIBUTE 286 -# define EXTENSION 287 -# define LABEL 288 -# define REALPART 289 -# define IMAGPART 290 -# define VA_ARG 291 -# define CHOOSE_EXPR 292 -# define TYPES_COMPATIBLE_P 293 -# define FUNC_NAME 294 -# define OFFSETOF 295 -# define ASSIGN 296 -# define OROR 297 -# define ANDAND 298 -# define EQCOMPARE 299 -# define ARITHCOMPARE 300 -# define LSHIFT 301 -# define RSHIFT 302 -# define UNARY 303 -# define PLUSPLUS 304 -# define MINUSMINUS 305 -# define HYPERUNARY 306 -# define POINTSAT 307 -# define AT_INTERFACE 308 -# define AT_IMPLEMENTATION 309 -# define AT_END 310 -# define AT_SELECTOR 311 -# define AT_DEFS 312 -# define AT_ENCODE 313 -# define CLASSNAME 314 -# define AT_PUBLIC 315 -# define AT_PRIVATE 316 -# define AT_PROTECTED 317 -# define AT_PROTOCOL 318 -# define AT_CLASS 319 -# define AT_ALIAS 320 -# define AT_THROW 321 -# define AT_TRY 322 -# define AT_CATCH 323 -# define AT_FINALLY 324 -# define AT_SYNCHRONIZED 325 -# define OBJC_STRING 326 - -#line 34 "c-parse.y" - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "tm.h" -#include "tree.h" -#include "langhooks.h" -#include "input.h" -#include "cpplib.h" -#include "intl.h" -#include "timevar.h" -#include "c-pragma.h" /* For YYDEBUG definition, and parse_in. */ -#include "c-tree.h" -#include "flags.h" -#include "varray.h" -#include "output.h" -#include "toplev.h" -#include "ggc.h" -#include "c-common.h" - -#define YYERROR1 { yyerror ("syntax error"); YYERROR; } - -/* Like the default stack expander, except (1) use realloc when possible, - (2) impose no hard maxiumum on stack size, (3) REALLY do not use alloca. - - Irritatingly, YYSTYPE is defined after this %{ %} block, so we cannot - give malloced_yyvs its proper type. This is ok since all we need from - it is to be able to free it. */ - -static short *malloced_yyss; -static void *malloced_yyvs; - -#define yyoverflow(MSG, SS, SSSIZE, VS, VSSIZE, YYSSZ) \ -do { \ - size_t newsize; \ - short *newss; \ - YYSTYPE *newvs; \ - newsize = *(YYSSZ) *= 2; \ - if (malloced_yyss) \ - { \ - newss = really_call_realloc (*(SS), newsize * sizeof (short)); \ - newvs = really_call_realloc (*(VS), newsize * sizeof (YYSTYPE)); \ - } \ - else \ - { \ - newss = really_call_malloc (newsize * sizeof (short)); \ - newvs = really_call_malloc (newsize * sizeof (YYSTYPE)); \ - if (newss) \ - memcpy (newss, *(SS), (SSSIZE)); \ - if (newvs) \ - memcpy (newvs, *(VS), (VSSIZE)); \ - } \ - if (!newss || !newvs) \ - { \ - yyerror (MSG); \ - return 2; \ - } \ - *(SS) = newss; \ - *(VS) = newvs; \ - malloced_yyss = newss; \ - malloced_yyvs = (void *) newvs; \ -} while (0) - -#line 100 "c-parse.y" -#ifndef YYSTYPE -typedef union {long itype; tree ttype; void *otype; struct c_expr exprtype; - struct c_arg_info *arginfotype; struct c_declarator *dtrtype; - struct c_type_name *typenametype; struct c_parm *parmtype; - struct c_declspecs *dsptype; struct c_typespec tstype; - enum tree_code code; location_t location; } yystype; -# define YYSTYPE yystype -# define YYSTYPE_IS_TRIVIAL 1 -#endif -#line 251 "c-parse.y" - -/* Declaration specifiers of the current declaration. */ -static struct c_declspecs *current_declspecs; -static GTY(()) tree prefix_attributes; - -/* List of all the attributes applying to the identifier currently being - declared; includes prefix_attributes and possibly some more attributes - just after a comma. */ -static GTY(()) tree all_prefix_attributes; - -/* Structure to save declaration specifiers. */ -struct c_declspec_stack { - /* Saved value of current_declspecs. */ - struct c_declspecs *current_declspecs; - /* Saved value of prefix_attributes. */ - tree prefix_attributes; - /* Saved value of all_prefix_attributes. */ - tree all_prefix_attributes; - /* Next level of stack. */ - struct c_declspec_stack *next; -}; - -/* Stack of saved values of current_declspecs, prefix_attributes and - all_prefix_attributes. */ -static struct c_declspec_stack *declspec_stack; - -/* INDIRECT_REF with a TREE_TYPE of the type being queried for offsetof. */ -static tree offsetof_base; - -/* PUSH_DECLSPEC_STACK is called from setspecs; POP_DECLSPEC_STACK - should be called from the productions making use of setspecs. */ -#define PUSH_DECLSPEC_STACK \ - do { \ - struct c_declspec_stack *t = XOBNEW (&parser_obstack, \ - struct c_declspec_stack); \ - t->current_declspecs = current_declspecs; \ - t->prefix_attributes = prefix_attributes; \ - t->all_prefix_attributes = all_prefix_attributes; \ - t->next = declspec_stack; \ - declspec_stack = t; \ - } while (0) - -#define POP_DECLSPEC_STACK \ - do { \ - current_declspecs = declspec_stack->current_declspecs; \ - prefix_attributes = declspec_stack->prefix_attributes; \ - all_prefix_attributes = declspec_stack->all_prefix_attributes; \ - declspec_stack = declspec_stack->next; \ - } while (0) - -/* For __extension__, save/restore the warning flags which are - controlled by __extension__. */ -#define SAVE_EXT_FLAGS() \ - (pedantic \ - | (warn_pointer_arith << 1) \ - | (warn_traditional << 2) \ - | (flag_iso << 3)) - -#define RESTORE_EXT_FLAGS(val) \ - do { \ - pedantic = val & 1; \ - warn_pointer_arith = (val >> 1) & 1; \ - warn_traditional = (val >> 2) & 1; \ - flag_iso = (val >> 3) & 1; \ - } while (0) - - -#define OBJC_NEED_RAW_IDENTIFIER(VAL) /* nothing */ - -/* Tell yyparse how to print a token's value, if yydebug is set. */ - -#define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL) - -static void yyprint (FILE *, int, YYSTYPE); -static void yyerror (const char *); -static int yylexname (void); -static inline int _yylex (void); -static int yylex (void); -static void init_reswords (void); - - /* Initialization routine for this file. */ -void -c_parse_init (void) -{ - init_reswords (); -} - -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif - - - -#define YYFINAL 933 -#define YYFLAG -32768 -#define YYNTBASE 95 - -/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ -#define YYTRANSLATE(x) ((unsigned)(x) <= 326 ? yytranslate[x] : 303) - -/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */ -static const char yytranslate[] = -{ - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 90, 2, 2, 2, 59, 50, 2, - 66, 92, 57, 55, 91, 56, 65, 58, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 45, 87, - 2, 43, 2, 44, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 67, 2, 94, 49, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 93, 48, 88, 89, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, 42, 46, 47, 51, - 52, 53, 54, 60, 61, 62, 63, 64, 68, 69, - 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, - 80, 81, 82, 83, 84, 85, 86 -}; - -#if YYDEBUG -static const short yyprhs[] = -{ - 0, 0, 1, 3, 4, 8, 9, 14, 16, 18, - 20, 23, 24, 28, 33, 38, 41, 44, 47, 49, - 50, 51, 60, 65, 66, 67, 76, 81, 82, 83, - 91, 95, 97, 99, 101, 103, 105, 107, 109, 111, - 113, 115, 119, 120, 122, 124, 128, 130, 133, 136, - 139, 142, 145, 150, 153, 158, 161, 164, 166, 168, - 170, 172, 177, 179, 183, 187, 191, 195, 199, 203, - 207, 211, 215, 219, 223, 227, 228, 233, 234, 239, - 240, 241, 249, 250, 256, 260, 264, 266, 268, 270, - 272, 273, 281, 285, 289, 293, 297, 302, 309, 310, - 318, 323, 332, 337, 344, 349, 354, 358, 362, 365, - 368, 370, 374, 379, 380, 382, 385, 387, 389, 392, - 395, 400, 405, 408, 411, 414, 415, 417, 422, 427, - 431, 435, 438, 441, 443, 446, 449, 452, 455, 458, - 460, 463, 465, 468, 471, 474, 477, 480, 483, 485, - 488, 491, 494, 497, 500, 503, 506, 509, 512, 515, - 518, 521, 524, 527, 530, 533, 535, 538, 541, 544, - 547, 550, 553, 556, 559, 562, 565, 568, 571, 574, - 577, 580, 583, 586, 589, 592, 595, 598, 601, 604, - 607, 610, 613, 616, 619, 622, 625, 628, 631, 634, - 637, 640, 643, 646, 649, 652, 655, 658, 661, 664, - 667, 669, 671, 673, 675, 677, 679, 681, 683, 685, - 687, 689, 691, 693, 695, 697, 699, 701, 703, 705, - 707, 709, 711, 713, 715, 717, 719, 721, 723, 725, - 727, 729, 731, 733, 735, 737, 739, 741, 743, 745, - 747, 749, 751, 753, 755, 757, 759, 761, 763, 765, - 767, 769, 771, 773, 775, 777, 779, 780, 782, 784, - 786, 788, 790, 792, 794, 796, 801, 806, 808, 813, - 815, 820, 821, 828, 832, 833, 840, 844, 845, 847, - 849, 852, 861, 865, 867, 871, 872, 874, 879, 886, - 891, 893, 895, 897, 899, 901, 903, 905, 906, 911, - 913, 914, 917, 919, 923, 927, 930, 931, 936, 938, - 939, 944, 946, 948, 950, 953, 956, 958, 964, 968, - 969, 970, 977, 978, 979, 986, 988, 990, 995, 999, - 1002, 1006, 1008, 1010, 1012, 1016, 1019, 1021, 1025, 1028, - 1032, 1036, 1041, 1045, 1050, 1054, 1057, 1059, 1061, 1064, - 1066, 1069, 1071, 1074, 1075, 1083, 1089, 1090, 1098, 1104, - 1105, 1114, 1115, 1123, 1126, 1129, 1132, 1133, 1135, 1136, - 1138, 1140, 1143, 1144, 1148, 1151, 1155, 1158, 1162, 1164, - 1166, 1169, 1171, 1176, 1178, 1183, 1186, 1191, 1195, 1198, - 1203, 1207, 1209, 1213, 1215, 1217, 1221, 1222, 1226, 1227, - 1229, 1230, 1232, 1235, 1237, 1239, 1241, 1245, 1248, 1252, - 1257, 1261, 1264, 1267, 1269, 1274, 1278, 1283, 1289, 1295, - 1297, 1299, 1301, 1303, 1305, 1308, 1311, 1314, 1317, 1319, - 1322, 1325, 1328, 1330, 1333, 1336, 1339, 1342, 1344, 1347, - 1349, 1351, 1353, 1355, 1358, 1359, 1360, 1362, 1364, 1367, - 1371, 1373, 1376, 1378, 1380, 1384, 1386, 1388, 1391, 1394, - 1395, 1396, 1399, 1403, 1406, 1409, 1412, 1416, 1420, 1422, - 1432, 1442, 1450, 1458, 1459, 1460, 1470, 1471, 1472, 1486, - 1487, 1489, 1492, 1494, 1497, 1499, 1512, 1513, 1522, 1525, - 1527, 1529, 1531, 1533, 1535, 1538, 1541, 1544, 1548, 1550, - 1554, 1559, 1561, 1563, 1565, 1569, 1575, 1578, 1583, 1590, - 1591, 1593, 1596, 1601, 1610, 1612, 1616, 1622, 1630, 1631, - 1633, 1634, 1636, 1638, 1642, 1649, 1659, 1661, 1665, 1667, - 1668, 1669, 1670, 1674, 1677, 1678, 1679, 1686, 1689, 1690, - 1692, 1694, 1698, 1700, 1704, 1709, 1714, 1718, 1723, 1727, - 1732, 1737, 1741, 1746, 1750, 1752, 1753, 1757, 1759, 1762, - 1764, 1768, 1770, 1774 -}; -static const short yyrhs[] = -{ - -1, 96, 0, 0, 100, 97, 99, 0, 0, 96, - 100, 98, 99, 0, 102, 0, 101, 0, 276, 0, - 302, 99, 0, 0, 134, 168, 87, 0, 154, 134, - 168, 87, 0, 153, 134, 167, 87, 0, 160, 87, - 0, 1, 87, 0, 1, 88, 0, 87, 0, 0, - 0, 153, 134, 197, 103, 129, 249, 104, 243, 0, - 153, 134, 197, 1, 0, 0, 0, 154, 134, 202, - 105, 129, 249, 106, 243, 0, 154, 134, 202, 1, - 0, 0, 0, 134, 202, 107, 129, 249, 108, 243, - 0, 134, 202, 1, 0, 3, 0, 4, 0, 50, - 0, 56, 0, 55, 0, 61, 0, 62, 0, 89, - 0, 90, 0, 119, 0, 111, 91, 119, 0, 0, - 113, 0, 119, 0, 113, 91, 119, 0, 125, 0, - 57, 118, 0, 302, 118, 0, 110, 118, 0, 47, - 109, 0, 115, 114, 0, 115, 66, 223, 92, 0, - 116, 114, 0, 116, 66, 223, 92, 0, 35, 118, - 0, 36, 118, 0, 13, 0, 31, 0, 30, 0, - 114, 0, 66, 223, 92, 118, 0, 118, 0, 119, - 55, 119, 0, 119, 56, 119, 0, 119, 57, 119, - 0, 119, 58, 119, 0, 119, 59, 119, 0, 119, - 53, 119, 0, 119, 54, 119, 0, 119, 52, 119, - 0, 119, 51, 119, 0, 119, 50, 119, 0, 119, - 48, 119, 0, 119, 49, 119, 0, 0, 119, 47, - 120, 119, 0, 0, 119, 46, 121, 119, 0, 0, - 0, 119, 44, 122, 111, 45, 123, 119, 0, 0, - 119, 44, 124, 45, 119, 0, 119, 43, 119, 0, - 119, 42, 119, 0, 3, 0, 10, 0, 11, 0, - 40, 0, 0, 66, 223, 92, 93, 126, 182, 88, - 0, 66, 111, 92, 0, 66, 1, 92, 0, 247, - 245, 92, 0, 247, 1, 92, 0, 125, 66, 112, - 92, 0, 37, 66, 119, 91, 223, 92, 0, 0, - 41, 66, 223, 91, 127, 128, 92, 0, 41, 66, - 1, 92, 0, 38, 66, 119, 91, 119, 91, 119, - 92, 0, 38, 66, 1, 92, 0, 39, 66, 223, - 91, 223, 92, 0, 39, 66, 1, 92, 0, 125, - 67, 111, 94, 0, 125, 65, 109, 0, 125, 64, - 109, 0, 125, 61, 0, 125, 62, 0, 109, 0, - 128, 65, 109, 0, 128, 67, 111, 94, 0, 0, - 131, 0, 249, 132, 0, 130, 0, 238, 0, 131, - 130, 0, 130, 238, 0, 155, 134, 167, 87, 0, - 156, 134, 168, 87, 0, 155, 87, 0, 156, 87, - 0, 249, 136, 0, 0, 173, 0, 153, 134, 167, - 87, 0, 154, 134, 168, 87, 0, 153, 134, 191, - 0, 154, 134, 194, 0, 160, 87, 0, 302, 136, - 0, 8, 0, 137, 8, 0, 138, 8, 0, 137, - 174, 0, 139, 8, 0, 140, 8, 0, 174, 0, - 139, 174, 0, 162, 0, 141, 8, 0, 142, 8, - 0, 141, 164, 0, 142, 164, 0, 137, 162, 0, - 138, 162, 0, 163, 0, 141, 174, 0, 141, 165, - 0, 142, 165, 0, 137, 163, 0, 138, 163, 0, - 143, 8, 0, 144, 8, 0, 143, 164, 0, 144, - 164, 0, 139, 162, 0, 140, 162, 0, 143, 174, - 0, 143, 165, 0, 144, 165, 0, 139, 163, 0, - 140, 163, 0, 179, 0, 145, 8, 0, 146, 8, - 0, 137, 179, 0, 138, 179, 0, 145, 179, 0, - 146, 179, 0, 145, 174, 0, 147, 8, 0, 148, - 8, 0, 139, 179, 0, 140, 179, 0, 147, 179, - 0, 148, 179, 0, 147, 174, 0, 149, 8, 0, - 150, 8, 0, 149, 164, 0, 150, 164, 0, 145, - 162, 0, 146, 162, 0, 141, 179, 0, 142, 179, - 0, 149, 179, 0, 150, 179, 0, 149, 174, 0, - 149, 165, 0, 150, 165, 0, 145, 163, 0, 146, - 163, 0, 151, 8, 0, 152, 8, 0, 151, 164, - 0, 152, 164, 0, 147, 162, 0, 148, 162, 0, - 143, 179, 0, 144, 179, 0, 151, 179, 0, 152, - 179, 0, 151, 174, 0, 151, 165, 0, 152, 165, - 0, 147, 163, 0, 148, 163, 0, 141, 0, 142, - 0, 143, 0, 144, 0, 149, 0, 150, 0, 151, - 0, 152, 0, 137, 0, 138, 0, 139, 0, 140, - 0, 145, 0, 146, 0, 147, 0, 148, 0, 141, - 0, 142, 0, 149, 0, 150, 0, 137, 0, 138, - 0, 145, 0, 146, 0, 141, 0, 142, 0, 143, - 0, 144, 0, 137, 0, 138, 0, 139, 0, 140, - 0, 141, 0, 142, 0, 143, 0, 144, 0, 137, - 0, 138, 0, 139, 0, 140, 0, 137, 0, 138, - 0, 139, 0, 140, 0, 141, 0, 142, 0, 143, - 0, 144, 0, 145, 0, 146, 0, 147, 0, 148, - 0, 149, 0, 150, 0, 151, 0, 152, 0, 0, - 158, 0, 164, 0, 166, 0, 165, 0, 7, 0, - 211, 0, 206, 0, 4, 0, 117, 66, 111, 92, - 0, 117, 66, 223, 92, 0, 169, 0, 167, 91, - 135, 169, 0, 171, 0, 168, 91, 135, 171, 0, - 0, 197, 275, 173, 43, 170, 180, 0, 197, 275, - 173, 0, 0, 202, 275, 173, 43, 172, 180, 0, - 202, 275, 173, 0, 0, 174, 0, 175, 0, 174, - 175, 0, 32, 285, 66, 66, 176, 92, 92, 286, - 0, 32, 1, 286, 0, 177, 0, 176, 91, 177, - 0, 0, 178, 0, 178, 66, 3, 92, 0, 178, - 66, 3, 91, 113, 92, 0, 178, 66, 112, 92, - 0, 109, 0, 179, 0, 7, 0, 8, 0, 6, - 0, 5, 0, 119, 0, 0, 93, 181, 182, 88, - 0, 1, 0, 0, 183, 212, 0, 184, 0, 183, - 91, 184, 0, 188, 43, 186, 0, 190, 186, 0, - 0, 109, 45, 185, 186, 0, 186, 0, 0, 93, - 187, 182, 88, 0, 119, 0, 1, 0, 189, 0, - 188, 189, 0, 65, 109, 0, 190, 0, 67, 119, - 12, 119, 94, 0, 67, 119, 94, 0, 0, 0, - 197, 192, 129, 249, 193, 248, 0, 0, 0, 202, - 195, 129, 249, 196, 248, 0, 198, 0, 202, 0, - 66, 173, 198, 92, 0, 198, 66, 297, 0, 198, - 231, 0, 57, 161, 198, 0, 4, 0, 200, 0, - 201, 0, 200, 66, 297, 0, 200, 231, 0, 4, - 0, 201, 66, 297, 0, 201, 231, 0, 57, 161, - 200, 0, 57, 161, 201, 0, 66, 173, 201, 92, - 0, 202, 66, 297, 0, 66, 173, 202, 92, 0, - 57, 161, 202, 0, 202, 231, 0, 3, 0, 15, - 0, 15, 174, 0, 16, 0, 16, 174, 0, 14, - 0, 14, 174, 0, 0, 203, 109, 93, 207, 214, - 88, 173, 0, 203, 93, 214, 88, 173, 0, 0, - 204, 109, 93, 208, 214, 88, 173, 0, 204, 93, - 214, 88, 173, 0, 0, 205, 109, 93, 209, 221, - 213, 88, 173, 0, 0, 205, 93, 210, 221, 213, - 88, 173, 0, 203, 109, 0, 204, 109, 0, 205, - 109, 0, 0, 91, 0, 0, 91, 0, 215, 0, - 215, 216, 0, 0, 215, 216, 87, 0, 215, 87, - 0, 157, 134, 217, 0, 157, 134, 0, 158, 134, - 218, 0, 158, 0, 1, 0, 302, 216, 0, 219, - 0, 217, 91, 135, 219, 0, 220, 0, 218, 91, - 135, 220, 0, 197, 173, 0, 197, 45, 119, 173, - 0, 45, 119, 173, 0, 202, 173, 0, 202, 45, - 119, 173, 0, 45, 119, 173, 0, 222, 0, 221, - 91, 222, 0, 1, 0, 109, 0, 109, 43, 119, - 0, 0, 159, 224, 225, 0, 0, 227, 0, 0, - 227, 0, 228, 174, 0, 229, 0, 228, 0, 230, - 0, 57, 161, 228, 0, 57, 161, 0, 57, 161, - 229, 0, 66, 173, 227, 92, 0, 230, 66, 287, - 0, 230, 231, 0, 66, 287, 0, 231, 0, 67, - 161, 119, 94, 0, 67, 161, 94, 0, 67, 161, - 57, 94, 0, 67, 6, 161, 119, 94, 0, 67, - 158, 6, 119, 94, 0, 233, 0, 234, 0, 235, - 0, 236, 0, 252, 0, 233, 252, 0, 234, 252, - 0, 235, 252, 0, 236, 252, 0, 133, 0, 233, - 133, 0, 234, 133, 0, 236, 133, 0, 253, 0, - 233, 253, 0, 234, 253, 0, 235, 253, 0, 236, - 253, 0, 238, 0, 237, 238, 0, 233, 0, 234, - 0, 235, 0, 236, 0, 1, 87, 0, 0, 0, - 241, 0, 242, 0, 241, 242, 0, 34, 301, 87, - 0, 248, 0, 1, 248, 0, 93, 0, 88, 0, - 240, 246, 88, 0, 232, 0, 1, 0, 66, 93, - 0, 244, 245, 0, 0, 0, 250, 253, 0, 239, - 250, 252, 0, 249, 272, 0, 249, 273, 0, 249, - 111, 0, 239, 250, 257, 0, 239, 250, 87, 0, - 251, 0, 17, 239, 249, 66, 254, 92, 255, 18, - 256, 0, 17, 239, 249, 66, 254, 92, 256, 18, - 256, 0, 17, 239, 249, 66, 254, 92, 255, 0, - 17, 239, 249, 66, 254, 92, 256, 0, 0, 0, - 19, 239, 249, 66, 254, 92, 258, 259, 251, 0, - 0, 0, 20, 239, 249, 258, 259, 251, 19, 262, - 263, 66, 254, 92, 87, 0, 0, 111, 0, 264, - 87, 0, 136, 0, 249, 264, 0, 264, 0, 21, - 239, 66, 265, 249, 266, 87, 267, 92, 258, 259, - 251, 0, 0, 22, 239, 66, 111, 92, 270, 258, - 251, 0, 111, 87, 0, 257, 0, 260, 0, 261, - 0, 268, 0, 269, 0, 25, 87, 0, 26, 87, - 0, 27, 87, 0, 27, 111, 87, 0, 277, 0, - 28, 109, 87, 0, 28, 57, 111, 87, 0, 87, - 0, 248, 0, 271, 0, 23, 119, 45, 0, 23, - 119, 12, 119, 45, 0, 24, 45, 0, 109, 249, - 45, 173, 0, 29, 285, 66, 284, 92, 286, 0, - 0, 274, 0, 274, 87, 0, 29, 1, 286, 87, - 0, 29, 279, 285, 66, 278, 92, 286, 87, 0, - 284, 0, 284, 45, 280, 0, 284, 45, 280, 45, - 280, 0, 284, 45, 280, 45, 280, 45, 283, 0, - 0, 8, 0, 0, 281, 0, 282, 0, 281, 91, - 282, 0, 284, 286, 66, 111, 92, 285, 0, 67, - 109, 94, 284, 286, 66, 111, 92, 285, 0, 284, - 0, 283, 91, 284, 0, 11, 0, 0, 0, 0, - 173, 288, 289, 0, 292, 92, 0, 0, 0, 293, - 87, 290, 173, 291, 289, 0, 1, 92, 0, 0, - 12, 0, 293, 0, 293, 91, 12, 0, 295, 0, - 293, 91, 294, 0, 153, 134, 199, 173, 0, 153, - 134, 202, 173, 0, 153, 134, 226, 0, 154, 134, - 202, 173, 0, 154, 134, 226, 0, 155, 296, 199, - 173, 0, 155, 296, 202, 173, 0, 155, 296, 226, - 0, 156, 296, 202, 173, 0, 156, 296, 226, 0, - 134, 0, 0, 173, 298, 299, 0, 289, 0, 300, - 92, 0, 3, 0, 300, 91, 3, 0, 109, 0, - 301, 91, 109, 0, 33, 0 -}; - -#endif - -#if YYDEBUG -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const short yyrline[] = -{ - 0, 341, 345, 352, 352, 355, 355, 360, 362, 363, - 364, 370, 374, 378, 380, 382, 384, 385, 386, 391, - 391, 391, 403, 405, 405, 405, 416, 418, 418, 418, - 429, 433, 435, 438, 440, 442, 447, 449, 451, 453, - 457, 458, 463, 466, 469, 472, 476, 478, 482, 485, - 490, 493, 500, 504, 509, 514, 517, 522, 526, 530, - 534, 536, 541, 543, 545, 547, 549, 551, 553, 555, - 557, 559, 561, 563, 565, 567, 567, 574, 574, 581, - 581, 581, 593, 593, 605, 609, 616, 624, 626, 628, - 631, 631, 652, 657, 659, 665, 670, 673, 677, 677, - 687, 689, 701, 703, 715, 717, 720, 723, 729, 732, - 741, 744, 746, 750, 752, 758, 763, 765, 766, 767, - 774, 777, 779, 782, 790, 799, 819, 824, 827, 829, - 831, 833, 835, 880, 883, 885, 889, 894, 897, 901, - 904, 908, 911, 913, 915, 917, 919, 921, 925, 928, - 930, 932, 934, 936, 940, 943, 945, 947, 949, 951, - 955, 958, 960, 962, 964, 968, 971, 973, 975, 977, - 979, 981, 985, 990, 993, 995, 997, 999, 1001, 1005, - 1010, 1013, 1015, 1017, 1019, 1021, 1023, 1025, 1027, 1029, - 1033, 1036, 1038, 1040, 1042, 1046, 1049, 1051, 1053, 1055, - 1057, 1059, 1061, 1063, 1065, 1069, 1072, 1074, 1076, 1078, - 1083, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1094, 1096, - 1097, 1098, 1099, 1100, 1101, 1102, 1105, 1107, 1108, 1109, - 1112, 1114, 1115, 1116, 1119, 1121, 1122, 1123, 1126, 1128, - 1129, 1130, 1133, 1135, 1136, 1137, 1138, 1139, 1140, 1141, - 1144, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, - 1155, 1156, 1157, 1158, 1159, 1160, 1164, 1167, 1192, 1194, - 1197, 1201, 1206, 1209, 1213, 1219, 1229, 1240, 1242, 1245, - 1247, 1250, 1250, 1266, 1274, 1274, 1290, 1298, 1301, 1305, - 1308, 1312, 1316, 1320, 1323, 1327, 1330, 1332, 1334, 1336, - 1343, 1345, 1346, 1347, 1350, 1352, 1357, 1360, 1360, 1364, - 1369, 1373, 1376, 1378, 1383, 1387, 1390, 1390, 1396, 1399, - 1399, 1404, 1406, 1409, 1411, 1414, 1417, 1420, 1425, 1429, - 1429, 1429, 1459, 1459, 1459, 1492, 1494, 1499, 1502, 1504, - 1506, 1508, 1516, 1518, 1521, 1524, 1526, 1530, 1533, 1535, - 1537, 1539, 1546, 1549, 1551, 1553, 1555, 1559, 1562, 1566, - 1569, 1573, 1576, 1586, 1586, 1595, 1601, 1601, 1607, 1613, - 1613, 1619, 1619, 1627, 1630, 1632, 1640, 1642, 1645, 1647, - 1664, 1667, 1672, 1674, 1676, 1681, 1685, 1693, 1696, 1701, - 1703, 1708, 1710, 1714, 1716, 1720, 1725, 1729, 1736, 1741, - 1745, 1755, 1757, 1762, 1767, 1770, 1774, 1774, 1784, 1787, - 1790, 1794, 1797, 1803, 1805, 1808, 1810, 1814, 1818, 1822, - 1825, 1827, 1829, 1832, 1839, 1842, 1844, 1846, 1849, 1859, - 1861, 1862, 1866, 1869, 1871, 1872, 1873, 1874, 1877, 1879, - 1885, 1886, 1889, 1891, 1892, 1893, 1894, 1897, 1899, 1902, - 1904, 1905, 1906, 1909, 1913, 1919, 1921, 1926, 1928, 1931, - 1945, 1948, 1951, 1954, 1955, 1958, 1960, 1963, 1975, 1983, - 1989, 1991, 1995, 2000, 2018, 2023, 2035, 2040, 2045, 2048, - 2053, 2057, 2061, 2067, 2071, 2075, 2084, 2084, 2084, 2095, - 2098, 2102, 2105, 2109, 2121, 2125, 2135, 2135, 2148, 2151, - 2153, 2155, 2157, 2159, 2161, 2163, 2165, 2167, 2169, 2170, - 2172, 2174, 2179, 2182, 2189, 2191, 2193, 2195, 2211, 2218, - 2221, 2225, 2228, 2234, 2240, 2245, 2248, 2251, 2257, 2260, - 2273, 2275, 2278, 2280, 2284, 2289, 2296, 2299, 2304, 2316, - 2320, 2330, 2330, 2339, 2341, 2341, 2341, 2348, 2358, 2364, - 2373, 2375, 2379, 2382, 2388, 2393, 2397, 2400, 2405, 2412, - 2417, 2421, 2424, 2429, 2434, 2443, 2443, 2452, 2454, 2468, - 2471, 2476, 2479, 2483 -}; -#endif - - -#if (YYDEBUG) || defined YYERROR_VERBOSE - -/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ -static const char *const yytname[] = -{ - "$", "error", "$undefined.", "IDENTIFIER", "TYPENAME", "SCSPEC", "STATIC", - "TYPESPEC", "TYPE_QUAL", "OBJC_TYPE_QUAL", "CONSTANT", "STRING", - "ELLIPSIS", "SIZEOF", "ENUM", "STRUCT", "UNION", "IF", "ELSE", "WHILE", - "DO", "FOR", "SWITCH", "CASE", "DEFAULT", "BREAK", "CONTINUE", "RETURN", - "GOTO", "ASM_KEYWORD", "TYPEOF", "ALIGNOF", "ATTRIBUTE", "EXTENSION", - "LABEL", "REALPART", "IMAGPART", "VA_ARG", "CHOOSE_EXPR", - "TYPES_COMPATIBLE_P", "FUNC_NAME", "OFFSETOF", "ASSIGN", "'='", "'?'", - "':'", "OROR", "ANDAND", "'|'", "'^'", "'&'", "EQCOMPARE", - "ARITHCOMPARE", "LSHIFT", "RSHIFT", "'+'", "'-'", "'*'", "'/'", "'%'", - "UNARY", "PLUSPLUS", "MINUSMINUS", "HYPERUNARY", "POINTSAT", "'.'", - "'('", "'['", "AT_INTERFACE", "AT_IMPLEMENTATION", "AT_END", - "AT_SELECTOR", "AT_DEFS", "AT_ENCODE", "CLASSNAME", "AT_PUBLIC", - "AT_PRIVATE", "AT_PROTECTED", "AT_PROTOCOL", "AT_CLASS", "AT_ALIAS", - "AT_THROW", "AT_TRY", "AT_CATCH", "AT_FINALLY", "AT_SYNCHRONIZED", - "OBJC_STRING", "';'", "'}'", "'~'", "'!'", "','", "')'", "'{'", "']'", - "program", "extdefs", "@1", "@2", "extdef", "save_obstack_position", - "datadef", "fndef", "@3", "@4", "@5", "@6", "@7", "@8", "identifier", - "unop", "expr", "exprlist", "nonnull_exprlist", "unary_expr", "sizeof", - "alignof", "typeof", "cast_expr", "expr_no_commas", "@9", "@10", "@11", - "@12", "@13", "primary", "@14", "@15", "offsetof_member_designator", - "old_style_parm_decls", "lineno_datadecl", "datadecls", "datadecl", - "lineno_decl", "setspecs", "maybe_resetattrs", "decl", - "declspecs_nosc_nots_nosa_noea", "declspecs_nosc_nots_nosa_ea", - "declspecs_nosc_nots_sa_noea", "declspecs_nosc_nots_sa_ea", - "declspecs_nosc_ts_nosa_noea", "declspecs_nosc_ts_nosa_ea", - "declspecs_nosc_ts_sa_noea", "declspecs_nosc_ts_sa_ea", - "declspecs_sc_nots_nosa_noea", "declspecs_sc_nots_nosa_ea", - "declspecs_sc_nots_sa_noea", "declspecs_sc_nots_sa_ea", - "declspecs_sc_ts_nosa_noea", "declspecs_sc_ts_nosa_ea", - "declspecs_sc_ts_sa_noea", "declspecs_sc_ts_sa_ea", "declspecs_ts", - "declspecs_nots", "declspecs_ts_nosa", "declspecs_nots_nosa", - "declspecs_nosc_ts", "declspecs_nosc_nots", "declspecs_nosc", - "declspecs", "maybe_type_quals_attrs", "typespec_nonattr", - "typespec_attr", "typespec_reserved_nonattr", "typespec_reserved_attr", - "typespec_nonreserved_nonattr", "initdecls", "notype_initdecls", - "initdcl", "@16", "notype_initdcl", "@17", "maybe_attribute", - "attributes", "attribute", "attribute_list", "attrib", "any_word", - "scspec", "init", "@18", "initlist_maybe_comma", "initlist1", "initelt", - "@19", "initval", "@20", "designator_list", "designator", - "array_designator", "nested_function", "@21", "@22", - "notype_nested_function", "@23", "@24", "declarator", - "after_type_declarator", "parm_declarator", - "parm_declarator_starttypename", "parm_declarator_nostarttypename", - "notype_declarator", "struct_head", "union_head", "enum_head", - "structsp_attr", "@25", "@26", "@27", "@28", "structsp_nonattr", - "maybecomma", "maybecomma_warn", "component_decl_list", - "component_decl_list2", "component_decl", "components", - "components_notype", "component_declarator", - "component_notype_declarator", "enumlist", "enumerator", "typename", - "@29", "absdcl", "absdcl_maybe_attribute", "absdcl1", "absdcl1_noea", - "absdcl1_ea", "direct_absdcl1", "array_declarator", "stmts_and_decls", - "lineno_stmt_decl_or_labels_ending_stmt", - "lineno_stmt_decl_or_labels_ending_decl", - "lineno_stmt_decl_or_labels_ending_label", - "lineno_stmt_decl_or_labels_ending_error", "lineno_stmt_decl_or_labels", - "errstmt", "c99_block_start", "maybe_label_decls", "label_decls", - "label_decl", "compstmt_or_error", "compstmt_start", "compstmt_nostart", - "compstmt_contents_nonempty", "compstmt_primary_start", "compstmt", - "save_location", "lineno_labels", "c99_block_lineno_labeled_stmt", - "lineno_stmt", "lineno_label", "condition", "if_statement_1", - "if_statement_2", "if_statement", "start_break", "start_continue", - "while_statement", "do_statement", "@30", "@31", "xexpr", - "for_init_stmt", "for_cond_expr", "for_incr_expr", "for_statement", - "switch_statement", "@32", "stmt_nocomp", "stmt", "label", - "simple_asm_expr", "maybeasm", "asmdef", "asm_stmt", "asm_argument", - "maybe_volatile", "asm_operands", "nonnull_asm_operands", "asm_operand", - "asm_clobbers", "asm_string", "stop_string_translation", - "start_string_translation", "parmlist", "@33", "parmlist_1", "@34", - "@35", "parmlist_2", "parms", "parm", "firstparm", "setspecs_fp", - "parmlist_or_identifiers", "@36", "parmlist_or_identifiers_1", - "identifiers", "identifiers_or_typenames", "extension", 0 -}; -#endif - -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const short yyr1[] = -{ - 0, 95, 95, 97, 96, 98, 96, 99, 99, 99, - 99, 100, 101, 101, 101, 101, 101, 101, 101, 103, - 104, 102, 102, 105, 106, 102, 102, 107, 108, 102, - 102, 109, 109, 110, 110, 110, 110, 110, 110, 110, - 111, 111, 112, 112, 113, 113, 114, 114, 114, 114, - 114, 114, 114, 114, 114, 114, 114, 115, 116, 117, - 118, 118, 119, 119, 119, 119, 119, 119, 119, 119, - 119, 119, 119, 119, 119, 120, 119, 121, 119, 122, - 123, 119, 124, 119, 119, 119, 125, 125, 125, 125, - 126, 125, 125, 125, 125, 125, 125, 125, 127, 125, - 125, 125, 125, 125, 125, 125, 125, 125, 125, 125, - 128, 128, 128, 129, 129, 130, 131, 131, 131, 131, - 132, 132, 132, 132, 133, 134, 135, 136, 136, 136, - 136, 136, 136, 137, 137, 137, 138, 139, 139, 140, - 140, 141, 141, 141, 141, 141, 141, 141, 142, 142, - 142, 142, 142, 142, 143, 143, 143, 143, 143, 143, - 144, 144, 144, 144, 144, 145, 145, 145, 145, 145, - 145, 145, 146, 147, 147, 147, 147, 147, 147, 148, - 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, - 150, 150, 150, 150, 150, 151, 151, 151, 151, 151, - 151, 151, 151, 151, 151, 152, 152, 152, 152, 152, - 153, 153, 153, 153, 153, 153, 153, 153, 154, 154, - 154, 154, 154, 154, 154, 154, 155, 155, 155, 155, - 156, 156, 156, 156, 157, 157, 157, 157, 158, 158, - 158, 158, 159, 159, 159, 159, 159, 159, 159, 159, - 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, - 160, 160, 160, 160, 160, 160, 161, 161, 162, 162, - 163, 164, 164, 165, 166, 166, 166, 167, 167, 168, - 168, 170, 169, 169, 172, 171, 171, 173, 173, 174, - 174, 175, 175, 176, 176, 177, 177, 177, 177, 177, - 178, 178, 178, 178, 179, 179, 180, 181, 180, 180, - 182, 182, 183, 183, 184, 184, 185, 184, 184, 187, - 186, 186, 186, 188, 188, 189, 189, 190, 190, 192, - 193, 191, 195, 196, 194, 197, 197, 198, 198, 198, - 198, 198, 199, 199, 200, 200, 200, 201, 201, 201, - 201, 201, 202, 202, 202, 202, 202, 203, 203, 204, - 204, 205, 205, 207, 206, 206, 208, 206, 206, 209, - 206, 210, 206, 211, 211, 211, 212, 212, 213, 213, - 214, 214, 215, 215, 215, 216, 216, 216, 216, 216, - 216, 217, 217, 218, 218, 219, 219, 219, 220, 220, - 220, 221, 221, 221, 222, 222, 224, 223, 225, 225, - 226, 226, 226, 227, 227, 228, 228, 229, 229, 230, - 230, 230, 230, 230, 231, 231, 231, 231, 231, 232, - 232, 232, 232, 233, 233, 233, 233, 233, 234, 234, - 234, 234, 235, 235, 235, 235, 235, 236, 236, 237, - 237, 237, 237, 238, 239, 240, 240, 241, 241, 242, - 243, 243, 244, 245, 245, 246, 246, 247, 248, 249, - 250, 250, 251, 252, 253, 254, 255, 256, 256, 257, - 257, 257, 257, 258, 259, 260, 262, 263, 261, 264, - 264, 265, 265, 266, 267, 268, 270, 269, 271, 271, - 271, 271, 271, 271, 271, 271, 271, 271, 271, 271, - 271, 271, 272, 272, 273, 273, 273, 273, 274, 275, - 275, 276, 276, 277, 278, 278, 278, 278, 279, 279, - 280, 280, 281, 281, 282, 282, 283, 283, 284, 285, - 286, 288, 287, 289, 290, 291, 289, 289, 292, 292, - 292, 292, 293, 293, 294, 294, 294, 294, 294, 295, - 295, 295, 295, 295, 296, 298, 297, 299, 299, 300, - 300, 301, 301, 302 -}; - -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const short yyr2[] = -{ - 0, 0, 1, 0, 3, 0, 4, 1, 1, 1, - 2, 0, 3, 4, 4, 2, 2, 2, 1, 0, - 0, 8, 4, 0, 0, 8, 4, 0, 0, 7, - 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 3, 0, 1, 1, 3, 1, 2, 2, 2, - 2, 2, 4, 2, 4, 2, 2, 1, 1, 1, - 1, 4, 1, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 3, 0, 4, 0, 4, 0, - 0, 7, 0, 5, 3, 3, 1, 1, 1, 1, - 0, 7, 3, 3, 3, 3, 4, 6, 0, 7, - 4, 8, 4, 6, 4, 4, 3, 3, 2, 2, - 1, 3, 4, 0, 1, 2, 1, 1, 2, 2, - 4, 4, 2, 2, 2, 0, 1, 4, 4, 3, - 3, 2, 2, 1, 2, 2, 2, 2, 2, 1, - 2, 1, 2, 2, 2, 2, 2, 2, 1, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, - 1, 1, 1, 1, 1, 4, 4, 1, 4, 1, - 4, 0, 6, 3, 0, 6, 3, 0, 1, 1, - 2, 8, 3, 1, 3, 0, 1, 4, 6, 4, - 1, 1, 1, 1, 1, 1, 1, 0, 4, 1, - 0, 2, 1, 3, 3, 2, 0, 4, 1, 0, - 4, 1, 1, 1, 2, 2, 1, 5, 3, 0, - 0, 6, 0, 0, 6, 1, 1, 4, 3, 2, - 3, 1, 1, 1, 3, 2, 1, 3, 2, 3, - 3, 4, 3, 4, 3, 2, 1, 1, 2, 1, - 2, 1, 2, 0, 7, 5, 0, 7, 5, 0, - 8, 0, 7, 2, 2, 2, 0, 1, 0, 1, - 1, 2, 0, 3, 2, 3, 2, 3, 1, 1, - 2, 1, 4, 1, 4, 2, 4, 3, 2, 4, - 3, 1, 3, 1, 1, 3, 0, 3, 0, 1, - 0, 1, 2, 1, 1, 1, 3, 2, 3, 4, - 3, 2, 2, 1, 4, 3, 4, 5, 5, 1, - 1, 1, 1, 1, 2, 2, 2, 2, 1, 2, - 2, 2, 1, 2, 2, 2, 2, 1, 2, 1, - 1, 1, 1, 2, 0, 0, 1, 1, 2, 3, - 1, 2, 1, 1, 3, 1, 1, 2, 2, 0, - 0, 2, 3, 2, 2, 2, 3, 3, 1, 9, - 9, 7, 7, 0, 0, 9, 0, 0, 13, 0, - 1, 2, 1, 2, 1, 12, 0, 8, 2, 1, - 1, 1, 1, 1, 2, 2, 2, 3, 1, 3, - 4, 1, 1, 1, 3, 5, 2, 4, 6, 0, - 1, 2, 4, 8, 1, 3, 5, 7, 0, 1, - 0, 1, 1, 3, 6, 9, 1, 3, 1, 0, - 0, 0, 3, 2, 0, 0, 6, 2, 0, 1, - 1, 3, 1, 3, 4, 4, 3, 4, 3, 4, - 4, 3, 4, 3, 1, 0, 3, 1, 2, 1, - 3, 1, 3, 1 -}; - -/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE - doesn't specify something else to do. Zero means the default is an - error. */ -static const short yydefact[] = -{ - 11, 11, 3, 5, 0, 0, 0, 274, 305, 304, - 271, 133, 361, 357, 359, 0, 59, 0, 573, 18, - 4, 8, 7, 0, 0, 218, 219, 220, 221, 210, - 211, 212, 213, 222, 223, 224, 225, 214, 215, 216, - 217, 125, 125, 0, 141, 148, 268, 270, 269, 139, - 289, 165, 0, 0, 0, 273, 272, 0, 9, 0, - 6, 16, 17, 362, 358, 360, 540, 0, 540, 0, - 0, 356, 266, 287, 0, 279, 0, 134, 146, 152, - 136, 168, 135, 147, 153, 169, 137, 158, 163, 140, - 175, 138, 159, 164, 176, 142, 144, 150, 149, 186, - 143, 145, 151, 187, 154, 156, 161, 160, 201, 155, - 157, 162, 202, 166, 184, 193, 172, 170, 167, 185, - 194, 171, 173, 199, 208, 179, 177, 174, 200, 209, - 178, 180, 182, 191, 190, 188, 181, 183, 192, 189, - 195, 197, 206, 205, 203, 196, 198, 207, 204, 0, - 0, 15, 290, 31, 32, 382, 373, 382, 374, 371, - 375, 521, 10, 0, 0, 292, 0, 86, 87, 88, - 57, 58, 0, 0, 0, 0, 0, 89, 0, 0, - 33, 35, 34, 0, 36, 37, 0, 38, 39, 0, - 0, 60, 0, 0, 62, 40, 46, 246, 247, 248, - 249, 242, 243, 244, 245, 406, 0, 0, 0, 238, - 239, 240, 241, 267, 0, 0, 288, 12, 287, 30, - 539, 287, 266, 0, 355, 520, 287, 341, 266, 287, - 0, 277, 0, 335, 336, 0, 0, 0, 0, 363, - 0, 366, 0, 369, 522, 538, 0, 295, 55, 56, - 0, 0, 0, 0, 50, 47, 0, 467, 0, 0, - 49, 0, 275, 0, 51, 0, 53, 0, 0, 79, - 77, 75, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 108, 109, 0, 0, 42, 0, - 408, 276, 0, 0, 463, 0, 456, 457, 0, 48, - 354, 0, 0, 126, 565, 352, 266, 267, 0, 0, - 469, 0, 469, 117, 0, 286, 0, 0, 14, 287, - 22, 0, 287, 287, 339, 13, 26, 0, 287, 389, - 384, 238, 239, 240, 241, 234, 235, 236, 237, 125, - 125, 381, 0, 382, 287, 382, 403, 404, 378, 401, - 0, 540, 302, 303, 300, 0, 293, 296, 301, 0, - 0, 0, 0, 0, 0, 0, 93, 92, 0, 41, - 0, 0, 85, 84, 0, 0, 0, 0, 73, 74, - 72, 71, 70, 68, 69, 63, 64, 65, 66, 67, - 107, 106, 0, 43, 44, 0, 266, 287, 407, 409, - 414, 413, 415, 423, 95, 571, 0, 466, 438, 465, - 469, 469, 469, 469, 0, 447, 0, 0, 433, 442, - 458, 94, 353, 280, 519, 0, 0, 0, 0, 425, - 0, 453, 28, 119, 118, 115, 230, 231, 226, 227, - 232, 233, 228, 229, 125, 125, 284, 340, 0, 0, - 469, 283, 338, 469, 365, 386, 0, 383, 390, 0, - 368, 0, 0, 379, 0, 378, 518, 295, 0, 42, - 0, 102, 0, 104, 0, 100, 98, 90, 61, 52, - 54, 0, 0, 78, 76, 96, 0, 105, 417, 541, - 422, 287, 421, 459, 0, 439, 434, 443, 440, 435, - 444, 0, 436, 445, 441, 437, 446, 448, 464, 86, - 274, 454, 454, 454, 454, 454, 0, 0, 0, 0, - 0, 0, 528, 511, 462, 469, 0, 124, 125, 125, - 0, 455, 512, 499, 500, 501, 502, 503, 513, 473, - 474, 508, 0, 0, 569, 549, 125, 125, 567, 0, - 550, 552, 566, 0, 0, 0, 426, 424, 0, 122, - 0, 123, 0, 0, 337, 278, 519, 20, 281, 24, - 0, 287, 385, 391, 0, 287, 387, 393, 287, 287, - 405, 402, 287, 0, 294, 540, 86, 0, 0, 0, - 0, 0, 0, 80, 83, 45, 416, 418, 0, 0, - 541, 420, 572, 469, 469, 469, 0, 0, 0, 516, - 504, 505, 506, 0, 0, 0, 529, 539, 0, 498, - 0, 0, 131, 468, 132, 547, 564, 410, 410, 543, - 544, 0, 0, 568, 427, 428, 0, 29, 460, 0, - 0, 309, 307, 306, 285, 0, 0, 0, 287, 0, - 395, 287, 287, 0, 398, 287, 364, 367, 372, 287, - 291, 0, 297, 299, 97, 0, 103, 110, 0, 322, - 0, 0, 319, 0, 321, 0, 376, 312, 318, 0, - 323, 0, 0, 419, 542, 0, 0, 483, 489, 0, - 0, 514, 507, 0, 509, 0, 287, 0, 129, 329, - 0, 130, 332, 346, 266, 287, 287, 342, 343, 287, - 561, 411, 414, 266, 287, 287, 563, 287, 551, 218, - 219, 220, 221, 210, 211, 212, 213, 222, 223, 224, - 225, 214, 215, 216, 217, 125, 125, 553, 570, 461, - 120, 121, 0, 21, 282, 25, 397, 287, 0, 400, - 287, 0, 370, 0, 0, 0, 0, 99, 325, 0, - 0, 316, 91, 0, 311, 0, 324, 326, 315, 81, - 469, 469, 484, 490, 492, 0, 469, 0, 0, 510, - 0, 517, 127, 0, 128, 0, 417, 541, 559, 287, - 345, 287, 348, 560, 412, 417, 541, 562, 545, 410, - 410, 0, 396, 392, 399, 394, 298, 101, 111, 0, - 0, 328, 0, 0, 313, 314, 0, 0, 0, 454, - 491, 469, 496, 515, 0, 524, 469, 469, 349, 350, - 0, 344, 347, 0, 287, 287, 556, 287, 558, 308, - 112, 0, 320, 317, 475, 454, 483, 470, 0, 489, - 0, 483, 540, 530, 330, 333, 351, 546, 554, 555, - 557, 327, 470, 478, 481, 482, 484, 469, 486, 493, - 489, 454, 0, 0, 525, 531, 532, 540, 0, 0, - 469, 454, 454, 454, 472, 471, 487, 494, 0, 497, - 523, 0, 530, 0, 0, 331, 334, 477, 476, 470, - 479, 480, 485, 0, 483, 0, 526, 533, 0, 469, - 469, 484, 540, 0, 0, 0, 454, 0, 527, 536, - 539, 0, 495, 0, 0, 534, 488, 0, 537, 539, - 535, 0, 0, 0 -}; - -static const short yydefgoto[] = -{ - 931, 1, 4, 5, 20, 2, 21, 22, 321, 645, - 327, 647, 223, 558, 673, 189, 258, 392, 393, 191, - 192, 193, 23, 194, 195, 377, 376, 374, 682, 375, - 196, 592, 591, 668, 310, 311, 312, 435, 408, 24, - 302, 527, 197, 198, 199, 200, 201, 202, 203, 204, - 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, - 546, 547, 339, 213, 205, 43, 214, 44, 45, 46, - 47, 48, 230, 74, 231, 646, 75, 563, 303, 216, - 50, 355, 356, 357, 51, 644, 742, 675, 676, 677, - 813, 678, 760, 679, 680, 681, 698, 783, 878, 701, - 785, 879, 566, 233, 706, 707, 708, 234, 52, 53, - 54, 55, 343, 345, 350, 242, 56, 764, 464, 237, - 238, 341, 572, 576, 573, 577, 348, 349, 206, 290, - 398, 710, 711, 400, 401, 402, 224, 409, 410, 411, - 412, 413, 414, 313, 847, 295, 296, 297, 637, 531, - 298, 416, 207, 638, 314, 867, 863, 884, 885, 817, - 864, 865, 533, 772, 819, 534, 535, 886, 903, 775, - 776, 850, 888, 536, 537, 851, 538, 539, 540, 225, - 226, 58, 541, 824, 617, 874, 875, 876, 918, 877, - 67, 163, 490, 599, 548, 717, 833, 549, 550, 737, - 551, 627, 305, 425, 552, 553, 406, 208 -}; - -static const short yypact[] = -{ - 113, 155,-32768,-32768, 1362, 1362, 281,-32768,-32768,-32768, - -32768,-32768, 104, 104, 104, 96,-32768, 100,-32768,-32768, - -32768,-32768,-32768, 54, 245, 1127, 1094, 1132, 1602, 202, - 1193, 398, 1210, 1306, 1658, 1582, 1686, 554, 1260, 972, - 1367,-32768,-32768, 117,-32768,-32768,-32768,-32768,-32768, 104, - -32768,-32768, 74, 76, 84,-32768,-32768, 134,-32768, 1362, - -32768,-32768,-32768, 104, 104, 104,-32768, 157,-32768, 173, - 2564,-32768, 271, 104, 41,-32768, 1468,-32768,-32768,-32768, - 104,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 104, - -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 104,-32768, - -32768,-32768,-32768,-32768,-32768,-32768,-32768, 104,-32768,-32768, - -32768,-32768,-32768,-32768,-32768,-32768, 104,-32768,-32768,-32768, - -32768,-32768,-32768,-32768,-32768, 104,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768, 104,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768, 104,-32768,-32768,-32768,-32768,-32768, 284, - 245,-32768,-32768,-32768,-32768,-32768, 164,-32768, 171,-32768, - 189,-32768,-32768, 207, 301,-32768, 255,-32768,-32768,-32768, - -32768,-32768, 2646, 2646, 260, 310, 334,-32768, 342, 434, - -32768,-32768,-32768, 2646,-32768,-32768, 1030,-32768,-32768, 2646, - 376,-32768, 2687, 2728,-32768, 3160, 1359, 2431, 607, 3041, - 3153, 540, 582, 709, 759,-32768, 318, 1764, 2646, 278, - 329, 285, 408,-32768, 245, 245, 104,-32768, 104,-32768, - -32768, 104, 369, 379,-32768,-32768, 104,-32768, 271, 104, - 47,-32768, 1241, 470, 491, 180, 2092, 330, 994,-32768, - 336,-32768, 378,-32768,-32768,-32768, 361, 645,-32768,-32768, - 2646, 2439, 1716, 1808,-32768,-32768, 386,-32768, 473, 403, - -32768, 2646,-32768, 1030,-32768, 1030,-32768, 2646, 2646, 399, - -32768,-32768, 2646, 2646, 2646, 2646, 2646, 2646, 2646, 2646, - 2646, 2646, 2646, 2646,-32768,-32768, 434, 434, 2646, 2646, - 383,-32768, 405, 434,-32768, 1877, 431,-32768, 426,-32768, - 491, 206, 245,-32768,-32768,-32768, 271, 469, 2107, 433, - -32768, 577, 57,-32768, 1691, 483, 284, 284,-32768, 104, - -32768, 379, 104, 104,-32768,-32768,-32768, 379, 104,-32768, - -32768, 2431, 607, 3041, 3153, 540, 582, 709, 759,-32768, - 507, 441, 1159,-32768, 104,-32768,-32768, 487, 443,-32768, - 378,-32768,-32768,-32768,-32768, 537,-32768, 474,-32768, 2916, - 458, 2935, 460, 452, 475, 480,-32768,-32768, 2375, 3160, - 482, 485, 3160, 3160, 2646, 534, 2646, 2646, 2532, 911, - 1247, 959, 1058, 698, 698, 567, 567,-32768,-32768,-32768, - -32768,-32768, 495, 511, 3160, 308, 271, 104,-32768,-32768, - -32768,-32768, 597,-32768,-32768,-32768, 222, 433,-32768,-32768, - 88, 90, 93, 94, 605,-32768, 516, 2259,-32768,-32768, - -32768,-32768,-32768,-32768, 225, 914, 2646, 2646, 2167,-32768, - 2790,-32768,-32768,-32768,-32768,-32768, 2097, 3105, 1472, 1402, - 2205, 3122, 1728, 1512, 523, 531,-32768, 470, 298, 284, - -32768, 587,-32768,-32768,-32768, 388, 114,-32768,-32768, 544, - -32768, 546, 2646, 434, 548, 443,-32768, 645, 552, 2769, - 3054,-32768, 2646,-32768, 3054,-32768,-32768,-32768,-32768, 545, - 545, 82, 2646, 3189, 3123,-32768, 2646,-32768, 383, 383, - -32768, 104,-32768,-32768, 434,-32768,-32768,-32768,-32768,-32768, - -32768, 2334,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 612, - 614,-32768,-32768,-32768,-32768,-32768, 2646, 616, 578, 580, - 2605, 144, 661,-32768,-32768,-32768, 240,-32768,-32768,-32768, - 584, 69,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, - -32768,-32768, 2503, 586,-32768,-32768,-32768,-32768,-32768, 599, - 258,-32768,-32768, 592, 2818, 2839,-32768,-32768, 63,-32768, - 284,-32768, 245, 1985,-32768,-32768, 647,-32768,-32768,-32768, - 2646, 199, 598,-32768, 2646, 391, 620,-32768, 104, 104, - 3160,-32768, 104, 606,-32768,-32768, 609, 604, 613, 2962, - 622, 434, 1401,-32768, 3176, 3160,-32768,-32768, 626, 944, - -32768,-32768,-32768,-32768,-32768,-32768, 632, 655, 2985,-32768, - -32768,-32768,-32768, 320, 2646, 639,-32768,-32768, 684,-32768, - 284, 245,-32768,-32768,-32768,-32768,-32768, 136, 209,-32768, - -32768, 1998, 730,-32768,-32768,-32768, 642,-32768,-32768, 365, - 368,-32768,-32768, 3160,-32768, 63, 1985, 63, 3045, 2646, - -32768, 104, 3045, 2646,-32768, 104,-32768,-32768,-32768, 104, - -32768, 2646,-32768,-32768,-32768, 2646,-32768,-32768, 178,-32768, - 434, 2646,-32768, 693, 3160, 654, 667,-32768,-32768, 186, - -32768, 1918, 2646,-32768,-32768, 702, 704,-32768, 2503, 2646, - 2646,-32768,-32768, 373,-32768, 706, 104, 392,-32768, 83, - 430,-32768, 448,-32768, 271, 104, 104, 636, 641, 229, - -32768,-32768, 104, 271, 104, 229,-32768, 104,-32768, 2097, - 3105, 2297, 3135, 1472, 1402, 2236, 1747, 2205, 3122, 2516, - 3140, 1728, 1512, 3100, 2325,-32768,-32768,-32768,-32768,-32768, - -32768,-32768, 1401,-32768,-32768,-32768,-32768, 3045, 388,-32768, - 3045, 114,-32768, 640, 2888, 434, 2646,-32768,-32768, 1817, - 1401,-32768,-32768, 1620,-32768, 2026,-32768,-32768,-32768, 3176, - -32768,-32768,-32768, 694,-32768, 700,-32768, 653, 3142,-32768, - 301,-32768,-32768, 379,-32768, 379, 136, 233,-32768, 104, - -32768, 104,-32768,-32768, 104, 209, 209,-32768,-32768, 136, - 209, 701,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 352, - 2646,-32768, 703, 2026,-32768,-32768, 2646, 708, 718,-32768, - -32768,-32768,-32768,-32768, 720, 770,-32768,-32768, 636, 641, - 305,-32768,-32768, 944, 104, 229,-32768, 229,-32768,-32768, - -32768, 2867,-32768,-32768, 694,-32768,-32768,-32768, 797, 2646, - 737,-32768,-32768, 120,-32768,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768, 808, 813,-32768,-32768,-32768,-32768, - 2646,-32768, 745, 434, 791, 747,-32768,-32768, 642, 642, - 48,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 751,-32768, - -32768, 750, 120, 120, 785,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768, 786,-32768, 301, 814,-32768, 2646, 773, - -32768,-32768,-32768, 301, 685, 774,-32768, 799, 776,-32768, - -32768, 783,-32768, 2646, 301,-32768,-32768, 687,-32768,-32768, - -32768, 872, 873,-32768 -}; - -static const short yypgoto[] = -{ - -32768,-32768,-32768,-32768, 191, 891,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768, -28,-32768, -69, 425, 235, 603, - -32768,-32768,-32768, -127, 1076,-32768,-32768,-32768,-32768,-32768, - -32768,-32768,-32768,-32768, -278, 588,-32768,-32768, -50, 236, - -296, -502, 0, 2, 24, 46, 4, 9, 31, 105, - -302, -295, 267, 274, -292, -284, 275, 276, -350, -348, - 594, 602,-32768, -167,-32768, -363, -181, 794, 822, 471, - 903,-32768, -462, -140, 453,-32768, 621,-32768, 34, 457, - -32,-32768, 444,-32768, 850, 279,-32768, -636,-32768, 161, - -32768, -628,-32768,-32768, 257, 259,-32768,-32768,-32768,-32768, - -32768,-32768, -131, 481, 138, 153, 16, 18,-32768,-32768, - -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 488, -118, - -32768, 615,-32768,-32768, 198, 196, 623, 492, -100,-32768, - -32768, -594, -263, -467, -428,-32768, 601,-32768,-32768,-32768, - -32768,-32768,-32768, -219, -369,-32768,-32768, 658, -434,-32768, - 450,-32768,-32768, -380, 451, -777, -767, -222, -213, -727, - -32768, -41, 102, -732, -631,-32768,-32768,-32768,-32768, -741, - -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 95, - -212,-32768,-32768,-32768,-32768, 91,-32768, 92,-32768, -153, - -17, -66, 484,-32768, -596,-32768,-32768,-32768,-32768,-32768, - -32768, 437, -285,-32768,-32768,-32768,-32768, 11 -}; - - -#define YYLAST 3248 - - -static const short yytable[] = -{ - 69, 190, 165, 684, 25, 25, 26, 26, 29, 29, - 235, 246, 440, 30, 30, 59, 59, 152, 232, 441, - 322, 596, 442, 449, 156, 158, 160, 399, 27, 27, - 443, 152, 152, 152, 716, 31, 31, 532, 452, 240, - 624, 308, 76, 450, 818, 248, 249, 316, 152, 453, - 28, 28, 848, 768, 530, 307, 255, 152, -114, 25, - 597, 26, 260, 29, 636, 511, 152, 528, 30, 529, - 59, 340, 209, 418, 210, 152, 415, 153, 154, 153, - 154, 299, 419, 27, 152, 880, 259, 153, 154, -449, - 31, -450, 433, 152, -451, -452, 211, 66, 639, 57, - 57, 68, 152, 293, 889, 28, 801, 215, 869, 32, - 32, 152, 220, -1, 866, -519, 902, 71, 212, 871, - 70, 532, 909, 440, 812, 426, -519, 593, 217, 887, - 441, 245, 218, 442, 318, 897, 17, 815, 319, 71, - 703, 443, 603, 604, 605, 606, 607, 153, 154, 922, - -114, 254, 363, 365, 57, -2, 524, 294, 697, 574, - 712, 712, -539, 370, 32, 371, -539, 155, 236, 157, - -519, 72, 911, 261, -519, 340, -429, 159, -430, 530, - 73, -431, -432, 915, 152, 843, 774, 873, 496, 499, - 502, 505, 528, 704, 529, 507, 60, 497, 500, 503, - 506, 614, 705, 222, 151, 836, 838, 8, 9, 10, - 95, 743, 71, 745, 347, 488, 12, 13, 14, 354, - 395, 161, 209, 164, 210, 459, 598, 461, 209, 765, - 210, 17, 300, 301, 17, 883, 71, 857, 331, 166, - 332, 478, 335, 755, 649, 756, 211, 336, 71, 342, - 162, 670, 211, 671, 220, 304, 739, 239, 390, 391, - 315, 17, 333, 317, 241, 405, 713, 325, 212, 337, - 757, 218, 221, 222, 212, 714, 222, 149, 150, 11, - 916, 735, 243, 736, 334, 466, 77, 71, 227, -254, - 704, 221, 222, 86, 244, 221, 222, 440, 422, 705, - 222, 255, 72, 17, 441, 481, 209, 442, 210, 493, - 17, 73, 245, 494, 436, 443, 437, 17, 438, 596, - 424, 247, 347, 439, 571, 530, 250, 619, 596, 727, - 211, 261, 712, 712, 300, 301, 728, 82, 528, 731, - 529, 228, 331, 338, 332, 630, 335, 732, 526, 631, - 229, 336, 212, 342, 322, 748, 451, 304, 597, 751, - 495, 498, 454, 504, 323, 222, 333, 597, 61, 62, - 588, 791, 222, 337, 590, 306, 251, 11, 460, 346, - 309, 153, 154, -469, -469, -469, -469, -469, 334, 525, - 564, 71, 227, -469, -469, -469, 209, 856, 210, 261, - 252, 17, 487, 8, 9, 10, 104, 692, 253, -469, - 291, 261, 12, 13, 14, 299, 91, 25, 328, 26, - 211, 29, 640, 17, 344, 436, 30, 437, 542, 438, - 17, 489, 526, 570, 439, 347, 653, 153, 154, 354, - 396, 27, 212, 261, -82, 228, 840, 338, 31, 397, - 222, 613, 740, 351, 229, 741, 319, 221, 222, 218, - 779, 49, 49, 28, 261, 293, 602, 261, 262, 63, - 64, 65, -113, 525, 575, 427, 862, 220, 366, 782, - -519, 700, 80, 319, 89, -256, 98, 322, 107, 699, - 116, -519, 125, 615, 134, 368, 143, 404, 895, 896, - 96, 101, 105, 110, 831, 826, 832, 827, 132, 137, - 141, 146, 899, 899, 221, 222, 49, 784, 421, 660, - 431, 218, 32, 786, 598, 600, 446, 49, 457, 49, - 462, 440, 795, 598, 463, -519, 323, 222, 441, -519, - 469, 442, 25, 474, 26, 693, 29, 10, 95, 443, - 471, 30, 473, 542, 12, 13, 14, 221, 222, 8, - 9, 10, 131, 667, 261, 367, 27, 475, 12, 13, - 14, 476, 17, 31, 479, 455, 456, 480, 309, 482, - 424, -116, -116, -116, -116, -116, 17, 485, 28, 10, - 100, -116, -116, -116, -388, -388, 12, 13, 14, 436, - 695, 437, 486, 438, 508, 650, 309, -116, 439, 654, - 559, 7, 656, 657, 10, 82, 658, 571, 561, 773, - 777, 12, 13, 14, 281, 282, 283, 825, 467, 468, - 568, 719, 578, 720, 579, 723, 582, 16, 477, 702, - 724, -262, 758, 49, 585, 709, 715, 32, 153, 154, - 8, 9, 352, 353, 80, 721, 89, -31, 98, -32, - 107, 609, 725, 491, 222, 610, 80, 611, 89, 616, - -116, 622, 96, 101, 105, 110, 220, 722, 625, 49, - 560, 562, 746, 632, 633, 49, 749, 809, 25, 651, - 26, 629, 29, 752, 659, 49, 663, 30, 688, 542, - 661, 662, 789, 222, 209, 664, 210, 791, 222, 49, - 49, 655, 27, 209, 666, 210, 10, 104, 683, 31, - 49, 689, 49, 12, 13, 14, 694, 808, 211, 696, - 781, 486, 806, 738, 28, 524, 726, 211, 761, 787, - 788, 17, 762, 793, 261, 822, 417, 844, 796, 797, - 212, 798, 912, 279, 280, 281, 282, 283, 763, 212, - 919, 432, 152, 49, 620, 621, 10, 109, 770, 575, - 771, 928, 780, 12, 13, 14, 261, 920, 261, 929, - 773, 802, 626, 626, 804, 261, 872, 820, 80, 839, - 89, 842, 98, 32, 107, 264, 266, 447, 448, 49, - 845, 773, 829, 830, 300, 301, 96, 101, 105, 110, - 846, 894, 852, 300, 301, 853, 868, 835, 837, 78, - 83, 87, 92, 304, 870, 304, 881, 114, 119, 123, - 128, 882, 890, 436, 324, 437, 892, 438, 893, 914, - 900, 901, 439, 904, 905, 891, 917, 79, 84, 88, - 93, 908, 910, 49, 927, 115, 120, 124, 129, 913, - 897, 417, 417, 501, 417, 923, 921, 924, 858, 859, - 926, 860, 932, 933, 49, 81, 85, 90, 94, 99, - 103, 108, 112, 117, 121, 126, 130, 135, 139, 144, - 148, 403, 3, 80, 587, 98, 753, 116, 729, 134, - 434, 567, 565, 925, 569, 730, 733, 734, 444, 96, - 101, 584, 930, 132, 137, 543, 445, 544, 7, 8, - 9, 10, 11, 423, 814, 744, 545, 49, 12, 13, - 14, 49, 97, 102, 106, 111, 766, 834, 767, 828, - 133, 138, 142, 147, 16, 543, 803, 805, 7, 8, - 9, 10, 11, 583, 420, 581, 545, 458, 12, 13, - 14, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 799, 800, 465, 16, 601, 618, 8, 9, 10, - 140, 623, 898, 906, 628, 907, 12, 13, 14, 0, - 0, 78, 83, 87, 92, 329, 0, 0, 7, 49, - 0, 10, 11, 492, 17, 0, -548, 0, 12, 13, - 14, 276, 277, 278, 279, 280, 281, 282, 283, 79, - 84, 88, 93, 0, 16, 0, 17, 18, 0, 0, - 0, 256, 0, 167, 7, 0, -548, 10, 11, 0, - 168, 169, 0, 170, 12, 13, 14, 0, 324, 324, - 0, 0, 0, 0, 685, 686, 687, 0, 0, -264, - 16, 171, 17, 18, 0, 172, 173, 174, 175, 176, - 177, 178, 0, 0, 0, 0, 0, 179, 0, 0, - 180, 330, -380, 0, 0, 181, 182, 183, 49, 403, - 403, 184, 185, 0, 0, 0, 186, 358, 7, 8, - 9, 10, 82, 0, 97, 102, 106, 111, 12, 13, - 14, 277, 278, 279, 280, 281, 282, 283, 0, 187, - 188, 0, 0, 257, 16, 78, 83, 87, 92, 0, - 0, 7, 8, 9, 10, 77, 7, 8, 9, 10, - 86, 12, 13, 14, 0, 49, 12, 13, 14, 0, - 0, 0, 0, 79, 84, 88, 93, 16, 0, 17, - 329, 49, 16, 7, 17, 0, 10, 11, 0, 794, - 49, 0, 0, 12, 13, 14, 80, 0, 89, 0, - 98, -251, 107, 0, 116, 0, 125, 0, 134, 16, - 143, 17, 18, 0, 96, 101, 105, 110, 8, 9, - 10, 100, 132, 137, 141, 146, 0, 12, 13, 14, - 0, 0, 0, 0, -250, 8, 9, 10, 109, -252, - 0, 816, 816, 0, 12, 13, 14, 821, 403, 403, - 78, 83, 0, 0, 114, 119, 0, 0, 97, 102, - 106, 111, 320, 0, 0, -19, -19, -19, -19, -19, - 0, 0, 0, 0, 0, -19, -19, -19, 79, 84, - 0, 0, 115, 120, 0, 8, 9, 10, 136, 0, - 220, -19, 849, -519, 12, 13, 14, 854, 855, 0, - -255, 0, 0, 0, -519, 0, 81, 85, 99, 103, - 117, 121, 135, 139, 0, 0, 0, -257, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 0, 790, 792, - 7, 8, 9, 10, 113, 0, 0, 358, 501, 0, - 12, 13, 14, 0, 0, 0, 359, 361, -519, 0, - 0, 501, -519, 0, -19, 0, 16, 369, 17, 0, - 0, 97, 102, 372, 373, 133, 138, -263, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, - 501, 816, 0, 6, 394, -125, 7, 8, 9, 10, - 11, 0, 8, 9, 10, 145, 12, 13, 14, 0, - 0, 12, 13, 14, 430, 0, 0, 403, 403, 0, - 0, 15, 16, -258, 17, 18, 403, 403, 0, 0, - 403, 403, 669, 0, 509, 154, 0, 8, 9, 10, - 100, 168, 169, 0, 170, 0, 12, 13, 14, -125, - 284, 285, 0, 286, 287, 288, 289, 0, -125, 790, - 792, 792, 171, 0, 18, 0, 172, 173, 174, 175, - 176, 177, 178, 0, 0, 0, 0, 0, 179, 19, - 0, 180, 483, 484, -265, 0, 181, 182, 183, 0, - 0, 0, 184, 185, 0, 0, 670, 186, 671, 219, - 0, 0, -27, -27, -27, -27, -27, 8, 9, 10, - 95, 0, -27, -27, -27, 0, 12, 13, 14, -310, - 187, 188, 0, 0, 672, 0, 0, 220, -27, 0, - -519, 0, 554, 555, 17, 0, 0, 0, 0, 0, - 0, -519, 0, 78, 83, 87, 92, 8, 9, 10, - 136, 114, 119, 123, 128, 0, 12, 13, 14, 0, - 0, 0, 0, 0, 221, 222, 0, 0, 580, 0, - 0, 79, 84, 88, 93, 394, 0, 0, 589, 115, - 120, 124, 129, 0, 0, -519, 0, 0, 594, -519, - 0, -27, 595, 0, 0, 0, 0, 0, 0, 81, - 85, 90, 94, 99, 103, 108, 112, 117, 121, 126, - 130, 135, 139, 144, 148, 0, 7, 8, 9, 10, - 122, 0, 608, 0, 0, 0, 12, 13, 14, 0, - 0, 0, 0, 0, 0, 0, 7, 8, 9, 10, - 91, 0, 16, 0, 17, 0, 12, 13, 14, 0, - 0, 669, 0, 509, 154, 0, 97, 102, 106, 111, - 168, 169, 16, 170, 133, 138, 142, 147, 0, 643, - 0, 0, 0, 0, 0, 0, 648, 0, 0, 0, - 652, 171, 0, 18, 0, 172, 173, 174, 175, 176, - 177, 178, 7, 8, 9, 10, 118, 179, 674, -260, - 180, 0, 12, 13, 14, 181, 182, 183, 0, 0, - 0, 184, 185, 0, 0, 670, 186, 671, 16, -253, - 7, 8, 9, 10, 127, 7, 8, 9, 10, 11, - 12, 13, 14, 0, 0, 12, 13, 14, -377, 187, - 188, 0, 0, 672, 0, 0, 16, 362, 0, 0, - 7, 16, 643, 10, 11, 747, 0, 0, 0, 750, - 12, 13, 14, 8, 9, 10, 131, 394, 0, 0, - 0, 754, 12, 13, 14, -259, 16, 759, 17, 0, - 0, 0, 8, 9, 10, 109, 0, 674, 769, 0, - 17, 12, 13, 14, 0, 292, 778, -455, -455, -455, - -455, -455, -455, -261, -455, -455, 0, -455, -455, -455, - -455, -455, 0, -455, -455, -455, -455, -455, -455, -455, - -455, -455, -455, -455, -455, -455, -455, -455, 293, -455, - -455, -455, -455, -455, -455, -455, 0, 0, 0, 364, - 0, -455, 7, 0, -455, 10, 11, 0, 674, -455, - -455, -455, 12, 13, 14, -455, -455, 0, 0, 810, - -455, 0, 0, 0, 0, 0, 674, 0, 16, 674, - 17, 674, 0, 0, 0, 0, 0, 0, 0, 0, - 0, -455, 294, -455, -455, 0, 0, -455, 0, 267, - 268, 269, 0, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 0, 407, 0, - -469, -469, -469, -469, -469, -469, 841, -469, -469, 674, - -469, -469, -469, -469, -469, 0, -469, -469, -469, -469, - -469, -469, -469, -469, -469, -469, -469, -469, -469, -469, - -469, 811, -469, -469, -469, -469, -469, -469, -469, 669, - 0, 167, 0, 0, -469, 0, 0, -469, 168, 169, - 0, 170, -469, -469, -469, 0, 0, 0, -469, -469, - 0, 0, 0, -469, 0, 0, 0, 0, 0, 171, - 0, 18, 0, 172, 173, 174, 175, 176, 177, 178, - 0, -326, 0, 0, -469, 179, -469, -469, 180, 0, - -469, 0, 0, 181, 182, 183, 0, 0, 0, 184, - 185, 0, 0, -326, 186, -326, 641, 0, 167, 0, - 0, 0, 0, 0, 0, 168, 169, 0, 170, 0, - 0, 0, 7, 8, 9, 10, 11, 187, 188, 0, - 718, 672, 12, 13, 14, 0, 171, 0, 18, 0, - 172, 173, 174, 175, 176, 177, 178, 669, 16, 167, - 17, 0, 179, 0, 0, 180, 168, 169, 0, 170, - 181, 182, 183, 0, 0, 0, 184, 185, 0, 0, - 0, 186, 0, 0, 0, 0, 0, 171, 0, 18, - 0, 172, 173, 174, 175, 176, 177, 178, 0, 0, - 0, 0, 0, 179, 187, 188, 180, 0, 642, 0, - 0, 181, 182, 183, 0, 0, 0, 184, 185, 0, - 0, 0, 186, 326, 0, 0, -23, -23, -23, -23, - -23, 7, 8, 9, 10, 77, -23, -23, -23, 0, - 167, 12, 13, 14, 0, 187, 188, 168, 169, 672, - 170, 220, -23, 0, -519, 0, 0, 16, 0, 17, - 0, 0, 0, 0, 0, -519, 0, 0, 171, 0, - 18, 0, 172, 173, 174, 175, 176, 177, 178, 0, - 0, 0, 0, 0, 179, 0, 0, 180, 221, 222, - 0, 0, 181, 182, 428, 0, 0, 0, 184, 185, - 167, 0, 0, 186, 0, 0, 0, 168, 169, -519, - 170, 0, 0, -519, 0, -23, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 187, 188, 171, 0, - 18, 429, 172, 173, 174, 175, 176, 177, 178, 7, - 8, 9, 10, 113, 179, 0, 0, 180, 0, 12, - 13, 14, 181, 182, 183, 0, 0, 0, 184, 185, - 0, 0, 0, 186, 0, 16, 0, 17, 0, 0, - 0, 8, 9, 10, 104, 0, 0, 0, 0, 0, - 12, 13, 14, 0, 0, 0, 187, 188, 0, 0, - 0, 556, 509, 510, 8, 9, 10, 11, 17, 168, - 169, 0, 170, 12, 13, 14, 511, 0, 512, 513, - 514, 515, 516, 517, 518, 519, 520, 521, 522, 16, - 171, 17, 18, 0, 172, 173, 174, 175, 176, 177, - 178, 7, 8, 9, 10, 86, 179, 0, 0, 180, - 0, 12, 13, 14, 181, 182, 183, 0, 0, 0, - 184, 185, 0, 0, 0, 186, 0, 16, 0, 17, - 8, 9, 10, 145, 0, 0, 0, 509, 154, 12, - 13, 14, 0, 0, 168, 169, 523, 170, 187, 188, - 0, 511, 524, 512, 513, 514, 515, 516, 517, 518, - 519, 520, 521, 522, 0, 171, 0, 18, 0, 172, - 173, 174, 175, 176, 177, 178, 0, 0, 167, 0, - 0, 179, 0, 0, 180, 168, 169, 0, 170, 181, - 182, 183, 0, 0, 0, 184, 185, 0, 0, 0, - 186, 0, 0, 0, 0, 0, 171, 0, 18, 0, - 172, 173, 174, 175, 176, 177, 178, 0, 0, 0, - 0, 523, 179, 187, 188, 180, 0, 524, 0, 0, - 181, 182, 183, 0, 0, 7, 184, 185, 10, 77, - 360, 186, 167, 0, 0, 12, 13, 14, 0, 168, - 169, 0, 170, 0, 0, 0, 0, 0, 0, 0, - 0, 16, 0, 17, 187, 188, 0, 0, 477, 0, - 171, 0, 18, 0, 172, 173, 174, 175, 176, 177, - 178, 0, 0, 0, 0, 0, 179, 0, 0, 180, - 0, 0, 0, 0, 181, 182, 183, 0, 0, 0, - 184, 185, 0, 0, 0, 186, 167, 7, 8, 9, - 10, 11, 0, 168, 169, 0, 170, 12, 13, 14, - 7, 8, 9, 10, 122, 0, 0, 0, 187, 188, - 12, 13, 14, 16, 171, 17, 18, 0, 172, 173, - 174, 175, 176, 177, 178, 0, 16, 0, 17, 0, - 179, 0, 0, 180, 0, 0, 0, 0, 181, 182, - 183, 0, 0, 0, 184, 185, 0, 167, 7, 186, - 0, 10, 11, 0, 168, 169, 0, 170, 12, 13, - 14, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 187, 188, 16, 171, 17, 18, 0, 172, - 173, 174, 175, 176, 177, 178, 0, 0, 167, 0, - 0, 179, 0, 0, 180, 168, 169, 0, 170, 181, - 182, 183, 0, 0, 0, 184, 185, 0, 0, 0, - 186, 0, 0, 0, 0, 0, 171, 0, 18, 0, - 172, 173, 174, 175, 176, 177, 178, 0, 0, 167, - 0, 0, 179, 187, 188, 180, 168, 169, 0, 170, - 181, 182, 183, 0, 0, 0, 184, 185, 0, 0, - 0, 186, 0, 0, 0, 0, 0, 171, 0, 18, - 0, 172, 173, 174, 175, 176, 177, 178, 0, 0, - 167, 0, 612, 179, 187, 188, 180, 168, 169, 0, - 170, 181, 182, 183, 0, 0, 0, 184, 185, 0, - 0, 0, 186, 0, 0, 0, 0, 0, 171, 0, - 18, 0, 172, 173, 174, 175, 176, 177, 178, 0, - 0, 167, 0, 0, 179, 187, 188, 180, 168, 169, - 0, 170, 181, 182, 183, 0, 0, 0, 184, 185, - 0, 0, 0, 263, 0, 0, 0, 0, 0, 171, - 0, 18, 0, 172, 173, 174, 175, 176, 177, 178, - 0, 0, 586, 0, 0, 179, 187, 188, 180, 168, - 169, 0, 170, 181, 182, 183, 0, 0, 0, 184, - 185, 0, 0, 0, 265, 0, 0, 0, 0, 0, - 171, 0, 18, 0, 172, 173, 174, 175, 176, 177, - 178, 0, 0, 0, 0, 0, 179, 187, 188, 180, - 0, 0, 0, 0, 181, 182, 183, 0, 0, 0, - 184, 185, 267, 268, 269, 186, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 0, 0, 0, 0, 0, 0, 0, 0, 187, 188, - 267, 268, 269, 0, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 0, 0, - 0, 267, 268, 269, 557, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 267, - 268, 269, 634, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 0, 0, 0, - 267, 268, 269, 635, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 282, 283, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 267, 268, - 269, 861, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 0, 267, 268, 269, - 807, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 0, 0, 690, 0, 0, - 0, 0, 0, 0, 267, 268, 269, 470, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 0, 0, 0, 0, 472, 267, 268, 269, - 691, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 7, 0, 0, 10, 86, - 0, 0, 0, 665, 0, 12, 13, 14, 7, 0, - 0, 10, 11, 0, 0, 0, 0, 0, 12, 13, - 14, 16, 0, 17, 0, 0, 0, 17, 0, 0, - 0, 0, 0, 0, 16, 0, 17, 267, 268, 269, - 0, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 8, 9, 10, 140, 7, - 8, 9, 10, 82, 12, 13, 14, 0, 0, 12, - 13, 14, 0, 0, 0, 0, 7, 8, 9, 10, - 118, 0, 17, 0, 0, 16, 12, 13, 14, 7, - 8, 9, 10, 91, 7, 8, 9, 10, 127, 12, - 13, 14, 16, 0, 12, 13, 14, 7, 0, 0, - 10, 91, 0, 0, 0, 16, 0, 12, 13, 14, - 16, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 16, 267, 268, 269, 823, 270, 271, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 282, 283, 267, 268, 269, 0, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 269, 0, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283 -}; - -static const short yycheck[] = -{ - 17, 70, 68, 599, 4, 5, 4, 5, 4, 5, - 150, 164, 314, 4, 5, 4, 5, 49, 149, 314, - 232, 488, 314, 319, 52, 53, 54, 290, 4, 5, - 314, 63, 64, 65, 628, 4, 5, 417, 323, 157, - 542, 222, 24, 321, 771, 172, 173, 228, 80, 327, - 4, 5, 819, 681, 417, 222, 183, 89, 1, 59, - 488, 59, 189, 59, 1, 17, 98, 417, 59, 417, - 59, 238, 72, 295, 72, 107, 295, 3, 4, 3, - 4, 208, 295, 59, 116, 862, 186, 3, 4, 1, - 59, 1, 311, 125, 1, 1, 72, 1, 560, 4, - 5, 1, 134, 34, 871, 59, 742, 73, 849, 4, - 5, 143, 29, 0, 846, 32, 883, 3, 72, 851, - 66, 501, 899, 425, 760, 306, 43, 45, 87, 870, - 425, 11, 91, 425, 87, 87, 32, 765, 91, 3, - 4, 425, 511, 512, 513, 514, 515, 3, 4, 916, - 93, 179, 252, 253, 59, 0, 93, 88, 620, 45, - 627, 628, 66, 263, 59, 265, 66, 93, 150, 93, - 87, 57, 904, 91, 91, 342, 88, 93, 88, 542, - 66, 88, 88, 910, 216, 813, 688, 67, 410, 411, - 412, 413, 542, 57, 542, 414, 5, 410, 411, 412, - 413, 57, 66, 67, 87, 799, 800, 5, 6, 7, - 8, 645, 3, 647, 242, 396, 14, 15, 16, 247, - 289, 87, 222, 66, 222, 343, 489, 345, 228, 43, - 228, 32, 214, 215, 32, 866, 3, 833, 238, 66, - 238, 368, 238, 65, 45, 67, 222, 238, 3, 238, - 59, 65, 228, 67, 29, 221, 636, 93, 286, 287, - 226, 32, 238, 229, 93, 293, 57, 87, 222, 238, - 92, 91, 66, 67, 228, 66, 67, 41, 42, 8, - 911, 631, 93, 631, 238, 351, 8, 3, 4, 87, - 57, 66, 67, 8, 87, 66, 67, 599, 92, 66, - 67, 428, 57, 32, 599, 374, 306, 599, 306, 87, - 32, 66, 11, 91, 314, 599, 314, 32, 314, 786, - 302, 66, 350, 314, 455, 688, 66, 87, 795, 631, - 306, 91, 799, 800, 316, 317, 631, 8, 688, 631, - 688, 57, 342, 238, 342, 87, 342, 631, 417, 91, - 66, 342, 306, 342, 566, 651, 322, 323, 786, 655, - 410, 411, 328, 413, 66, 67, 342, 795, 87, 88, - 470, 66, 67, 342, 474, 6, 66, 8, 344, 1, - 1, 3, 4, 4, 5, 6, 7, 8, 342, 417, - 92, 3, 4, 14, 15, 16, 396, 92, 396, 91, - 66, 32, 94, 5, 6, 7, 8, 87, 66, 30, - 92, 91, 14, 15, 16, 542, 8, 417, 88, 417, - 396, 417, 562, 32, 88, 425, 417, 425, 417, 425, - 32, 397, 501, 45, 425, 463, 45, 3, 4, 467, - 57, 417, 396, 91, 45, 57, 94, 342, 417, 66, - 67, 520, 87, 92, 66, 87, 91, 66, 67, 91, - 87, 4, 5, 417, 91, 34, 494, 91, 92, 12, - 13, 14, 93, 501, 456, 6, 845, 29, 92, 87, - 32, 621, 25, 91, 27, 87, 29, 699, 31, 620, - 33, 43, 35, 521, 37, 92, 39, 92, 878, 879, - 29, 30, 31, 32, 789, 783, 791, 785, 37, 38, - 39, 40, 881, 882, 66, 67, 59, 87, 92, 585, - 87, 91, 417, 704, 787, 491, 43, 70, 87, 72, - 43, 833, 713, 796, 91, 87, 66, 67, 833, 91, - 66, 833, 542, 91, 542, 614, 542, 7, 8, 833, - 92, 542, 92, 542, 14, 15, 16, 66, 67, 5, - 6, 7, 8, 591, 91, 92, 542, 92, 14, 15, - 16, 91, 32, 542, 92, 339, 340, 92, 1, 45, - 562, 4, 5, 6, 7, 8, 32, 92, 542, 7, - 8, 14, 15, 16, 87, 88, 14, 15, 16, 599, - 617, 599, 91, 599, 88, 571, 1, 30, 599, 575, - 87, 4, 578, 579, 7, 8, 582, 748, 87, 688, - 689, 14, 15, 16, 57, 58, 59, 780, 91, 92, - 43, 631, 88, 631, 88, 631, 88, 30, 93, 621, - 631, 87, 670, 186, 92, 627, 628, 542, 3, 4, - 5, 6, 7, 8, 197, 631, 199, 45, 201, 45, - 203, 45, 631, 66, 67, 87, 209, 87, 211, 8, - 93, 87, 201, 202, 203, 204, 29, 631, 92, 222, - 444, 445, 648, 91, 92, 228, 652, 756, 688, 91, - 688, 92, 688, 659, 88, 238, 92, 688, 66, 688, - 91, 92, 66, 67, 704, 92, 704, 66, 67, 252, - 253, 91, 688, 713, 92, 713, 7, 8, 92, 688, - 263, 66, 265, 14, 15, 16, 87, 755, 704, 45, - 696, 91, 92, 3, 688, 93, 631, 713, 45, 705, - 706, 32, 88, 709, 91, 92, 295, 816, 714, 715, - 704, 717, 905, 55, 56, 57, 58, 59, 91, 713, - 913, 310, 794, 306, 528, 529, 7, 8, 66, 751, - 66, 924, 66, 14, 15, 16, 91, 92, 91, 92, - 849, 747, 546, 547, 750, 91, 852, 87, 331, 88, - 333, 88, 335, 688, 337, 192, 193, 316, 317, 342, - 92, 870, 786, 787, 786, 787, 335, 336, 337, 338, - 92, 877, 92, 795, 796, 45, 19, 799, 800, 25, - 26, 27, 28, 789, 87, 791, 18, 33, 34, 35, - 36, 18, 87, 833, 233, 833, 45, 833, 91, 908, - 881, 882, 833, 92, 94, 873, 912, 25, 26, 27, - 28, 66, 66, 396, 923, 33, 34, 35, 36, 45, - 87, 410, 411, 412, 413, 66, 92, 91, 834, 835, - 87, 837, 0, 0, 417, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, - 40, 290, 1, 436, 469, 438, 661, 440, 631, 442, - 312, 450, 449, 920, 453, 631, 631, 631, 314, 438, - 439, 467, 929, 442, 443, 1, 314, 3, 4, 5, - 6, 7, 8, 302, 763, 646, 12, 470, 14, 15, - 16, 474, 29, 30, 31, 32, 679, 799, 679, 786, - 37, 38, 39, 40, 30, 1, 748, 751, 4, 5, - 6, 7, 8, 465, 296, 463, 12, 342, 14, 15, - 16, 50, 51, 52, 53, 54, 55, 56, 57, 58, - 59, 735, 736, 350, 30, 491, 525, 5, 6, 7, - 8, 531, 880, 892, 547, 893, 14, 15, 16, -1, - -1, 197, 198, 199, 200, 1, -1, -1, 4, 542, - -1, 7, 8, 402, 32, -1, 92, -1, 14, 15, - 16, 52, 53, 54, 55, 56, 57, 58, 59, 197, - 198, 199, 200, -1, 30, -1, 32, 33, -1, -1, - -1, 1, -1, 3, 4, -1, 92, 7, 8, -1, - 10, 11, -1, 13, 14, 15, 16, -1, 447, 448, - -1, -1, -1, -1, 603, 604, 605, -1, -1, 87, - 30, 31, 32, 33, -1, 35, 36, 37, 38, 39, - 40, 41, -1, -1, -1, -1, -1, 47, -1, -1, - 50, 87, 88, -1, -1, 55, 56, 57, 631, 488, - 489, 61, 62, -1, -1, -1, 66, 247, 4, 5, - 6, 7, 8, -1, 201, 202, 203, 204, 14, 15, - 16, 53, 54, 55, 56, 57, 58, 59, -1, 89, - 90, -1, -1, 93, 30, 331, 332, 333, 334, -1, - -1, 4, 5, 6, 7, 8, 4, 5, 6, 7, - 8, 14, 15, 16, -1, 688, 14, 15, 16, -1, - -1, -1, -1, 331, 332, 333, 334, 30, -1, 32, - 1, 704, 30, 4, 32, -1, 7, 8, -1, 712, - 713, -1, -1, 14, 15, 16, 719, -1, 721, -1, - 723, 87, 725, -1, 727, -1, 729, -1, 731, 30, - 733, 32, 33, -1, 723, 724, 725, 726, 5, 6, - 7, 8, 731, 732, 733, 734, -1, 14, 15, 16, - -1, -1, -1, -1, 87, 5, 6, 7, 8, 87, - -1, 770, 771, -1, 14, 15, 16, 776, 627, 628, - 436, 437, -1, -1, 440, 441, -1, -1, 335, 336, - 337, 338, 1, -1, -1, 4, 5, 6, 7, 8, - -1, -1, -1, -1, -1, 14, 15, 16, 436, 437, - -1, -1, 440, 441, -1, 5, 6, 7, 8, -1, - 29, 30, 821, 32, 14, 15, 16, 826, 827, -1, - 87, -1, -1, -1, 43, -1, 436, 437, 438, 439, - 440, 441, 442, 443, -1, -1, -1, 87, 51, 52, - 53, 54, 55, 56, 57, 58, 59, -1, 707, 708, - 4, 5, 6, 7, 8, -1, -1, 467, 867, -1, - 14, 15, 16, -1, -1, -1, 250, 251, 87, -1, - -1, 880, 91, -1, 93, -1, 30, 261, 32, -1, - -1, 438, 439, 267, 268, 442, 443, 87, 272, 273, - 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, - 909, 910, -1, 1, 288, 3, 4, 5, 6, 7, - 8, -1, 5, 6, 7, 8, 14, 15, 16, -1, - -1, 14, 15, 16, 308, -1, -1, 786, 787, -1, - -1, 29, 30, 87, 32, 33, 795, 796, -1, -1, - 799, 800, 1, -1, 3, 4, -1, 5, 6, 7, - 8, 10, 11, -1, 13, -1, 14, 15, 16, 57, - 61, 62, -1, 64, 65, 66, 67, -1, 66, 828, - 829, 830, 31, -1, 33, -1, 35, 36, 37, 38, - 39, 40, 41, -1, -1, -1, -1, -1, 47, 87, - -1, 50, 376, 377, 87, -1, 55, 56, 57, -1, - -1, -1, 61, 62, -1, -1, 65, 66, 67, 1, - -1, -1, 4, 5, 6, 7, 8, 5, 6, 7, - 8, -1, 14, 15, 16, -1, 14, 15, 16, 88, - 89, 90, -1, -1, 93, -1, -1, 29, 30, -1, - 32, -1, 426, 427, 32, -1, -1, -1, -1, -1, - -1, 43, -1, 719, 720, 721, 722, 5, 6, 7, - 8, 727, 728, 729, 730, -1, 14, 15, 16, -1, - -1, -1, -1, -1, 66, 67, -1, -1, 462, -1, - -1, 719, 720, 721, 722, 469, -1, -1, 472, 727, - 728, 729, 730, -1, -1, 87, -1, -1, 482, 91, - -1, 93, 486, -1, -1, -1, -1, -1, -1, 719, - 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, - 730, 731, 732, 733, 734, -1, 4, 5, 6, 7, - 8, -1, 516, -1, -1, -1, 14, 15, 16, -1, - -1, -1, -1, -1, -1, -1, 4, 5, 6, 7, - 8, -1, 30, -1, 32, -1, 14, 15, 16, -1, - -1, 1, -1, 3, 4, -1, 723, 724, 725, 726, - 10, 11, 30, 13, 731, 732, 733, 734, -1, 563, - -1, -1, -1, -1, -1, -1, 570, -1, -1, -1, - 574, 31, -1, 33, -1, 35, 36, 37, 38, 39, - 40, 41, 4, 5, 6, 7, 8, 47, 592, 87, - 50, -1, 14, 15, 16, 55, 56, 57, -1, -1, - -1, 61, 62, -1, -1, 65, 66, 67, 30, 87, - 4, 5, 6, 7, 8, 4, 5, 6, 7, 8, - 14, 15, 16, -1, -1, 14, 15, 16, 88, 89, - 90, -1, -1, 93, -1, -1, 30, 1, -1, -1, - 4, 30, 646, 7, 8, 649, -1, -1, -1, 653, - 14, 15, 16, 5, 6, 7, 8, 661, -1, -1, - -1, 665, 14, 15, 16, 87, 30, 671, 32, -1, - -1, -1, 5, 6, 7, 8, -1, 681, 682, -1, - 32, 14, 15, 16, -1, 1, 690, 3, 4, 5, - 6, 7, 8, 87, 10, 11, -1, 13, 14, 15, - 16, 17, -1, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, - 36, 37, 38, 39, 40, 41, -1, -1, -1, 1, - -1, 47, 4, -1, 50, 7, 8, -1, 742, 55, - 56, 57, 14, 15, 16, 61, 62, -1, -1, 12, - 66, -1, -1, -1, -1, -1, 760, -1, 30, 763, - 32, 765, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 87, 88, 89, 90, -1, -1, 93, -1, 42, - 43, 44, -1, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, -1, 1, -1, - 3, 4, 5, 6, 7, 8, 810, 10, 11, 813, - 13, 14, 15, 16, 17, -1, 19, 20, 21, 22, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 94, 35, 36, 37, 38, 39, 40, 41, 1, - -1, 3, -1, -1, 47, -1, -1, 50, 10, 11, - -1, 13, 55, 56, 57, -1, -1, -1, 61, 62, - -1, -1, -1, 66, -1, -1, -1, -1, -1, 31, - -1, 33, -1, 35, 36, 37, 38, 39, 40, 41, - -1, 43, -1, -1, 87, 47, 89, 90, 50, -1, - 93, -1, -1, 55, 56, 57, -1, -1, -1, 61, - 62, -1, -1, 65, 66, 67, 1, -1, 3, -1, - -1, -1, -1, -1, -1, 10, 11, -1, 13, -1, - -1, -1, 4, 5, 6, 7, 8, 89, 90, -1, - 12, 93, 14, 15, 16, -1, 31, -1, 33, -1, - 35, 36, 37, 38, 39, 40, 41, 1, 30, 3, - 32, -1, 47, -1, -1, 50, 10, 11, -1, 13, - 55, 56, 57, -1, -1, -1, 61, 62, -1, -1, - -1, 66, -1, -1, -1, -1, -1, 31, -1, 33, - -1, 35, 36, 37, 38, 39, 40, 41, -1, -1, - -1, -1, -1, 47, 89, 90, 50, -1, 93, -1, - -1, 55, 56, 57, -1, -1, -1, 61, 62, -1, - -1, -1, 66, 1, -1, -1, 4, 5, 6, 7, - 8, 4, 5, 6, 7, 8, 14, 15, 16, -1, - 3, 14, 15, 16, -1, 89, 90, 10, 11, 93, - 13, 29, 30, -1, 32, -1, -1, 30, -1, 32, - -1, -1, -1, -1, -1, 43, -1, -1, 31, -1, - 33, -1, 35, 36, 37, 38, 39, 40, 41, -1, - -1, -1, -1, -1, 47, -1, -1, 50, 66, 67, - -1, -1, 55, 56, 57, -1, -1, -1, 61, 62, - 3, -1, -1, 66, -1, -1, -1, 10, 11, 87, - 13, -1, -1, 91, -1, 93, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 89, 90, 31, -1, - 33, 94, 35, 36, 37, 38, 39, 40, 41, 4, - 5, 6, 7, 8, 47, -1, -1, 50, -1, 14, - 15, 16, 55, 56, 57, -1, -1, -1, 61, 62, - -1, -1, -1, 66, -1, 30, -1, 32, -1, -1, - -1, 5, 6, 7, 8, -1, -1, -1, -1, -1, - 14, 15, 16, -1, -1, -1, 89, 90, -1, -1, - -1, 94, 3, 4, 5, 6, 7, 8, 32, 10, - 11, -1, 13, 14, 15, 16, 17, -1, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, -1, 35, 36, 37, 38, 39, 40, - 41, 4, 5, 6, 7, 8, 47, -1, -1, 50, - -1, 14, 15, 16, 55, 56, 57, -1, -1, -1, - 61, 62, -1, -1, -1, 66, -1, 30, -1, 32, - 5, 6, 7, 8, -1, -1, -1, 3, 4, 14, - 15, 16, -1, -1, 10, 11, 87, 13, 89, 90, - -1, 17, 93, 19, 20, 21, 22, 23, 24, 25, - 26, 27, 28, 29, -1, 31, -1, 33, -1, 35, - 36, 37, 38, 39, 40, 41, -1, -1, 3, -1, - -1, 47, -1, -1, 50, 10, 11, -1, 13, 55, - 56, 57, -1, -1, -1, 61, 62, -1, -1, -1, - 66, -1, -1, -1, -1, -1, 31, -1, 33, -1, - 35, 36, 37, 38, 39, 40, 41, -1, -1, -1, - -1, 87, 47, 89, 90, 50, -1, 93, -1, -1, - 55, 56, 57, -1, -1, 4, 61, 62, 7, 8, - 1, 66, 3, -1, -1, 14, 15, 16, -1, 10, - 11, -1, 13, -1, -1, -1, -1, -1, -1, -1, - -1, 30, -1, 32, 89, 90, -1, -1, 93, -1, - 31, -1, 33, -1, 35, 36, 37, 38, 39, 40, - 41, -1, -1, -1, -1, -1, 47, -1, -1, 50, - -1, -1, -1, -1, 55, 56, 57, -1, -1, -1, - 61, 62, -1, -1, -1, 66, 3, 4, 5, 6, - 7, 8, -1, 10, 11, -1, 13, 14, 15, 16, - 4, 5, 6, 7, 8, -1, -1, -1, 89, 90, - 14, 15, 16, 30, 31, 32, 33, -1, 35, 36, - 37, 38, 39, 40, 41, -1, 30, -1, 32, -1, - 47, -1, -1, 50, -1, -1, -1, -1, 55, 56, - 57, -1, -1, -1, 61, 62, -1, 3, 4, 66, - -1, 7, 8, -1, 10, 11, -1, 13, 14, 15, - 16, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 89, 90, 30, 31, 32, 33, -1, 35, - 36, 37, 38, 39, 40, 41, -1, -1, 3, -1, - -1, 47, -1, -1, 50, 10, 11, -1, 13, 55, - 56, 57, -1, -1, -1, 61, 62, -1, -1, -1, - 66, -1, -1, -1, -1, -1, 31, -1, 33, -1, - 35, 36, 37, 38, 39, 40, 41, -1, -1, 3, - -1, -1, 47, 89, 90, 50, 10, 11, -1, 13, - 55, 56, 57, -1, -1, -1, 61, 62, -1, -1, - -1, 66, -1, -1, -1, -1, -1, 31, -1, 33, - -1, 35, 36, 37, 38, 39, 40, 41, -1, -1, - 3, -1, 87, 47, 89, 90, 50, 10, 11, -1, - 13, 55, 56, 57, -1, -1, -1, 61, 62, -1, - -1, -1, 66, -1, -1, -1, -1, -1, 31, -1, - 33, -1, 35, 36, 37, 38, 39, 40, 41, -1, - -1, 3, -1, -1, 47, 89, 90, 50, 10, 11, - -1, 13, 55, 56, 57, -1, -1, -1, 61, 62, - -1, -1, -1, 66, -1, -1, -1, -1, -1, 31, - -1, 33, -1, 35, 36, 37, 38, 39, 40, 41, - -1, -1, 3, -1, -1, 47, 89, 90, 50, 10, - 11, -1, 13, 55, 56, 57, -1, -1, -1, 61, - 62, -1, -1, -1, 66, -1, -1, -1, -1, -1, - 31, -1, 33, -1, 35, 36, 37, 38, 39, 40, - 41, -1, -1, -1, -1, -1, 47, 89, 90, 50, - -1, -1, -1, -1, 55, 56, 57, -1, -1, -1, - 61, 62, 42, 43, 44, 66, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - -1, -1, -1, -1, -1, -1, -1, -1, 89, 90, - 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, -1, -1, - -1, 42, 43, 44, 94, 46, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 42, - 43, 44, 94, 46, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, 59, -1, -1, -1, - 42, 43, 44, 94, 46, 47, 48, 49, 50, 51, - 52, 53, 54, 55, 56, 57, 58, 59, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 42, 43, - 44, 94, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, -1, 42, 43, 44, - 92, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, -1, -1, 12, -1, -1, - -1, -1, -1, -1, 42, 43, 44, 91, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, -1, -1, -1, -1, 91, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 4, -1, -1, 7, 8, - -1, -1, -1, 91, -1, 14, 15, 16, 4, -1, - -1, 7, 8, -1, -1, -1, -1, -1, 14, 15, - 16, 30, -1, 32, -1, -1, -1, 32, -1, -1, - -1, -1, -1, -1, 30, -1, 32, 42, 43, 44, - -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, 59, 5, 6, 7, 8, 4, - 5, 6, 7, 8, 14, 15, 16, -1, -1, 14, - 15, 16, -1, -1, -1, -1, 4, 5, 6, 7, - 8, -1, 32, -1, -1, 30, 14, 15, 16, 4, - 5, 6, 7, 8, 4, 5, 6, 7, 8, 14, - 15, 16, 30, -1, 14, 15, 16, 4, -1, -1, - 7, 8, -1, -1, -1, 30, -1, 14, 15, 16, - 30, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 30, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, 59, 42, 43, 44, -1, 46, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, - 44, -1, 46, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, 59, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, 59 -}; -/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ -#line 3 "/usr/share/bison/bison.simple" - -/* Skeleton output parser for bison, - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software - Foundation, Inc. - - 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, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -/* As a special exception, when this file is copied by Bison into a - Bison output file, you may use that output file without restriction. - This special exception was added by the Free Software Foundation - in version 1.24 of Bison. */ - -/* This is the parser code that is written into each bison parser when - the %semantic_parser declaration is not specified in the grammar. - It was written by Richard Stallman by simplifying the hairy parser - used when %semantic_parser is specified. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# if YYSTACK_USE_ALLOCA -# define YYSTACK_ALLOC alloca -# else -# ifndef YYSTACK_USE_ALLOCA -# if defined (alloca) || defined (_ALLOCA_H) -# define YYSTACK_ALLOC alloca -# else -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# endif -# endif -# endif -# endif - -# ifdef YYSTACK_ALLOC - /* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) -# else -# if defined (__STDC__) || defined (__cplusplus) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# endif -# define YYSTACK_ALLOC malloc -# define YYSTACK_FREE free -# endif -#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ - - -#if (! defined (yyoverflow) \ - && (! defined (__cplusplus) \ - || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union yyalloc -{ - short yyss; - YYSTYPE yyvs; -# if YYLSP_NEEDED - YYLTYPE yyls; -# endif -}; - -/* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -# if YYLSP_NEEDED -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ - + 2 * YYSTACK_GAP_MAX) -# else -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAX) -# endif - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - register YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ - while (0) -# endif -# endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -# define YYSTACK_RELOCATE(Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ - yyptr += yynewbytes / sizeof (*yyptr); \ - } \ - while (0) - -#endif - - -#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) -# define YYSIZE_T __SIZE_TYPE__ -#endif -#if ! defined (YYSIZE_T) && defined (size_t) -# define YYSIZE_T size_t -#endif -#if ! defined (YYSIZE_T) -# if defined (__STDC__) || defined (__cplusplus) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# endif -#endif -#if ! defined (YYSIZE_T) -# define YYSIZE_T unsigned int -#endif - -#define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) -#define YYEMPTY -2 -#define YYEOF 0 -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrlab1 -/* Like YYERROR except do call yyerror. This remains here temporarily - to ease the transition to the new meaning of YYERROR, for GCC. - Once GCC version 2 has supplanted version 1, this can go. */ -#define YYFAIL goto yyerrlab -#define YYRECOVERING() (!!yyerrstatus) -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY && yylen == 1) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - yychar1 = YYTRANSLATE (yychar); \ - YYPOPSTACK; \ - goto yybackup; \ - } \ - else \ - { \ - yyerror ("syntax error: cannot back up"); \ - YYERROR; \ - } \ -while (0) - -#define YYTERROR 1 -#define YYERRCODE 256 - - -/* YYLLOC_DEFAULT -- Compute the default location (before the actions - are run). - - When YYLLOC_DEFAULT is run, CURRENT is set the location of the - first token. By default, to implement support for ranges, extend - its range to the last symbol. */ - -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - Current.last_line = Rhs[N].last_line; \ - Current.last_column = Rhs[N].last_column; -#endif - - -/* YYLEX -- calling `yylex' with the right arguments. */ - -#if YYPURE -# if YYLSP_NEEDED -# ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) -# else -# define YYLEX yylex (&yylval, &yylloc) -# endif -# else /* !YYLSP_NEEDED */ -# ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, YYLEX_PARAM) -# else -# define YYLEX yylex (&yylval) -# endif -# endif /* !YYLSP_NEEDED */ -#else /* !YYPURE */ -# define YYLEX yylex () -#endif /* !YYPURE */ - - -/* Enable debugging if requested. */ -#if YYDEBUG - -# ifndef YYFPRINTF -# include /* INFRINGES ON USER NAME SPACE */ -# define YYFPRINTF fprintf -# endif - -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (0) -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int yydebug; -#else /* !YYDEBUG */ -# define YYDPRINTF(Args) -#endif /* !YYDEBUG */ - -/* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH -# define YYINITDEPTH 200 -#endif - -/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only - if the built-in stack extension method is used). - - Do not make this value too large; the results are undefined if - SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) - evaluated with infinite-precision integer arithmetic. */ - -#if YYMAXDEPTH == 0 -# undef YYMAXDEPTH -#endif - -#ifndef YYMAXDEPTH -# define YYMAXDEPTH 10000 -#endif - -#ifdef YYERROR_VERBOSE - -# ifndef yystrlen -# if defined (__GLIBC__) && defined (_STRING_H) -# define yystrlen strlen -# else -/* Return the length of YYSTR. */ -static YYSIZE_T -# if defined (__STDC__) || defined (__cplusplus) -yystrlen (const char *yystr) -# else -yystrlen (yystr) - const char *yystr; -# endif -{ - register const char *yys = yystr; - - while (*yys++ != '\0') - continue; - - return yys - yystr - 1; -} -# endif -# endif - -# ifndef yystpcpy -# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) -# define yystpcpy stpcpy -# else -/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in - YYDEST. */ -static char * -# if defined (__STDC__) || defined (__cplusplus) -yystpcpy (char *yydest, const char *yysrc) -# else -yystpcpy (yydest, yysrc) - char *yydest; - const char *yysrc; -# endif -{ - register char *yyd = yydest; - register const char *yys = yysrc; - - while ((*yyd++ = *yys++) != '\0') - continue; - - return yyd - 1; -} -# endif -# endif -#endif - -#line 315 "/usr/share/bison/bison.simple" - - -/* The user can define YYPARSE_PARAM as the name of an argument to be passed - into yyparse. The argument should have type void *. - It should actually point to an object. - Grammar actions can access the variable by casting it - to the proper pointer type. */ - -#ifdef YYPARSE_PARAM -# if defined (__STDC__) || defined (__cplusplus) -# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM -# define YYPARSE_PARAM_DECL -# else -# define YYPARSE_PARAM_ARG YYPARSE_PARAM -# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; -# endif -#else /* !YYPARSE_PARAM */ -# define YYPARSE_PARAM_ARG -# define YYPARSE_PARAM_DECL -#endif /* !YYPARSE_PARAM */ - -/* Prevent warning if -Wstrict-prototypes. */ -#ifdef __GNUC__ -# ifdef YYPARSE_PARAM -int yyparse (void *); -# else -int yyparse (void); -# endif -#endif - -/* YY_DECL_VARIABLES -- depending whether we use a pure parser, - variables are global, or local to YYPARSE. */ - -#define YY_DECL_NON_LSP_VARIABLES \ -/* The lookahead symbol. */ \ -int yychar; \ - \ -/* The semantic value of the lookahead symbol. */ \ -YYSTYPE yylval; \ - \ -/* Number of parse errors so far. */ \ -int yynerrs; - -#if YYLSP_NEEDED -# define YY_DECL_VARIABLES \ -YY_DECL_NON_LSP_VARIABLES \ - \ -/* Location data for the lookahead symbol. */ \ -YYLTYPE yylloc; -#else -# define YY_DECL_VARIABLES \ -YY_DECL_NON_LSP_VARIABLES -#endif - - -/* If nonreentrant, generate the variables here. */ - -#if !YYPURE -YY_DECL_VARIABLES -#endif /* !YYPURE */ - -int -yyparse (YYPARSE_PARAM_ARG) - YYPARSE_PARAM_DECL -{ - /* If reentrant, generate the variables here. */ -#if YYPURE - YY_DECL_VARIABLES -#endif /* !YYPURE */ - - register int yystate; - register int yyn; - int yyresult; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus; - /* Lookahead token as an internal (translated) token number. */ - int yychar1 = 0; - - /* Three stacks and their tools: - `yyss': related to states, - `yyvs': related to semantic values, - `yyls': related to locations. - - Refer to the stacks thru separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* The state stack. */ - short yyssa[YYINITDEPTH]; - short *yyss = yyssa; - register short *yyssp; - - /* The semantic value stack. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs = yyvsa; - register YYSTYPE *yyvsp; - -#if YYLSP_NEEDED - /* The location stack. */ - YYLTYPE yylsa[YYINITDEPTH]; - YYLTYPE *yyls = yylsa; - YYLTYPE *yylsp; -#endif - -#if YYLSP_NEEDED -# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) -#else -# define YYPOPSTACK (yyvsp--, yyssp--) -#endif - - YYSIZE_T yystacksize = YYINITDEPTH; - - - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; -#if YYLSP_NEEDED - YYLTYPE yyloc; -#endif - - /* When reducing, the number of symbols on the RHS of the reduced - rule. */ - int yylen; - - YYDPRINTF ((stderr, "Starting parse\n")); - - yystate = 0; - yyerrstatus = 0; - yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */ - - /* Initialize stack pointers. - Waste one element of value and location stack - so that they stay on the same level as the state stack. - The wasted elements are never initialized. */ - - yyssp = yyss; - yyvsp = yyvs; -#if YYLSP_NEEDED - yylsp = yyls; -#endif - goto yysetstate; - -/*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | -`------------------------------------------------------------*/ - yynewstate: - /* In all cases, when you get here, the value and location stacks - have just been pushed. so pushing a state here evens the stacks. - */ - yyssp++; - - yysetstate: - *yyssp = yystate; - - if (yyssp >= yyss + yystacksize - 1) - { - /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; - -#ifdef yyoverflow - { - /* Give user a chance to reallocate the stack. Use copies of - these so that the &'s don't force the real ones into - memory. */ - YYSTYPE *yyvs1 = yyvs; - short *yyss1 = yyss; - - /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. */ -# if YYLSP_NEEDED - YYLTYPE *yyls1 = yyls; - /* This used to be a conditional around just the two extra args, - but that might be undefined if yyoverflow is a macro. */ - yyoverflow ("parser stack overflow", - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - &yyls1, yysize * sizeof (*yylsp), - &yystacksize); - yyls = yyls1; -# else - yyoverflow ("parser stack overflow", - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - &yystacksize); -# endif - yyss = yyss1; - yyvs = yyvs1; - } -#else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyoverflowlab; -# else - /* Extend the stack our own way. */ - if (yystacksize >= YYMAXDEPTH) - goto yyoverflowlab; - yystacksize *= 2; - if (yystacksize > YYMAXDEPTH) - yystacksize = YYMAXDEPTH; - - { - short *yyss1 = yyss; - union yyalloc *yyptr = - (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); - if (! yyptr) - goto yyoverflowlab; - YYSTACK_RELOCATE (yyss); - YYSTACK_RELOCATE (yyvs); -# if YYLSP_NEEDED - YYSTACK_RELOCATE (yyls); -# endif -# undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE (yyss1); - } -# endif -#endif /* no yyoverflow */ - - yyssp = yyss + yysize - 1; - yyvsp = yyvs + yysize - 1; -#if YYLSP_NEEDED - yylsp = yyls + yysize - 1; -#endif - - YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); - - if (yyssp >= yyss + yystacksize - 1) - YYABORT; - } - - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); - - goto yybackup; - - -/*-----------. -| yybackup. | -`-----------*/ -yybackup: - -/* Do appropriate processing given the current state. */ -/* Read a lookahead token if we need one and don't already have one. */ -/* yyresume: */ - - /* First try to decide what to do without reference to lookahead token. */ - - yyn = yypact[yystate]; - if (yyn == YYFLAG) - goto yydefault; - - /* Not known => get a lookahead token if don't already have one. */ - - /* yychar is either YYEMPTY or YYEOF - or a valid token in external form. */ - - if (yychar == YYEMPTY) - { - YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; - } - - /* Convert token to internal form (in yychar1) for indexing tables with */ - - if (yychar <= 0) /* This means end of input. */ - { - yychar1 = 0; - yychar = YYEOF; /* Don't call YYLEX any more */ - - YYDPRINTF ((stderr, "Now at end of input.\n")); - } - else - { - yychar1 = YYTRANSLATE (yychar); - -#if YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables - which are defined only if `YYDEBUG' is set. */ - if (yydebug) - { - YYFPRINTF (stderr, "Next token is %d (%s", - yychar, yytname[yychar1]); - /* Give the individual parser a way to print the precise - meaning of a token, for further debugging info. */ -# ifdef YYPRINT - YYPRINT (stderr, yychar, yylval); -# endif - YYFPRINTF (stderr, ")\n"); - } -#endif - } - - yyn += yychar1; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) - goto yydefault; - - yyn = yytable[yyn]; - - /* yyn is what to do for this token type in this state. - Negative => reduce, -yyn is rule number. - Positive => shift, yyn is new state. - New state is final state => don't bother to shift, - just return success. - 0, or most negative number => error. */ - - if (yyn < 0) - { - if (yyn == YYFLAG) - goto yyerrlab; - yyn = -yyn; - goto yyreduce; - } - else if (yyn == 0) - goto yyerrlab; - - if (yyn == YYFINAL) - YYACCEPT; - - /* Shift the lookahead token. */ - YYDPRINTF ((stderr, "Shifting token %d (%s), ", - yychar, yytname[yychar1])); - - /* Discard the token being shifted unless it is eof. */ - if (yychar != YYEOF) - yychar = YYEMPTY; - - *++yyvsp = yylval; -#if YYLSP_NEEDED - *++yylsp = yylloc; -#endif - - /* Count tokens shifted since error; after three, turn off error - status. */ - if (yyerrstatus) - yyerrstatus--; - - yystate = yyn; - goto yynewstate; - - -/*-----------------------------------------------------------. -| yydefault -- do the default action for the current state. | -`-----------------------------------------------------------*/ -yydefault: - yyn = yydefact[yystate]; - if (yyn == 0) - goto yyerrlab; - goto yyreduce; - - -/*-----------------------------. -| yyreduce -- Do a reduction. | -`-----------------------------*/ -yyreduce: - /* yyn is the number of a rule to reduce with. */ - yylen = yyr2[yyn]; - - /* If YYLEN is nonzero, implement the default value of the action: - `$$ = $1'. - - Otherwise, the following line sets YYVAL to the semantic value of - the lookahead token. This behavior is undocumented and Bison - users should not rely upon it. Assigning to YYVAL - unconditionally makes the parser a bit smaller, and it avoids a - GCC warning that YYVAL may be used uninitialized. */ - yyval = yyvsp[1-yylen]; - -#if YYLSP_NEEDED - /* Similarly for the default location. Let the user run additional - commands if for instance locations are ranges. */ - yyloc = yylsp[1-yylen]; - YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); -#endif - -#if YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables which - are defined only if `YYDEBUG' is set. */ - if (yydebug) - { - int yyi; - - YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", - yyn, yyrline[yyn]); - - /* Print the symbols being reduced, and their result. */ - for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) - YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); - YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); - } -#endif - - switch (yyn) { - -case 1: -#line 342 "c-parse.y" -{ if (pedantic) - pedwarn ("ISO C forbids an empty source file"); - ; - break;} -case 3: -#line 353 "c-parse.y" -{ yyval.dsptype = NULL; ; - break;} -case 4: -#line 354 "c-parse.y" -{ obstack_free (&parser_obstack, yyvsp[-2].otype); ; - break;} -case 5: -#line 356 "c-parse.y" -{ yyval.dsptype = NULL; ggc_collect (); ; - break;} -case 6: -#line 357 "c-parse.y" -{ obstack_free (&parser_obstack, yyvsp[-2].otype); ; - break;} -case 10: -#line 365 "c-parse.y" -{ RESTORE_EXT_FLAGS (yyvsp[-1].itype); ; - break;} -case 11: -#line 371 "c-parse.y" -{ yyval.otype = obstack_alloc (&parser_obstack, 0); ; - break;} -case 12: -#line 376 "c-parse.y" -{ pedwarn ("data definition has no type or storage class"); - POP_DECLSPEC_STACK; ; - break;} -case 13: -#line 379 "c-parse.y" -{ POP_DECLSPEC_STACK; ; - break;} -case 14: -#line 381 "c-parse.y" -{ POP_DECLSPEC_STACK; ; - break;} -case 15: -#line 383 "c-parse.y" -{ shadow_tag (finish_declspecs (yyvsp[-1].dsptype)); ; - break;} -case 18: -#line 387 "c-parse.y" -{ if (pedantic) - pedwarn ("ISO C does not allow extra %<;%> outside of a function"); ; - break;} -case 19: -#line 393 "c-parse.y" -{ if (!start_function (current_declspecs, yyvsp[0].dtrtype, - all_prefix_attributes)) - YYERROR1; - ; - break;} -case 20: -#line 398 "c-parse.y" -{ DECL_SOURCE_LOCATION (current_function_decl) = yyvsp[0].location; - store_parm_decls (); ; - break;} -case 21: -#line 401 "c-parse.y" -{ finish_function (); - POP_DECLSPEC_STACK; ; - break;} -case 22: -#line 404 "c-parse.y" -{ POP_DECLSPEC_STACK; ; - break;} -case 23: -#line 406 "c-parse.y" -{ if (!start_function (current_declspecs, yyvsp[0].dtrtype, - all_prefix_attributes)) - YYERROR1; - ; - break;} -case 24: -#line 411 "c-parse.y" -{ DECL_SOURCE_LOCATION (current_function_decl) = yyvsp[0].location; - store_parm_decls (); ; - break;} -case 25: -#line 414 "c-parse.y" -{ finish_function (); - POP_DECLSPEC_STACK; ; - break;} -case 26: -#line 417 "c-parse.y" -{ POP_DECLSPEC_STACK; ; - break;} -case 27: -#line 419 "c-parse.y" -{ if (!start_function (current_declspecs, yyvsp[0].dtrtype, - all_prefix_attributes)) - YYERROR1; - ; - break;} -case 28: -#line 424 "c-parse.y" -{ DECL_SOURCE_LOCATION (current_function_decl) = yyvsp[0].location; - store_parm_decls (); ; - break;} -case 29: -#line 427 "c-parse.y" -{ finish_function (); - POP_DECLSPEC_STACK; ; - break;} -case 30: -#line 430 "c-parse.y" -{ POP_DECLSPEC_STACK; ; - break;} -case 33: -#line 439 "c-parse.y" -{ yyval.code = ADDR_EXPR; ; - break;} -case 34: -#line 441 "c-parse.y" -{ yyval.code = NEGATE_EXPR; ; - break;} -case 35: -#line 443 "c-parse.y" -{ yyval.code = CONVERT_EXPR; - if (warn_traditional && !in_system_header) - warning ("traditional C rejects the unary plus operator"); - ; - break;} -case 36: -#line 448 "c-parse.y" -{ yyval.code = PREINCREMENT_EXPR; ; - break;} -case 37: -#line 450 "c-parse.y" -{ yyval.code = PREDECREMENT_EXPR; ; - break;} -case 38: -#line 452 "c-parse.y" -{ yyval.code = BIT_NOT_EXPR; ; - break;} -case 39: -#line 454 "c-parse.y" -{ yyval.code = TRUTH_NOT_EXPR; ; - break;} -case 41: -#line 459 "c-parse.y" -{ yyval.exprtype.value = build_compound_expr (yyvsp[-2].exprtype.value, yyvsp[0].exprtype.value); - yyval.exprtype.original_code = COMPOUND_EXPR; ; - break;} -case 42: -#line 465 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 44: -#line 471 "c-parse.y" -{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].exprtype.value); ; - break;} -case 45: -#line 473 "c-parse.y" -{ chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].exprtype.value)); ; - break;} -case 47: -#line 479 "c-parse.y" -{ yyval.exprtype.value = build_indirect_ref (yyvsp[0].exprtype.value, "unary *"); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 48: -#line 483 "c-parse.y" -{ yyval.exprtype = yyvsp[0].exprtype; - RESTORE_EXT_FLAGS (yyvsp[-1].itype); ; - break;} -case 49: -#line 486 "c-parse.y" -{ yyval.exprtype.value = build_unary_op (yyvsp[-1].code, yyvsp[0].exprtype.value, 0); - overflow_warning (yyval.exprtype.value); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 50: -#line 491 "c-parse.y" -{ yyval.exprtype.value = finish_label_address_expr (yyvsp[0].ttype); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 51: -#line 494 "c-parse.y" -{ skip_evaluation--; - in_sizeof--; - if (TREE_CODE (yyvsp[0].exprtype.value) == COMPONENT_REF - && DECL_C_BIT_FIELD (TREE_OPERAND (yyvsp[0].exprtype.value, 1))) - error ("% applied to a bit-field"); - yyval.exprtype = c_expr_sizeof_expr (yyvsp[0].exprtype); ; - break;} -case 52: -#line 501 "c-parse.y" -{ skip_evaluation--; - in_sizeof--; - yyval.exprtype = c_expr_sizeof_type (yyvsp[-1].typenametype); ; - break;} -case 53: -#line 505 "c-parse.y" -{ skip_evaluation--; - in_alignof--; - yyval.exprtype.value = c_alignof_expr (yyvsp[0].exprtype.value); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 54: -#line 510 "c-parse.y" -{ skip_evaluation--; - in_alignof--; - yyval.exprtype.value = c_alignof (groktypename (yyvsp[-1].typenametype)); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 55: -#line 515 "c-parse.y" -{ yyval.exprtype.value = build_unary_op (REALPART_EXPR, yyvsp[0].exprtype.value, 0); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 56: -#line 518 "c-parse.y" -{ yyval.exprtype.value = build_unary_op (IMAGPART_EXPR, yyvsp[0].exprtype.value, 0); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 57: -#line 523 "c-parse.y" -{ skip_evaluation++; in_sizeof++; ; - break;} -case 58: -#line 527 "c-parse.y" -{ skip_evaluation++; in_alignof++; ; - break;} -case 59: -#line 531 "c-parse.y" -{ skip_evaluation++; in_typeof++; ; - break;} -case 61: -#line 537 "c-parse.y" -{ yyval.exprtype.value = c_cast_expr (yyvsp[-2].typenametype, yyvsp[0].exprtype.value); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 63: -#line 544 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 64: -#line 546 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 65: -#line 548 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 66: -#line 550 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 67: -#line 552 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 68: -#line 554 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 69: -#line 556 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 70: -#line 558 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 71: -#line 560 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 72: -#line 562 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 73: -#line 564 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 74: -#line 566 "c-parse.y" -{ yyval.exprtype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].exprtype, yyvsp[0].exprtype); ; - break;} -case 75: -#line 568 "c-parse.y" -{ yyvsp[-1].exprtype.value = lang_hooks.truthvalue_conversion - (default_conversion (yyvsp[-1].exprtype.value)); - skip_evaluation += yyvsp[-1].exprtype.value == truthvalue_false_node; ; - break;} -case 76: -#line 572 "c-parse.y" -{ skip_evaluation -= yyvsp[-3].exprtype.value == truthvalue_false_node; - yyval.exprtype = parser_build_binary_op (TRUTH_ANDIF_EXPR, yyvsp[-3].exprtype, yyvsp[0].exprtype); ; - break;} -case 77: -#line 575 "c-parse.y" -{ yyvsp[-1].exprtype.value = lang_hooks.truthvalue_conversion - (default_conversion (yyvsp[-1].exprtype.value)); - skip_evaluation += yyvsp[-1].exprtype.value == truthvalue_true_node; ; - break;} -case 78: -#line 579 "c-parse.y" -{ skip_evaluation -= yyvsp[-3].exprtype.value == truthvalue_true_node; - yyval.exprtype = parser_build_binary_op (TRUTH_ORIF_EXPR, yyvsp[-3].exprtype, yyvsp[0].exprtype); ; - break;} -case 79: -#line 582 "c-parse.y" -{ yyvsp[-1].exprtype.value = lang_hooks.truthvalue_conversion - (default_conversion (yyvsp[-1].exprtype.value)); - skip_evaluation += yyvsp[-1].exprtype.value == truthvalue_false_node; ; - break;} -case 80: -#line 586 "c-parse.y" -{ skip_evaluation += ((yyvsp[-4].exprtype.value == truthvalue_true_node) - - (yyvsp[-4].exprtype.value == truthvalue_false_node)); ; - break;} -case 81: -#line 589 "c-parse.y" -{ skip_evaluation -= yyvsp[-6].exprtype.value == truthvalue_true_node; - yyval.exprtype.value = build_conditional_expr (yyvsp[-6].exprtype.value, yyvsp[-3].exprtype.value, - yyvsp[0].exprtype.value); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 82: -#line 594 "c-parse.y" -{ if (pedantic) - pedwarn ("ISO C forbids omitting the middle term of a ?: expression"); - /* Make sure first operand is calculated only once. */ - yyvsp[0].ttype = save_expr (default_conversion (yyvsp[-1].exprtype.value)); - yyvsp[-1].exprtype.value = lang_hooks.truthvalue_conversion (yyvsp[0].ttype); - skip_evaluation += yyvsp[-1].exprtype.value == truthvalue_true_node; ; - break;} -case 83: -#line 601 "c-parse.y" -{ skip_evaluation -= yyvsp[-4].exprtype.value == truthvalue_true_node; - yyval.exprtype.value = build_conditional_expr (yyvsp[-4].exprtype.value, yyvsp[-3].ttype, - yyvsp[0].exprtype.value); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 84: -#line 606 "c-parse.y" -{ yyval.exprtype.value = build_modify_expr (yyvsp[-2].exprtype.value, NOP_EXPR, yyvsp[0].exprtype.value); - yyval.exprtype.original_code = MODIFY_EXPR; - ; - break;} -case 85: -#line 610 "c-parse.y" -{ yyval.exprtype.value = build_modify_expr (yyvsp[-2].exprtype.value, yyvsp[-1].code, yyvsp[0].exprtype.value); - TREE_NO_WARNING (yyval.exprtype.value) = 1; - yyval.exprtype.original_code = ERROR_MARK; - ; - break;} -case 86: -#line 618 "c-parse.y" -{ - if (yychar == YYEMPTY) - yychar = YYLEX; - yyval.exprtype.value = build_external_ref (yyvsp[0].ttype, yychar == '('); - yyval.exprtype.original_code = ERROR_MARK; - ; - break;} -case 87: -#line 625 "c-parse.y" -{ yyval.exprtype.value = yyvsp[0].ttype; yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 88: -#line 627 "c-parse.y" -{ yyval.exprtype.value = yyvsp[0].ttype; yyval.exprtype.original_code = STRING_CST; ; - break;} -case 89: -#line 629 "c-parse.y" -{ yyval.exprtype.value = fname_decl (C_RID_CODE (yyvsp[0].ttype), yyvsp[0].ttype); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 90: -#line 632 "c-parse.y" -{ start_init (NULL_TREE, NULL, 0); - yyval.ttype = groktypename (yyvsp[-2].typenametype); - if (C_TYPE_VARIABLE_SIZE (yyval.ttype)) - { - error ("compound literal has variable size"); - yyval.ttype = error_mark_node; - } - really_start_incremental_init (yyval.ttype); ; - break;} -case 91: -#line 641 "c-parse.y" -{ struct c_expr init = pop_init_level (0); - tree constructor = init.value; - tree type = yyvsp[-2].ttype; - finish_init (); - maybe_warn_string_init (type, init); - - if (pedantic && !flag_isoc99) - pedwarn ("ISO C90 forbids compound literals"); - yyval.exprtype.value = build_compound_literal (type, constructor); - yyval.exprtype.original_code = ERROR_MARK; - ; - break;} -case 92: -#line 653 "c-parse.y" -{ yyval.exprtype.value = yyvsp[-1].exprtype.value; - if (TREE_CODE (yyval.exprtype.value) == MODIFY_EXPR) - TREE_NO_WARNING (yyval.exprtype.value) = 1; - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 93: -#line 658 "c-parse.y" -{ yyval.exprtype.value = error_mark_node; yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 94: -#line 660 "c-parse.y" -{ if (pedantic) - pedwarn ("ISO C forbids braced-groups within expressions"); - yyval.exprtype.value = c_finish_stmt_expr (yyvsp[-2].ttype); - yyval.exprtype.original_code = ERROR_MARK; - ; - break;} -case 95: -#line 666 "c-parse.y" -{ c_finish_stmt_expr (yyvsp[-2].ttype); - yyval.exprtype.value = error_mark_node; - yyval.exprtype.original_code = ERROR_MARK; - ; - break;} -case 96: -#line 671 "c-parse.y" -{ yyval.exprtype.value = build_function_call (yyvsp[-3].exprtype.value, yyvsp[-1].ttype); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 97: -#line 674 "c-parse.y" -{ yyval.exprtype.value = build_va_arg (yyvsp[-3].exprtype.value, groktypename (yyvsp[-1].typenametype)); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 98: -#line 678 "c-parse.y" -{ tree type = groktypename (yyvsp[-1].typenametype); - if (type == error_mark_node) - offsetof_base = error_mark_node; - else - offsetof_base = build1 (INDIRECT_REF, type, NULL); - ; - break;} -case 99: -#line 685 "c-parse.y" -{ yyval.exprtype.value = fold_offsetof (yyvsp[-1].ttype); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 100: -#line 688 "c-parse.y" -{ yyval.exprtype.value = error_mark_node; yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 101: -#line 691 "c-parse.y" -{ - tree c; - - c = fold (yyvsp[-5].exprtype.value); - STRIP_NOPS (c); - if (TREE_CODE (c) != INTEGER_CST) - error ("first argument to %<__builtin_choose_expr%> not" - " a constant"); - yyval.exprtype = integer_zerop (c) ? yyvsp[-1].exprtype : yyvsp[-3].exprtype; - ; - break;} -case 102: -#line 702 "c-parse.y" -{ yyval.exprtype.value = error_mark_node; yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 103: -#line 704 "c-parse.y" -{ - tree e1, e2; - - e1 = TYPE_MAIN_VARIANT (groktypename (yyvsp[-3].typenametype)); - e2 = TYPE_MAIN_VARIANT (groktypename (yyvsp[-1].typenametype)); - - yyval.exprtype.value = comptypes (e1, e2) - ? build_int_cst (NULL_TREE, 1) - : build_int_cst (NULL_TREE, 0); - yyval.exprtype.original_code = ERROR_MARK; - ; - break;} -case 104: -#line 716 "c-parse.y" -{ yyval.exprtype.value = error_mark_node; yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 105: -#line 718 "c-parse.y" -{ yyval.exprtype.value = build_array_ref (yyvsp[-3].exprtype.value, yyvsp[-1].exprtype.value); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 106: -#line 721 "c-parse.y" -{ yyval.exprtype.value = build_component_ref (yyvsp[-2].exprtype.value, yyvsp[0].ttype); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 107: -#line 724 "c-parse.y" -{ - tree expr = build_indirect_ref (yyvsp[-2].exprtype.value, "->"); - yyval.exprtype.value = build_component_ref (expr, yyvsp[0].ttype); - yyval.exprtype.original_code = ERROR_MARK; - ; - break;} -case 108: -#line 730 "c-parse.y" -{ yyval.exprtype.value = build_unary_op (POSTINCREMENT_EXPR, yyvsp[-1].exprtype.value, 0); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 109: -#line 733 "c-parse.y" -{ yyval.exprtype.value = build_unary_op (POSTDECREMENT_EXPR, yyvsp[-1].exprtype.value, 0); - yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 110: -#line 743 "c-parse.y" -{ yyval.ttype = build_component_ref (offsetof_base, yyvsp[0].ttype); ; - break;} -case 111: -#line 745 "c-parse.y" -{ yyval.ttype = build_component_ref (yyvsp[-2].ttype, yyvsp[0].ttype); ; - break;} -case 112: -#line 747 "c-parse.y" -{ yyval.ttype = build_array_ref (yyvsp[-3].ttype, yyvsp[-1].exprtype.value); ; - break;} -case 115: -#line 760 "c-parse.y" -{ ; - break;} -case 120: -#line 776 "c-parse.y" -{ POP_DECLSPEC_STACK; ; - break;} -case 121: -#line 778 "c-parse.y" -{ POP_DECLSPEC_STACK; ; - break;} -case 122: -#line 780 "c-parse.y" -{ shadow_tag_warned (finish_declspecs (yyvsp[-1].dsptype), 1); - pedwarn ("empty declaration"); ; - break;} -case 123: -#line 783 "c-parse.y" -{ pedwarn ("empty declaration"); ; - break;} -case 124: -#line 792 "c-parse.y" -{ ; - break;} -case 125: -#line 800 "c-parse.y" -{ pending_xref_error (); - PUSH_DECLSPEC_STACK; - if (yyvsp[0].dsptype) - { - prefix_attributes = yyvsp[0].dsptype->attrs; - yyvsp[0].dsptype->attrs = NULL_TREE; - current_declspecs = yyvsp[0].dsptype; - } - else - { - prefix_attributes = NULL_TREE; - current_declspecs = build_null_declspecs (); - } - current_declspecs = finish_declspecs (current_declspecs); - all_prefix_attributes = prefix_attributes; ; - break;} -case 126: -#line 821 "c-parse.y" -{ all_prefix_attributes = chainon (yyvsp[0].ttype, prefix_attributes); ; - break;} -case 127: -#line 826 "c-parse.y" -{ POP_DECLSPEC_STACK; ; - break;} -case 128: -#line 828 "c-parse.y" -{ POP_DECLSPEC_STACK; ; - break;} -case 129: -#line 830 "c-parse.y" -{ POP_DECLSPEC_STACK; ; - break;} -case 130: -#line 832 "c-parse.y" -{ POP_DECLSPEC_STACK; ; - break;} -case 131: -#line 834 "c-parse.y" -{ shadow_tag (finish_declspecs (yyvsp[-1].dsptype)); ; - break;} -case 132: -#line 836 "c-parse.y" -{ RESTORE_EXT_FLAGS (yyvsp[-1].itype); ; - break;} -case 133: -#line 882 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (build_null_declspecs (), yyvsp[0].ttype); ; - break;} -case 134: -#line 884 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 135: -#line 886 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 136: -#line 891 "c-parse.y" -{ yyval.dsptype = declspecs_add_attrs (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 137: -#line 896 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 138: -#line 898 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 139: -#line 903 "c-parse.y" -{ yyval.dsptype = declspecs_add_attrs (build_null_declspecs (), yyvsp[0].ttype); ; - break;} -case 140: -#line 905 "c-parse.y" -{ yyval.dsptype = declspecs_add_attrs (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 141: -#line 910 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (build_null_declspecs (), yyvsp[0].tstype); ; - break;} -case 142: -#line 912 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 143: -#line 914 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 144: -#line 916 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 145: -#line 918 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 146: -#line 920 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 147: -#line 922 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 148: -#line 927 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (build_null_declspecs (), yyvsp[0].tstype); ; - break;} -case 149: -#line 929 "c-parse.y" -{ yyval.dsptype = declspecs_add_attrs (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 150: -#line 931 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 151: -#line 933 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 152: -#line 935 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 153: -#line 937 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 154: -#line 942 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 155: -#line 944 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 156: -#line 946 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 157: -#line 948 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 158: -#line 950 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 159: -#line 952 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 160: -#line 957 "c-parse.y" -{ yyval.dsptype = declspecs_add_attrs (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 161: -#line 959 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 162: -#line 961 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 163: -#line 963 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 164: -#line 965 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 165: -#line 970 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (build_null_declspecs (), yyvsp[0].ttype); ; - break;} -case 166: -#line 972 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 167: -#line 974 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 168: -#line 976 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 169: -#line 978 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 170: -#line 980 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 171: -#line 982 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 172: -#line 987 "c-parse.y" -{ yyval.dsptype = declspecs_add_attrs (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 173: -#line 992 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 174: -#line 994 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 175: -#line 996 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 176: -#line 998 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 177: -#line 1000 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 178: -#line 1002 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 179: -#line 1007 "c-parse.y" -{ yyval.dsptype = declspecs_add_attrs (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 180: -#line 1012 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 181: -#line 1014 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 182: -#line 1016 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 183: -#line 1018 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 184: -#line 1020 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 185: -#line 1022 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 186: -#line 1024 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 187: -#line 1026 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 188: -#line 1028 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 189: -#line 1030 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 190: -#line 1035 "c-parse.y" -{ yyval.dsptype = declspecs_add_attrs (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 191: -#line 1037 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 192: -#line 1039 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 193: -#line 1041 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 194: -#line 1043 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 195: -#line 1048 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 196: -#line 1050 "c-parse.y" -{ yyval.dsptype = declspecs_add_qual (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 197: -#line 1052 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 198: -#line 1054 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 199: -#line 1056 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 200: -#line 1058 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 201: -#line 1060 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 202: -#line 1062 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 203: -#line 1064 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 204: -#line 1066 "c-parse.y" -{ yyval.dsptype = declspecs_add_scspec (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 205: -#line 1071 "c-parse.y" -{ yyval.dsptype = declspecs_add_attrs (yyvsp[-1].dsptype, yyvsp[0].ttype); ; - break;} -case 206: -#line 1073 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 207: -#line 1075 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 208: -#line 1077 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 209: -#line 1079 "c-parse.y" -{ yyval.dsptype = declspecs_add_type (yyvsp[-1].dsptype, yyvsp[0].tstype); ; - break;} -case 266: -#line 1166 "c-parse.y" -{ yyval.dsptype = NULL; ; - break;} -case 267: -#line 1168 "c-parse.y" -{ yyval.dsptype = yyvsp[0].dsptype; ; - break;} -case 271: -#line 1203 "c-parse.y" -{ OBJC_NEED_RAW_IDENTIFIER (1); - yyval.tstype.kind = ctsk_resword; - yyval.tstype.spec = yyvsp[0].ttype; ; - break;} -case 274: -#line 1215 "c-parse.y" -{ /* For a typedef name, record the meaning, not the name. - In case of `foo foo, bar;'. */ - yyval.tstype.kind = ctsk_typedef; - yyval.tstype.spec = lookup_name (yyvsp[0].ttype); ; - break;} -case 275: -#line 1220 "c-parse.y" -{ skip_evaluation--; - in_typeof--; - if (TREE_CODE (yyvsp[-1].exprtype.value) == COMPONENT_REF - && DECL_C_BIT_FIELD (TREE_OPERAND (yyvsp[-1].exprtype.value, 1))) - error ("% applied to a bit-field"); - yyval.tstype.kind = ctsk_typeof; - yyval.tstype.spec = TREE_TYPE (yyvsp[-1].exprtype.value); - pop_maybe_used (variably_modified_type_p (yyval.tstype.spec, - NULL_TREE)); ; - break;} -case 276: -#line 1230 "c-parse.y" -{ skip_evaluation--; - in_typeof--; - yyval.tstype.kind = ctsk_typeof; - yyval.tstype.spec = groktypename (yyvsp[-1].typenametype); - pop_maybe_used (variably_modified_type_p (yyval.tstype.spec, - NULL_TREE)); ; - break;} -case 281: -#line 1252 "c-parse.y" -{ yyval.ttype = start_decl (yyvsp[-3].dtrtype, current_declspecs, true, - chainon (yyvsp[-1].ttype, all_prefix_attributes)); - if (!yyval.ttype) - yyval.ttype = error_mark_node; - start_init (yyval.ttype, yyvsp[-2].ttype, global_bindings_p ()); ; - break;} -case 282: -#line 1259 "c-parse.y" -{ finish_init (); - if (yyvsp[-1].ttype != error_mark_node) - { - maybe_warn_string_init (TREE_TYPE (yyvsp[-1].ttype), yyvsp[0].exprtype); - finish_decl (yyvsp[-1].ttype, yyvsp[0].exprtype.value, yyvsp[-4].ttype); - } - ; - break;} -case 283: -#line 1267 "c-parse.y" -{ tree d = start_decl (yyvsp[-2].dtrtype, current_declspecs, false, - chainon (yyvsp[0].ttype, all_prefix_attributes)); - if (d) - finish_decl (d, NULL_TREE, yyvsp[-1].ttype); - ; - break;} -case 284: -#line 1276 "c-parse.y" -{ yyval.ttype = start_decl (yyvsp[-3].dtrtype, current_declspecs, true, - chainon (yyvsp[-1].ttype, all_prefix_attributes)); - if (!yyval.ttype) - yyval.ttype = error_mark_node; - start_init (yyval.ttype, yyvsp[-2].ttype, global_bindings_p ()); ; - break;} -case 285: -#line 1283 "c-parse.y" -{ finish_init (); - if (yyvsp[-1].ttype != error_mark_node) - { - maybe_warn_string_init (TREE_TYPE (yyvsp[-1].ttype), yyvsp[0].exprtype); - finish_decl (yyvsp[-1].ttype, yyvsp[0].exprtype.value, yyvsp[-4].ttype); - } - ; - break;} -case 286: -#line 1291 "c-parse.y" -{ tree d = start_decl (yyvsp[-2].dtrtype, current_declspecs, false, - chainon (yyvsp[0].ttype, all_prefix_attributes)); - if (d) - finish_decl (d, NULL_TREE, yyvsp[-1].ttype); ; - break;} -case 287: -#line 1300 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 288: -#line 1302 "c-parse.y" -{ yyval.ttype = yyvsp[0].ttype; ; - break;} -case 289: -#line 1307 "c-parse.y" -{ yyval.ttype = yyvsp[0].ttype; ; - break;} -case 290: -#line 1309 "c-parse.y" -{ yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype); ; - break;} -case 291: -#line 1315 "c-parse.y" -{ yyval.ttype = yyvsp[-3].ttype; ; - break;} -case 292: -#line 1317 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 293: -#line 1322 "c-parse.y" -{ yyval.ttype = yyvsp[0].ttype; ; - break;} -case 294: -#line 1324 "c-parse.y" -{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[0].ttype); ; - break;} -case 295: -#line 1329 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 296: -#line 1331 "c-parse.y" -{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); ; - break;} -case 297: -#line 1333 "c-parse.y" -{ yyval.ttype = build_tree_list (yyvsp[-3].ttype, build_tree_list (NULL_TREE, yyvsp[-1].ttype)); ; - break;} -case 298: -#line 1335 "c-parse.y" -{ yyval.ttype = build_tree_list (yyvsp[-5].ttype, tree_cons (NULL_TREE, yyvsp[-3].ttype, yyvsp[-1].ttype)); ; - break;} -case 299: -#line 1337 "c-parse.y" -{ yyval.ttype = build_tree_list (yyvsp[-3].ttype, yyvsp[-1].ttype); ; - break;} -case 306: -#line 1359 "c-parse.y" -{ yyval.exprtype = yyvsp[0].exprtype; ; - break;} -case 307: -#line 1361 "c-parse.y" -{ really_start_incremental_init (NULL_TREE); ; - break;} -case 308: -#line 1363 "c-parse.y" -{ yyval.exprtype = pop_init_level (0); ; - break;} -case 309: -#line 1365 "c-parse.y" -{ yyval.exprtype.value = error_mark_node; yyval.exprtype.original_code = ERROR_MARK; ; - break;} -case 310: -#line 1371 "c-parse.y" -{ if (pedantic) - pedwarn ("ISO C forbids empty initializer braces"); ; - break;} -case 314: -#line 1385 "c-parse.y" -{ if (pedantic && !flag_isoc99) - pedwarn ("ISO C90 forbids specifying subobject to initialize"); ; - break;} -case 315: -#line 1388 "c-parse.y" -{ if (pedantic) - pedwarn ("obsolete use of designated initializer without %<=%>"); ; - break;} -case 316: -#line 1391 "c-parse.y" -{ set_init_label (yyvsp[-1].ttype); - if (pedantic) - pedwarn ("obsolete use of designated initializer with %<:%>"); ; - break;} -case 317: -#line 1395 "c-parse.y" -{; - break;} -case 319: -#line 1401 "c-parse.y" -{ push_init_level (0); ; - break;} -case 320: -#line 1403 "c-parse.y" -{ process_init_element (pop_init_level (0)); ; - break;} -case 321: -#line 1405 "c-parse.y" -{ process_init_element (yyvsp[0].exprtype); ; - break;} -case 325: -#line 1416 "c-parse.y" -{ set_init_label (yyvsp[0].ttype); ; - break;} -case 327: -#line 1422 "c-parse.y" -{ set_init_index (yyvsp[-3].exprtype.value, yyvsp[-1].exprtype.value); - if (pedantic) - pedwarn ("ISO C forbids specifying range of elements to initialize"); ; - break;} -case 328: -#line 1426 "c-parse.y" -{ set_init_index (yyvsp[-1].exprtype.value, NULL_TREE); ; - break;} -case 329: -#line 1431 "c-parse.y" -{ if (pedantic) - pedwarn ("ISO C forbids nested functions"); - - push_function_context (); - if (!start_function (current_declspecs, yyvsp[0].dtrtype, - all_prefix_attributes)) - { - pop_function_context (); - YYERROR1; - } - ; - break;} -case 330: -#line 1443 "c-parse.y" -{ tree decl = current_function_decl; - DECL_SOURCE_LOCATION (decl) = yyvsp[0].location; - store_parm_decls (); ; - break;} -case 331: -#line 1452 "c-parse.y" -{ tree decl = current_function_decl; - add_stmt (yyvsp[0].ttype); - finish_function (); - pop_function_context (); - add_stmt (build_stmt (DECL_EXPR, decl)); ; - break;} -case 332: -#line 1461 "c-parse.y" -{ if (pedantic) - pedwarn ("ISO C forbids nested functions"); - - push_function_context (); - if (!start_function (current_declspecs, yyvsp[0].dtrtype, - all_prefix_attributes)) - { - pop_function_context (); - YYERROR1; - } - ; - break;} -case 333: -#line 1473 "c-parse.y" -{ tree decl = current_function_decl; - DECL_SOURCE_LOCATION (decl) = yyvsp[0].location; - store_parm_decls (); ; - break;} -case 334: -#line 1482 "c-parse.y" -{ tree decl = current_function_decl; - add_stmt (yyvsp[0].ttype); - finish_function (); - pop_function_context (); - add_stmt (build_stmt (DECL_EXPR, decl)); ; - break;} -case 337: -#line 1501 "c-parse.y" -{ yyval.dtrtype = yyvsp[-2].ttype ? build_attrs_declarator (yyvsp[-2].ttype, yyvsp[-1].dtrtype) : yyvsp[-1].dtrtype; ; - break;} -case 338: -#line 1503 "c-parse.y" -{ yyval.dtrtype = build_function_declarator (yyvsp[0].arginfotype, yyvsp[-2].dtrtype); ; - break;} -case 339: -#line 1505 "c-parse.y" -{ yyval.dtrtype = set_array_declarator_inner (yyvsp[0].dtrtype, yyvsp[-1].dtrtype, false); ; - break;} -case 340: -#line 1507 "c-parse.y" -{ yyval.dtrtype = make_pointer_declarator (yyvsp[-1].dsptype, yyvsp[0].dtrtype); ; - break;} -case 341: -#line 1509 "c-parse.y" -{ yyval.dtrtype = build_id_declarator (yyvsp[0].ttype); ; - break;} -case 344: -#line 1523 "c-parse.y" -{ yyval.dtrtype = build_function_declarator (yyvsp[0].arginfotype, yyvsp[-2].dtrtype); ; - break;} -case 345: -#line 1525 "c-parse.y" -{ yyval.dtrtype = set_array_declarator_inner (yyvsp[0].dtrtype, yyvsp[-1].dtrtype, false); ; - break;} -case 346: -#line 1527 "c-parse.y" -{ yyval.dtrtype = build_id_declarator (yyvsp[0].ttype); ; - break;} -case 347: -#line 1532 "c-parse.y" -{ yyval.dtrtype = build_function_declarator (yyvsp[0].arginfotype, yyvsp[-2].dtrtype); ; - break;} -case 348: -#line 1534 "c-parse.y" -{ yyval.dtrtype = set_array_declarator_inner (yyvsp[0].dtrtype, yyvsp[-1].dtrtype, false); ; - break;} -case 349: -#line 1536 "c-parse.y" -{ yyval.dtrtype = make_pointer_declarator (yyvsp[-1].dsptype, yyvsp[0].dtrtype); ; - break;} -case 350: -#line 1538 "c-parse.y" -{ yyval.dtrtype = make_pointer_declarator (yyvsp[-1].dsptype, yyvsp[0].dtrtype); ; - break;} -case 351: -#line 1540 "c-parse.y" -{ yyval.dtrtype = yyvsp[-2].ttype ? build_attrs_declarator (yyvsp[-2].ttype, yyvsp[-1].dtrtype) : yyvsp[-1].dtrtype; ; - break;} -case 352: -#line 1548 "c-parse.y" -{ yyval.dtrtype = build_function_declarator (yyvsp[0].arginfotype, yyvsp[-2].dtrtype); ; - break;} -case 353: -#line 1550 "c-parse.y" -{ yyval.dtrtype = yyvsp[-2].ttype ? build_attrs_declarator (yyvsp[-2].ttype, yyvsp[-1].dtrtype) : yyvsp[-1].dtrtype; ; - break;} -case 354: -#line 1552 "c-parse.y" -{ yyval.dtrtype = make_pointer_declarator (yyvsp[-1].dsptype, yyvsp[0].dtrtype); ; - break;} -case 355: -#line 1554 "c-parse.y" -{ yyval.dtrtype = set_array_declarator_inner (yyvsp[0].dtrtype, yyvsp[-1].dtrtype, false); ; - break;} -case 356: -#line 1556 "c-parse.y" -{ yyval.dtrtype = build_id_declarator (yyvsp[0].ttype); ; - break;} -case 357: -#line 1561 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 358: -#line 1563 "c-parse.y" -{ yyval.ttype = yyvsp[0].ttype; ; - break;} -case 359: -#line 1568 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 360: -#line 1570 "c-parse.y" -{ yyval.ttype = yyvsp[0].ttype; ; - break;} -case 361: -#line 1575 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 362: -#line 1577 "c-parse.y" -{ yyval.ttype = yyvsp[0].ttype; ; - break;} -case 363: -#line 1588 "c-parse.y" -{ yyval.ttype = start_struct (RECORD_TYPE, yyvsp[-1].ttype); - /* Start scope of tag before parsing components. */ - ; - break;} -case 364: -#line 1592 "c-parse.y" -{ yyval.tstype.spec = finish_struct (yyvsp[-3].ttype, nreverse (yyvsp[-2].ttype), - chainon (yyvsp[-6].ttype, yyvsp[0].ttype)); - yyval.tstype.kind = ctsk_tagdef; ; - break;} -case 365: -#line 1596 "c-parse.y" -{ yyval.tstype.spec = finish_struct (start_struct (RECORD_TYPE, - NULL_TREE), - nreverse (yyvsp[-2].ttype), chainon (yyvsp[-4].ttype, yyvsp[0].ttype)); - yyval.tstype.kind = ctsk_tagdef; - ; - break;} -case 366: -#line 1602 "c-parse.y" -{ yyval.ttype = start_struct (UNION_TYPE, yyvsp[-1].ttype); ; - break;} -case 367: -#line 1604 "c-parse.y" -{ yyval.tstype.spec = finish_struct (yyvsp[-3].ttype, nreverse (yyvsp[-2].ttype), - chainon (yyvsp[-6].ttype, yyvsp[0].ttype)); - yyval.tstype.kind = ctsk_tagdef; ; - break;} -case 368: -#line 1608 "c-parse.y" -{ yyval.tstype.spec = finish_struct (start_struct (UNION_TYPE, - NULL_TREE), - nreverse (yyvsp[-2].ttype), chainon (yyvsp[-4].ttype, yyvsp[0].ttype)); - yyval.tstype.kind = ctsk_tagdef; - ; - break;} -case 369: -#line 1614 "c-parse.y" -{ yyval.ttype = start_enum (yyvsp[-1].ttype); ; - break;} -case 370: -#line 1616 "c-parse.y" -{ yyval.tstype.spec = finish_enum (yyvsp[-4].ttype, nreverse (yyvsp[-3].ttype), - chainon (yyvsp[-7].ttype, yyvsp[0].ttype)); - yyval.tstype.kind = ctsk_tagdef; ; - break;} -case 371: -#line 1620 "c-parse.y" -{ yyval.ttype = start_enum (NULL_TREE); ; - break;} -case 372: -#line 1622 "c-parse.y" -{ yyval.tstype.spec = finish_enum (yyvsp[-4].ttype, nreverse (yyvsp[-3].ttype), - chainon (yyvsp[-6].ttype, yyvsp[0].ttype)); - yyval.tstype.kind = ctsk_tagdef; ; - break;} -case 373: -#line 1629 "c-parse.y" -{ yyval.tstype = parser_xref_tag (RECORD_TYPE, yyvsp[0].ttype); ; - break;} -case 374: -#line 1631 "c-parse.y" -{ yyval.tstype = parser_xref_tag (UNION_TYPE, yyvsp[0].ttype); ; - break;} -case 375: -#line 1633 "c-parse.y" -{ yyval.tstype = parser_xref_tag (ENUMERAL_TYPE, yyvsp[0].ttype); - /* In ISO C, enumerated types can be referred to - only if already defined. */ - if (pedantic && !COMPLETE_TYPE_P (yyval.tstype.spec)) - pedwarn ("ISO C forbids forward references to % types"); ; - break;} -case 379: -#line 1648 "c-parse.y" -{ if (pedantic && !flag_isoc99) - pedwarn ("comma at end of enumerator list"); ; - break;} -case 380: -#line 1666 "c-parse.y" -{ yyval.ttype = yyvsp[0].ttype; ; - break;} -case 381: -#line 1668 "c-parse.y" -{ yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-1].ttype); - pedwarn ("no semicolon at end of struct or union"); ; - break;} -case 382: -#line 1673 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 383: -#line 1675 "c-parse.y" -{ yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[-2].ttype); ; - break;} -case 384: -#line 1677 "c-parse.y" -{ if (pedantic) - pedwarn ("extra semicolon in struct or union specified"); ; - break;} -case 385: -#line 1683 "c-parse.y" -{ yyval.ttype = yyvsp[0].ttype; - POP_DECLSPEC_STACK; ; - break;} -case 386: -#line 1686 "c-parse.y" -{ - /* Support for unnamed structs or unions as members of - structs or unions (which is [a] useful and [b] supports - MS P-SDK). */ - yyval.ttype = grokfield (build_id_declarator (NULL_TREE), - current_declspecs, NULL_TREE); - POP_DECLSPEC_STACK; ; - break;} -case 387: -#line 1694 "c-parse.y" -{ yyval.ttype = yyvsp[0].ttype; - POP_DECLSPEC_STACK; ; - break;} -case 388: -#line 1697 "c-parse.y" -{ if (pedantic) - pedwarn ("ISO C forbids member declarations with no members"); - shadow_tag_warned (finish_declspecs (yyvsp[0].dsptype), pedantic); - yyval.ttype = NULL_TREE; ; - break;} -case 389: -#line 1702 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 390: -#line 1704 "c-parse.y" -{ yyval.ttype = yyvsp[0].ttype; - RESTORE_EXT_FLAGS (yyvsp[-1].itype); ; - break;} -case 392: -#line 1711 "c-parse.y" -{ TREE_CHAIN (yyvsp[0].ttype) = yyvsp[-3].ttype; yyval.ttype = yyvsp[0].ttype; ; - break;} -case 394: -#line 1717 "c-parse.y" -{ TREE_CHAIN (yyvsp[0].ttype) = yyvsp[-3].ttype; yyval.ttype = yyvsp[0].ttype; ; - break;} -case 395: -#line 1722 "c-parse.y" -{ yyval.ttype = grokfield (yyvsp[-1].dtrtype, current_declspecs, NULL_TREE); - decl_attributes (&yyval.ttype, - chainon (yyvsp[0].ttype, all_prefix_attributes), 0); ; - break;} -case 396: -#line 1726 "c-parse.y" -{ yyval.ttype = grokfield (yyvsp[-3].dtrtype, current_declspecs, yyvsp[-1].exprtype.value); - decl_attributes (&yyval.ttype, - chainon (yyvsp[0].ttype, all_prefix_attributes), 0); ; - break;} -case 397: -#line 1730 "c-parse.y" -{ yyval.ttype = grokfield (build_id_declarator (NULL_TREE), - current_declspecs, yyvsp[-1].exprtype.value); - decl_attributes (&yyval.ttype, - chainon (yyvsp[0].ttype, all_prefix_attributes), 0); ; - break;} -case 398: -#line 1738 "c-parse.y" -{ yyval.ttype = grokfield (yyvsp[-1].dtrtype, current_declspecs, NULL_TREE); - decl_attributes (&yyval.ttype, - chainon (yyvsp[0].ttype, all_prefix_attributes), 0); ; - break;} -case 399: -#line 1742 "c-parse.y" -{ yyval.ttype = grokfield (yyvsp[-3].dtrtype, current_declspecs, yyvsp[-1].exprtype.value); - decl_attributes (&yyval.ttype, - chainon (yyvsp[0].ttype, all_prefix_attributes), 0); ; - break;} -case 400: -#line 1746 "c-parse.y" -{ yyval.ttype = grokfield (build_id_declarator (NULL_TREE), - current_declspecs, yyvsp[-1].exprtype.value); - decl_attributes (&yyval.ttype, - chainon (yyvsp[0].ttype, all_prefix_attributes), 0); ; - break;} -case 402: -#line 1758 "c-parse.y" -{ if (yyvsp[-2].ttype == error_mark_node) - yyval.ttype = yyvsp[-2].ttype; - else - TREE_CHAIN (yyvsp[0].ttype) = yyvsp[-2].ttype, yyval.ttype = yyvsp[0].ttype; ; - break;} -case 403: -#line 1763 "c-parse.y" -{ yyval.ttype = error_mark_node; ; - break;} -case 404: -#line 1769 "c-parse.y" -{ yyval.ttype = build_enumerator (yyvsp[0].ttype, NULL_TREE); ; - break;} -case 405: -#line 1771 "c-parse.y" -{ yyval.ttype = build_enumerator (yyvsp[-2].ttype, yyvsp[0].exprtype.value); ; - break;} -case 406: -#line 1776 "c-parse.y" -{ pending_xref_error (); - yyval.dsptype = finish_declspecs (yyvsp[0].dsptype); ; - break;} -case 407: -#line 1779 "c-parse.y" -{ yyval.typenametype = XOBNEW (&parser_obstack, struct c_type_name); - yyval.typenametype->specs = yyvsp[-1].dsptype; - yyval.typenametype->declarator = yyvsp[0].dtrtype; ; - break;} -case 408: -#line 1786 "c-parse.y" -{ yyval.dtrtype = build_id_declarator (NULL_TREE); ; - break;} -case 410: -#line 1792 "c-parse.y" -{ yyval.parmtype = build_c_parm (current_declspecs, all_prefix_attributes, - build_id_declarator (NULL_TREE)); ; - break;} -case 411: -#line 1795 "c-parse.y" -{ yyval.parmtype = build_c_parm (current_declspecs, all_prefix_attributes, - yyvsp[0].dtrtype); ; - break;} -case 412: -#line 1798 "c-parse.y" -{ yyval.parmtype = build_c_parm (current_declspecs, - chainon (yyvsp[0].ttype, all_prefix_attributes), - yyvsp[-1].dtrtype); ; - break;} -case 416: -#line 1811 "c-parse.y" -{ yyval.dtrtype = make_pointer_declarator (yyvsp[-1].dsptype, yyvsp[0].dtrtype); ; - break;} -case 417: -#line 1816 "c-parse.y" -{ yyval.dtrtype = make_pointer_declarator - (yyvsp[0].dsptype, build_id_declarator (NULL_TREE)); ; - break;} -case 418: -#line 1819 "c-parse.y" -{ yyval.dtrtype = make_pointer_declarator (yyvsp[-1].dsptype, yyvsp[0].dtrtype); ; - break;} -case 419: -#line 1824 "c-parse.y" -{ yyval.dtrtype = yyvsp[-2].ttype ? build_attrs_declarator (yyvsp[-2].ttype, yyvsp[-1].dtrtype) : yyvsp[-1].dtrtype; ; - break;} -case 420: -#line 1826 "c-parse.y" -{ yyval.dtrtype = build_function_declarator (yyvsp[0].arginfotype, yyvsp[-2].dtrtype); ; - break;} -case 421: -#line 1828 "c-parse.y" -{ yyval.dtrtype = set_array_declarator_inner (yyvsp[0].dtrtype, yyvsp[-1].dtrtype, true); ; - break;} -case 422: -#line 1830 "c-parse.y" -{ yyval.dtrtype = build_function_declarator - (yyvsp[0].arginfotype, build_id_declarator (NULL_TREE)); ; - break;} -case 423: -#line 1833 "c-parse.y" -{ yyval.dtrtype = set_array_declarator_inner - (yyvsp[0].dtrtype, build_id_declarator (NULL_TREE), true); ; - break;} -case 424: -#line 1841 "c-parse.y" -{ yyval.dtrtype = build_array_declarator (yyvsp[-1].exprtype.value, yyvsp[-2].dsptype, false, false); ; - break;} -case 425: -#line 1843 "c-parse.y" -{ yyval.dtrtype = build_array_declarator (NULL_TREE, yyvsp[-1].dsptype, false, false); ; - break;} -case 426: -#line 1845 "c-parse.y" -{ yyval.dtrtype = build_array_declarator (NULL_TREE, yyvsp[-2].dsptype, false, true); ; - break;} -case 427: -#line 1847 "c-parse.y" -{ yyval.dtrtype = build_array_declarator (yyvsp[-1].exprtype.value, yyvsp[-2].dsptype, true, false); ; - break;} -case 428: -#line 1850 "c-parse.y" -{ yyval.dtrtype = build_array_declarator (yyvsp[-1].exprtype.value, yyvsp[-3].dsptype, true, false); ; - break;} -case 431: -#line 1863 "c-parse.y" -{ - error ("label at end of compound statement"); - ; - break;} -case 439: -#line 1880 "c-parse.y" -{ - if ((pedantic && !flag_isoc99) - || warn_declaration_after_statement) - pedwarn_c90 ("ISO C90 forbids mixed declarations and code"); - ; - break;} -case 454: -#line 1914 "c-parse.y" -{ yyval.ttype = c_begin_compound_stmt (flag_isoc99); ; - break;} -case 456: -#line 1922 "c-parse.y" -{ if (pedantic) - pedwarn ("ISO C forbids label declarations"); ; - break;} -case 459: -#line 1933 "c-parse.y" -{ tree link; - for (link = yyvsp[-1].ttype; link; link = TREE_CHAIN (link)) - { - tree label = declare_label (TREE_VALUE (link)); - C_DECLARED_LABEL_FLAG (label) = 1; - add_stmt (build_stmt (DECL_EXPR, label)); - } - ; - break;} -case 460: -#line 1947 "c-parse.y" -{ add_stmt (yyvsp[0].ttype); ; - break;} -case 462: -#line 1951 "c-parse.y" -{ yyval.ttype = c_begin_compound_stmt (true); ; - break;} -case 467: -#line 1965 "c-parse.y" -{ if (cur_stmt_list == NULL) - { - error ("braced-group within expression allowed " - "only inside a function"); - YYERROR; - } - yyval.ttype = c_begin_stmt_expr (); - ; - break;} -case 468: -#line 1976 "c-parse.y" -{ yyval.ttype = c_end_compound_stmt (yyvsp[-1].ttype, true); ; - break;} -case 469: -#line 1984 "c-parse.y" -{ if (yychar == YYEMPTY) - yychar = YYLEX; - yyval.location = input_location; ; - break;} -case 472: -#line 1997 "c-parse.y" -{ yyval.ttype = c_end_compound_stmt (yyvsp[-2].ttype, flag_isoc99); ; - break;} -case 473: -#line 2002 "c-parse.y" -{ - /* Two cases cannot and do not have line numbers associated: - If stmt is degenerate, such as "2;", then stmt is an - INTEGER_CST, which cannot hold line numbers. But that's - ok because the statement will either be changed to a - MODIFY_EXPR during gimplification of the statement expr, - or discarded. If stmt was compound, but without new - variables, we will have skipped the creation of a BIND - and will have a bare STATEMENT_LIST. But that's ok - because (recursively) all of the component statments - should already have line numbers assigned. */ - if (yyvsp[0].ttype && EXPR_P (yyvsp[0].ttype)) - SET_EXPR_LOCATION (yyvsp[0].ttype, yyvsp[-1].location); - ; - break;} -case 474: -#line 2020 "c-parse.y" -{ if (yyvsp[0].ttype) SET_EXPR_LOCATION (yyvsp[0].ttype, yyvsp[-1].location); ; - break;} -case 475: -#line 2024 "c-parse.y" -{ yyval.ttype = lang_hooks.truthvalue_conversion (yyvsp[0].exprtype.value); - if (EXPR_P (yyval.ttype)) - SET_EXPR_LOCATION (yyval.ttype, yyvsp[-1].location); ; - break;} -case 476: -#line 2037 "c-parse.y" -{ yyval.ttype = c_end_compound_stmt (yyvsp[-2].ttype, flag_isoc99); ; - break;} -case 477: -#line 2042 "c-parse.y" -{ if (extra_warnings) - add_stmt (build (NOP_EXPR, NULL_TREE, NULL_TREE)); - yyval.ttype = c_end_compound_stmt (yyvsp[-2].ttype, flag_isoc99); ; - break;} -case 479: -#line 2051 "c-parse.y" -{ c_finish_if_stmt (yyvsp[-6].location, yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype, true); - add_stmt (c_end_compound_stmt (yyvsp[-7].ttype, flag_isoc99)); ; - break;} -case 480: -#line 2055 "c-parse.y" -{ c_finish_if_stmt (yyvsp[-6].location, yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype, false); - add_stmt (c_end_compound_stmt (yyvsp[-7].ttype, flag_isoc99)); ; - break;} -case 481: -#line 2059 "c-parse.y" -{ c_finish_if_stmt (yyvsp[-4].location, yyvsp[-2].ttype, yyvsp[0].ttype, NULL, true); - add_stmt (c_end_compound_stmt (yyvsp[-5].ttype, flag_isoc99)); ; - break;} -case 482: -#line 2063 "c-parse.y" -{ c_finish_if_stmt (yyvsp[-4].location, yyvsp[-2].ttype, yyvsp[0].ttype, NULL, false); - add_stmt (c_end_compound_stmt (yyvsp[-5].ttype, flag_isoc99)); ; - break;} -case 483: -#line 2068 "c-parse.y" -{ yyval.ttype = c_break_label; c_break_label = NULL; ; - break;} -case 484: -#line 2072 "c-parse.y" -{ yyval.ttype = c_cont_label; c_cont_label = NULL; ; - break;} -case 485: -#line 2078 "c-parse.y" -{ c_finish_loop (yyvsp[-6].location, yyvsp[-4].ttype, NULL, yyvsp[0].ttype, c_break_label, - c_cont_label, true); - add_stmt (c_end_compound_stmt (yyvsp[-7].ttype, flag_isoc99)); - c_break_label = yyvsp[-2].ttype; c_cont_label = yyvsp[-1].ttype; ; - break;} -case 486: -#line 2087 "c-parse.y" -{ yyval.ttype = c_break_label; c_break_label = yyvsp[-3].ttype; ; - break;} -case 487: -#line 2088 "c-parse.y" -{ yyval.ttype = c_cont_label; c_cont_label = yyvsp[-3].ttype; ; - break;} -case 488: -#line 2090 "c-parse.y" -{ c_finish_loop (yyvsp[-10].location, yyvsp[-2].ttype, NULL, yyvsp[-7].ttype, yyvsp[-5].ttype, - yyvsp[-4].ttype, false); - add_stmt (c_end_compound_stmt (yyvsp[-11].ttype, flag_isoc99)); ; - break;} -case 489: -#line 2097 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 490: -#line 2099 "c-parse.y" -{ yyval.ttype = yyvsp[0].exprtype.value; ; - break;} -case 491: -#line 2104 "c-parse.y" -{ c_finish_expr_stmt (yyvsp[-1].ttype); ; - break;} -case 492: -#line 2106 "c-parse.y" -{ check_for_loop_decls (); ; - break;} -case 493: -#line 2110 "c-parse.y" -{ if (yyvsp[0].ttype) - { - yyval.ttype = lang_hooks.truthvalue_conversion (yyvsp[0].ttype); - if (EXPR_P (yyval.ttype)) - SET_EXPR_LOCATION (yyval.ttype, yyvsp[-1].location); - } - else - yyval.ttype = NULL; - ; - break;} -case 494: -#line 2122 "c-parse.y" -{ yyval.ttype = c_process_expr_stmt (yyvsp[0].ttype); ; - break;} -case 495: -#line 2129 "c-parse.y" -{ c_finish_loop (yyvsp[-7].location, yyvsp[-6].ttype, yyvsp[-4].ttype, yyvsp[0].ttype, c_break_label, - c_cont_label, true); - add_stmt (c_end_compound_stmt (yyvsp[-10].ttype, flag_isoc99)); - c_break_label = yyvsp[-2].ttype; c_cont_label = yyvsp[-1].ttype; ; - break;} -case 496: -#line 2137 "c-parse.y" -{ yyval.ttype = c_start_case (yyvsp[-1].exprtype.value); ; - break;} -case 497: -#line 2139 "c-parse.y" -{ c_finish_case (yyvsp[0].ttype); - if (c_break_label) - add_stmt (build (LABEL_EXPR, void_type_node, - c_break_label)); - c_break_label = yyvsp[-1].ttype; - add_stmt (c_end_compound_stmt (yyvsp[-6].ttype, flag_isoc99)); ; - break;} -case 498: -#line 2150 "c-parse.y" -{ yyval.ttype = c_finish_expr_stmt (yyvsp[-1].exprtype.value); ; - break;} -case 499: -#line 2152 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 500: -#line 2154 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 501: -#line 2156 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 502: -#line 2158 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 503: -#line 2160 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 504: -#line 2162 "c-parse.y" -{ yyval.ttype = c_finish_bc_stmt (&c_break_label, true); ; - break;} -case 505: -#line 2164 "c-parse.y" -{ yyval.ttype = c_finish_bc_stmt (&c_cont_label, false); ; - break;} -case 506: -#line 2166 "c-parse.y" -{ yyval.ttype = c_finish_return (NULL_TREE); ; - break;} -case 507: -#line 2168 "c-parse.y" -{ yyval.ttype = c_finish_return (yyvsp[-1].exprtype.value); ; - break;} -case 509: -#line 2171 "c-parse.y" -{ yyval.ttype = c_finish_goto_label (yyvsp[-1].ttype); ; - break;} -case 510: -#line 2173 "c-parse.y" -{ yyval.ttype = c_finish_goto_ptr (yyvsp[-1].exprtype.value); ; - break;} -case 511: -#line 2175 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 512: -#line 2181 "c-parse.y" -{ add_stmt (yyvsp[0].ttype); yyval.ttype = NULL_TREE; ; - break;} -case 514: -#line 2190 "c-parse.y" -{ yyval.ttype = do_case (yyvsp[-1].exprtype.value, NULL_TREE); ; - break;} -case 515: -#line 2192 "c-parse.y" -{ yyval.ttype = do_case (yyvsp[-3].exprtype.value, yyvsp[-1].exprtype.value); ; - break;} -case 516: -#line 2194 "c-parse.y" -{ yyval.ttype = do_case (NULL_TREE, NULL_TREE); ; - break;} -case 517: -#line 2196 "c-parse.y" -{ tree label = define_label (yyvsp[-2].location, yyvsp[-3].ttype); - if (label) - { - decl_attributes (&label, yyvsp[0].ttype, 0); - yyval.ttype = add_stmt (build_stmt (LABEL_EXPR, label)); - } - else - yyval.ttype = NULL_TREE; - ; - break;} -case 518: -#line 2214 "c-parse.y" -{ yyval.ttype = yyvsp[-2].ttype; ; - break;} -case 519: -#line 2220 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 521: -#line 2227 "c-parse.y" -{ assemble_asm (yyvsp[-1].ttype); ; - break;} -case 522: -#line 2229 "c-parse.y" -{; - break;} -case 523: -#line 2237 "c-parse.y" -{ yyval.ttype = build_asm_stmt (yyvsp[-6].ttype, yyvsp[-3].ttype); ; - break;} -case 524: -#line 2243 "c-parse.y" -{ yyval.ttype = build_asm_expr (yyvsp[0].ttype, 0, 0, 0, true); ; - break;} -case 525: -#line 2246 "c-parse.y" -{ yyval.ttype = build_asm_expr (yyvsp[-2].ttype, yyvsp[0].ttype, 0, 0, false); ; - break;} -case 526: -#line 2249 "c-parse.y" -{ yyval.ttype = build_asm_expr (yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype, 0, false); ; - break;} -case 527: -#line 2252 "c-parse.y" -{ yyval.ttype = build_asm_expr (yyvsp[-6].ttype, yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype, false); ; - break;} -case 528: -#line 2259 "c-parse.y" -{ yyval.ttype = 0; ; - break;} -case 529: -#line 2261 "c-parse.y" -{ if (yyvsp[0].ttype != ridpointers[RID_VOLATILE]) - { - warning ("%E qualifier ignored on asm", yyvsp[0].ttype); - yyval.ttype = 0; - } - else - yyval.ttype = yyvsp[0].ttype; - ; - break;} -case 530: -#line 2274 "c-parse.y" -{ yyval.ttype = NULL_TREE; ; - break;} -case 533: -#line 2281 "c-parse.y" -{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[0].ttype); ; - break;} -case 534: -#line 2287 "c-parse.y" -{ yyval.ttype = build_tree_list (build_tree_list (NULL_TREE, yyvsp[-5].ttype), - yyvsp[-2].exprtype.value); ; - break;} -case 535: -#line 2291 "c-parse.y" -{ yyvsp[-7].ttype = build_string (IDENTIFIER_LENGTH (yyvsp[-7].ttype), - IDENTIFIER_POINTER (yyvsp[-7].ttype)); - yyval.ttype = build_tree_list (build_tree_list (yyvsp[-7].ttype, yyvsp[-5].ttype), yyvsp[-2].exprtype.value); ; - break;} -case 536: -#line 2298 "c-parse.y" -{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE); ; - break;} -case 537: -#line 2300 "c-parse.y" -{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-2].ttype); ; - break;} -case 538: -#line 2306 "c-parse.y" -{ if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (yyvsp[0].ttype))) - != char_type_node) - { - error ("wide string literal in %"); - yyval.ttype = build_string (1, ""); - } - else - yyval.ttype = yyvsp[0].ttype; ; - break;} -case 539: -#line 2317 "c-parse.y" -{ c_lex_string_translate = 0; ; - break;} -case 540: -#line 2321 "c-parse.y" -{ c_lex_string_translate = 1; ; - break;} -case 541: -#line 2332 "c-parse.y" -{ push_scope (); - declare_parm_level (); ; - break;} -case 542: -#line 2335 "c-parse.y" -{ yyval.arginfotype = yyvsp[0].arginfotype; - pop_scope (); ; - break;} -case 544: -#line 2342 "c-parse.y" -{ mark_forward_parm_decls (); ; - break;} -case 545: -#line 2344 "c-parse.y" -{ /* Dummy action so attributes are in known place - on parser stack. */ ; - break;} -case 546: -#line 2347 "c-parse.y" -{ yyval.arginfotype = yyvsp[0].arginfotype; ; - break;} -case 547: -#line 2349 "c-parse.y" -{ yyval.arginfotype = XOBNEW (&parser_obstack, struct c_arg_info); - yyval.arginfotype->parms = 0; - yyval.arginfotype->tags = 0; - yyval.arginfotype->types = 0; - yyval.arginfotype->others = 0; ; - break;} -case 548: -#line 2359 "c-parse.y" -{ yyval.arginfotype = XOBNEW (&parser_obstack, struct c_arg_info); - yyval.arginfotype->parms = 0; - yyval.arginfotype->tags = 0; - yyval.arginfotype->types = 0; - yyval.arginfotype->others = 0; ; - break;} -case 549: -#line 2365 "c-parse.y" -{ yyval.arginfotype = XOBNEW (&parser_obstack, struct c_arg_info); - yyval.arginfotype->parms = 0; - yyval.arginfotype->tags = 0; - yyval.arginfotype->others = 0; - /* Suppress -Wold-style-definition for this case. */ - yyval.arginfotype->types = error_mark_node; - error ("ISO C requires a named argument before %<...%>"); - ; - break;} -case 550: -#line 2374 "c-parse.y" -{ yyval.arginfotype = get_parm_info (/*ellipsis=*/false); ; - break;} -case 551: -#line 2376 "c-parse.y" -{ yyval.arginfotype = get_parm_info (/*ellipsis=*/true); ; - break;} -case 552: -#line 2381 "c-parse.y" -{ push_parm_decl (yyvsp[0].parmtype); ; - break;} -case 553: -#line 2383 "c-parse.y" -{ push_parm_decl (yyvsp[0].parmtype); ; - break;} -case 554: -#line 2390 "c-parse.y" -{ yyval.parmtype = build_c_parm (current_declspecs, - chainon (yyvsp[0].ttype, all_prefix_attributes), yyvsp[-1].dtrtype); - POP_DECLSPEC_STACK; ; - break;} -case 555: -#line 2394 "c-parse.y" -{ yyval.parmtype = build_c_parm (current_declspecs, - chainon (yyvsp[0].ttype, all_prefix_attributes), yyvsp[-1].dtrtype); - POP_DECLSPEC_STACK; ; - break;} -case 556: -#line 2398 "c-parse.y" -{ yyval.parmtype = yyvsp[0].parmtype; - POP_DECLSPEC_STACK; ; - break;} -case 557: -#line 2401 "c-parse.y" -{ yyval.parmtype = build_c_parm (current_declspecs, - chainon (yyvsp[0].ttype, all_prefix_attributes), yyvsp[-1].dtrtype); - POP_DECLSPEC_STACK; ; - break;} -case 558: -#line 2406 "c-parse.y" -{ yyval.parmtype = yyvsp[0].parmtype; - POP_DECLSPEC_STACK; ; - break;} -case 559: -#line 2414 "c-parse.y" -{ yyval.parmtype = build_c_parm (current_declspecs, - chainon (yyvsp[0].ttype, all_prefix_attributes), yyvsp[-1].dtrtype); - POP_DECLSPEC_STACK; ; - break;} -case 560: -#line 2418 "c-parse.y" -{ yyval.parmtype = build_c_parm (current_declspecs, - chainon (yyvsp[0].ttype, all_prefix_attributes), yyvsp[-1].dtrtype); - POP_DECLSPEC_STACK; ; - break;} -case 561: -#line 2422 "c-parse.y" -{ yyval.parmtype = yyvsp[0].parmtype; - POP_DECLSPEC_STACK; ; - break;} -case 562: -#line 2425 "c-parse.y" -{ yyval.parmtype = build_c_parm (current_declspecs, - chainon (yyvsp[0].ttype, all_prefix_attributes), yyvsp[-1].dtrtype); - POP_DECLSPEC_STACK; ; - break;} -case 563: -#line 2430 "c-parse.y" -{ yyval.parmtype = yyvsp[0].parmtype; - POP_DECLSPEC_STACK; ; - break;} -case 564: -#line 2436 "c-parse.y" -{ prefix_attributes = chainon (prefix_attributes, yyvsp[-3].ttype); - all_prefix_attributes = prefix_attributes; ; - break;} -case 565: -#line 2445 "c-parse.y" -{ push_scope (); - declare_parm_level (); ; - break;} -case 566: -#line 2448 "c-parse.y" -{ yyval.arginfotype = yyvsp[0].arginfotype; - pop_scope (); ; - break;} -case 568: -#line 2455 "c-parse.y" -{ yyval.arginfotype = XOBNEW (&parser_obstack, struct c_arg_info); - yyval.arginfotype->parms = 0; - yyval.arginfotype->tags = 0; - yyval.arginfotype->types = yyvsp[-1].ttype; - yyval.arginfotype->others = 0; - - /* Make sure we have a parmlist after attributes. */ - if (yyvsp[-3].ttype != 0) - YYERROR1; - ; - break;} -case 569: -#line 2470 "c-parse.y" -{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ; - break;} -case 570: -#line 2472 "c-parse.y" -{ yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; - break;} -case 571: -#line 2478 "c-parse.y" -{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ; - break;} -case 572: -#line 2480 "c-parse.y" -{ yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; - break;} -case 573: -#line 2485 "c-parse.y" -{ yyval.itype = SAVE_EXT_FLAGS (); - pedantic = 0; - warn_pointer_arith = 0; - warn_traditional = 0; - flag_iso = 0; ; - break;} -} - -#line 705 "/usr/share/bison/bison.simple" - - - yyvsp -= yylen; - yyssp -= yylen; -#if YYLSP_NEEDED - yylsp -= yylen; -#endif - -#if YYDEBUG - if (yydebug) - { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif - - *++yyvsp = yyval; -#if YYLSP_NEEDED - *++yylsp = yyloc; -#endif - - /* Now `shift' the result of the reduction. Determine what state - that goes to, based on the state we popped back to and the rule - number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTBASE] + *yyssp; - if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTBASE]; - - goto yynewstate; - - -/*------------------------------------. -| yyerrlab -- here on detecting error | -`------------------------------------*/ -yyerrlab: - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus) - { - ++yynerrs; - -#ifdef YYERROR_VERBOSE - yyn = yypact[yystate]; - - if (yyn > YYFLAG && yyn < YYLAST) - { - YYSIZE_T yysize = 0; - char *yymsg; - int yyx, yycount; - - yycount = 0; - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) - if (yycheck[yyx + yyn] == yyx) - yysize += yystrlen (yytname[yyx]) + 15, yycount++; - yysize += yystrlen ("parse error, unexpected ") + 1; - yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); - yymsg = (char *) YYSTACK_ALLOC (yysize); - if (yymsg != 0) - { - char *yyp = yystpcpy (yymsg, "parse error, unexpected "); - yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); - - if (yycount < 5) - { - yycount = 0; - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); - yyx++) - if (yycheck[yyx + yyn] == yyx) - { - const char *yyq = ! yycount ? ", expecting " : " or "; - yyp = yystpcpy (yyp, yyq); - yyp = yystpcpy (yyp, yytname[yyx]); - yycount++; - } - } - yyerror (yymsg); - YYSTACK_FREE (yymsg); - } - else - yyerror ("parse error; also virtual memory exhausted"); - } - else -#endif /* defined (YYERROR_VERBOSE) */ - yyerror ("parse error"); - } - goto yyerrlab1; - - -/*--------------------------------------------------. -| yyerrlab1 -- error raised explicitly by an action | -`--------------------------------------------------*/ -yyerrlab1: - if (yyerrstatus == 3) - { - /* If just tried and failed to reuse lookahead token after an - error, discard it. */ - - /* return failure if at end of input */ - if (yychar == YYEOF) - YYABORT; - YYDPRINTF ((stderr, "Discarding token %d (%s).\n", - yychar, yytname[yychar1])); - yychar = YYEMPTY; - } - - /* Else will try to reuse lookahead token after shifting the error - token. */ - - yyerrstatus = 3; /* Each real token shifted decrements this */ - - goto yyerrhandle; - - -/*-------------------------------------------------------------------. -| yyerrdefault -- current state does not do anything special for the | -| error token. | -`-------------------------------------------------------------------*/ -yyerrdefault: -#if 0 - /* This is wrong; only states that explicitly want error tokens - should shift them. */ - - /* If its default is to accept any token, ok. Otherwise pop it. */ - yyn = yydefact[yystate]; - if (yyn) - goto yydefault; -#endif - - -/*---------------------------------------------------------------. -| yyerrpop -- pop the current state because it cannot handle the | -| error token | -`---------------------------------------------------------------*/ -yyerrpop: - if (yyssp == yyss) - YYABORT; - yyvsp--; - yystate = *--yyssp; -#if YYLSP_NEEDED - yylsp--; -#endif - -#if YYDEBUG - if (yydebug) - { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "Error: state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif - -/*--------------. -| yyerrhandle. | -`--------------*/ -yyerrhandle: - yyn = yypact[yystate]; - if (yyn == YYFLAG) - goto yyerrdefault; - - yyn += YYTERROR; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) - goto yyerrdefault; - - yyn = yytable[yyn]; - if (yyn < 0) - { - if (yyn == YYFLAG) - goto yyerrpop; - yyn = -yyn; - goto yyreduce; - } - else if (yyn == 0) - goto yyerrpop; - - if (yyn == YYFINAL) - YYACCEPT; - - YYDPRINTF ((stderr, "Shifting error token, ")); - - *++yyvsp = yylval; -#if YYLSP_NEEDED - *++yylsp = yylloc; -#endif - - yystate = yyn; - goto yynewstate; - - -/*-------------------------------------. -| yyacceptlab -- YYACCEPT comes here. | -`-------------------------------------*/ -yyacceptlab: - yyresult = 0; - goto yyreturn; - -/*-----------------------------------. -| yyabortlab -- YYABORT comes here. | -`-----------------------------------*/ -yyabortlab: - yyresult = 1; - goto yyreturn; - -/*---------------------------------------------. -| yyoverflowab -- parser overflow comes here. | -`---------------------------------------------*/ -yyoverflowlab: - yyerror ("parser stack overflow"); - yyresult = 2; - /* Fall through. */ - -yyreturn: -#ifndef yyoverflow - if (yyss != yyssa) - YYSTACK_FREE (yyss); -#endif - return yyresult; -} -#line 2492 "c-parse.y" - - -/* yylex() is a thin wrapper around c_lex(), all it does is translate - cpplib.h's token codes into yacc's token codes. */ - -static enum cpp_ttype last_token; - -/* The reserved keyword table. */ -struct resword -{ - const char *word; - ENUM_BITFIELD(rid) rid : 16; - unsigned int disable : 16; -}; - -/* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is - _true_. */ -#define D_C89 0x01 /* not in C89 */ -#define D_EXT 0x02 /* GCC extension */ -#define D_EXT89 0x04 /* GCC extension incorporated in C99 */ -#define D_OBJC 0x08 /* Objective C only */ - -static const struct resword reswords[] = -{ - { "_Bool", RID_BOOL, 0 }, - { "_Complex", RID_COMPLEX, 0 }, - { "__FUNCTION__", RID_FUNCTION_NAME, 0 }, - { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 }, - { "__alignof", RID_ALIGNOF, 0 }, - { "__alignof__", RID_ALIGNOF, 0 }, - { "__asm", RID_ASM, 0 }, - { "__asm__", RID_ASM, 0 }, - { "__attribute", RID_ATTRIBUTE, 0 }, - { "__attribute__", RID_ATTRIBUTE, 0 }, - { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 }, - { "__builtin_offsetof", RID_OFFSETOF, 0 }, - { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 }, - { "__builtin_va_arg", RID_VA_ARG, 0 }, - { "__complex", RID_COMPLEX, 0 }, - { "__complex__", RID_COMPLEX, 0 }, - { "__const", RID_CONST, 0 }, - { "__const__", RID_CONST, 0 }, - { "__extension__", RID_EXTENSION, 0 }, - { "__func__", RID_C99_FUNCTION_NAME, 0 }, - { "__imag", RID_IMAGPART, 0 }, - { "__imag__", RID_IMAGPART, 0 }, - { "__inline", RID_INLINE, 0 }, - { "__inline__", RID_INLINE, 0 }, - { "__label__", RID_LABEL, 0 }, - { "__real", RID_REALPART, 0 }, - { "__real__", RID_REALPART, 0 }, - { "__restrict", RID_RESTRICT, 0 }, - { "__restrict__", RID_RESTRICT, 0 }, - { "__signed", RID_SIGNED, 0 }, - { "__signed__", RID_SIGNED, 0 }, - { "__thread", RID_THREAD, 0 }, - { "__typeof", RID_TYPEOF, 0 }, - { "__typeof__", RID_TYPEOF, 0 }, - { "__volatile", RID_VOLATILE, 0 }, - { "__volatile__", RID_VOLATILE, 0 }, - { "asm", RID_ASM, D_EXT }, - { "auto", RID_AUTO, 0 }, - { "break", RID_BREAK, 0 }, - { "case", RID_CASE, 0 }, - { "char", RID_CHAR, 0 }, - { "const", RID_CONST, 0 }, - { "continue", RID_CONTINUE, 0 }, - { "default", RID_DEFAULT, 0 }, - { "do", RID_DO, 0 }, - { "double", RID_DOUBLE, 0 }, - { "else", RID_ELSE, 0 }, - { "enum", RID_ENUM, 0 }, - { "extern", RID_EXTERN, 0 }, - { "float", RID_FLOAT, 0 }, - { "for", RID_FOR, 0 }, - { "goto", RID_GOTO, 0 }, - { "if", RID_IF, 0 }, - { "inline", RID_INLINE, D_EXT89 }, - { "int", RID_INT, 0 }, - { "long", RID_LONG, 0 }, - { "register", RID_REGISTER, 0 }, - { "restrict", RID_RESTRICT, D_C89 }, - { "return", RID_RETURN, 0 }, - { "short", RID_SHORT, 0 }, - { "signed", RID_SIGNED, 0 }, - { "sizeof", RID_SIZEOF, 0 }, - { "static", RID_STATIC, 0 }, - { "struct", RID_STRUCT, 0 }, - { "switch", RID_SWITCH, 0 }, - { "typedef", RID_TYPEDEF, 0 }, - { "typeof", RID_TYPEOF, D_EXT }, - { "union", RID_UNION, 0 }, - { "unsigned", RID_UNSIGNED, 0 }, - { "void", RID_VOID, 0 }, - { "volatile", RID_VOLATILE, 0 }, - { "while", RID_WHILE, 0 }, - -}; -#define N_reswords (sizeof reswords / sizeof (struct resword)) - -/* Table mapping from RID_* constants to yacc token numbers. - Unfortunately we have to have entries for all the keywords in all - three languages. */ -static const short rid_to_yy[RID_MAX] = -{ - /* RID_STATIC */ STATIC, - /* RID_UNSIGNED */ TYPESPEC, - /* RID_LONG */ TYPESPEC, - /* RID_CONST */ TYPE_QUAL, - /* RID_EXTERN */ SCSPEC, - /* RID_REGISTER */ SCSPEC, - /* RID_TYPEDEF */ SCSPEC, - /* RID_SHORT */ TYPESPEC, - /* RID_INLINE */ SCSPEC, - /* RID_VOLATILE */ TYPE_QUAL, - /* RID_SIGNED */ TYPESPEC, - /* RID_AUTO */ SCSPEC, - /* RID_RESTRICT */ TYPE_QUAL, - - /* C extensions */ - /* RID_COMPLEX */ TYPESPEC, - /* RID_THREAD */ SCSPEC, - - /* C++ */ - /* RID_FRIEND */ 0, - /* RID_VIRTUAL */ 0, - /* RID_EXPLICIT */ 0, - /* RID_EXPORT */ 0, - /* RID_MUTABLE */ 0, - - /* ObjC */ - /* RID_IN */ OBJC_TYPE_QUAL, - /* RID_OUT */ OBJC_TYPE_QUAL, - /* RID_INOUT */ OBJC_TYPE_QUAL, - /* RID_BYCOPY */ OBJC_TYPE_QUAL, - /* RID_BYREF */ OBJC_TYPE_QUAL, - /* RID_ONEWAY */ OBJC_TYPE_QUAL, - - /* C */ - /* RID_INT */ TYPESPEC, - /* RID_CHAR */ TYPESPEC, - /* RID_FLOAT */ TYPESPEC, - /* RID_DOUBLE */ TYPESPEC, - /* RID_VOID */ TYPESPEC, - /* RID_ENUM */ ENUM, - /* RID_STRUCT */ STRUCT, - /* RID_UNION */ UNION, - /* RID_IF */ IF, - /* RID_ELSE */ ELSE, - /* RID_WHILE */ WHILE, - /* RID_DO */ DO, - /* RID_FOR */ FOR, - /* RID_SWITCH */ SWITCH, - /* RID_CASE */ CASE, - /* RID_DEFAULT */ DEFAULT, - /* RID_BREAK */ BREAK, - /* RID_CONTINUE */ CONTINUE, - /* RID_RETURN */ RETURN, - /* RID_GOTO */ GOTO, - /* RID_SIZEOF */ SIZEOF, - - /* C extensions */ - /* RID_ASM */ ASM_KEYWORD, - /* RID_TYPEOF */ TYPEOF, - /* RID_ALIGNOF */ ALIGNOF, - /* RID_ATTRIBUTE */ ATTRIBUTE, - /* RID_VA_ARG */ VA_ARG, - /* RID_EXTENSION */ EXTENSION, - /* RID_IMAGPART */ IMAGPART, - /* RID_REALPART */ REALPART, - /* RID_LABEL */ LABEL, - - /* RID_CHOOSE_EXPR */ CHOOSE_EXPR, - /* RID_TYPES_COMPATIBLE_P */ TYPES_COMPATIBLE_P, - - /* RID_FUNCTION_NAME */ FUNC_NAME, - /* RID_PRETTY_FUNCTION_NAME */ FUNC_NAME, - /* RID_C99_FUNCTION_NAME */ FUNC_NAME, - - /* C++ */ - /* RID_BOOL */ TYPESPEC, - /* RID_WCHAR */ 0, - /* RID_CLASS */ 0, - /* RID_PUBLIC */ 0, - /* RID_PRIVATE */ 0, - /* RID_PROTECTED */ 0, - /* RID_TEMPLATE */ 0, - /* RID_NULL */ 0, - /* RID_CATCH */ 0, - /* RID_DELETE */ 0, - /* RID_FALSE */ 0, - /* RID_NAMESPACE */ 0, - /* RID_NEW */ 0, - /* RID_OFFSETOF */ OFFSETOF, - /* RID_OPERATOR */ 0, - /* RID_THIS */ 0, - /* RID_THROW */ 0, - /* RID_TRUE */ 0, - /* RID_TRY */ 0, - /* RID_TYPENAME */ 0, - /* RID_TYPEID */ 0, - /* RID_USING */ 0, - - /* casts */ - /* RID_CONSTCAST */ 0, - /* RID_DYNCAST */ 0, - /* RID_REINTCAST */ 0, - /* RID_STATCAST */ 0, - - /* Objective C */ - /* RID_AT_ENCODE */ AT_ENCODE, - /* RID_AT_END */ AT_END, - /* RID_AT_CLASS */ AT_CLASS, - /* RID_AT_ALIAS */ AT_ALIAS, - /* RID_AT_DEFS */ AT_DEFS, - /* RID_AT_PRIVATE */ AT_PRIVATE, - /* RID_AT_PROTECTED */ AT_PROTECTED, - /* RID_AT_PUBLIC */ AT_PUBLIC, - /* RID_AT_PROTOCOL */ AT_PROTOCOL, - /* RID_AT_SELECTOR */ AT_SELECTOR, - /* RID_AT_THROW */ AT_THROW, - /* RID_AT_TRY */ AT_TRY, - /* RID_AT_CATCH */ AT_CATCH, - /* RID_AT_FINALLY */ AT_FINALLY, - /* RID_AT_SYNCHRONIZED */ AT_SYNCHRONIZED, - /* RID_AT_INTERFACE */ AT_INTERFACE, - /* RID_AT_IMPLEMENTATION */ AT_IMPLEMENTATION -}; - -static void -init_reswords (void) -{ - unsigned int i; - tree id; - int mask = (flag_isoc99 ? 0 : D_C89) - | (flag_no_asm ? (flag_isoc99 ? D_EXT : D_EXT|D_EXT89) : 0); - - if (!c_dialect_objc ()) - mask |= D_OBJC; - - ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX); - for (i = 0; i < N_reswords; i++) - { - /* If a keyword is disabled, do not enter it into the table - and so create a canonical spelling that isn't a keyword. */ - if (reswords[i].disable & mask) - continue; - - id = get_identifier (reswords[i].word); - C_RID_CODE (id) = reswords[i].rid; - C_IS_RESERVED_WORD (id) = 1; - ridpointers [(int) reswords[i].rid] = id; - } -} - -#define NAME(type) cpp_type2name (type) - -static void -yyerror (const char *msgid) -{ - c_parse_error (msgid, last_token, yylval.ttype); -} - -static int -yylexname (void) -{ - tree decl; - - - if (C_IS_RESERVED_WORD (yylval.ttype)) - { - enum rid rid_code = C_RID_CODE (yylval.ttype); - - { - /* Return the canonical spelling for this keyword. */ - yylval.ttype = ridpointers[(int) rid_code]; - return rid_to_yy[(int) rid_code]; - } - } - - decl = lookup_name (yylval.ttype); - if (decl) - { - if (TREE_CODE (decl) == TYPE_DECL) - return TYPENAME; - } - - return IDENTIFIER; -} - -static inline int -_yylex (void) -{ - get_next: - last_token = c_lex (&yylval.ttype); - switch (last_token) - { - case CPP_EQ: return '='; - case CPP_NOT: return '!'; - case CPP_GREATER: yylval.code = GT_EXPR; return ARITHCOMPARE; - case CPP_LESS: yylval.code = LT_EXPR; return ARITHCOMPARE; - case CPP_PLUS: yylval.code = PLUS_EXPR; return '+'; - case CPP_MINUS: yylval.code = MINUS_EXPR; return '-'; - case CPP_MULT: yylval.code = MULT_EXPR; return '*'; - case CPP_DIV: yylval.code = TRUNC_DIV_EXPR; return '/'; - case CPP_MOD: yylval.code = TRUNC_MOD_EXPR; return '%'; - case CPP_AND: yylval.code = BIT_AND_EXPR; return '&'; - case CPP_OR: yylval.code = BIT_IOR_EXPR; return '|'; - case CPP_XOR: yylval.code = BIT_XOR_EXPR; return '^'; - case CPP_RSHIFT: yylval.code = RSHIFT_EXPR; return RSHIFT; - case CPP_LSHIFT: yylval.code = LSHIFT_EXPR; return LSHIFT; - - case CPP_COMPL: return '~'; - case CPP_AND_AND: return ANDAND; - case CPP_OR_OR: return OROR; - case CPP_QUERY: return '?'; - case CPP_OPEN_PAREN: return '('; - case CPP_EQ_EQ: yylval.code = EQ_EXPR; return EQCOMPARE; - case CPP_NOT_EQ: yylval.code = NE_EXPR; return EQCOMPARE; - case CPP_GREATER_EQ:yylval.code = GE_EXPR; return ARITHCOMPARE; - case CPP_LESS_EQ: yylval.code = LE_EXPR; return ARITHCOMPARE; - - case CPP_PLUS_EQ: yylval.code = PLUS_EXPR; return ASSIGN; - case CPP_MINUS_EQ: yylval.code = MINUS_EXPR; return ASSIGN; - case CPP_MULT_EQ: yylval.code = MULT_EXPR; return ASSIGN; - case CPP_DIV_EQ: yylval.code = TRUNC_DIV_EXPR; return ASSIGN; - case CPP_MOD_EQ: yylval.code = TRUNC_MOD_EXPR; return ASSIGN; - case CPP_AND_EQ: yylval.code = BIT_AND_EXPR; return ASSIGN; - case CPP_OR_EQ: yylval.code = BIT_IOR_EXPR; return ASSIGN; - case CPP_XOR_EQ: yylval.code = BIT_XOR_EXPR; return ASSIGN; - case CPP_RSHIFT_EQ: yylval.code = RSHIFT_EXPR; return ASSIGN; - case CPP_LSHIFT_EQ: yylval.code = LSHIFT_EXPR; return ASSIGN; - - case CPP_OPEN_SQUARE: return '['; - case CPP_CLOSE_SQUARE: return ']'; - case CPP_OPEN_BRACE: return '{'; - case CPP_CLOSE_BRACE: return '}'; - case CPP_ELLIPSIS: return ELLIPSIS; - - case CPP_PLUS_PLUS: return PLUSPLUS; - case CPP_MINUS_MINUS: return MINUSMINUS; - case CPP_DEREF: return POINTSAT; - case CPP_DOT: return '.'; - - /* The following tokens may affect the interpretation of any - identifiers following, if doing Objective-C. */ - case CPP_COLON: OBJC_NEED_RAW_IDENTIFIER (0); return ':'; - case CPP_COMMA: OBJC_NEED_RAW_IDENTIFIER (0); return ','; - case CPP_CLOSE_PAREN: OBJC_NEED_RAW_IDENTIFIER (0); return ')'; - case CPP_SEMICOLON: OBJC_NEED_RAW_IDENTIFIER (0); return ';'; - - case CPP_EOF: - return 0; - - case CPP_NAME: - return yylexname (); - - case CPP_AT_NAME: - /* This only happens in Objective-C; it must be a keyword. */ - return rid_to_yy [(int) C_RID_CODE (yylval.ttype)]; - - case CPP_NUMBER: - case CPP_CHAR: - case CPP_WCHAR: - return CONSTANT; - - case CPP_STRING: - case CPP_WSTRING: - return STRING; - - case CPP_OBJC_STRING: - return OBJC_STRING; - - /* These tokens are C++ specific (and will not be generated - in C mode, but let's be cautious). */ - case CPP_SCOPE: - case CPP_DEREF_STAR: - case CPP_DOT_STAR: - case CPP_MIN_EQ: - case CPP_MAX_EQ: - case CPP_MIN: - case CPP_MAX: - /* These tokens should not survive translation phase 4. */ - case CPP_HASH: - case CPP_PASTE: - error ("syntax error at %qs token", NAME(last_token)); - goto get_next; - - default: - abort (); - } - /* NOTREACHED */ -} - -static int -yylex (void) -{ - int r; - timevar_push (TV_LEX); - r = _yylex(); - timevar_pop (TV_LEX); - return r; -} - -/* Function used when yydebug is set, to print a token in more detail. */ - -static void -yyprint (FILE *file, int yychar, YYSTYPE yyl) -{ - tree t = yyl.ttype; - - fprintf (file, " [%s]", NAME(last_token)); - - switch (yychar) - { - case IDENTIFIER: - case TYPENAME: - case TYPESPEC: - case TYPE_QUAL: - case SCSPEC: - case STATIC: - if (IDENTIFIER_POINTER (t)) - fprintf (file, " '%s'", IDENTIFIER_POINTER (t)); - break; - - case CONSTANT: - fprintf (file, " %s", GET_MODE_NAME (TYPE_MODE (TREE_TYPE (t)))); - if (TREE_CODE (t) == INTEGER_CST) - { - fputs (" ", file); - fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX, - TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t)); - } - break; - } -} - -/* This is not the ideal place to put this, but we have to get it out - of c-lex.c because cp/lex.c has its own version. */ - -/* Parse the file. */ -void -c_parse_file (void) -{ - yyparse (); - - if (malloced_yyss) - { - free (malloced_yyss); - free (malloced_yyvs); - malloced_yyss = 0; - } -} - -#ifdef __XGETTEXT__ -/* Depending on the version of Bison used to compile this grammar, - it may issue generic diagnostics spelled "syntax error" or - "parse error". To prevent this from changing the translation - template randomly, we list all the variants of this particular - diagnostic here. Translators: there is no fine distinction - between diagnostics with "syntax error" in them, and diagnostics - with "parse error" in them. It's okay to give them both the same - translation. */ -const char d1[] = N_("syntax error"); -const char d2[] = N_("parse error"); -const char d3[] = N_("syntax error; also virtual memory exhausted"); -const char d4[] = N_("parse error; also virtual memory exhausted"); -const char d5[] = N_("syntax error: cannot back up"); -const char d6[] = N_("parse error: cannot back up"); -#endif - -#include "gt-c-parse.h" +/* A Bison parser, made by GNU Bison 2.0. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + + 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, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Written by Richard Stallman by simplifying the original so called + ``semantic'' parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + IDENTIFIER = 258, + TYPENAME = 259, + SCSPEC = 260, + STATIC = 261, + TYPESPEC = 262, + TYPE_QUAL = 263, + OBJC_TYPE_QUAL = 264, + CONSTANT = 265, + STRING = 266, + ELLIPSIS = 267, + SIZEOF = 268, + ENUM = 269, + STRUCT = 270, + UNION = 271, + IF = 272, + ELSE = 273, + WHILE = 274, + DO = 275, + FOR = 276, + SWITCH = 277, + CASE = 278, + DEFAULT = 279, + BREAK = 280, + CONTINUE = 281, + RETURN = 282, + GOTO = 283, + ASM_KEYWORD = 284, + TYPEOF = 285, + ALIGNOF = 286, + ATTRIBUTE = 287, + EXTENSION = 288, + LABEL = 289, + REALPART = 290, + IMAGPART = 291, + VA_ARG = 292, + CHOOSE_EXPR = 293, + TYPES_COMPATIBLE_P = 294, + FUNC_NAME = 295, + OFFSETOF = 296, + ASSIGN = 297, + OROR = 298, + ANDAND = 299, + EQCOMPARE = 300, + ARITHCOMPARE = 301, + RSHIFT = 302, + LSHIFT = 303, + MINUSMINUS = 304, + PLUSPLUS = 305, + UNARY = 306, + HYPERUNARY = 307, + POINTSAT = 308, + AT_INTERFACE = 309, + AT_IMPLEMENTATION = 310, + AT_END = 311, + AT_SELECTOR = 312, + AT_DEFS = 313, + AT_ENCODE = 314, + CLASSNAME = 315, + AT_PUBLIC = 316, + AT_PRIVATE = 317, + AT_PROTECTED = 318, + AT_PROTOCOL = 319, + AT_CLASS = 320, + AT_ALIAS = 321, + AT_THROW = 322, + AT_TRY = 323, + AT_CATCH = 324, + AT_FINALLY = 325, + AT_SYNCHRONIZED = 326, + OBJC_STRING = 327 + }; +#endif +#define IDENTIFIER 258 +#define TYPENAME 259 +#define SCSPEC 260 +#define STATIC 261 +#define TYPESPEC 262 +#define TYPE_QUAL 263 +#define OBJC_TYPE_QUAL 264 +#define CONSTANT 265 +#define STRING 266 +#define ELLIPSIS 267 +#define SIZEOF 268 +#define ENUM 269 +#define STRUCT 270 +#define UNION 271 +#define IF 272 +#define ELSE 273 +#define WHILE 274 +#define DO 275 +#define FOR 276 +#define SWITCH 277 +#define CASE 278 +#define DEFAULT 279 +#define BREAK 280 +#define CONTINUE 281 +#define RETURN 282 +#define GOTO 283 +#define ASM_KEYWORD 284 +#define TYPEOF 285 +#define ALIGNOF 286 +#define ATTRIBUTE 287 +#define EXTENSION 288 +#define LABEL 289 +#define REALPART 290 +#define IMAGPART 291 +#define VA_ARG 292 +#define CHOOSE_EXPR 293 +#define TYPES_COMPATIBLE_P 294 +#define FUNC_NAME 295 +#define OFFSETOF 296 +#define ASSIGN 297 +#define OROR 298 +#define ANDAND 299 +#define EQCOMPARE 300 +#define ARITHCOMPARE 301 +#define RSHIFT 302 +#define LSHIFT 303 +#define MINUSMINUS 304 +#define PLUSPLUS 305 +#define UNARY 306 +#define HYPERUNARY 307 +#define POINTSAT 308 +#define AT_INTERFACE 309 +#define AT_IMPLEMENTATION 310 +#define AT_END 311 +#define AT_SELECTOR 312 +#define AT_DEFS 313 +#define AT_ENCODE 314 +#define CLASSNAME 315 +#define AT_PUBLIC 316 +#define AT_PRIVATE 317 +#define AT_PROTECTED 318 +#define AT_PROTOCOL 319 +#define AT_CLASS 320 +#define AT_ALIAS 321 +#define AT_THROW 322 +#define AT_TRY 323 +#define AT_CATCH 324 +#define AT_FINALLY 325 +#define AT_SYNCHRONIZED 326 +#define OBJC_STRING 327 + + + + +/* Copy the first part of user declarations. */ +#line 34 "c-parse.y" + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "tree.h" +#include "langhooks.h" +#include "input.h" +#include "cpplib.h" +#include "intl.h" +#include "timevar.h" +#include "c-pragma.h" /* For YYDEBUG definition, and parse_in. */ +#include "c-tree.h" +#include "flags.h" +#include "varray.h" +#include "output.h" +#include "toplev.h" +#include "ggc.h" +#include "c-common.h" + +#define YYERROR1 { yyerror ("syntax error"); YYERROR; } + +/* Like the default stack expander, except (1) use realloc when possible, + (2) impose no hard maxiumum on stack size, (3) REALLY do not use alloca. + + Irritatingly, YYSTYPE is defined after this %{ %} block, so we cannot + give malloced_yyvs its proper type. This is ok since all we need from + it is to be able to free it. */ + +static short *malloced_yyss; +static void *malloced_yyvs; + +#define yyoverflow(MSG, SS, SSSIZE, VS, VSSIZE, YYSSZ) \ +do { \ + size_t newsize; \ + short *newss; \ + YYSTYPE *newvs; \ + newsize = *(YYSSZ) *= 2; \ + if (malloced_yyss) \ + { \ + newss = really_call_realloc (*(SS), newsize * sizeof (short)); \ + newvs = really_call_realloc (*(VS), newsize * sizeof (YYSTYPE)); \ + } \ + else \ + { \ + newss = really_call_malloc (newsize * sizeof (short)); \ + newvs = really_call_malloc (newsize * sizeof (YYSTYPE)); \ + if (newss) \ + memcpy (newss, *(SS), (SSSIZE)); \ + if (newvs) \ + memcpy (newvs, *(VS), (VSSIZE)); \ + } \ + if (!newss || !newvs) \ + { \ + yyerror (MSG); \ + return 2; \ + } \ + *(SS) = newss; \ + *(VS) = newvs; \ + malloced_yyss = newss; \ + malloced_yyvs = (void *) newvs; \ +} while (0) + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +#line 100 "c-parse.y" +typedef union YYSTYPE {long itype; tree ttype; void *otype; struct c_expr exprtype; + struct c_arg_info *arginfotype; struct c_declarator *dtrtype; + struct c_type_name *typenametype; struct c_parm *parmtype; + struct c_declspecs *dsptype; struct c_typespec tstype; + enum tree_code code; location_t location; } YYSTYPE; +/* Line 190 of yacc.c. */ +#line 290 "c-parse.c" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + + + +/* Copy the second part of user declarations. */ +#line 251 "c-parse.y" + +/* Declaration specifiers of the current declaration. */ +static struct c_declspecs *current_declspecs; +static GTY(()) tree prefix_attributes; + +/* List of all the attributes applying to the identifier currently being + declared; includes prefix_attributes and possibly some more attributes + just after a comma. */ +static GTY(()) tree all_prefix_attributes; + +/* Structure to save declaration specifiers. */ +struct c_declspec_stack { + /* Saved value of current_declspecs. */ + struct c_declspecs *current_declspecs; + /* Saved value of prefix_attributes. */ + tree prefix_attributes; + /* Saved value of all_prefix_attributes. */ + tree all_prefix_attributes; + /* Next level of stack. */ + struct c_declspec_stack *next; +}; + +/* Stack of saved values of current_declspecs, prefix_attributes and + all_prefix_attributes. */ +static struct c_declspec_stack *declspec_stack; + +/* INDIRECT_REF with a TREE_TYPE of the type being queried for offsetof. */ +static tree offsetof_base; + +/* PUSH_DECLSPEC_STACK is called from setspecs; POP_DECLSPEC_STACK + should be called from the productions making use of setspecs. */ +#define PUSH_DECLSPEC_STACK \ + do { \ + struct c_declspec_stack *t = XOBNEW (&parser_obstack, \ + struct c_declspec_stack); \ + t->current_declspecs = current_declspecs; \ + t->prefix_attributes = prefix_attributes; \ + t->all_prefix_attributes = all_prefix_attributes; \ + t->next = declspec_stack; \ + declspec_stack = t; \ + } while (0) + +#define POP_DECLSPEC_STACK \ + do { \ + current_declspecs = declspec_stack->current_declspecs; \ + prefix_attributes = declspec_stack->prefix_attributes; \ + all_prefix_attributes = declspec_stack->all_prefix_attributes; \ + declspec_stack = declspec_stack->next; \ + } while (0) + +/* For __extension__, save/restore the warning flags which are + controlled by __extension__. */ +#define SAVE_EXT_FLAGS() \ + (pedantic \ + | (warn_pointer_arith << 1) \ + | (warn_traditional << 2) \ + | (flag_iso << 3)) + +#define RESTORE_EXT_FLAGS(val) \ + do { \ + pedantic = val & 1; \ + warn_pointer_arith = (val >> 1) & 1; \ + warn_traditional = (val >> 2) & 1; \ + flag_iso = (val >> 3) & 1; \ + } while (0) + + +#define OBJC_NEED_RAW_IDENTIFIER(VAL) /* nothing */ + +/* Tell yyparse how to print a token's value, if yydebug is set. */ + +#define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL) + +static void yyprint (FILE *, int, YYSTYPE); +static void yyerror (const char *); +static int yylexname (void); +static inline int _yylex (void); +static int yylex (void); +static void init_reswords (void); + + /* Initialization routine for this file. */ +void +c_parse_init (void) +{ + init_reswords (); +} + + + +/* Line 213 of yacc.c. */ +#line 390 "c-parse.c" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +# ifndef YYFREE +# define YYFREE free +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# endif + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# else +# define YYSTACK_ALLOC alloca +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short int yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined (__GNUC__) && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short int yysigned_char; +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 4 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 3307 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 95 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 209 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 574 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 933 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 327 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 90, 2, 2, 2, 59, 50, 2, + 65, 92, 57, 55, 91, 56, 64, 58, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 45, 87, + 2, 42, 2, 44, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 66, 2, 94, 49, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 93, 48, 88, 89, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 43, 46, 47, + 51, 52, 53, 54, 60, 61, 62, 63, 67, 68, + 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, + 79, 80, 81, 82, 83, 84, 85, 86 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned short int yyprhs[] = +{ + 0, 0, 3, 4, 6, 7, 11, 12, 17, 19, + 21, 23, 26, 27, 31, 36, 41, 44, 47, 50, + 52, 53, 54, 63, 68, 69, 70, 79, 84, 85, + 86, 94, 98, 100, 102, 104, 106, 108, 110, 112, + 114, 116, 118, 122, 123, 125, 127, 131, 133, 136, + 139, 142, 145, 148, 153, 156, 161, 164, 167, 169, + 171, 173, 175, 180, 182, 186, 190, 194, 198, 202, + 206, 210, 214, 218, 222, 226, 230, 231, 236, 237, + 242, 243, 244, 252, 253, 259, 263, 267, 269, 271, + 273, 275, 276, 284, 288, 292, 296, 300, 305, 312, + 313, 321, 326, 335, 340, 347, 352, 357, 361, 365, + 368, 371, 373, 377, 382, 383, 385, 388, 390, 392, + 395, 398, 403, 408, 411, 414, 417, 418, 420, 425, + 430, 434, 438, 441, 444, 446, 449, 452, 455, 458, + 461, 463, 466, 468, 471, 474, 477, 480, 483, 486, + 488, 491, 494, 497, 500, 503, 506, 509, 512, 515, + 518, 521, 524, 527, 530, 533, 536, 538, 541, 544, + 547, 550, 553, 556, 559, 562, 565, 568, 571, 574, + 577, 580, 583, 586, 589, 592, 595, 598, 601, 604, + 607, 610, 613, 616, 619, 622, 625, 628, 631, 634, + 637, 640, 643, 646, 649, 652, 655, 658, 661, 664, + 667, 670, 672, 674, 676, 678, 680, 682, 684, 686, + 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, + 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, + 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, + 748, 750, 752, 754, 756, 758, 760, 762, 764, 766, + 768, 770, 772, 774, 776, 778, 780, 782, 783, 785, + 787, 789, 791, 793, 795, 797, 799, 804, 809, 811, + 816, 818, 823, 824, 831, 835, 836, 843, 847, 848, + 850, 852, 855, 864, 868, 870, 874, 875, 877, 882, + 889, 894, 896, 898, 900, 902, 904, 906, 908, 909, + 914, 916, 917, 920, 922, 926, 930, 933, 934, 939, + 941, 942, 947, 949, 951, 953, 956, 959, 961, 967, + 971, 972, 973, 980, 981, 982, 989, 991, 993, 998, + 1002, 1005, 1009, 1011, 1013, 1015, 1019, 1022, 1024, 1028, + 1031, 1035, 1039, 1044, 1048, 1053, 1057, 1060, 1062, 1064, + 1067, 1069, 1072, 1074, 1077, 1078, 1086, 1092, 1093, 1101, + 1107, 1108, 1117, 1118, 1126, 1129, 1132, 1135, 1136, 1138, + 1139, 1141, 1143, 1146, 1147, 1151, 1154, 1158, 1161, 1165, + 1167, 1169, 1172, 1174, 1179, 1181, 1186, 1189, 1194, 1198, + 1201, 1206, 1210, 1212, 1216, 1218, 1220, 1224, 1225, 1229, + 1230, 1232, 1233, 1235, 1238, 1240, 1242, 1244, 1248, 1251, + 1255, 1260, 1264, 1267, 1270, 1272, 1277, 1281, 1286, 1292, + 1298, 1300, 1302, 1304, 1306, 1308, 1311, 1314, 1317, 1320, + 1322, 1325, 1328, 1331, 1333, 1336, 1339, 1342, 1345, 1347, + 1350, 1352, 1354, 1356, 1358, 1361, 1362, 1363, 1365, 1367, + 1370, 1374, 1376, 1379, 1381, 1383, 1387, 1389, 1391, 1394, + 1397, 1398, 1399, 1402, 1406, 1409, 1412, 1415, 1419, 1423, + 1425, 1435, 1445, 1453, 1461, 1462, 1463, 1473, 1474, 1475, + 1489, 1490, 1492, 1495, 1497, 1500, 1502, 1515, 1516, 1525, + 1528, 1530, 1532, 1534, 1536, 1538, 1541, 1544, 1547, 1551, + 1553, 1557, 1562, 1564, 1566, 1568, 1572, 1578, 1581, 1586, + 1593, 1594, 1596, 1599, 1604, 1613, 1615, 1619, 1625, 1633, + 1634, 1636, 1637, 1639, 1641, 1645, 1652, 1662, 1664, 1668, + 1670, 1671, 1672, 1673, 1677, 1680, 1681, 1682, 1689, 1692, + 1693, 1695, 1697, 1701, 1703, 1707, 1712, 1717, 1721, 1726, + 1730, 1735, 1740, 1744, 1749, 1753, 1755, 1756, 1760, 1762, + 1765, 1767, 1771, 1773, 1777 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const short int yyrhs[] = +{ + 96, 0, -1, -1, 97, -1, -1, 101, 98, 100, + -1, -1, 97, 101, 99, 100, -1, 103, -1, 102, + -1, 277, -1, 303, 100, -1, -1, 135, 169, 87, + -1, 155, 135, 169, 87, -1, 154, 135, 168, 87, + -1, 161, 87, -1, 1, 87, -1, 1, 88, -1, + 87, -1, -1, -1, 154, 135, 198, 104, 130, 250, + 105, 244, -1, 154, 135, 198, 1, -1, -1, -1, + 155, 135, 203, 106, 130, 250, 107, 244, -1, 155, + 135, 203, 1, -1, -1, -1, 135, 203, 108, 130, + 250, 109, 244, -1, 135, 203, 1, -1, 3, -1, + 4, -1, 50, -1, 56, -1, 55, -1, 61, -1, + 60, -1, 89, -1, 90, -1, 120, -1, 112, 91, + 120, -1, -1, 114, -1, 120, -1, 114, 91, 120, + -1, 126, -1, 57, 119, -1, 303, 119, -1, 111, + 119, -1, 47, 110, -1, 116, 115, -1, 116, 65, + 224, 92, -1, 117, 115, -1, 117, 65, 224, 92, + -1, 35, 119, -1, 36, 119, -1, 13, -1, 31, + -1, 30, -1, 115, -1, 65, 224, 92, 119, -1, + 119, -1, 120, 55, 120, -1, 120, 56, 120, -1, + 120, 57, 120, -1, 120, 58, 120, -1, 120, 59, + 120, -1, 120, 54, 120, -1, 120, 53, 120, -1, + 120, 52, 120, -1, 120, 51, 120, -1, 120, 50, + 120, -1, 120, 48, 120, -1, 120, 49, 120, -1, + -1, 120, 47, 121, 120, -1, -1, 120, 46, 122, + 120, -1, -1, -1, 120, 44, 123, 112, 45, 124, + 120, -1, -1, 120, 44, 125, 45, 120, -1, 120, + 42, 120, -1, 120, 43, 120, -1, 3, -1, 10, + -1, 11, -1, 40, -1, -1, 65, 224, 92, 93, + 127, 183, 88, -1, 65, 112, 92, -1, 65, 1, + 92, -1, 248, 246, 92, -1, 248, 1, 92, -1, + 126, 65, 113, 92, -1, 37, 65, 120, 91, 224, + 92, -1, -1, 41, 65, 224, 91, 128, 129, 92, + -1, 41, 65, 1, 92, -1, 38, 65, 120, 91, + 120, 91, 120, 92, -1, 38, 65, 1, 92, -1, + 39, 65, 224, 91, 224, 92, -1, 39, 65, 1, + 92, -1, 126, 66, 112, 94, -1, 126, 64, 110, + -1, 126, 67, 110, -1, 126, 61, -1, 126, 60, + -1, 110, -1, 129, 64, 110, -1, 129, 66, 112, + 94, -1, -1, 132, -1, 250, 133, -1, 131, -1, + 239, -1, 132, 131, -1, 131, 239, -1, 156, 135, + 168, 87, -1, 157, 135, 169, 87, -1, 156, 87, + -1, 157, 87, -1, 250, 137, -1, -1, 174, -1, + 154, 135, 168, 87, -1, 155, 135, 169, 87, -1, + 154, 135, 192, -1, 155, 135, 195, -1, 161, 87, + -1, 303, 137, -1, 8, -1, 138, 8, -1, 139, + 8, -1, 138, 175, -1, 140, 8, -1, 141, 8, + -1, 175, -1, 140, 175, -1, 163, -1, 142, 8, + -1, 143, 8, -1, 142, 165, -1, 143, 165, -1, + 138, 163, -1, 139, 163, -1, 164, -1, 142, 175, + -1, 142, 166, -1, 143, 166, -1, 138, 164, -1, + 139, 164, -1, 144, 8, -1, 145, 8, -1, 144, + 165, -1, 145, 165, -1, 140, 163, -1, 141, 163, + -1, 144, 175, -1, 144, 166, -1, 145, 166, -1, + 140, 164, -1, 141, 164, -1, 180, -1, 146, 8, + -1, 147, 8, -1, 138, 180, -1, 139, 180, -1, + 146, 180, -1, 147, 180, -1, 146, 175, -1, 148, + 8, -1, 149, 8, -1, 140, 180, -1, 141, 180, + -1, 148, 180, -1, 149, 180, -1, 148, 175, -1, + 150, 8, -1, 151, 8, -1, 150, 165, -1, 151, + 165, -1, 146, 163, -1, 147, 163, -1, 142, 180, + -1, 143, 180, -1, 150, 180, -1, 151, 180, -1, + 150, 175, -1, 150, 166, -1, 151, 166, -1, 146, + 164, -1, 147, 164, -1, 152, 8, -1, 153, 8, + -1, 152, 165, -1, 153, 165, -1, 148, 163, -1, + 149, 163, -1, 144, 180, -1, 145, 180, -1, 152, + 180, -1, 153, 180, -1, 152, 175, -1, 152, 166, + -1, 153, 166, -1, 148, 164, -1, 149, 164, -1, + 142, -1, 143, -1, 144, -1, 145, -1, 150, -1, + 151, -1, 152, -1, 153, -1, 138, -1, 139, -1, + 140, -1, 141, -1, 146, -1, 147, -1, 148, -1, + 149, -1, 142, -1, 143, -1, 150, -1, 151, -1, + 138, -1, 139, -1, 146, -1, 147, -1, 142, -1, + 143, -1, 144, -1, 145, -1, 138, -1, 139, -1, + 140, -1, 141, -1, 142, -1, 143, -1, 144, -1, + 145, -1, 138, -1, 139, -1, 140, -1, 141, -1, + 138, -1, 139, -1, 140, -1, 141, -1, 142, -1, + 143, -1, 144, -1, 145, -1, 146, -1, 147, -1, + 148, -1, 149, -1, 150, -1, 151, -1, 152, -1, + 153, -1, -1, 159, -1, 165, -1, 167, -1, 166, + -1, 7, -1, 212, -1, 207, -1, 4, -1, 118, + 65, 112, 92, -1, 118, 65, 224, 92, -1, 170, + -1, 168, 91, 136, 170, -1, 172, -1, 169, 91, + 136, 172, -1, -1, 198, 276, 174, 42, 171, 181, + -1, 198, 276, 174, -1, -1, 203, 276, 174, 42, + 173, 181, -1, 203, 276, 174, -1, -1, 175, -1, + 176, -1, 175, 176, -1, 32, 286, 65, 65, 177, + 92, 92, 287, -1, 32, 1, 287, -1, 178, -1, + 177, 91, 178, -1, -1, 179, -1, 179, 65, 3, + 92, -1, 179, 65, 3, 91, 114, 92, -1, 179, + 65, 113, 92, -1, 110, -1, 180, -1, 7, -1, + 8, -1, 6, -1, 5, -1, 120, -1, -1, 93, + 182, 183, 88, -1, 1, -1, -1, 184, 213, -1, + 185, -1, 184, 91, 185, -1, 189, 42, 187, -1, + 191, 187, -1, -1, 110, 45, 186, 187, -1, 187, + -1, -1, 93, 188, 183, 88, -1, 120, -1, 1, + -1, 190, -1, 189, 190, -1, 64, 110, -1, 191, + -1, 66, 120, 12, 120, 94, -1, 66, 120, 94, + -1, -1, -1, 198, 193, 130, 250, 194, 249, -1, + -1, -1, 203, 196, 130, 250, 197, 249, -1, 199, + -1, 203, -1, 65, 174, 199, 92, -1, 199, 65, + 298, -1, 199, 232, -1, 57, 162, 199, -1, 4, + -1, 201, -1, 202, -1, 201, 65, 298, -1, 201, + 232, -1, 4, -1, 202, 65, 298, -1, 202, 232, + -1, 57, 162, 201, -1, 57, 162, 202, -1, 65, + 174, 202, 92, -1, 203, 65, 298, -1, 65, 174, + 203, 92, -1, 57, 162, 203, -1, 203, 232, -1, + 3, -1, 15, -1, 15, 175, -1, 16, -1, 16, + 175, -1, 14, -1, 14, 175, -1, -1, 204, 110, + 93, 208, 215, 88, 174, -1, 204, 93, 215, 88, + 174, -1, -1, 205, 110, 93, 209, 215, 88, 174, + -1, 205, 93, 215, 88, 174, -1, -1, 206, 110, + 93, 210, 222, 214, 88, 174, -1, -1, 206, 93, + 211, 222, 214, 88, 174, -1, 204, 110, -1, 205, + 110, -1, 206, 110, -1, -1, 91, -1, -1, 91, + -1, 216, -1, 216, 217, -1, -1, 216, 217, 87, + -1, 216, 87, -1, 158, 135, 218, -1, 158, 135, + -1, 159, 135, 219, -1, 159, -1, 1, -1, 303, + 217, -1, 220, -1, 218, 91, 136, 220, -1, 221, + -1, 219, 91, 136, 221, -1, 198, 174, -1, 198, + 45, 120, 174, -1, 45, 120, 174, -1, 203, 174, + -1, 203, 45, 120, 174, -1, 45, 120, 174, -1, + 223, -1, 222, 91, 223, -1, 1, -1, 110, -1, + 110, 42, 120, -1, -1, 160, 225, 226, -1, -1, + 228, -1, -1, 228, -1, 229, 175, -1, 230, -1, + 229, -1, 231, -1, 57, 162, 229, -1, 57, 162, + -1, 57, 162, 230, -1, 65, 174, 228, 92, -1, + 231, 65, 288, -1, 231, 232, -1, 65, 288, -1, + 232, -1, 66, 162, 120, 94, -1, 66, 162, 94, + -1, 66, 162, 57, 94, -1, 66, 6, 162, 120, + 94, -1, 66, 159, 6, 120, 94, -1, 234, -1, + 235, -1, 236, -1, 237, -1, 253, -1, 234, 253, + -1, 235, 253, -1, 236, 253, -1, 237, 253, -1, + 134, -1, 234, 134, -1, 235, 134, -1, 237, 134, + -1, 254, -1, 234, 254, -1, 235, 254, -1, 236, + 254, -1, 237, 254, -1, 239, -1, 238, 239, -1, + 234, -1, 235, -1, 236, -1, 237, -1, 1, 87, + -1, -1, -1, 242, -1, 243, -1, 242, 243, -1, + 34, 302, 87, -1, 249, -1, 1, 249, -1, 93, + -1, 88, -1, 241, 247, 88, -1, 233, -1, 1, + -1, 65, 93, -1, 245, 246, -1, -1, -1, 251, + 254, -1, 240, 251, 253, -1, 250, 273, -1, 250, + 274, -1, 250, 112, -1, 240, 251, 258, -1, 240, + 251, 87, -1, 252, -1, 17, 240, 250, 65, 255, + 92, 256, 18, 257, -1, 17, 240, 250, 65, 255, + 92, 257, 18, 257, -1, 17, 240, 250, 65, 255, + 92, 256, -1, 17, 240, 250, 65, 255, 92, 257, + -1, -1, -1, 19, 240, 250, 65, 255, 92, 259, + 260, 252, -1, -1, -1, 20, 240, 250, 259, 260, + 252, 19, 263, 264, 65, 255, 92, 87, -1, -1, + 112, -1, 265, 87, -1, 137, -1, 250, 265, -1, + 265, -1, 21, 240, 65, 266, 250, 267, 87, 268, + 92, 259, 260, 252, -1, -1, 22, 240, 65, 112, + 92, 271, 259, 252, -1, 112, 87, -1, 258, -1, + 261, -1, 262, -1, 269, -1, 270, -1, 25, 87, + -1, 26, 87, -1, 27, 87, -1, 27, 112, 87, + -1, 278, -1, 28, 110, 87, -1, 28, 57, 112, + 87, -1, 87, -1, 249, -1, 272, -1, 23, 120, + 45, -1, 23, 120, 12, 120, 45, -1, 24, 45, + -1, 110, 250, 45, 174, -1, 29, 286, 65, 285, + 92, 287, -1, -1, 275, -1, 275, 87, -1, 29, + 1, 287, 87, -1, 29, 280, 286, 65, 279, 92, + 287, 87, -1, 285, -1, 285, 45, 281, -1, 285, + 45, 281, 45, 281, -1, 285, 45, 281, 45, 281, + 45, 284, -1, -1, 8, -1, -1, 282, -1, 283, + -1, 282, 91, 283, -1, 285, 287, 65, 112, 92, + 286, -1, 66, 110, 94, 285, 287, 65, 112, 92, + 286, -1, 285, -1, 284, 91, 285, -1, 11, -1, + -1, -1, -1, 174, 289, 290, -1, 293, 92, -1, + -1, -1, 294, 87, 291, 174, 292, 290, -1, 1, + 92, -1, -1, 12, -1, 294, -1, 294, 91, 12, + -1, 296, -1, 294, 91, 295, -1, 154, 135, 200, + 174, -1, 154, 135, 203, 174, -1, 154, 135, 227, + -1, 155, 135, 203, 174, -1, 155, 135, 227, -1, + 156, 297, 200, 174, -1, 156, 297, 203, 174, -1, + 156, 297, 227, -1, 157, 297, 203, 174, -1, 157, + 297, 227, -1, 135, -1, -1, 174, 299, 300, -1, + 290, -1, 301, 92, -1, 3, -1, 301, 91, 3, + -1, 110, -1, 302, 91, 110, -1, 33, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned short int yyrline[] = +{ + 0, 342, 342, 345, 353, 353, 356, 355, 361, 362, + 363, 364, 371, 375, 378, 380, 382, 384, 385, 386, + 393, 398, 392, 403, 406, 411, 405, 416, 419, 424, + 418, 429, 434, 435, 438, 440, 442, 447, 449, 451, + 453, 457, 458, 465, 466, 470, 472, 477, 478, 482, + 485, 490, 493, 500, 504, 509, 514, 517, 523, 527, + 531, 535, 536, 542, 543, 545, 547, 549, 551, 553, + 555, 557, 559, 561, 563, 565, 568, 567, 575, 574, + 582, 586, 581, 594, 593, 605, 609, 617, 624, 626, + 628, 632, 631, 652, 657, 659, 665, 670, 673, 678, + 677, 687, 689, 701, 703, 715, 717, 720, 723, 729, + 732, 742, 744, 746, 750, 752, 759, 764, 765, 766, + 767, 775, 777, 779, 782, 791, 800, 820, 825, 827, + 829, 831, 833, 835, 881, 883, 885, 890, 895, 897, + 902, 904, 909, 911, 913, 915, 917, 919, 921, 926, + 928, 930, 932, 934, 936, 941, 943, 945, 947, 949, + 951, 956, 958, 960, 962, 964, 969, 971, 973, 975, + 977, 979, 981, 986, 991, 993, 995, 997, 999, 1001, + 1006, 1011, 1013, 1015, 1017, 1019, 1021, 1023, 1025, 1027, + 1029, 1034, 1036, 1038, 1040, 1042, 1047, 1049, 1051, 1053, + 1055, 1057, 1059, 1061, 1063, 1065, 1070, 1072, 1074, 1076, + 1078, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1095, + 1096, 1097, 1098, 1099, 1100, 1101, 1102, 1106, 1107, 1108, + 1109, 1113, 1114, 1115, 1116, 1120, 1121, 1122, 1123, 1127, + 1128, 1129, 1130, 1134, 1135, 1136, 1137, 1138, 1139, 1140, + 1141, 1145, 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, + 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1166, 1167, 1193, + 1194, 1198, 1202, 1206, 1210, 1214, 1219, 1229, 1241, 1242, + 1246, 1247, 1252, 1251, 1266, 1276, 1275, 1290, 1300, 1301, + 1306, 1308, 1313, 1316, 1321, 1323, 1329, 1330, 1332, 1334, + 1336, 1344, 1345, 1346, 1347, 1351, 1352, 1358, 1361, 1360, + 1364, 1371, 1373, 1377, 1378, 1384, 1387, 1391, 1390, 1396, + 1401, 1400, 1404, 1406, 1410, 1411, 1415, 1417, 1421, 1425, + 1431, 1443, 1430, 1461, 1473, 1460, 1493, 1494, 1500, 1502, + 1504, 1506, 1508, 1517, 1518, 1522, 1524, 1526, 1531, 1533, + 1535, 1537, 1539, 1547, 1549, 1551, 1553, 1555, 1560, 1562, + 1567, 1569, 1574, 1576, 1588, 1587, 1595, 1602, 1601, 1607, + 1614, 1613, 1620, 1619, 1628, 1630, 1632, 1640, 1642, 1645, + 1647, 1665, 1667, 1673, 1674, 1676, 1682, 1685, 1693, 1696, + 1701, 1703, 1709, 1710, 1715, 1716, 1721, 1725, 1729, 1737, + 1741, 1745, 1756, 1757, 1762, 1768, 1770, 1776, 1775, 1786, + 1787, 1792, 1794, 1797, 1804, 1805, 1809, 1810, 1815, 1818, + 1823, 1825, 1827, 1829, 1832, 1840, 1842, 1844, 1846, 1849, + 1860, 1861, 1862, 1866, 1870, 1871, 1872, 1873, 1874, 1878, + 1879, 1885, 1886, 1890, 1891, 1892, 1893, 1894, 1898, 1899, + 1903, 1904, 1905, 1906, 1909, 1914, 1919, 1921, 1927, 1928, + 1932, 1946, 1948, 1951, 1954, 1955, 1959, 1960, 1964, 1975, + 1984, 1989, 1991, 1996, 2001, 2019, 2023, 2036, 2041, 2045, + 2049, 2053, 2057, 2061, 2068, 2072, 2076, 2087, 2088, 2085, + 2097, 2098, 2103, 2105, 2109, 2121, 2126, 2137, 2136, 2149, + 2151, 2153, 2155, 2157, 2159, 2161, 2163, 2165, 2167, 2169, + 2170, 2172, 2174, 2180, 2182, 2189, 2191, 2193, 2195, 2212, + 2220, 2221, 2226, 2228, 2235, 2242, 2245, 2248, 2251, 2259, + 2260, 2274, 2275, 2279, 2280, 2285, 2289, 2297, 2299, 2305, + 2317, 2321, 2332, 2331, 2340, 2342, 2344, 2341, 2348, 2359, + 2364, 2373, 2375, 2380, 2382, 2389, 2393, 2397, 2400, 2405, + 2413, 2417, 2421, 2424, 2429, 2435, 2445, 2444, 2453, 2454, + 2469, 2471, 2477, 2479, 2484 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "IDENTIFIER", "TYPENAME", "SCSPEC", + "STATIC", "TYPESPEC", "TYPE_QUAL", "OBJC_TYPE_QUAL", "CONSTANT", + "STRING", "ELLIPSIS", "SIZEOF", "ENUM", "STRUCT", "UNION", "IF", "ELSE", + "WHILE", "DO", "FOR", "SWITCH", "CASE", "DEFAULT", "BREAK", "CONTINUE", + "RETURN", "GOTO", "ASM_KEYWORD", "TYPEOF", "ALIGNOF", "ATTRIBUTE", + "EXTENSION", "LABEL", "REALPART", "IMAGPART", "VA_ARG", "CHOOSE_EXPR", + "TYPES_COMPATIBLE_P", "FUNC_NAME", "OFFSETOF", "'='", "ASSIGN", "'?'", + "':'", "OROR", "ANDAND", "'|'", "'^'", "'&'", "EQCOMPARE", + "ARITHCOMPARE", "RSHIFT", "LSHIFT", "'+'", "'-'", "'*'", "'/'", "'%'", + "MINUSMINUS", "PLUSPLUS", "UNARY", "HYPERUNARY", "'.'", "'('", "'['", + "POINTSAT", "AT_INTERFACE", "AT_IMPLEMENTATION", "AT_END", "AT_SELECTOR", + "AT_DEFS", "AT_ENCODE", "CLASSNAME", "AT_PUBLIC", "AT_PRIVATE", + "AT_PROTECTED", "AT_PROTOCOL", "AT_CLASS", "AT_ALIAS", "AT_THROW", + "AT_TRY", "AT_CATCH", "AT_FINALLY", "AT_SYNCHRONIZED", "OBJC_STRING", + "';'", "'}'", "'~'", "'!'", "','", "')'", "'{'", "']'", "$accept", + "program", "extdefs", "@1", "@2", "extdef", "save_obstack_position", + "datadef", "fndef", "@3", "@4", "@5", "@6", "@7", "@8", "identifier", + "unop", "expr", "exprlist", "nonnull_exprlist", "unary_expr", "sizeof", + "alignof", "typeof", "cast_expr", "expr_no_commas", "@9", "@10", "@11", + "@12", "@13", "primary", "@14", "@15", "offsetof_member_designator", + "old_style_parm_decls", "lineno_datadecl", "datadecls", "datadecl", + "lineno_decl", "setspecs", "maybe_resetattrs", "decl", + "declspecs_nosc_nots_nosa_noea", "declspecs_nosc_nots_nosa_ea", + "declspecs_nosc_nots_sa_noea", "declspecs_nosc_nots_sa_ea", + "declspecs_nosc_ts_nosa_noea", "declspecs_nosc_ts_nosa_ea", + "declspecs_nosc_ts_sa_noea", "declspecs_nosc_ts_sa_ea", + "declspecs_sc_nots_nosa_noea", "declspecs_sc_nots_nosa_ea", + "declspecs_sc_nots_sa_noea", "declspecs_sc_nots_sa_ea", + "declspecs_sc_ts_nosa_noea", "declspecs_sc_ts_nosa_ea", + "declspecs_sc_ts_sa_noea", "declspecs_sc_ts_sa_ea", "declspecs_ts", + "declspecs_nots", "declspecs_ts_nosa", "declspecs_nots_nosa", + "declspecs_nosc_ts", "declspecs_nosc_nots", "declspecs_nosc", + "declspecs", "maybe_type_quals_attrs", "typespec_nonattr", + "typespec_attr", "typespec_reserved_nonattr", "typespec_reserved_attr", + "typespec_nonreserved_nonattr", "initdecls", "notype_initdecls", + "initdcl", "@16", "notype_initdcl", "@17", "maybe_attribute", + "attributes", "attribute", "attribute_list", "attrib", "any_word", + "scspec", "init", "@18", "initlist_maybe_comma", "initlist1", "initelt", + "@19", "initval", "@20", "designator_list", "designator", + "array_designator", "nested_function", "@21", "@22", + "notype_nested_function", "@23", "@24", "declarator", + "after_type_declarator", "parm_declarator", + "parm_declarator_starttypename", "parm_declarator_nostarttypename", + "notype_declarator", "struct_head", "union_head", "enum_head", + "structsp_attr", "@25", "@26", "@27", "@28", "structsp_nonattr", + "maybecomma", "maybecomma_warn", "component_decl_list", + "component_decl_list2", "component_decl", "components", + "components_notype", "component_declarator", + "component_notype_declarator", "enumlist", "enumerator", "typename", + "@29", "absdcl", "absdcl_maybe_attribute", "absdcl1", "absdcl1_noea", + "absdcl1_ea", "direct_absdcl1", "array_declarator", "stmts_and_decls", + "lineno_stmt_decl_or_labels_ending_stmt", + "lineno_stmt_decl_or_labels_ending_decl", + "lineno_stmt_decl_or_labels_ending_label", + "lineno_stmt_decl_or_labels_ending_error", "lineno_stmt_decl_or_labels", + "errstmt", "c99_block_start", "maybe_label_decls", "label_decls", + "label_decl", "compstmt_or_error", "compstmt_start", "compstmt_nostart", + "compstmt_contents_nonempty", "compstmt_primary_start", "compstmt", + "save_location", "lineno_labels", "c99_block_lineno_labeled_stmt", + "lineno_stmt", "lineno_label", "condition", "if_statement_1", + "if_statement_2", "if_statement", "start_break", "start_continue", + "while_statement", "do_statement", "@30", "@31", "xexpr", + "for_init_stmt", "for_cond_expr", "for_incr_expr", "for_statement", + "switch_statement", "@32", "stmt_nocomp", "stmt", "label", + "simple_asm_expr", "maybeasm", "asmdef", "asm_stmt", "asm_argument", + "maybe_volatile", "asm_operands", "nonnull_asm_operands", "asm_operand", + "asm_clobbers", "asm_string", "stop_string_translation", + "start_string_translation", "parmlist", "@33", "parmlist_1", "@34", + "@35", "parmlist_2", "parms", "parm", "firstparm", "setspecs_fp", + "parmlist_or_identifiers", "@36", "parmlist_or_identifiers_1", + "identifiers", "identifiers_or_typenames", "extension", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short int yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 61, 297, 63, 58, 298, 299, 124, 94, + 38, 300, 301, 302, 303, 43, 45, 42, 47, 37, + 304, 305, 306, 307, 46, 40, 91, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 59, 125, 126, + 33, 44, 41, 123, 93 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned short int yyr1[] = +{ + 0, 95, 96, 96, 98, 97, 99, 97, 100, 100, + 100, 100, 101, 102, 102, 102, 102, 102, 102, 102, + 104, 105, 103, 103, 106, 107, 103, 103, 108, 109, + 103, 103, 110, 110, 111, 111, 111, 111, 111, 111, + 111, 112, 112, 113, 113, 114, 114, 115, 115, 115, + 115, 115, 115, 115, 115, 115, 115, 115, 116, 117, + 118, 119, 119, 120, 120, 120, 120, 120, 120, 120, + 120, 120, 120, 120, 120, 120, 121, 120, 122, 120, + 123, 124, 120, 125, 120, 120, 120, 126, 126, 126, + 126, 127, 126, 126, 126, 126, 126, 126, 126, 128, + 126, 126, 126, 126, 126, 126, 126, 126, 126, 126, + 126, 129, 129, 129, 130, 130, 131, 132, 132, 132, + 132, 133, 133, 133, 133, 134, 135, 136, 137, 137, + 137, 137, 137, 137, 138, 138, 138, 139, 140, 140, + 141, 141, 142, 142, 142, 142, 142, 142, 142, 143, + 143, 143, 143, 143, 143, 144, 144, 144, 144, 144, + 144, 145, 145, 145, 145, 145, 146, 146, 146, 146, + 146, 146, 146, 147, 148, 148, 148, 148, 148, 148, + 149, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 151, 151, 151, 151, 151, 152, 152, 152, 152, + 152, 152, 152, 152, 152, 152, 153, 153, 153, 153, + 153, 154, 154, 154, 154, 154, 154, 154, 154, 155, + 155, 155, 155, 155, 155, 155, 155, 156, 156, 156, + 156, 157, 157, 157, 157, 158, 158, 158, 158, 159, + 159, 159, 159, 160, 160, 160, 160, 160, 160, 160, + 160, 161, 161, 161, 161, 161, 161, 161, 161, 161, + 161, 161, 161, 161, 161, 161, 161, 162, 162, 163, + 163, 164, 165, 165, 166, 167, 167, 167, 168, 168, + 169, 169, 171, 170, 170, 173, 172, 172, 174, 174, + 175, 175, 176, 176, 177, 177, 178, 178, 178, 178, + 178, 179, 179, 179, 179, 180, 180, 181, 182, 181, + 181, 183, 183, 184, 184, 185, 185, 186, 185, 185, + 188, 187, 187, 187, 189, 189, 190, 190, 191, 191, + 193, 194, 192, 196, 197, 195, 198, 198, 199, 199, + 199, 199, 199, 200, 200, 201, 201, 201, 202, 202, + 202, 202, 202, 203, 203, 203, 203, 203, 204, 204, + 205, 205, 206, 206, 208, 207, 207, 209, 207, 207, + 210, 207, 211, 207, 212, 212, 212, 213, 213, 214, + 214, 215, 215, 216, 216, 216, 217, 217, 217, 217, + 217, 217, 218, 218, 219, 219, 220, 220, 220, 221, + 221, 221, 222, 222, 222, 223, 223, 225, 224, 226, + 226, 227, 227, 227, 228, 228, 229, 229, 230, 230, + 231, 231, 231, 231, 231, 232, 232, 232, 232, 232, + 233, 233, 233, 233, 234, 234, 234, 234, 234, 235, + 235, 235, 235, 236, 236, 236, 236, 236, 237, 237, + 238, 238, 238, 238, 239, 240, 241, 241, 242, 242, + 243, 244, 244, 245, 246, 246, 247, 247, 248, 249, + 250, 251, 251, 252, 253, 254, 255, 256, 257, 257, + 258, 258, 258, 258, 259, 260, 261, 263, 264, 262, + 265, 265, 266, 266, 267, 268, 269, 271, 270, 272, + 272, 272, 272, 272, 272, 272, 272, 272, 272, 272, + 272, 272, 272, 273, 273, 274, 274, 274, 274, 275, + 276, 276, 277, 277, 278, 279, 279, 279, 279, 280, + 280, 281, 281, 282, 282, 283, 283, 284, 284, 285, + 286, 287, 289, 288, 290, 291, 292, 290, 290, 293, + 293, 293, 293, 294, 294, 295, 295, 295, 295, 295, + 296, 296, 296, 296, 296, 297, 299, 298, 300, 300, + 301, 301, 302, 302, 303 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = +{ + 0, 2, 0, 1, 0, 3, 0, 4, 1, 1, + 1, 2, 0, 3, 4, 4, 2, 2, 2, 1, + 0, 0, 8, 4, 0, 0, 8, 4, 0, 0, + 7, 3, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 3, 0, 1, 1, 3, 1, 2, 2, + 2, 2, 2, 4, 2, 4, 2, 2, 1, 1, + 1, 1, 4, 1, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 0, 4, 0, 4, + 0, 0, 7, 0, 5, 3, 3, 1, 1, 1, + 1, 0, 7, 3, 3, 3, 3, 4, 6, 0, + 7, 4, 8, 4, 6, 4, 4, 3, 3, 2, + 2, 1, 3, 4, 0, 1, 2, 1, 1, 2, + 2, 4, 4, 2, 2, 2, 0, 1, 4, 4, + 3, 3, 2, 2, 1, 2, 2, 2, 2, 2, + 1, 2, 1, 2, 2, 2, 2, 2, 2, 1, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, + 1, 1, 1, 1, 1, 1, 4, 4, 1, 4, + 1, 4, 0, 6, 3, 0, 6, 3, 0, 1, + 1, 2, 8, 3, 1, 3, 0, 1, 4, 6, + 4, 1, 1, 1, 1, 1, 1, 1, 0, 4, + 1, 0, 2, 1, 3, 3, 2, 0, 4, 1, + 0, 4, 1, 1, 1, 2, 2, 1, 5, 3, + 0, 0, 6, 0, 0, 6, 1, 1, 4, 3, + 2, 3, 1, 1, 1, 3, 2, 1, 3, 2, + 3, 3, 4, 3, 4, 3, 2, 1, 1, 2, + 1, 2, 1, 2, 0, 7, 5, 0, 7, 5, + 0, 8, 0, 7, 2, 2, 2, 0, 1, 0, + 1, 1, 2, 0, 3, 2, 3, 2, 3, 1, + 1, 2, 1, 4, 1, 4, 2, 4, 3, 2, + 4, 3, 1, 3, 1, 1, 3, 0, 3, 0, + 1, 0, 1, 2, 1, 1, 1, 3, 2, 3, + 4, 3, 2, 2, 1, 4, 3, 4, 5, 5, + 1, 1, 1, 1, 1, 2, 2, 2, 2, 1, + 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, + 1, 1, 1, 1, 2, 0, 0, 1, 1, 2, + 3, 1, 2, 1, 1, 3, 1, 1, 2, 2, + 0, 0, 2, 3, 2, 2, 2, 3, 3, 1, + 9, 9, 7, 7, 0, 0, 9, 0, 0, 13, + 0, 1, 2, 1, 2, 1, 12, 0, 8, 2, + 1, 1, 1, 1, 1, 2, 2, 2, 3, 1, + 3, 4, 1, 1, 1, 3, 5, 2, 4, 6, + 0, 1, 2, 4, 8, 1, 3, 5, 7, 0, + 1, 0, 1, 1, 3, 6, 9, 1, 3, 1, + 0, 0, 0, 3, 2, 0, 0, 6, 2, 0, + 1, 1, 3, 1, 3, 4, 4, 3, 4, 3, + 4, 4, 3, 4, 3, 1, 0, 3, 1, 2, + 1, 3, 1, 3, 1 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned short int yydefact[] = +{ + 12, 0, 12, 4, 1, 6, 0, 0, 0, 275, + 306, 305, 272, 134, 362, 358, 360, 0, 60, 0, + 574, 19, 5, 9, 8, 0, 0, 219, 220, 221, + 222, 211, 212, 213, 214, 223, 224, 225, 226, 215, + 216, 217, 218, 126, 126, 0, 142, 149, 269, 271, + 270, 140, 290, 166, 0, 0, 0, 274, 273, 0, + 10, 0, 7, 17, 18, 363, 359, 361, 541, 0, + 541, 0, 0, 357, 267, 288, 0, 280, 0, 135, + 147, 153, 137, 169, 136, 148, 154, 170, 138, 159, + 164, 141, 176, 139, 160, 165, 177, 143, 145, 151, + 150, 187, 144, 146, 152, 188, 155, 157, 162, 161, + 202, 156, 158, 163, 203, 167, 185, 194, 173, 171, + 168, 186, 195, 172, 174, 200, 209, 180, 178, 175, + 201, 210, 179, 181, 183, 192, 191, 189, 182, 184, + 193, 190, 196, 198, 207, 206, 204, 197, 199, 208, + 205, 0, 0, 16, 291, 32, 33, 383, 374, 383, + 375, 372, 376, 522, 11, 0, 0, 293, 0, 87, + 88, 89, 58, 59, 0, 0, 0, 0, 0, 90, + 0, 0, 34, 36, 35, 0, 38, 37, 0, 39, + 40, 0, 0, 61, 0, 0, 63, 41, 47, 247, + 248, 249, 250, 243, 244, 245, 246, 407, 0, 0, + 0, 239, 240, 241, 242, 268, 0, 0, 289, 13, + 288, 31, 540, 288, 267, 0, 356, 521, 288, 342, + 267, 288, 0, 278, 0, 336, 337, 0, 0, 0, + 0, 364, 0, 367, 0, 370, 523, 539, 0, 296, + 56, 57, 0, 0, 0, 0, 51, 48, 0, 468, + 0, 0, 50, 0, 276, 0, 52, 0, 54, 0, + 0, 80, 78, 76, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 110, 109, 0, 43, + 0, 0, 409, 277, 0, 0, 464, 0, 457, 458, + 0, 49, 355, 0, 0, 127, 566, 353, 267, 268, + 0, 0, 470, 0, 470, 118, 0, 287, 0, 0, + 15, 288, 23, 0, 288, 288, 340, 14, 27, 0, + 288, 390, 385, 239, 240, 241, 242, 235, 236, 237, + 238, 126, 126, 382, 0, 383, 288, 383, 404, 405, + 379, 402, 0, 541, 303, 304, 301, 0, 294, 297, + 302, 0, 0, 0, 0, 0, 0, 0, 94, 93, + 0, 42, 0, 0, 85, 86, 0, 0, 0, 0, + 74, 75, 73, 72, 71, 70, 69, 64, 65, 66, + 67, 68, 107, 0, 44, 45, 0, 108, 267, 288, + 408, 410, 415, 414, 416, 424, 96, 572, 0, 467, + 439, 466, 470, 470, 470, 470, 0, 448, 0, 0, + 434, 443, 459, 95, 354, 281, 520, 0, 0, 0, + 0, 426, 0, 454, 29, 120, 119, 116, 231, 232, + 227, 228, 233, 234, 229, 230, 126, 126, 285, 341, + 0, 0, 470, 284, 339, 470, 366, 387, 0, 384, + 391, 0, 369, 0, 0, 380, 0, 379, 519, 296, + 0, 43, 0, 103, 0, 105, 0, 101, 99, 91, + 62, 53, 55, 0, 0, 79, 77, 97, 0, 106, + 418, 542, 423, 288, 422, 460, 0, 440, 435, 444, + 441, 436, 445, 0, 437, 446, 442, 438, 447, 449, + 465, 87, 275, 455, 455, 455, 455, 455, 0, 0, + 0, 0, 0, 0, 529, 512, 463, 470, 0, 125, + 126, 126, 0, 456, 513, 500, 501, 502, 503, 504, + 514, 474, 475, 509, 0, 0, 570, 550, 126, 126, + 568, 0, 551, 553, 567, 0, 0, 0, 427, 425, + 0, 123, 0, 124, 0, 0, 338, 279, 520, 21, + 282, 25, 0, 288, 386, 392, 0, 288, 388, 394, + 288, 288, 406, 403, 288, 0, 295, 541, 87, 0, + 0, 0, 0, 0, 0, 81, 84, 46, 417, 419, + 0, 0, 542, 421, 573, 470, 470, 470, 0, 0, + 0, 517, 505, 506, 507, 0, 0, 0, 530, 540, + 0, 499, 0, 0, 132, 469, 133, 548, 565, 411, + 411, 544, 545, 0, 0, 569, 428, 429, 0, 30, + 461, 0, 0, 310, 308, 307, 286, 0, 0, 0, + 288, 0, 396, 288, 288, 0, 399, 288, 365, 368, + 373, 288, 292, 0, 298, 300, 98, 0, 104, 111, + 0, 323, 0, 0, 320, 0, 322, 0, 377, 313, + 319, 0, 324, 0, 0, 420, 543, 0, 0, 484, + 490, 0, 0, 515, 508, 0, 510, 0, 288, 0, + 130, 330, 0, 131, 333, 347, 267, 288, 288, 343, + 344, 288, 562, 412, 415, 267, 288, 288, 564, 288, + 552, 219, 220, 221, 222, 211, 212, 213, 214, 223, + 224, 225, 226, 215, 216, 217, 218, 126, 126, 554, + 571, 462, 121, 122, 0, 22, 283, 26, 398, 288, + 0, 401, 288, 0, 371, 0, 0, 0, 0, 100, + 326, 0, 0, 317, 92, 0, 312, 0, 325, 327, + 316, 82, 470, 470, 485, 491, 493, 0, 470, 0, + 0, 511, 0, 518, 128, 0, 129, 0, 418, 542, + 560, 288, 346, 288, 349, 561, 413, 418, 542, 563, + 546, 411, 411, 0, 397, 393, 400, 395, 299, 102, + 112, 0, 0, 329, 0, 0, 314, 315, 0, 0, + 0, 455, 492, 470, 497, 516, 0, 525, 470, 470, + 350, 351, 0, 345, 348, 0, 288, 288, 557, 288, + 559, 309, 113, 0, 321, 318, 476, 455, 484, 471, + 0, 490, 0, 484, 541, 531, 331, 334, 352, 547, + 555, 556, 558, 328, 471, 479, 482, 483, 485, 470, + 487, 494, 490, 455, 0, 0, 526, 532, 533, 541, + 0, 0, 470, 455, 455, 455, 473, 472, 488, 495, + 0, 498, 524, 0, 531, 0, 0, 332, 335, 478, + 477, 471, 480, 481, 486, 0, 484, 0, 527, 534, + 0, 470, 470, 485, 541, 0, 0, 0, 455, 0, + 528, 537, 540, 0, 496, 0, 0, 535, 489, 0, + 538, 540, 536 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const short int yydefgoto[] = +{ + -1, 1, 2, 6, 7, 22, 3, 23, 24, 323, + 647, 329, 649, 225, 560, 675, 191, 260, 393, 394, + 193, 194, 195, 25, 196, 197, 379, 378, 376, 684, + 377, 198, 594, 593, 670, 312, 313, 314, 437, 410, + 26, 304, 529, 199, 200, 201, 202, 203, 204, 205, + 206, 35, 36, 37, 38, 39, 40, 41, 42, 43, + 44, 548, 549, 341, 215, 207, 45, 216, 46, 47, + 48, 49, 50, 232, 76, 233, 648, 77, 565, 305, + 218, 52, 357, 358, 359, 53, 646, 744, 677, 678, + 679, 815, 680, 762, 681, 682, 683, 700, 785, 880, + 703, 787, 881, 568, 235, 708, 709, 710, 236, 54, + 55, 56, 57, 345, 347, 352, 244, 58, 766, 466, + 239, 240, 343, 574, 578, 575, 579, 350, 351, 208, + 292, 400, 712, 713, 402, 403, 404, 226, 411, 412, + 413, 414, 415, 416, 315, 849, 297, 298, 299, 639, + 533, 300, 418, 209, 640, 316, 869, 865, 886, 887, + 819, 866, 867, 535, 774, 821, 536, 537, 888, 905, + 777, 778, 852, 890, 538, 539, 853, 540, 541, 542, + 227, 228, 60, 543, 826, 619, 876, 877, 878, 920, + 879, 69, 165, 492, 601, 550, 719, 835, 551, 552, + 739, 553, 629, 307, 427, 554, 555, 408, 210 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -781 +static const short int yypact[] = +{ + 109, 117, 136, -781, -781, -781, 2777, 2777, 215, -781, + -781, -781, -781, -781, 106, 106, 106, 84, -781, 94, + -781, -781, -781, -781, -781, 61, 131, 1169, 663, 1640, + 1064, 913, 450, 970, 1431, 1809, 1361, 1887, 1541, 1980, + 2238, 2116, 2242, -781, -781, 108, -781, -781, -781, -781, + -781, 106, -781, -781, 104, 110, 116, -781, -781, 111, + -781, 2777, -781, -781, -781, 106, 106, 106, -781, 139, + -781, 148, 2509, -781, 89, 106, 179, -781, 1293, -781, + -781, -781, 106, -781, -781, -781, -781, -781, -781, -781, + -781, 106, -781, -781, -781, -781, -781, -781, -781, -781, + 106, -781, -781, -781, -781, -781, -781, -781, -781, 106, + -781, -781, -781, -781, -781, -781, -781, -781, 106, -781, + -781, -781, -781, -781, -781, -781, -781, 106, -781, -781, + -781, -781, -781, -781, -781, -781, 106, -781, -781, -781, + -781, -781, -781, -781, -781, 106, -781, -781, -781, -781, + -781, 197, 131, -781, -781, -781, -781, -781, 125, -781, + 130, -781, 159, -781, -781, 147, 266, -781, 230, -781, + -781, -781, -781, -781, 2591, 2591, 248, 256, 268, -781, + 278, 495, -781, -781, -781, 2591, -781, -781, 1089, -781, + -781, 2591, 425, -781, 2632, 2673, -781, 3209, 718, 957, + 525, 1839, 1288, 506, 780, 597, 1148, -781, 272, 1771, + 2591, 347, 382, 352, 395, -781, 131, 131, 106, -781, + 106, -781, -781, 106, 361, 400, -781, -781, 106, -781, + 89, 106, 213, -781, 1219, 482, 487, 283, 2111, 330, + 875, -781, 340, -781, 432, -781, -781, -781, 353, 473, + -781, -781, 2591, 2383, 1323, 3052, -781, -781, 360, -781, + 475, 377, -781, 2591, -781, 1089, -781, 1089, -781, 2591, + 2591, 441, -781, -781, 2591, 2591, 2591, 2591, 2591, 2591, + 2591, 2591, 2591, 2591, 2591, 2591, -781, -781, 495, 2591, + 2591, 495, 226, -781, 402, 495, -781, 1575, 466, -781, + 416, -781, 487, 38, 131, -781, -781, -781, 89, 512, + 2134, 436, -781, 936, 49, -781, 2484, 493, 197, 197, + -781, 106, -781, 400, 106, 106, -781, -781, -781, 400, + 106, -781, -781, 957, 525, 1839, 1288, 506, 780, 597, + 1148, -781, 474, 463, 1214, -781, 106, -781, -781, 514, + 485, -781, 432, -781, -781, -781, -781, 477, -781, 489, + -781, 2921, 472, 2942, 510, 488, 524, 539, -781, -781, + 1473, 3209, 540, 542, 3209, 3209, 2591, 596, 2591, 2591, + 2105, 3248, 1030, 1626, 1969, 354, 354, 403, 403, -781, + -781, -781, -781, 567, 581, 3209, 289, -781, 89, 106, + -781, -781, -781, -781, 505, -781, -781, -781, 286, 436, + -781, -781, 63, 70, 81, 90, 685, -781, 601, 2267, + -781, -781, -781, -781, -781, -781, 222, 1003, 2591, 2591, + 2175, -781, 2797, -781, -781, -781, -781, -781, 2305, 3167, + 1487, 730, 3086, 3172, 1545, 857, 607, 609, -781, 482, + 261, 197, -781, 656, -781, -781, -781, 254, 337, -781, + -781, 613, -781, 615, 2591, 495, 617, 485, -781, 473, + 618, 2714, 2728, -781, 2591, -781, 2728, -781, -781, -781, + -781, 619, 619, 36, 2591, 3238, 3171, -781, 2591, -781, + 226, 226, -781, 106, -781, -781, 495, -781, -781, -781, + -781, -781, -781, 2342, -781, -781, -781, -781, -781, -781, + -781, 666, 669, -781, -781, -781, -781, -781, 2591, 671, + 630, 632, 2550, 275, 715, -781, -781, -781, 298, -781, + -781, -781, 638, 126, -781, -781, -781, -781, -781, -781, + -781, -781, -781, -781, 2446, 635, -781, -781, -781, -781, + -781, 639, 301, -781, -781, 515, 2823, 2846, -781, -781, + 64, -781, 197, -781, 131, 2008, -781, -781, 704, -781, + -781, -781, 2591, 80, 650, -781, 2591, 216, 651, -781, + 106, 106, 3209, -781, 106, 667, -781, -781, 518, 664, + 672, 2967, 676, 495, 1874, -781, 3225, 3209, -781, -781, + 680, 1389, -781, -781, -781, -781, -781, -781, 696, 708, + 2992, -781, -781, -781, -781, 308, 2591, 688, -781, -781, + 736, -781, 197, 131, -781, -781, -781, -781, -781, 97, + 178, -781, -781, 3057, 786, -781, -781, -781, 698, -781, + -781, 333, 351, -781, -781, 3209, -781, 64, 2008, 64, + 3111, 2591, -781, 106, 3111, 2591, -781, 106, -781, -781, + -781, 106, -781, 2591, -781, -781, -781, 2591, -781, -781, + 220, -781, 495, 2591, -781, 747, 3209, 709, 721, -781, + -781, 189, -781, 1656, 2591, -781, -781, 734, 735, -781, + 2446, 2591, 2591, -781, -781, 357, -781, 741, 106, 376, + -781, 207, 401, -781, 711, -781, 89, 106, 106, 532, + 558, 224, -781, -781, 106, 89, 106, 224, -781, 106, + -781, 2305, 3167, 3091, 3185, 1487, 730, 1694, 1038, 3086, + 3172, 3120, 3202, 1545, 857, 1723, 1257, -781, -781, -781, + -781, -781, -781, -781, 1874, -781, -781, -781, -781, 3111, + 254, -781, 3111, 337, -781, 536, 2895, 495, 2591, -781, + -781, 2774, 1874, -781, -781, 1942, -781, 2049, -781, -781, + -781, 3225, -781, -781, -781, 724, -781, 729, -781, 545, + 3191, -781, 266, -781, -781, 400, -781, 400, 97, 180, + -781, 106, -781, 106, -781, -781, 106, 178, 178, -781, + -781, 97, 178, 737, -781, -781, -781, -781, -781, -781, + -781, 306, 2591, -781, 738, 2049, -781, -781, 2591, 732, + 744, -781, -781, -781, -781, -781, 746, 782, -781, -781, + 532, 558, 284, -781, -781, 1389, 106, 224, -781, 224, + -781, -781, -781, 2872, -781, -781, 724, -781, -781, -781, + 810, 2591, 743, -781, -781, 66, -781, -781, -781, -781, + -781, -781, -781, -781, -781, -781, 822, 823, -781, -781, + -781, -781, 2591, -781, 756, 495, 800, 757, -781, -781, + 698, 698, 93, -781, -781, -781, -781, -781, -781, -781, + 759, -781, -781, 761, 66, 66, 791, -781, -781, -781, + -781, -781, -781, -781, -781, 792, -781, 266, 825, -781, + 2591, 787, -781, -781, -781, 266, 560, 783, -781, 819, + 794, -781, -781, 799, -781, 2591, 266, -781, -781, 562, + -781, -781, -781 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const short int yypgoto[] = +{ + -781, -781, -781, -781, -781, 76, 885, -781, -781, -781, + -781, -781, -781, -781, -781, -28, -781, -71, 417, 232, + 468, -781, -781, -781, -105, 1189, -781, -781, -781, -781, + -781, -781, -781, -781, -781, -280, 579, -781, -781, 113, + 112, -301, -500, -2, 0, 138, 219, 2, 7, 31, + 141, -305, -304, 264, 267, -292, -286, 280, 291, -383, + -359, 583, 585, -781, -162, -781, -373, -209, 620, 1012, + 133, 470, -781, -504, -133, 451, -781, 612, -781, 41, + 693, -34, -781, 453, -781, 554, 282, -781, -616, -781, + 161, -781, -638, -781, -781, 250, 251, -781, -781, -781, + -781, -781, -781, -135, 362, 135, 150, -123, 16, -781, + -781, -781, -781, -781, -781, -781, -781, -781, -781, 479, + -118, -781, 595, -781, -781, 199, 204, 616, 502, -115, + -781, -781, -591, -274, -443, -487, -781, 531, -781, -781, + -781, -781, -781, -781, -246, -461, -781, -781, 681, -551, + -781, 437, -781, -781, -397, 662, -777, -742, -221, -207, + -733, -781, -200, 87, -633, -780, -781, -781, -781, -781, + -757, -781, -781, -781, -781, -781, -781, -781, -781, -781, + 269, -205, -781, -781, -781, -781, 88, -781, 95, -781, + -156, -19, -68, 490, -781, -576, -781, -781, -781, -781, + -781, -781, 439, -302, -781, -781, -781, -781, 28 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -550 +static const short int yytable[] = +{ + 71, 192, 167, 599, 27, 27, 28, 28, 31, 31, + 248, 442, 443, 32, 32, 310, 234, 154, 401, 237, + 451, 318, 534, 454, 444, 686, 158, 160, 162, 324, + 445, 154, 154, 154, 61, 61, 530, 33, 33, 718, + 820, 242, 78, 452, 626, 770, 532, 598, 154, 455, + -115, 417, 605, 606, 607, 608, 609, 154, 641, 27, + 531, 28, 309, 31, -450, 638, 154, 435, 32, 250, + 251, -451, 211, 261, 212, 154, 420, 247, 342, 850, + 257, 595, -452, 62, 154, 68, 262, 882, 885, 61, + 421, -453, 33, 154, 871, 70, 745, 13, 747, 428, + 73, 705, 154, 223, 224, 301, 534, 155, 156, -2, + 513, 154, 19, 155, 156, 889, 217, 4, 699, 155, + 156, 19, 442, 443, 911, 651, 72, 263, 803, 817, + 424, 891, 875, 918, 73, 444, -3, 164, 19, 365, + 367, 445, -115, 904, 29, 29, 814, 34, 34, -540, + 372, -430, 373, 256, 706, 151, 152, 526, -431, -540, + 295, 530, 707, 224, 98, 103, 107, 112, 238, -432, + 509, 532, 134, 139, 143, 148, 924, 845, -433, 917, + 899, 73, 342, 73, 154, 531, 714, 714, 74, 490, + 776, 498, 501, 504, 507, 153, 75, 157, 163, 29, + 73, 229, 34, 159, 166, 499, 502, 505, 508, 161, + 838, 840, 213, 168, 296, 868, 349, 600, 241, 396, + 873, 356, 211, 243, 212, 30, 30, 461, 211, 463, + 212, 767, 302, 303, 246, 715, 222, 706, 333, -520, + 334, 741, 337, 716, 224, 707, 224, 338, 19, -520, + 737, 222, 245, 672, 230, 673, 19, 73, 229, 859, + 392, 655, 231, 397, 306, 480, 219, 407, 344, 317, + 220, 339, 319, 913, 738, 59, 59, 247, 155, 156, + 30, 223, 224, 398, 757, 468, 758, 223, 224, 223, + 224, 399, 224, 214, -520, 249, 442, 443, -520, 572, + 320, 599, 63, 64, 321, 483, 211, 530, 212, 444, + 599, 230, 759, 252, 438, 445, 439, 532, 440, 231, + 426, 253, 573, 441, 349, 257, 325, 224, 729, 730, + 59, 531, 616, 254, 302, 303, 98, 103, 107, 112, + 73, 733, 333, 255, 334, 598, 337, 734, 528, 793, + 224, 338, 750, 566, 598, 79, 753, 590, 714, 714, + 88, 592, 213, 324, 293, 453, 306, 308, 213, 13, + 327, 456, 344, 495, 220, 339, 858, 496, 335, 19, + 263, 340, 576, 489, 19, 621, 864, 462, 632, 263, + 84, 527, 633, 19, 74, 694, 211, 263, 212, 263, + 842, 311, 75, 93, -470, -470, -470, -470, -470, 281, + 282, 283, 284, 285, -470, -470, -470, 27, 330, 28, + 742, 31, 901, 901, 321, 438, 32, 439, 346, 440, + -470, 642, 528, 348, 441, 155, 156, 349, 743, 301, + 491, 356, 220, 214, 781, 353, 213, 544, 263, 214, + 33, 615, 368, 457, 458, 10, 11, 12, 102, 336, + 283, 284, 285, 784, 14, 15, 16, 321, 604, 370, + 98, 103, 107, 112, 577, 527, 155, 156, 10, 11, + 354, 355, 335, 897, 898, 340, -83, 701, 786, 833, + 702, 834, 220, -114, 406, 617, 324, 788, 155, 156, + 295, 99, 104, 108, 113, 828, 797, 829, 423, 135, + 140, 144, 149, 12, 97, 600, 263, 264, 429, 662, + 14, 15, 16, 433, 600, 497, 500, 214, 506, 9, + 442, 443, 12, 84, 602, 448, 213, -256, 19, 14, + 15, 16, 27, 444, 28, 695, 31, 325, 224, 445, + 459, 32, 223, 224, 471, 18, 464, 29, 562, 564, + 34, -389, -389, 336, 473, 669, 263, 369, 469, 470, + 493, 224, 544, 98, 103, 33, 465, 134, 139, 476, + 426, 83, 87, 92, 96, 101, 105, 110, 114, 119, + 123, 128, 132, 137, 141, 146, 150, 791, 224, 438, + 697, 439, 475, 440, 12, 106, 634, 635, 441, 663, + 664, 14, 15, 16, 652, 573, 477, 214, 656, 775, + 779, 658, 659, 793, 224, 660, 827, 488, 808, 19, + 478, 721, 481, 722, 482, 725, 263, 824, 30, 704, + 726, 484, 622, 623, 760, 711, 717, 80, 85, 89, + 94, 263, 922, 263, 931, 116, 121, 125, 130, 487, + 628, 628, 266, 268, 727, 831, 832, 9, 10, 11, + 12, 84, 488, 99, 104, 108, 113, 14, 15, 16, + 449, 450, 29, 902, 903, 34, 311, 811, 27, 510, + 28, 748, 31, 18, 561, 751, 563, 32, 570, 51, + 51, 580, 754, 581, 211, 584, 212, 65, 66, 67, + 587, -32, 479, 211, -33, 212, 611, 612, 544, 613, + 82, 33, 91, 618, 100, 624, 109, 627, 118, 810, + 127, 631, 136, 222, 145, 10, 11, 12, 102, 783, + 222, 653, 657, -520, 14, 15, 16, 846, 789, 790, + -252, 914, 795, -520, 51, 661, 665, 798, 799, 921, + 800, 690, 154, 30, 666, 51, 326, 51, 668, 577, + 930, 723, 685, 691, 728, 696, 223, 224, 286, 287, + 775, 698, 288, 289, 290, 291, 874, 12, 102, 740, + 804, 526, 763, 806, 14, 15, 16, 764, -520, 772, + 773, 775, -520, 360, 302, 303, 782, 99, 104, 108, + 113, 896, 765, 302, 303, 263, 822, 837, 839, 80, + 85, 89, 94, 405, 847, 841, 844, 855, 29, 870, + 872, 34, 306, 438, 306, 439, 848, 440, 854, 916, + 883, 884, 441, 892, 213, 894, 919, 893, 895, 801, + 802, 906, 724, 213, 929, 907, 910, 912, 98, 103, + 107, 112, 10, 11, 12, 138, 134, 139, 143, 148, + 915, 14, 15, 16, 899, 923, 331, 860, 861, 9, + 862, 51, 12, 13, 925, 926, 928, 5, 589, 14, + 15, 16, 82, 436, 91, 755, 100, 731, 109, 446, + 732, 447, 567, 927, 82, 18, 91, 19, 20, 30, + 99, 104, 932, 735, 135, 140, 425, 51, 10, 11, + 12, 97, 586, 51, 736, 214, 816, 14, 15, 16, + 746, 768, 769, 51, 214, 494, 836, 311, 830, 460, + -117, -117, -117, -117, -117, 19, 585, 51, 51, 805, + -117, -117, -117, 80, 85, 89, 94, 807, 51, 419, + 51, 9, 332, -381, 12, 79, -117, 583, 467, 900, + 625, 14, 15, 16, 434, 10, 11, 12, 106, 422, + 326, 326, 908, 603, 14, 15, 16, 18, 630, 19, + 909, 0, 83, 87, 101, 105, 119, 123, 137, 141, + -255, 51, 19, 0, 545, 0, 546, 9, 10, 11, + 12, 13, 0, 0, 0, 547, 0, 14, 15, 16, + 0, 405, 405, 360, 0, 0, 82, 0, 91, -117, + 100, 0, 109, 18, 0, 0, 0, 51, 0, 81, + 86, 90, 95, 10, 11, 12, 111, 117, 122, 126, + 131, 0, 14, 15, 16, 0, 0, -257, 80, 85, + 0, 0, 116, 121, 0, 0, 0, 0, 9, 10, + 11, 12, 93, 0, 419, 419, 503, 419, 14, 15, + 16, 277, 278, 279, 280, 281, 282, 283, 284, 285, + 258, 51, 169, 9, 18, -549, 12, 13, 0, 170, + 171, 0, 172, 14, 15, 16, 0, 0, 0, 0, + 0, 0, 51, 0, 569, 0, 0, 571, 0, 18, + 173, 19, 20, 0, 174, 175, 176, 177, 178, 179, + 180, 82, 0, 100, 0, 118, 181, 136, 0, 182, + 0, 0, 0, 0, 183, 184, 185, 0, 0, 186, + 187, -254, 0, 0, 188, 12, 111, 0, 0, 0, + 405, 405, 14, 15, 16, 51, 0, 0, 0, 51, + 0, 0, 0, 9, 10, 11, 12, 79, 189, 190, + 0, 0, 259, 14, 15, 16, 0, 0, 0, 620, + 0, 0, 0, 0, 0, 99, 104, 108, 113, 18, + 0, 19, 0, 135, 140, 144, 149, 0, 0, 0, + 0, 81, 86, 90, 95, 331, 0, 0, 9, 0, + 322, 12, 13, -20, -20, -20, -20, -20, 14, 15, + 16, 0, 0, -20, -20, -20, 0, 51, 0, 0, + 792, 794, 0, 0, 18, 0, 19, 20, 222, -20, + 0, -520, 0, 0, 0, 0, -251, 0, 0, 0, + 0, -520, 10, 11, 12, 147, 0, 687, 688, 689, + 0, 14, 15, 16, 0, 83, 87, 92, 96, 101, + 105, 110, 114, 119, 123, 128, 132, 137, 141, 146, + 150, 0, 9, 0, 221, 12, 93, -28, -28, -28, + -28, -28, 14, 15, 16, 0, -520, -28, -28, -28, + -520, 0, -20, 0, 0, 0, 0, 0, 18, 405, + 405, 0, 222, -28, 364, -520, 51, 9, 405, 405, + 12, 13, 405, 405, 0, -520, 0, 14, 15, 16, + 0, 80, 85, 89, 94, 81, 86, 90, 95, 116, + 121, 125, 130, 18, 0, 19, 0, 0, 223, 224, + 0, 792, 794, 794, 0, 9, 10, 11, 12, 120, + 0, 0, 0, 0, 0, 14, 15, 16, 0, 0, + -520, 0, 0, 51, -520, 0, -28, 0, 0, 0, + 545, 18, 0, 9, 10, 11, 12, 13, 0, 51, + 0, 547, 0, 14, 15, 16, 0, 796, 51, 0, + 0, 0, 0, 0, 82, 0, 91, 0, 100, 18, + 109, 0, 118, 0, 127, 0, 136, 0, 145, 0, + 0, 0, 0, 0, 818, 818, 10, 11, 12, 111, + 823, 361, 363, 0, 0, 14, 15, 16, -260, 0, + 81, 86, 371, 0, 117, 122, 0, 0, 374, 375, + 0, 0, 0, 380, 381, 382, 383, 384, 385, 386, + 387, 388, 389, 390, 391, 0, 169, 0, 395, 0, + 0, -549, 0, 170, 171, 851, 172, 0, 0, 0, + 856, 857, 10, 11, 12, 97, 0, 0, 0, 432, + 0, 14, 15, 16, 173, 0, 20, 0, 174, 175, + 176, 177, 178, 179, 180, 0, 0, 0, -258, 19, + 181, 0, 0, 182, 0, 0, 0, 0, 183, 184, + 185, 503, 0, 186, 187, 0, 0, 0, 188, 0, + 0, 0, 0, 0, 503, 9, 10, 11, 12, 129, + 10, 11, 12, 133, 0, 14, 15, 16, 0, 14, + 15, 16, 189, 190, 0, 0, 479, 485, 486, 0, + 0, 18, 0, 503, 818, 0, 409, 19, -470, -470, + -470, -470, -470, -470, 0, -470, -470, 0, -470, -470, + -470, -470, -470, 0, -470, -470, -470, -470, -470, -470, + -470, -470, -470, -470, -470, -470, -470, -470, -470, 0, + -470, -470, -470, -470, -470, -470, -470, 556, 557, 0, + 0, 0, -470, 0, 0, -470, 0, 0, -262, 0, + -470, -470, -470, 0, 0, -470, -470, 0, 0, 0, + -470, 0, 0, 0, 9, 10, 11, 12, 88, 0, + 0, 0, 0, 582, 14, 15, 16, 671, 0, 169, + 395, 0, -470, 591, -470, -470, 170, 171, -470, 172, + 18, 0, 19, 596, 0, 0, 0, 597, 278, 279, + 280, 281, 282, 283, 284, 285, 0, 173, 0, 20, + 0, 174, 175, 176, 177, 178, 179, 180, -327, 10, + 11, 12, 106, 181, 0, 0, 182, 610, 14, 15, + 16, 183, 184, 185, 0, 0, 186, 187, 0, 0, + -327, 188, -327, 0, 0, 0, 19, -253, 10, 11, + 12, 142, 0, 81, 86, 90, 95, 14, 15, 16, + 0, 117, 122, 126, 131, 189, 190, 0, 0, 674, + 0, 0, 0, 0, 645, 19, 0, 0, 0, 0, + 0, 650, 0, 0, 0, 654, 0, 0, 0, 0, + 0, 0, 294, 0, -456, -456, -456, -456, -456, -456, + 0, -456, -456, 676, -456, -456, -456, -456, -456, 0, + -456, -456, -456, -456, -456, -456, -456, -456, -456, -456, + -456, -456, -456, -456, -456, 295, -456, -456, -456, -456, + -456, -456, -456, 9, 10, 11, 12, 115, -456, 0, + 0, -456, 0, 14, 15, 16, -456, -456, -456, 0, + 0, -456, -456, 0, 0, 0, -456, 645, 0, 18, + 749, 19, 0, 9, 752, 0, 12, 88, 0, 0, + 0, 0, 395, 14, 15, 16, 756, 0, -456, 296, + -456, -456, 761, 0, -456, 0, 0, 0, 0, 18, + 0, 19, 676, 771, 0, 671, 0, 511, 156, 0, + 0, 780, 0, 0, 170, 171, 0, 172, 0, 0, + 0, 9, 10, 11, 12, 124, -259, 0, 0, 0, + 0, 14, 15, 16, 0, 173, 0, 20, 0, 174, + 175, 176, 177, 178, 179, 180, 0, 18, 0, 19, + 0, 181, 0, 0, 182, 0, 0, 0, 0, 183, + 184, 185, 0, 676, 186, 187, 0, 0, 672, 188, + 673, 0, 0, 671, 0, 511, 156, 0, 0, 0, + 0, 676, 170, 171, 676, 172, 676, 0, 0, 0, + 0, 0, -311, 189, 190, 0, 0, 674, 0, 0, + 0, 0, 0, 173, -261, 20, 0, 174, 175, 176, + 177, 178, 179, 180, 0, 10, 11, 12, 133, 181, + 0, 0, 182, 0, 14, 15, 16, 183, 184, 185, + 0, 843, 186, 187, 676, 0, 672, 188, 673, 643, + 0, 169, 19, 0, 0, 0, 0, 0, 170, 171, + 0, 172, 279, 280, 281, 282, 283, 284, 285, 0, + -378, 189, 190, 0, 0, 674, 0, 0, 0, 173, + 0, 20, 0, 174, 175, 176, 177, 178, 179, 180, + 671, 0, 169, 0, 0, 181, 0, 0, 182, 170, + 171, 0, 172, 183, 184, 185, 0, -263, 186, 187, + 0, 0, 0, 188, 0, 0, 0, 0, 0, 0, + 173, 0, 20, 0, 174, 175, 176, 177, 178, 179, + 180, 0, 0, 0, 0, 0, 181, 189, 190, 182, + 0, 644, 0, 0, 183, 184, 185, 0, 0, 186, + 187, 0, 328, 0, 188, -24, -24, -24, -24, -24, + 0, 10, 11, 12, 142, -24, -24, -24, 0, 0, + 14, 15, 16, 0, 0, 0, 0, 169, 189, 190, + 222, -24, 674, -520, 170, 171, 0, 172, 19, 0, + 0, 0, 0, -520, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 173, 0, 20, 0, 174, + 175, 176, 177, 178, 179, 180, 223, 224, 169, 0, + 0, 181, 0, 0, 182, 170, 171, 0, 172, 183, + 184, 430, 0, 0, 186, 187, 0, 0, -520, 188, + 0, 0, -520, -265, -24, 0, 173, 0, 20, 0, + 174, 175, 176, 177, 178, 179, 180, 0, 0, 0, + 0, 0, 181, 189, 190, 182, 0, 0, 431, 0, + 183, 184, 185, 0, 0, 186, 187, 0, 0, 0, + 188, 0, 0, 10, 11, 12, 138, 10, 11, 12, + 147, 0, 14, 15, 16, 0, 14, 15, 16, 0, + 0, 0, 0, 0, 189, 190, 0, 0, 0, 558, + 511, 512, 10, 11, 12, 13, 0, 170, 171, 0, + 172, 14, 15, 16, 513, 0, 514, 515, 516, 517, + 518, 519, 520, 521, 522, 523, 524, 18, 173, 19, + 20, 0, 174, 175, 176, 177, 178, 179, 180, 9, + 10, 11, 12, 79, 181, 0, 0, 182, 0, 14, + 15, 16, 183, 184, 185, -264, 0, 186, 187, -266, + 0, 0, 188, 0, 0, 18, 0, 19, 0, 0, + 0, 0, 0, 0, 0, 511, 156, 0, 0, 0, + 0, 0, 170, 171, 525, 172, 189, 190, 0, 513, + 526, 514, 515, 516, 517, 518, 519, 520, 521, 522, + 523, 524, 0, 173, 0, 20, 0, 174, 175, 176, + 177, 178, 179, 180, 362, 0, 169, 0, 0, 181, + 0, 0, 182, 170, 171, 0, 172, 183, 184, 185, + 0, 0, 186, 187, 0, 0, 0, 188, 0, 0, + 0, 0, 0, 0, 173, 0, 20, 0, 174, 175, + 176, 177, 178, 179, 180, 0, 0, 0, 0, 525, + 181, 189, 190, 182, 0, 526, 0, 0, 183, 184, + 185, 0, 0, 186, 187, 0, 0, 0, 188, 169, + 9, 10, 11, 12, 13, 0, 170, 171, 0, 172, + 14, 15, 16, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 189, 190, 0, 0, 18, 173, 19, 20, + 0, 174, 175, 176, 177, 178, 179, 180, 9, 10, + 11, 12, 13, 181, 0, 0, 182, 0, 14, 15, + 16, 183, 184, 185, 0, 0, 186, 187, 0, 0, + 0, 188, 169, 9, 18, 0, 12, 13, 0, 170, + 171, 0, 172, 14, 15, 16, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 189, 190, 0, 0, 18, + 173, 19, 20, 0, 174, 175, 176, 177, 178, 179, + 180, 0, 0, 169, 0, 0, 181, 0, 0, 182, + 170, 171, 0, 172, 183, 184, 185, 0, 0, 186, + 187, 0, 0, 0, 188, 0, 0, 0, 0, 0, + 0, 173, 0, 20, 0, 174, 175, 176, 177, 178, + 179, 180, 0, 0, 169, 0, 0, 181, 189, 190, + 182, 170, 171, 0, 172, 183, 184, 185, 0, 0, + 186, 187, 0, 0, 0, 188, 0, 0, 0, 0, + 0, 0, 173, 0, 20, 0, 174, 175, 176, 177, + 178, 179, 180, 0, 0, 169, 0, 614, 181, 189, + 190, 182, 170, 171, 0, 172, 183, 184, 185, 0, + 0, 186, 187, 0, 0, 0, 188, 0, 0, 0, + 0, 0, 0, 173, 0, 20, 0, 174, 175, 176, + 177, 178, 179, 180, 0, 0, 169, 0, 0, 181, + 189, 190, 182, 170, 171, 0, 172, 183, 184, 185, + 0, 0, 186, 187, 0, 0, 0, 265, 0, 0, + 0, 0, 0, 0, 173, 0, 20, 0, 174, 175, + 176, 177, 178, 179, 180, 0, 0, 588, 0, 0, + 181, 189, 190, 182, 170, 171, 0, 172, 183, 184, + 185, 0, 9, 186, 187, 12, 13, 0, 267, 0, + 0, 0, 14, 15, 16, 173, 0, 20, 0, 174, + 175, 176, 177, 178, 179, 180, 0, 0, 18, 0, + 19, 181, 189, 190, 182, 0, 0, 0, 0, 183, + 184, 185, 0, 0, 186, 187, 0, 0, 8, 188, + -126, 9, 10, 11, 12, 13, 812, 0, 0, 0, + 0, 14, 15, 16, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 189, 190, 0, 17, 18, 0, 19, + 20, 0, 0, 0, 0, 0, 269, 270, 271, 0, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 282, 283, 284, 285, -126, 0, 0, 0, 0, 269, + 270, 271, -126, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 0, 0, 0, + 0, 0, 0, 0, 21, 269, 270, 271, 813, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, + 283, 284, 285, 0, 0, 0, 0, 0, 269, 270, + 271, 559, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, 0, 0, 0, 0, + 0, 0, 0, 0, 269, 270, 271, 636, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 0, 0, 0, 0, 0, 269, 270, 271, + 637, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 0, 0, 0, 0, 0, + 0, 0, 0, 269, 270, 271, 863, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 0, 0, 0, 269, 270, 271, 809, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 0, 0, 692, 0, 0, 0, 0, 269, + 270, 271, 472, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 282, 283, 284, 285, 0, 0, 0, + 0, 0, 0, 474, 269, 270, 271, 693, 272, 273, + 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, + 284, 285, 0, 366, 0, 0, 9, 0, 667, 12, + 13, 9, 10, 11, 12, 13, 14, 15, 16, 720, + 0, 14, 15, 16, 0, 0, 0, 0, 0, 0, + 0, 0, 18, 0, 19, 0, 0, 18, 0, 19, + 9, 10, 11, 12, 115, 9, 10, 11, 12, 88, + 14, 15, 16, 0, 0, 14, 15, 16, 0, 0, + 0, 0, 0, 0, 0, 0, 18, 0, 19, 0, + 0, 18, 0, 19, 9, 10, 11, 12, 124, 0, + 0, 0, 0, 0, 14, 15, 16, 0, 0, 0, + 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, + 18, 0, 19, 269, 270, 271, 0, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 9, 10, 11, 12, 84, 9, 10, 11, 12, + 120, 14, 15, 16, 0, 0, 14, 15, 16, 9, + 10, 11, 12, 93, 0, 0, 0, 18, 0, 14, + 15, 16, 18, 0, 0, 0, 9, 10, 11, 12, + 129, 0, 0, 0, 0, 18, 14, 15, 16, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 0, 18, 269, 270, 271, 825, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 269, 270, 271, 0, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 271, + 0, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 273, 274, 275, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285, 276, 277, + 278, 279, 280, 281, 282, 283, 284, 285 +}; + +static const short int yycheck[] = +{ + 19, 72, 70, 490, 6, 7, 6, 7, 6, 7, + 166, 316, 316, 6, 7, 224, 151, 51, 292, 152, + 321, 230, 419, 325, 316, 601, 54, 55, 56, 234, + 316, 65, 66, 67, 6, 7, 419, 6, 7, 630, + 773, 159, 26, 323, 544, 683, 419, 490, 82, 329, + 1, 297, 513, 514, 515, 516, 517, 91, 562, 61, + 419, 61, 224, 61, 1, 1, 100, 313, 61, 174, + 175, 1, 74, 188, 74, 109, 297, 11, 240, 821, + 185, 45, 1, 7, 118, 1, 191, 864, 868, 61, + 297, 1, 61, 127, 851, 1, 647, 8, 649, 308, + 3, 4, 136, 65, 66, 210, 503, 3, 4, 0, + 17, 145, 32, 3, 4, 872, 75, 0, 622, 3, + 4, 32, 427, 427, 901, 45, 65, 91, 744, 767, + 92, 873, 66, 913, 3, 427, 0, 61, 32, 254, + 255, 427, 93, 885, 6, 7, 762, 6, 7, 65, + 265, 88, 267, 181, 57, 43, 44, 93, 88, 65, + 34, 544, 65, 66, 31, 32, 33, 34, 152, 88, + 416, 544, 39, 40, 41, 42, 918, 815, 88, 912, + 87, 3, 344, 3, 218, 544, 629, 630, 57, 398, + 690, 412, 413, 414, 415, 87, 65, 93, 87, 61, + 3, 4, 61, 93, 65, 412, 413, 414, 415, 93, + 801, 802, 74, 65, 88, 848, 244, 491, 93, 290, + 853, 249, 224, 93, 224, 6, 7, 345, 230, 347, + 230, 42, 216, 217, 87, 57, 29, 57, 240, 32, + 240, 638, 240, 65, 66, 65, 66, 240, 32, 42, + 633, 29, 93, 64, 57, 66, 32, 3, 4, 835, + 288, 45, 65, 291, 223, 370, 87, 295, 240, 228, + 91, 240, 231, 906, 633, 6, 7, 11, 3, 4, + 61, 65, 66, 57, 64, 353, 66, 65, 66, 65, + 66, 65, 66, 74, 87, 65, 601, 601, 91, 45, + 87, 788, 87, 88, 91, 376, 308, 690, 308, 601, + 797, 57, 92, 65, 316, 601, 316, 690, 316, 65, + 304, 65, 457, 316, 352, 430, 65, 66, 633, 633, + 61, 690, 57, 65, 318, 319, 203, 204, 205, 206, + 3, 633, 344, 65, 344, 788, 344, 633, 419, 65, + 66, 344, 653, 92, 797, 8, 657, 472, 801, 802, + 8, 476, 224, 568, 92, 324, 325, 6, 230, 8, + 87, 330, 344, 87, 91, 344, 92, 91, 240, 32, + 91, 240, 45, 94, 32, 87, 847, 346, 87, 91, + 8, 419, 91, 32, 57, 87, 398, 91, 398, 91, + 94, 1, 65, 8, 4, 5, 6, 7, 8, 55, + 56, 57, 58, 59, 14, 15, 16, 419, 88, 419, + 87, 419, 883, 884, 91, 427, 419, 427, 88, 427, + 30, 564, 503, 1, 427, 3, 4, 465, 87, 544, + 399, 469, 91, 224, 87, 92, 308, 419, 91, 230, + 419, 522, 92, 341, 342, 5, 6, 7, 8, 240, + 57, 58, 59, 87, 14, 15, 16, 91, 496, 92, + 337, 338, 339, 340, 458, 503, 3, 4, 5, 6, + 7, 8, 344, 880, 881, 344, 45, 622, 87, 791, + 623, 793, 91, 93, 92, 523, 701, 706, 3, 4, + 34, 31, 32, 33, 34, 785, 715, 787, 92, 39, + 40, 41, 42, 7, 8, 789, 91, 92, 6, 587, + 14, 15, 16, 87, 798, 412, 413, 308, 415, 4, + 835, 835, 7, 8, 493, 42, 398, 87, 32, 14, + 15, 16, 544, 835, 544, 616, 544, 65, 66, 835, + 87, 544, 65, 66, 65, 30, 42, 419, 446, 447, + 419, 87, 88, 344, 92, 593, 91, 92, 91, 92, + 65, 66, 544, 440, 441, 544, 91, 444, 445, 91, + 564, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 65, 66, 601, + 619, 601, 92, 601, 7, 8, 91, 92, 601, 91, + 92, 14, 15, 16, 573, 750, 92, 398, 577, 690, + 691, 580, 581, 65, 66, 584, 782, 91, 92, 32, + 91, 633, 92, 633, 92, 633, 91, 92, 419, 623, + 633, 45, 530, 531, 672, 629, 630, 27, 28, 29, + 30, 91, 92, 91, 92, 35, 36, 37, 38, 92, + 548, 549, 194, 195, 633, 788, 789, 4, 5, 6, + 7, 8, 91, 203, 204, 205, 206, 14, 15, 16, + 318, 319, 544, 883, 884, 544, 1, 758, 690, 88, + 690, 650, 690, 30, 87, 654, 87, 690, 42, 6, + 7, 88, 661, 88, 706, 88, 706, 14, 15, 16, + 92, 45, 93, 715, 45, 715, 45, 87, 690, 87, + 27, 690, 29, 8, 31, 87, 33, 92, 35, 757, + 37, 92, 39, 29, 41, 5, 6, 7, 8, 698, + 29, 91, 91, 32, 14, 15, 16, 818, 707, 708, + 87, 907, 711, 42, 61, 88, 92, 716, 717, 915, + 719, 65, 796, 544, 92, 72, 235, 74, 92, 753, + 926, 633, 92, 65, 633, 87, 65, 66, 60, 61, + 851, 45, 64, 65, 66, 67, 854, 7, 8, 3, + 749, 93, 45, 752, 14, 15, 16, 88, 87, 65, + 65, 872, 91, 249, 788, 789, 65, 337, 338, 339, + 340, 879, 91, 797, 798, 91, 87, 801, 802, 199, + 200, 201, 202, 292, 92, 88, 88, 45, 690, 19, + 87, 690, 791, 835, 793, 835, 92, 835, 92, 910, + 18, 18, 835, 87, 706, 45, 914, 875, 91, 737, + 738, 92, 633, 715, 925, 94, 65, 65, 725, 726, + 727, 728, 5, 6, 7, 8, 733, 734, 735, 736, + 45, 14, 15, 16, 87, 92, 1, 836, 837, 4, + 839, 188, 7, 8, 65, 91, 87, 2, 471, 14, + 15, 16, 199, 314, 201, 663, 203, 633, 205, 316, + 633, 316, 451, 922, 211, 30, 213, 32, 33, 690, + 440, 441, 931, 633, 444, 445, 304, 224, 5, 6, + 7, 8, 469, 230, 633, 706, 765, 14, 15, 16, + 648, 681, 681, 240, 715, 404, 801, 1, 788, 344, + 4, 5, 6, 7, 8, 32, 467, 254, 255, 750, + 14, 15, 16, 333, 334, 335, 336, 753, 265, 297, + 267, 4, 87, 88, 7, 8, 30, 465, 352, 882, + 533, 14, 15, 16, 312, 5, 6, 7, 8, 298, + 449, 450, 894, 493, 14, 15, 16, 30, 549, 32, + 895, -1, 438, 439, 440, 441, 442, 443, 444, 445, + 87, 308, 32, -1, 1, -1, 3, 4, 5, 6, + 7, 8, -1, -1, -1, 12, -1, 14, 15, 16, + -1, 490, 491, 469, -1, -1, 333, -1, 335, 93, + 337, -1, 339, 30, -1, -1, -1, 344, -1, 27, + 28, 29, 30, 5, 6, 7, 8, 35, 36, 37, + 38, -1, 14, 15, 16, -1, -1, 87, 438, 439, + -1, -1, 442, 443, -1, -1, -1, -1, 4, 5, + 6, 7, 8, -1, 412, 413, 414, 415, 14, 15, + 16, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 1, 398, 3, 4, 30, 92, 7, 8, -1, 10, + 11, -1, 13, 14, 15, 16, -1, -1, -1, -1, + -1, -1, 419, -1, 452, -1, -1, 455, -1, 30, + 31, 32, 33, -1, 35, 36, 37, 38, 39, 40, + 41, 438, -1, 440, -1, 442, 47, 444, -1, 50, + -1, -1, -1, -1, 55, 56, 57, -1, -1, 60, + 61, 87, -1, -1, 65, 7, 8, -1, -1, -1, + 629, 630, 14, 15, 16, 472, -1, -1, -1, 476, + -1, -1, -1, 4, 5, 6, 7, 8, 89, 90, + -1, -1, 93, 14, 15, 16, -1, -1, -1, 527, + -1, -1, -1, -1, -1, 725, 726, 727, 728, 30, + -1, 32, -1, 733, 734, 735, 736, -1, -1, -1, + -1, 199, 200, 201, 202, 1, -1, -1, 4, -1, + 1, 7, 8, 4, 5, 6, 7, 8, 14, 15, + 16, -1, -1, 14, 15, 16, -1, 544, -1, -1, + 709, 710, -1, -1, 30, -1, 32, 33, 29, 30, + -1, 32, -1, -1, -1, -1, 87, -1, -1, -1, + -1, 42, 5, 6, 7, 8, -1, 605, 606, 607, + -1, 14, 15, 16, -1, 721, 722, 723, 724, 725, + 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, + 736, -1, 4, -1, 1, 7, 8, 4, 5, 6, + 7, 8, 14, 15, 16, -1, 87, 14, 15, 16, + 91, -1, 93, -1, -1, -1, -1, -1, 30, 788, + 789, -1, 29, 30, 1, 32, 633, 4, 797, 798, + 7, 8, 801, 802, -1, 42, -1, 14, 15, 16, + -1, 721, 722, 723, 724, 333, 334, 335, 336, 729, + 730, 731, 732, 30, -1, 32, -1, -1, 65, 66, + -1, 830, 831, 832, -1, 4, 5, 6, 7, 8, + -1, -1, -1, -1, -1, 14, 15, 16, -1, -1, + 87, -1, -1, 690, 91, -1, 93, -1, -1, -1, + 1, 30, -1, 4, 5, 6, 7, 8, -1, 706, + -1, 12, -1, 14, 15, 16, -1, 714, 715, -1, + -1, -1, -1, -1, 721, -1, 723, -1, 725, 30, + 727, -1, 729, -1, 731, -1, 733, -1, 735, -1, + -1, -1, -1, -1, 772, 773, 5, 6, 7, 8, + 778, 252, 253, -1, -1, 14, 15, 16, 87, -1, + 438, 439, 263, -1, 442, 443, -1, -1, 269, 270, + -1, -1, -1, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, -1, 3, -1, 289, -1, + -1, 92, -1, 10, 11, 823, 13, -1, -1, -1, + 828, 829, 5, 6, 7, 8, -1, -1, -1, 310, + -1, 14, 15, 16, 31, -1, 33, -1, 35, 36, + 37, 38, 39, 40, 41, -1, -1, -1, 87, 32, + 47, -1, -1, 50, -1, -1, -1, -1, 55, 56, + 57, 869, -1, 60, 61, -1, -1, -1, 65, -1, + -1, -1, -1, -1, 882, 4, 5, 6, 7, 8, + 5, 6, 7, 8, -1, 14, 15, 16, -1, 14, + 15, 16, 89, 90, -1, -1, 93, 378, 379, -1, + -1, 30, -1, 911, 912, -1, 1, 32, 3, 4, + 5, 6, 7, 8, -1, 10, 11, -1, 13, 14, + 15, 16, 17, -1, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, -1, + 35, 36, 37, 38, 39, 40, 41, 428, 429, -1, + -1, -1, 47, -1, -1, 50, -1, -1, 87, -1, + 55, 56, 57, -1, -1, 60, 61, -1, -1, -1, + 65, -1, -1, -1, 4, 5, 6, 7, 8, -1, + -1, -1, -1, 464, 14, 15, 16, 1, -1, 3, + 471, -1, 87, 474, 89, 90, 10, 11, 93, 13, + 30, -1, 32, 484, -1, -1, -1, 488, 52, 53, + 54, 55, 56, 57, 58, 59, -1, 31, -1, 33, + -1, 35, 36, 37, 38, 39, 40, 41, 42, 5, + 6, 7, 8, 47, -1, -1, 50, 518, 14, 15, + 16, 55, 56, 57, -1, -1, 60, 61, -1, -1, + 64, 65, 66, -1, -1, -1, 32, 87, 5, 6, + 7, 8, -1, 721, 722, 723, 724, 14, 15, 16, + -1, 729, 730, 731, 732, 89, 90, -1, -1, 93, + -1, -1, -1, -1, 565, 32, -1, -1, -1, -1, + -1, 572, -1, -1, -1, 576, -1, -1, -1, -1, + -1, -1, 1, -1, 3, 4, 5, 6, 7, 8, + -1, 10, 11, 594, 13, 14, 15, 16, 17, -1, + 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, + 39, 40, 41, 4, 5, 6, 7, 8, 47, -1, + -1, 50, -1, 14, 15, 16, 55, 56, 57, -1, + -1, 60, 61, -1, -1, -1, 65, 648, -1, 30, + 651, 32, -1, 4, 655, -1, 7, 8, -1, -1, + -1, -1, 663, 14, 15, 16, 667, -1, 87, 88, + 89, 90, 673, -1, 93, -1, -1, -1, -1, 30, + -1, 32, 683, 684, -1, 1, -1, 3, 4, -1, + -1, 692, -1, -1, 10, 11, -1, 13, -1, -1, + -1, 4, 5, 6, 7, 8, 87, -1, -1, -1, + -1, 14, 15, 16, -1, 31, -1, 33, -1, 35, + 36, 37, 38, 39, 40, 41, -1, 30, -1, 32, + -1, 47, -1, -1, 50, -1, -1, -1, -1, 55, + 56, 57, -1, 744, 60, 61, -1, -1, 64, 65, + 66, -1, -1, 1, -1, 3, 4, -1, -1, -1, + -1, 762, 10, 11, 765, 13, 767, -1, -1, -1, + -1, -1, 88, 89, 90, -1, -1, 93, -1, -1, + -1, -1, -1, 31, 87, 33, -1, 35, 36, 37, + 38, 39, 40, 41, -1, 5, 6, 7, 8, 47, + -1, -1, 50, -1, 14, 15, 16, 55, 56, 57, + -1, 812, 60, 61, 815, -1, 64, 65, 66, 1, + -1, 3, 32, -1, -1, -1, -1, -1, 10, 11, + -1, 13, 53, 54, 55, 56, 57, 58, 59, -1, + 88, 89, 90, -1, -1, 93, -1, -1, -1, 31, + -1, 33, -1, 35, 36, 37, 38, 39, 40, 41, + 1, -1, 3, -1, -1, 47, -1, -1, 50, 10, + 11, -1, 13, 55, 56, 57, -1, 87, 60, 61, + -1, -1, -1, 65, -1, -1, -1, -1, -1, -1, + 31, -1, 33, -1, 35, 36, 37, 38, 39, 40, + 41, -1, -1, -1, -1, -1, 47, 89, 90, 50, + -1, 93, -1, -1, 55, 56, 57, -1, -1, 60, + 61, -1, 1, -1, 65, 4, 5, 6, 7, 8, + -1, 5, 6, 7, 8, 14, 15, 16, -1, -1, + 14, 15, 16, -1, -1, -1, -1, 3, 89, 90, + 29, 30, 93, 32, 10, 11, -1, 13, 32, -1, + -1, -1, -1, 42, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 31, -1, 33, -1, 35, + 36, 37, 38, 39, 40, 41, 65, 66, 3, -1, + -1, 47, -1, -1, 50, 10, 11, -1, 13, 55, + 56, 57, -1, -1, 60, 61, -1, -1, 87, 65, + -1, -1, 91, 87, 93, -1, 31, -1, 33, -1, + 35, 36, 37, 38, 39, 40, 41, -1, -1, -1, + -1, -1, 47, 89, 90, 50, -1, -1, 94, -1, + 55, 56, 57, -1, -1, 60, 61, -1, -1, -1, + 65, -1, -1, 5, 6, 7, 8, 5, 6, 7, + 8, -1, 14, 15, 16, -1, 14, 15, 16, -1, + -1, -1, -1, -1, 89, 90, -1, -1, -1, 94, + 3, 4, 5, 6, 7, 8, -1, 10, 11, -1, + 13, 14, 15, 16, 17, -1, 19, 20, 21, 22, + 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 33, -1, 35, 36, 37, 38, 39, 40, 41, 4, + 5, 6, 7, 8, 47, -1, -1, 50, -1, 14, + 15, 16, 55, 56, 57, 87, -1, 60, 61, 87, + -1, -1, 65, -1, -1, 30, -1, 32, -1, -1, + -1, -1, -1, -1, -1, 3, 4, -1, -1, -1, + -1, -1, 10, 11, 87, 13, 89, 90, -1, 17, + 93, 19, 20, 21, 22, 23, 24, 25, 26, 27, + 28, 29, -1, 31, -1, 33, -1, 35, 36, 37, + 38, 39, 40, 41, 1, -1, 3, -1, -1, 47, + -1, -1, 50, 10, 11, -1, 13, 55, 56, 57, + -1, -1, 60, 61, -1, -1, -1, 65, -1, -1, + -1, -1, -1, -1, 31, -1, 33, -1, 35, 36, + 37, 38, 39, 40, 41, -1, -1, -1, -1, 87, + 47, 89, 90, 50, -1, 93, -1, -1, 55, 56, + 57, -1, -1, 60, 61, -1, -1, -1, 65, 3, + 4, 5, 6, 7, 8, -1, 10, 11, -1, 13, + 14, 15, 16, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 89, 90, -1, -1, 30, 31, 32, 33, + -1, 35, 36, 37, 38, 39, 40, 41, 4, 5, + 6, 7, 8, 47, -1, -1, 50, -1, 14, 15, + 16, 55, 56, 57, -1, -1, 60, 61, -1, -1, + -1, 65, 3, 4, 30, -1, 7, 8, -1, 10, + 11, -1, 13, 14, 15, 16, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 89, 90, -1, -1, 30, + 31, 32, 33, -1, 35, 36, 37, 38, 39, 40, + 41, -1, -1, 3, -1, -1, 47, -1, -1, 50, + 10, 11, -1, 13, 55, 56, 57, -1, -1, 60, + 61, -1, -1, -1, 65, -1, -1, -1, -1, -1, + -1, 31, -1, 33, -1, 35, 36, 37, 38, 39, + 40, 41, -1, -1, 3, -1, -1, 47, 89, 90, + 50, 10, 11, -1, 13, 55, 56, 57, -1, -1, + 60, 61, -1, -1, -1, 65, -1, -1, -1, -1, + -1, -1, 31, -1, 33, -1, 35, 36, 37, 38, + 39, 40, 41, -1, -1, 3, -1, 87, 47, 89, + 90, 50, 10, 11, -1, 13, 55, 56, 57, -1, + -1, 60, 61, -1, -1, -1, 65, -1, -1, -1, + -1, -1, -1, 31, -1, 33, -1, 35, 36, 37, + 38, 39, 40, 41, -1, -1, 3, -1, -1, 47, + 89, 90, 50, 10, 11, -1, 13, 55, 56, 57, + -1, -1, 60, 61, -1, -1, -1, 65, -1, -1, + -1, -1, -1, -1, 31, -1, 33, -1, 35, 36, + 37, 38, 39, 40, 41, -1, -1, 3, -1, -1, + 47, 89, 90, 50, 10, 11, -1, 13, 55, 56, + 57, -1, 4, 60, 61, 7, 8, -1, 65, -1, + -1, -1, 14, 15, 16, 31, -1, 33, -1, 35, + 36, 37, 38, 39, 40, 41, -1, -1, 30, -1, + 32, 47, 89, 90, 50, -1, -1, -1, -1, 55, + 56, 57, -1, -1, 60, 61, -1, -1, 1, 65, + 3, 4, 5, 6, 7, 8, 12, -1, -1, -1, + -1, 14, 15, 16, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 89, 90, -1, 29, 30, -1, 32, + 33, -1, -1, -1, -1, -1, 42, 43, 44, -1, + 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 57, -1, -1, -1, -1, 42, + 43, 44, 65, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, -1, -1, -1, + -1, -1, -1, -1, 87, 42, 43, 44, 94, 46, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, 59, -1, -1, -1, -1, -1, 42, 43, + 44, 94, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, -1, -1, -1, -1, + -1, -1, -1, -1, 42, 43, 44, 94, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, -1, -1, -1, -1, -1, 42, 43, 44, + 94, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, -1, -1, -1, -1, -1, + -1, -1, -1, 42, 43, 44, 94, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, -1, -1, -1, 42, 43, 44, 92, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, -1, -1, 12, -1, -1, -1, -1, 42, + 43, 44, 91, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56, 57, 58, 59, -1, -1, -1, + -1, -1, -1, 91, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, 59, -1, 1, -1, -1, 4, -1, 91, 7, + 8, 4, 5, 6, 7, 8, 14, 15, 16, 12, + -1, 14, 15, 16, -1, -1, -1, -1, -1, -1, + -1, -1, 30, -1, 32, -1, -1, 30, -1, 32, + 4, 5, 6, 7, 8, 4, 5, 6, 7, 8, + 14, 15, 16, -1, -1, 14, 15, 16, -1, -1, + -1, -1, -1, -1, -1, -1, 30, -1, 32, -1, + -1, 30, -1, 32, 4, 5, 6, 7, 8, -1, + -1, -1, -1, -1, 14, 15, 16, -1, -1, -1, + -1, -1, -1, 32, -1, -1, -1, -1, -1, -1, + 30, -1, 32, 42, 43, 44, -1, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 4, 5, 6, 7, 8, 4, 5, 6, 7, + 8, 14, 15, 16, -1, -1, 14, 15, 16, 4, + 5, 6, 7, 8, -1, -1, -1, 30, -1, 14, + 15, 16, 30, -1, -1, -1, 4, 5, 6, 7, + 8, -1, -1, -1, -1, 30, 14, 15, 16, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, -1, 30, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + 59, 42, 43, 44, -1, 46, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, 59, 44, + -1, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 47, 48, 49, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59, 50, 51, + 52, 53, 54, 55, 56, 57, 58, 59 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned short int yystos[] = +{ + 0, 96, 97, 101, 0, 101, 98, 99, 1, 4, + 5, 6, 7, 8, 14, 15, 16, 29, 30, 32, + 33, 87, 100, 102, 103, 118, 135, 138, 139, 140, + 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, + 151, 152, 153, 154, 155, 161, 163, 164, 165, 166, + 167, 175, 176, 180, 204, 205, 206, 207, 212, 275, + 277, 303, 100, 87, 88, 175, 175, 175, 1, 286, + 1, 286, 65, 3, 57, 65, 169, 172, 203, 8, + 163, 164, 175, 180, 8, 163, 164, 180, 8, 163, + 164, 175, 180, 8, 163, 164, 180, 8, 165, 166, + 175, 180, 8, 165, 166, 180, 8, 165, 166, 175, + 180, 8, 165, 166, 180, 8, 163, 164, 175, 180, + 8, 163, 164, 180, 8, 163, 164, 175, 180, 8, + 163, 164, 180, 8, 165, 166, 175, 180, 8, 165, + 166, 180, 8, 165, 166, 175, 180, 8, 165, 166, + 180, 135, 135, 87, 176, 3, 4, 93, 110, 93, + 110, 93, 110, 87, 100, 287, 65, 287, 65, 3, + 10, 11, 13, 31, 35, 36, 37, 38, 39, 40, + 41, 47, 50, 55, 56, 57, 60, 61, 65, 89, + 90, 111, 112, 115, 116, 117, 119, 120, 126, 138, + 139, 140, 141, 142, 143, 144, 145, 160, 224, 248, + 303, 138, 139, 140, 141, 159, 162, 174, 175, 87, + 91, 1, 29, 65, 66, 108, 232, 275, 276, 4, + 57, 65, 168, 170, 198, 199, 203, 169, 203, 215, + 216, 93, 215, 93, 211, 93, 87, 11, 285, 65, + 119, 119, 65, 65, 65, 65, 110, 119, 1, 93, + 112, 224, 119, 91, 92, 65, 115, 65, 115, 42, + 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 64, 65, + 66, 67, 225, 92, 1, 34, 88, 241, 242, 243, + 246, 119, 203, 203, 136, 174, 174, 298, 6, 159, + 162, 1, 130, 131, 132, 239, 250, 174, 162, 174, + 87, 91, 1, 104, 276, 65, 232, 87, 1, 106, + 88, 1, 87, 138, 139, 140, 141, 142, 143, 144, + 145, 158, 159, 217, 303, 208, 88, 209, 1, 110, + 222, 223, 210, 92, 7, 8, 110, 177, 178, 179, + 180, 120, 1, 120, 1, 224, 1, 224, 92, 92, + 92, 120, 224, 224, 120, 120, 123, 125, 122, 121, + 120, 120, 120, 120, 120, 120, 120, 120, 120, 120, + 120, 120, 110, 113, 114, 120, 112, 110, 57, 65, + 226, 228, 229, 230, 231, 232, 92, 110, 302, 1, + 134, 233, 234, 235, 236, 237, 238, 239, 247, 250, + 253, 254, 243, 92, 92, 172, 203, 299, 162, 6, + 57, 94, 120, 87, 250, 239, 131, 133, 138, 139, + 142, 143, 146, 147, 150, 151, 156, 157, 42, 199, + 199, 136, 130, 174, 298, 130, 174, 135, 135, 87, + 217, 215, 174, 215, 42, 91, 214, 222, 287, 91, + 92, 65, 91, 92, 91, 92, 91, 92, 91, 93, + 119, 92, 92, 112, 45, 120, 120, 92, 91, 94, + 162, 174, 288, 65, 232, 87, 91, 134, 253, 254, + 134, 253, 254, 250, 253, 254, 134, 253, 254, 239, + 88, 3, 4, 17, 19, 20, 21, 22, 23, 24, + 25, 26, 27, 28, 29, 87, 93, 110, 112, 137, + 154, 155, 161, 245, 249, 258, 261, 262, 269, 270, + 272, 273, 274, 278, 303, 1, 3, 12, 156, 157, + 290, 293, 294, 296, 300, 301, 120, 120, 94, 94, + 109, 87, 135, 87, 135, 173, 92, 170, 198, 250, + 42, 250, 45, 198, 218, 220, 45, 203, 219, 221, + 88, 88, 120, 223, 88, 214, 178, 92, 3, 113, + 224, 120, 224, 128, 127, 45, 120, 120, 229, 230, + 228, 289, 174, 288, 110, 240, 240, 240, 240, 240, + 120, 45, 87, 87, 87, 112, 57, 110, 8, 280, + 250, 87, 135, 135, 87, 246, 137, 92, 135, 297, + 297, 92, 87, 91, 91, 92, 94, 94, 1, 244, + 249, 168, 169, 1, 93, 120, 181, 105, 171, 107, + 120, 45, 174, 91, 120, 45, 174, 91, 174, 174, + 174, 88, 287, 91, 92, 92, 92, 91, 92, 110, + 129, 1, 64, 66, 93, 110, 120, 183, 184, 185, + 187, 189, 190, 191, 124, 92, 290, 250, 250, 250, + 65, 65, 12, 45, 87, 112, 87, 286, 45, 168, + 192, 198, 169, 195, 203, 4, 57, 65, 200, 201, + 202, 203, 227, 228, 229, 57, 65, 203, 227, 291, + 12, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 148, 149, 150, 151, 152, 153, 154, 155, 295, + 3, 249, 87, 87, 182, 244, 181, 244, 174, 120, + 136, 174, 120, 136, 174, 114, 120, 64, 66, 92, + 110, 120, 188, 45, 88, 91, 213, 42, 190, 191, + 187, 120, 65, 65, 259, 112, 137, 265, 266, 112, + 120, 87, 65, 174, 87, 193, 87, 196, 162, 174, + 174, 65, 232, 65, 232, 174, 175, 162, 174, 174, + 174, 135, 135, 183, 174, 220, 174, 221, 92, 92, + 110, 112, 12, 94, 183, 186, 185, 187, 250, 255, + 255, 260, 87, 250, 92, 45, 279, 285, 130, 130, + 201, 202, 202, 298, 298, 292, 200, 203, 227, 203, + 227, 88, 94, 120, 88, 187, 112, 92, 92, 240, + 252, 250, 267, 271, 92, 45, 250, 250, 92, 290, + 174, 174, 174, 94, 240, 252, 256, 257, 259, 251, + 19, 265, 87, 259, 287, 66, 281, 282, 283, 285, + 194, 197, 251, 18, 18, 260, 253, 254, 263, 265, + 268, 252, 87, 110, 45, 91, 287, 249, 249, 87, + 258, 240, 257, 257, 252, 264, 92, 94, 281, 283, + 65, 251, 65, 259, 285, 45, 112, 255, 260, 287, + 284, 285, 92, 92, 252, 65, 91, 286, 87, 112, + 285, 92, 286 +}; + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int +#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror ("syntax error: cannot back up");\ + YYERROR; \ + } \ +while (0) + + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (0) +#endif + + +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef YY_LOCATION_PRINT +# if YYLTYPE_IS_TRIVIAL +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (YYLEX_PARAM) +#else +# define YYLEX yylex () +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yysymprint (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_stack_print (short int *bottom, short int *top) +#else +static void +yy_stack_print (bottom, top) + short int *bottom; + short int *top; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (/* Nothing. */; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_reduce_print (int yyrule) +#else +static void +yy_reduce_print (yyrule) + int yyrule; +#endif +{ + int yyi; + unsigned int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", + yyrule - 1, yylno); + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) + YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); + YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (Rule); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +#endif /* !YYERROR_VERBOSE */ + + + +#if YYDEBUG +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) +#else +static void +yysymprint (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# endif + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyoutput, ")"); +} + +#endif /* ! YYDEBUG */ +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM); +# else +int yyparse (); +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + + +/* The look-ahead symbol. */ +int yychar; + +/* The semantic value of the look-ahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM) +# else +int yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int +yyparse (void) +#else +int +yyparse () + +#endif +#endif +{ + + register int yystate; + register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Look-ahead token as an internal (translated) token number. */ + int yytoken = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short int yyssa[YYINITDEPTH]; + short int *yyss = yyssa; + register short int *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; + + + +#define YYPOPSTACK (yyvsp--, yyssp--) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ + int yylen; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + + yyvsp[0] = yylval; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short int *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyoverflowlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + short int *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a look-ahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to look-ahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a look-ahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the look-ahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; + + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + yystate = yyn; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: +#line 342 "c-parse.y" + { if (pedantic) + pedwarn ("ISO C forbids an empty source file"); + ;} + break; + + case 4: +#line 353 "c-parse.y" + { (yyval.dsptype) = NULL; ;} + break; + + case 5: +#line 354 "c-parse.y" + { obstack_free (&parser_obstack, (yyvsp[-2].otype)); ;} + break; + + case 6: +#line 356 "c-parse.y" + { (yyval.dsptype) = NULL; ggc_collect (); ;} + break; + + case 7: +#line 357 "c-parse.y" + { obstack_free (&parser_obstack, (yyvsp[-2].otype)); ;} + break; + + case 11: +#line 365 "c-parse.y" + { RESTORE_EXT_FLAGS ((yyvsp[-1].itype)); ;} + break; + + case 12: +#line 371 "c-parse.y" + { (yyval.otype) = obstack_alloc (&parser_obstack, 0); ;} + break; + + case 13: +#line 376 "c-parse.y" + { pedwarn ("data definition has no type or storage class"); + POP_DECLSPEC_STACK; ;} + break; + + case 14: +#line 379 "c-parse.y" + { POP_DECLSPEC_STACK; ;} + break; + + case 15: +#line 381 "c-parse.y" + { POP_DECLSPEC_STACK; ;} + break; + + case 16: +#line 383 "c-parse.y" + { shadow_tag (finish_declspecs ((yyvsp[-1].dsptype))); ;} + break; + + case 19: +#line 387 "c-parse.y" + { if (pedantic) + pedwarn ("ISO C does not allow extra %<;%> outside of a function"); ;} + break; + + case 20: +#line 393 "c-parse.y" + { if (!start_function (current_declspecs, (yyvsp[0].dtrtype), + all_prefix_attributes)) + YYERROR1; + ;} + break; + + case 21: +#line 398 "c-parse.y" + { DECL_SOURCE_LOCATION (current_function_decl) = (yyvsp[0].location); + store_parm_decls (); ;} + break; + + case 22: +#line 401 "c-parse.y" + { finish_function (); + POP_DECLSPEC_STACK; ;} + break; + + case 23: +#line 404 "c-parse.y" + { POP_DECLSPEC_STACK; ;} + break; + + case 24: +#line 406 "c-parse.y" + { if (!start_function (current_declspecs, (yyvsp[0].dtrtype), + all_prefix_attributes)) + YYERROR1; + ;} + break; + + case 25: +#line 411 "c-parse.y" + { DECL_SOURCE_LOCATION (current_function_decl) = (yyvsp[0].location); + store_parm_decls (); ;} + break; + + case 26: +#line 414 "c-parse.y" + { finish_function (); + POP_DECLSPEC_STACK; ;} + break; + + case 27: +#line 417 "c-parse.y" + { POP_DECLSPEC_STACK; ;} + break; + + case 28: +#line 419 "c-parse.y" + { if (!start_function (current_declspecs, (yyvsp[0].dtrtype), + all_prefix_attributes)) + YYERROR1; + ;} + break; + + case 29: +#line 424 "c-parse.y" + { DECL_SOURCE_LOCATION (current_function_decl) = (yyvsp[0].location); + store_parm_decls (); ;} + break; + + case 30: +#line 427 "c-parse.y" + { finish_function (); + POP_DECLSPEC_STACK; ;} + break; + + case 31: +#line 430 "c-parse.y" + { POP_DECLSPEC_STACK; ;} + break; + + case 34: +#line 439 "c-parse.y" + { (yyval.code) = ADDR_EXPR; ;} + break; + + case 35: +#line 441 "c-parse.y" + { (yyval.code) = NEGATE_EXPR; ;} + break; + + case 36: +#line 443 "c-parse.y" + { (yyval.code) = CONVERT_EXPR; + if (warn_traditional && !in_system_header) + warning ("traditional C rejects the unary plus operator"); + ;} + break; + + case 37: +#line 448 "c-parse.y" + { (yyval.code) = PREINCREMENT_EXPR; ;} + break; + + case 38: +#line 450 "c-parse.y" + { (yyval.code) = PREDECREMENT_EXPR; ;} + break; + + case 39: +#line 452 "c-parse.y" + { (yyval.code) = BIT_NOT_EXPR; ;} + break; + + case 40: +#line 454 "c-parse.y" + { (yyval.code) = TRUTH_NOT_EXPR; ;} + break; + + case 42: +#line 459 "c-parse.y" + { (yyval.exprtype).value = build_compound_expr ((yyvsp[-2].exprtype).value, (yyvsp[0].exprtype).value); + (yyval.exprtype).original_code = COMPOUND_EXPR; ;} + break; + + case 43: +#line 465 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 45: +#line 471 "c-parse.y" + { (yyval.ttype) = build_tree_list (NULL_TREE, (yyvsp[0].exprtype).value); ;} + break; + + case 46: +#line 473 "c-parse.y" + { chainon ((yyvsp[-2].ttype), build_tree_list (NULL_TREE, (yyvsp[0].exprtype).value)); ;} + break; + + case 48: +#line 479 "c-parse.y" + { (yyval.exprtype).value = build_indirect_ref ((yyvsp[0].exprtype).value, "unary *"); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 49: +#line 483 "c-parse.y" + { (yyval.exprtype) = (yyvsp[0].exprtype); + RESTORE_EXT_FLAGS ((yyvsp[-1].itype)); ;} + break; + + case 50: +#line 486 "c-parse.y" + { (yyval.exprtype).value = build_unary_op ((yyvsp[-1].code), (yyvsp[0].exprtype).value, 0); + overflow_warning ((yyval.exprtype).value); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 51: +#line 491 "c-parse.y" + { (yyval.exprtype).value = finish_label_address_expr ((yyvsp[0].ttype)); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 52: +#line 494 "c-parse.y" + { skip_evaluation--; + in_sizeof--; + if (TREE_CODE ((yyvsp[0].exprtype).value) == COMPONENT_REF + && DECL_C_BIT_FIELD (TREE_OPERAND ((yyvsp[0].exprtype).value, 1))) + error ("% applied to a bit-field"); + (yyval.exprtype) = c_expr_sizeof_expr ((yyvsp[0].exprtype)); ;} + break; + + case 53: +#line 501 "c-parse.y" + { skip_evaluation--; + in_sizeof--; + (yyval.exprtype) = c_expr_sizeof_type ((yyvsp[-1].typenametype)); ;} + break; + + case 54: +#line 505 "c-parse.y" + { skip_evaluation--; + in_alignof--; + (yyval.exprtype).value = c_alignof_expr ((yyvsp[0].exprtype).value); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 55: +#line 510 "c-parse.y" + { skip_evaluation--; + in_alignof--; + (yyval.exprtype).value = c_alignof (groktypename ((yyvsp[-1].typenametype))); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 56: +#line 515 "c-parse.y" + { (yyval.exprtype).value = build_unary_op (REALPART_EXPR, (yyvsp[0].exprtype).value, 0); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 57: +#line 518 "c-parse.y" + { (yyval.exprtype).value = build_unary_op (IMAGPART_EXPR, (yyvsp[0].exprtype).value, 0); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 58: +#line 523 "c-parse.y" + { skip_evaluation++; in_sizeof++; ;} + break; + + case 59: +#line 527 "c-parse.y" + { skip_evaluation++; in_alignof++; ;} + break; + + case 60: +#line 531 "c-parse.y" + { skip_evaluation++; in_typeof++; ;} + break; + + case 62: +#line 537 "c-parse.y" + { (yyval.exprtype).value = c_cast_expr ((yyvsp[-2].typenametype), (yyvsp[0].exprtype).value); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 64: +#line 544 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 65: +#line 546 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 66: +#line 548 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 67: +#line 550 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 68: +#line 552 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 69: +#line 554 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 70: +#line 556 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 71: +#line 558 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 72: +#line 560 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 73: +#line 562 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 74: +#line 564 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 75: +#line 566 "c-parse.y" + { (yyval.exprtype) = parser_build_binary_op ((yyvsp[-1].code), (yyvsp[-2].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 76: +#line 568 "c-parse.y" + { (yyvsp[-1].exprtype).value = lang_hooks.truthvalue_conversion + (default_conversion ((yyvsp[-1].exprtype).value)); + skip_evaluation += (yyvsp[-1].exprtype).value == truthvalue_false_node; ;} + break; + + case 77: +#line 572 "c-parse.y" + { skip_evaluation -= (yyvsp[-3].exprtype).value == truthvalue_false_node; + (yyval.exprtype) = parser_build_binary_op (TRUTH_ANDIF_EXPR, (yyvsp[-3].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 78: +#line 575 "c-parse.y" + { (yyvsp[-1].exprtype).value = lang_hooks.truthvalue_conversion + (default_conversion ((yyvsp[-1].exprtype).value)); + skip_evaluation += (yyvsp[-1].exprtype).value == truthvalue_true_node; ;} + break; + + case 79: +#line 579 "c-parse.y" + { skip_evaluation -= (yyvsp[-3].exprtype).value == truthvalue_true_node; + (yyval.exprtype) = parser_build_binary_op (TRUTH_ORIF_EXPR, (yyvsp[-3].exprtype), (yyvsp[0].exprtype)); ;} + break; + + case 80: +#line 582 "c-parse.y" + { (yyvsp[-1].exprtype).value = lang_hooks.truthvalue_conversion + (default_conversion ((yyvsp[-1].exprtype).value)); + skip_evaluation += (yyvsp[-1].exprtype).value == truthvalue_false_node; ;} + break; + + case 81: +#line 586 "c-parse.y" + { skip_evaluation += (((yyvsp[-4].exprtype).value == truthvalue_true_node) + - ((yyvsp[-4].exprtype).value == truthvalue_false_node)); ;} + break; + + case 82: +#line 589 "c-parse.y" + { skip_evaluation -= (yyvsp[-6].exprtype).value == truthvalue_true_node; + (yyval.exprtype).value = build_conditional_expr ((yyvsp[-6].exprtype).value, (yyvsp[-3].exprtype).value, + (yyvsp[0].exprtype).value); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 83: +#line 594 "c-parse.y" + { if (pedantic) + pedwarn ("ISO C forbids omitting the middle term of a ?: expression"); + /* Make sure first operand is calculated only once. */ + (yyvsp[0].ttype) = save_expr (default_conversion ((yyvsp[-1].exprtype).value)); + (yyvsp[-1].exprtype).value = lang_hooks.truthvalue_conversion ((yyvsp[0].ttype)); + skip_evaluation += (yyvsp[-1].exprtype).value == truthvalue_true_node; ;} + break; + + case 84: +#line 601 "c-parse.y" + { skip_evaluation -= (yyvsp[-4].exprtype).value == truthvalue_true_node; + (yyval.exprtype).value = build_conditional_expr ((yyvsp[-4].exprtype).value, (yyvsp[-3].ttype), + (yyvsp[0].exprtype).value); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 85: +#line 606 "c-parse.y" + { (yyval.exprtype).value = build_modify_expr ((yyvsp[-2].exprtype).value, NOP_EXPR, (yyvsp[0].exprtype).value); + (yyval.exprtype).original_code = MODIFY_EXPR; + ;} + break; + + case 86: +#line 610 "c-parse.y" + { (yyval.exprtype).value = build_modify_expr ((yyvsp[-2].exprtype).value, (yyvsp[-1].code), (yyvsp[0].exprtype).value); + TREE_NO_WARNING ((yyval.exprtype).value) = 1; + (yyval.exprtype).original_code = ERROR_MARK; + ;} + break; + + case 87: +#line 618 "c-parse.y" + { + if (yychar == YYEMPTY) + yychar = YYLEX; + (yyval.exprtype).value = build_external_ref ((yyvsp[0].ttype), yychar == '('); + (yyval.exprtype).original_code = ERROR_MARK; + ;} + break; + + case 88: +#line 625 "c-parse.y" + { (yyval.exprtype).value = (yyvsp[0].ttype); (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 89: +#line 627 "c-parse.y" + { (yyval.exprtype).value = (yyvsp[0].ttype); (yyval.exprtype).original_code = STRING_CST; ;} + break; + + case 90: +#line 629 "c-parse.y" + { (yyval.exprtype).value = fname_decl (C_RID_CODE ((yyvsp[0].ttype)), (yyvsp[0].ttype)); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 91: +#line 632 "c-parse.y" + { start_init (NULL_TREE, NULL, 0); + (yyval.ttype) = groktypename ((yyvsp[-2].typenametype)); + if (C_TYPE_VARIABLE_SIZE ((yyval.ttype))) + { + error ("compound literal has variable size"); + (yyval.ttype) = error_mark_node; + } + really_start_incremental_init ((yyval.ttype)); ;} + break; + + case 92: +#line 641 "c-parse.y" + { struct c_expr init = pop_init_level (0); + tree constructor = init.value; + tree type = (yyvsp[-2].ttype); + finish_init (); + maybe_warn_string_init (type, init); + + if (pedantic && !flag_isoc99) + pedwarn ("ISO C90 forbids compound literals"); + (yyval.exprtype).value = build_compound_literal (type, constructor); + (yyval.exprtype).original_code = ERROR_MARK; + ;} + break; + + case 93: +#line 653 "c-parse.y" + { (yyval.exprtype).value = (yyvsp[-1].exprtype).value; + if (TREE_CODE ((yyval.exprtype).value) == MODIFY_EXPR) + TREE_NO_WARNING ((yyval.exprtype).value) = 1; + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 94: +#line 658 "c-parse.y" + { (yyval.exprtype).value = error_mark_node; (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 95: +#line 660 "c-parse.y" + { if (pedantic) + pedwarn ("ISO C forbids braced-groups within expressions"); + (yyval.exprtype).value = c_finish_stmt_expr ((yyvsp[-2].ttype)); + (yyval.exprtype).original_code = ERROR_MARK; + ;} + break; + + case 96: +#line 666 "c-parse.y" + { c_finish_stmt_expr ((yyvsp[-2].ttype)); + (yyval.exprtype).value = error_mark_node; + (yyval.exprtype).original_code = ERROR_MARK; + ;} + break; + + case 97: +#line 671 "c-parse.y" + { (yyval.exprtype).value = build_function_call ((yyvsp[-3].exprtype).value, (yyvsp[-1].ttype)); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 98: +#line 674 "c-parse.y" + { (yyval.exprtype).value = build_va_arg ((yyvsp[-3].exprtype).value, groktypename ((yyvsp[-1].typenametype))); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 99: +#line 678 "c-parse.y" + { tree type = groktypename ((yyvsp[-1].typenametype)); + if (type == error_mark_node) + offsetof_base = error_mark_node; + else + offsetof_base = build1 (INDIRECT_REF, type, NULL); + ;} + break; + + case 100: +#line 685 "c-parse.y" + { (yyval.exprtype).value = fold_offsetof ((yyvsp[-1].ttype)); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 101: +#line 688 "c-parse.y" + { (yyval.exprtype).value = error_mark_node; (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 102: +#line 691 "c-parse.y" + { + tree c; + + c = fold ((yyvsp[-5].exprtype).value); + STRIP_NOPS (c); + if (TREE_CODE (c) != INTEGER_CST) + error ("first argument to %<__builtin_choose_expr%> not" + " a constant"); + (yyval.exprtype) = integer_zerop (c) ? (yyvsp[-1].exprtype) : (yyvsp[-3].exprtype); + ;} + break; + + case 103: +#line 702 "c-parse.y" + { (yyval.exprtype).value = error_mark_node; (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 104: +#line 704 "c-parse.y" + { + tree e1, e2; + + e1 = TYPE_MAIN_VARIANT (groktypename ((yyvsp[-3].typenametype))); + e2 = TYPE_MAIN_VARIANT (groktypename ((yyvsp[-1].typenametype))); + + (yyval.exprtype).value = comptypes (e1, e2) + ? build_int_cst (NULL_TREE, 1) + : build_int_cst (NULL_TREE, 0); + (yyval.exprtype).original_code = ERROR_MARK; + ;} + break; + + case 105: +#line 716 "c-parse.y" + { (yyval.exprtype).value = error_mark_node; (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 106: +#line 718 "c-parse.y" + { (yyval.exprtype).value = build_array_ref ((yyvsp[-3].exprtype).value, (yyvsp[-1].exprtype).value); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 107: +#line 721 "c-parse.y" + { (yyval.exprtype).value = build_component_ref ((yyvsp[-2].exprtype).value, (yyvsp[0].ttype)); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 108: +#line 724 "c-parse.y" + { + tree expr = build_indirect_ref ((yyvsp[-2].exprtype).value, "->"); + (yyval.exprtype).value = build_component_ref (expr, (yyvsp[0].ttype)); + (yyval.exprtype).original_code = ERROR_MARK; + ;} + break; + + case 109: +#line 730 "c-parse.y" + { (yyval.exprtype).value = build_unary_op (POSTINCREMENT_EXPR, (yyvsp[-1].exprtype).value, 0); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 110: +#line 733 "c-parse.y" + { (yyval.exprtype).value = build_unary_op (POSTDECREMENT_EXPR, (yyvsp[-1].exprtype).value, 0); + (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 111: +#line 743 "c-parse.y" + { (yyval.ttype) = build_component_ref (offsetof_base, (yyvsp[0].ttype)); ;} + break; + + case 112: +#line 745 "c-parse.y" + { (yyval.ttype) = build_component_ref ((yyvsp[-2].ttype), (yyvsp[0].ttype)); ;} + break; + + case 113: +#line 747 "c-parse.y" + { (yyval.ttype) = build_array_ref ((yyvsp[-3].ttype), (yyvsp[-1].exprtype).value); ;} + break; + + case 116: +#line 760 "c-parse.y" + { ;} + break; + + case 121: +#line 776 "c-parse.y" + { POP_DECLSPEC_STACK; ;} + break; + + case 122: +#line 778 "c-parse.y" + { POP_DECLSPEC_STACK; ;} + break; + + case 123: +#line 780 "c-parse.y" + { shadow_tag_warned (finish_declspecs ((yyvsp[-1].dsptype)), 1); + pedwarn ("empty declaration"); ;} + break; + + case 124: +#line 783 "c-parse.y" + { pedwarn ("empty declaration"); ;} + break; + + case 125: +#line 792 "c-parse.y" + { ;} + break; + + case 126: +#line 800 "c-parse.y" + { pending_xref_error (); + PUSH_DECLSPEC_STACK; + if ((yyvsp[0].dsptype)) + { + prefix_attributes = (yyvsp[0].dsptype)->attrs; + (yyvsp[0].dsptype)->attrs = NULL_TREE; + current_declspecs = (yyvsp[0].dsptype); + } + else + { + prefix_attributes = NULL_TREE; + current_declspecs = build_null_declspecs (); + } + current_declspecs = finish_declspecs (current_declspecs); + all_prefix_attributes = prefix_attributes; ;} + break; + + case 127: +#line 821 "c-parse.y" + { all_prefix_attributes = chainon ((yyvsp[0].ttype), prefix_attributes); ;} + break; + + case 128: +#line 826 "c-parse.y" + { POP_DECLSPEC_STACK; ;} + break; + + case 129: +#line 828 "c-parse.y" + { POP_DECLSPEC_STACK; ;} + break; + + case 130: +#line 830 "c-parse.y" + { POP_DECLSPEC_STACK; ;} + break; + + case 131: +#line 832 "c-parse.y" + { POP_DECLSPEC_STACK; ;} + break; + + case 132: +#line 834 "c-parse.y" + { shadow_tag (finish_declspecs ((yyvsp[-1].dsptype))); ;} + break; + + case 133: +#line 836 "c-parse.y" + { RESTORE_EXT_FLAGS ((yyvsp[-1].itype)); ;} + break; + + case 134: +#line 882 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual (build_null_declspecs (), (yyvsp[0].ttype)); ;} + break; + + case 135: +#line 884 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 136: +#line 886 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 137: +#line 891 "c-parse.y" + { (yyval.dsptype) = declspecs_add_attrs ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 138: +#line 896 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 139: +#line 898 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 140: +#line 903 "c-parse.y" + { (yyval.dsptype) = declspecs_add_attrs (build_null_declspecs (), (yyvsp[0].ttype)); ;} + break; + + case 141: +#line 905 "c-parse.y" + { (yyval.dsptype) = declspecs_add_attrs ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 142: +#line 910 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type (build_null_declspecs (), (yyvsp[0].tstype)); ;} + break; + + case 143: +#line 912 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 144: +#line 914 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 145: +#line 916 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 146: +#line 918 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 147: +#line 920 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 148: +#line 922 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 149: +#line 927 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type (build_null_declspecs (), (yyvsp[0].tstype)); ;} + break; + + case 150: +#line 929 "c-parse.y" + { (yyval.dsptype) = declspecs_add_attrs ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 151: +#line 931 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 152: +#line 933 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 153: +#line 935 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 154: +#line 937 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 155: +#line 942 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 156: +#line 944 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 157: +#line 946 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 158: +#line 948 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 159: +#line 950 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 160: +#line 952 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 161: +#line 957 "c-parse.y" + { (yyval.dsptype) = declspecs_add_attrs ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 162: +#line 959 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 163: +#line 961 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 164: +#line 963 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 165: +#line 965 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 166: +#line 970 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec (build_null_declspecs (), (yyvsp[0].ttype)); ;} + break; + + case 167: +#line 972 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 168: +#line 974 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 169: +#line 976 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 170: +#line 978 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 171: +#line 980 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 172: +#line 982 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 173: +#line 987 "c-parse.y" + { (yyval.dsptype) = declspecs_add_attrs ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 174: +#line 992 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 175: +#line 994 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 176: +#line 996 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 177: +#line 998 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 178: +#line 1000 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 179: +#line 1002 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 180: +#line 1007 "c-parse.y" + { (yyval.dsptype) = declspecs_add_attrs ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 181: +#line 1012 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 182: +#line 1014 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 183: +#line 1016 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 184: +#line 1018 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 185: +#line 1020 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 186: +#line 1022 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 187: +#line 1024 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 188: +#line 1026 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 189: +#line 1028 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 190: +#line 1030 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 191: +#line 1035 "c-parse.y" + { (yyval.dsptype) = declspecs_add_attrs ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 192: +#line 1037 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 193: +#line 1039 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 194: +#line 1041 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 195: +#line 1043 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 196: +#line 1048 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 197: +#line 1050 "c-parse.y" + { (yyval.dsptype) = declspecs_add_qual ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 198: +#line 1052 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 199: +#line 1054 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 200: +#line 1056 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 201: +#line 1058 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 202: +#line 1060 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 203: +#line 1062 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 204: +#line 1064 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 205: +#line 1066 "c-parse.y" + { (yyval.dsptype) = declspecs_add_scspec ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 206: +#line 1071 "c-parse.y" + { (yyval.dsptype) = declspecs_add_attrs ((yyvsp[-1].dsptype), (yyvsp[0].ttype)); ;} + break; + + case 207: +#line 1073 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 208: +#line 1075 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 209: +#line 1077 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 210: +#line 1079 "c-parse.y" + { (yyval.dsptype) = declspecs_add_type ((yyvsp[-1].dsptype), (yyvsp[0].tstype)); ;} + break; + + case 267: +#line 1166 "c-parse.y" + { (yyval.dsptype) = NULL; ;} + break; + + case 268: +#line 1168 "c-parse.y" + { (yyval.dsptype) = (yyvsp[0].dsptype); ;} + break; + + case 272: +#line 1203 "c-parse.y" + { OBJC_NEED_RAW_IDENTIFIER (1); + (yyval.tstype).kind = ctsk_resword; + (yyval.tstype).spec = (yyvsp[0].ttype); ;} + break; + + case 275: +#line 1215 "c-parse.y" + { /* For a typedef name, record the meaning, not the name. + In case of `foo foo, bar;'. */ + (yyval.tstype).kind = ctsk_typedef; + (yyval.tstype).spec = lookup_name ((yyvsp[0].ttype)); ;} + break; + + case 276: +#line 1220 "c-parse.y" + { skip_evaluation--; + in_typeof--; + if (TREE_CODE ((yyvsp[-1].exprtype).value) == COMPONENT_REF + && DECL_C_BIT_FIELD (TREE_OPERAND ((yyvsp[-1].exprtype).value, 1))) + error ("% applied to a bit-field"); + (yyval.tstype).kind = ctsk_typeof; + (yyval.tstype).spec = TREE_TYPE ((yyvsp[-1].exprtype).value); + pop_maybe_used (variably_modified_type_p ((yyval.tstype).spec, + NULL_TREE)); ;} + break; + + case 277: +#line 1230 "c-parse.y" + { skip_evaluation--; + in_typeof--; + (yyval.tstype).kind = ctsk_typeof; + (yyval.tstype).spec = groktypename ((yyvsp[-1].typenametype)); + pop_maybe_used (variably_modified_type_p ((yyval.tstype).spec, + NULL_TREE)); ;} + break; + + case 282: +#line 1252 "c-parse.y" + { (yyval.ttype) = start_decl ((yyvsp[-3].dtrtype), current_declspecs, true, + chainon ((yyvsp[-1].ttype), all_prefix_attributes)); + if (!(yyval.ttype)) + (yyval.ttype) = error_mark_node; + start_init ((yyval.ttype), (yyvsp[-2].ttype), global_bindings_p ()); ;} + break; + + case 283: +#line 1259 "c-parse.y" + { finish_init (); + if ((yyvsp[-1].ttype) != error_mark_node) + { + maybe_warn_string_init (TREE_TYPE ((yyvsp[-1].ttype)), (yyvsp[0].exprtype)); + finish_decl ((yyvsp[-1].ttype), (yyvsp[0].exprtype).value, (yyvsp[-4].ttype)); + } + ;} + break; + + case 284: +#line 1267 "c-parse.y" + { tree d = start_decl ((yyvsp[-2].dtrtype), current_declspecs, false, + chainon ((yyvsp[0].ttype), all_prefix_attributes)); + if (d) + finish_decl (d, NULL_TREE, (yyvsp[-1].ttype)); + ;} + break; + + case 285: +#line 1276 "c-parse.y" + { (yyval.ttype) = start_decl ((yyvsp[-3].dtrtype), current_declspecs, true, + chainon ((yyvsp[-1].ttype), all_prefix_attributes)); + if (!(yyval.ttype)) + (yyval.ttype) = error_mark_node; + start_init ((yyval.ttype), (yyvsp[-2].ttype), global_bindings_p ()); ;} + break; + + case 286: +#line 1283 "c-parse.y" + { finish_init (); + if ((yyvsp[-1].ttype) != error_mark_node) + { + maybe_warn_string_init (TREE_TYPE ((yyvsp[-1].ttype)), (yyvsp[0].exprtype)); + finish_decl ((yyvsp[-1].ttype), (yyvsp[0].exprtype).value, (yyvsp[-4].ttype)); + } + ;} + break; + + case 287: +#line 1291 "c-parse.y" + { tree d = start_decl ((yyvsp[-2].dtrtype), current_declspecs, false, + chainon ((yyvsp[0].ttype), all_prefix_attributes)); + if (d) + finish_decl (d, NULL_TREE, (yyvsp[-1].ttype)); ;} + break; + + case 288: +#line 1300 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 289: +#line 1302 "c-parse.y" + { (yyval.ttype) = (yyvsp[0].ttype); ;} + break; + + case 290: +#line 1307 "c-parse.y" + { (yyval.ttype) = (yyvsp[0].ttype); ;} + break; + + case 291: +#line 1309 "c-parse.y" + { (yyval.ttype) = chainon ((yyvsp[-1].ttype), (yyvsp[0].ttype)); ;} + break; + + case 292: +#line 1315 "c-parse.y" + { (yyval.ttype) = (yyvsp[-3].ttype); ;} + break; + + case 293: +#line 1317 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 294: +#line 1322 "c-parse.y" + { (yyval.ttype) = (yyvsp[0].ttype); ;} + break; + + case 295: +#line 1324 "c-parse.y" + { (yyval.ttype) = chainon ((yyvsp[-2].ttype), (yyvsp[0].ttype)); ;} + break; + + case 296: +#line 1329 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 297: +#line 1331 "c-parse.y" + { (yyval.ttype) = build_tree_list ((yyvsp[0].ttype), NULL_TREE); ;} + break; + + case 298: +#line 1333 "c-parse.y" + { (yyval.ttype) = build_tree_list ((yyvsp[-3].ttype), build_tree_list (NULL_TREE, (yyvsp[-1].ttype))); ;} + break; + + case 299: +#line 1335 "c-parse.y" + { (yyval.ttype) = build_tree_list ((yyvsp[-5].ttype), tree_cons (NULL_TREE, (yyvsp[-3].ttype), (yyvsp[-1].ttype))); ;} + break; + + case 300: +#line 1337 "c-parse.y" + { (yyval.ttype) = build_tree_list ((yyvsp[-3].ttype), (yyvsp[-1].ttype)); ;} + break; + + case 307: +#line 1359 "c-parse.y" + { (yyval.exprtype) = (yyvsp[0].exprtype); ;} + break; + + case 308: +#line 1361 "c-parse.y" + { really_start_incremental_init (NULL_TREE); ;} + break; + + case 309: +#line 1363 "c-parse.y" + { (yyval.exprtype) = pop_init_level (0); ;} + break; + + case 310: +#line 1365 "c-parse.y" + { (yyval.exprtype).value = error_mark_node; (yyval.exprtype).original_code = ERROR_MARK; ;} + break; + + case 311: +#line 1371 "c-parse.y" + { if (pedantic) + pedwarn ("ISO C forbids empty initializer braces"); ;} + break; + + case 315: +#line 1385 "c-parse.y" + { if (pedantic && !flag_isoc99) + pedwarn ("ISO C90 forbids specifying subobject to initialize"); ;} + break; + + case 316: +#line 1388 "c-parse.y" + { if (pedantic) + pedwarn ("obsolete use of designated initializer without %<=%>"); ;} + break; + + case 317: +#line 1391 "c-parse.y" + { set_init_label ((yyvsp[-1].ttype)); + if (pedantic) + pedwarn ("obsolete use of designated initializer with %<:%>"); ;} + break; + + case 318: +#line 1395 "c-parse.y" + {;} + break; + + case 320: +#line 1401 "c-parse.y" + { push_init_level (0); ;} + break; + + case 321: +#line 1403 "c-parse.y" + { process_init_element (pop_init_level (0)); ;} + break; + + case 322: +#line 1405 "c-parse.y" + { process_init_element ((yyvsp[0].exprtype)); ;} + break; + + case 326: +#line 1416 "c-parse.y" + { set_init_label ((yyvsp[0].ttype)); ;} + break; + + case 328: +#line 1422 "c-parse.y" + { set_init_index ((yyvsp[-3].exprtype).value, (yyvsp[-1].exprtype).value); + if (pedantic) + pedwarn ("ISO C forbids specifying range of elements to initialize"); ;} + break; + + case 329: +#line 1426 "c-parse.y" + { set_init_index ((yyvsp[-1].exprtype).value, NULL_TREE); ;} + break; + + case 330: +#line 1431 "c-parse.y" + { if (pedantic) + pedwarn ("ISO C forbids nested functions"); + + push_function_context (); + if (!start_function (current_declspecs, (yyvsp[0].dtrtype), + all_prefix_attributes)) + { + pop_function_context (); + YYERROR1; + } + ;} + break; + + case 331: +#line 1443 "c-parse.y" + { tree decl = current_function_decl; + DECL_SOURCE_LOCATION (decl) = (yyvsp[0].location); + store_parm_decls (); ;} + break; + + case 332: +#line 1452 "c-parse.y" + { tree decl = current_function_decl; + add_stmt ((yyvsp[0].ttype)); + finish_function (); + pop_function_context (); + add_stmt (build_stmt (DECL_EXPR, decl)); ;} + break; + + case 333: +#line 1461 "c-parse.y" + { if (pedantic) + pedwarn ("ISO C forbids nested functions"); + + push_function_context (); + if (!start_function (current_declspecs, (yyvsp[0].dtrtype), + all_prefix_attributes)) + { + pop_function_context (); + YYERROR1; + } + ;} + break; + + case 334: +#line 1473 "c-parse.y" + { tree decl = current_function_decl; + DECL_SOURCE_LOCATION (decl) = (yyvsp[0].location); + store_parm_decls (); ;} + break; + + case 335: +#line 1482 "c-parse.y" + { tree decl = current_function_decl; + add_stmt ((yyvsp[0].ttype)); + finish_function (); + pop_function_context (); + add_stmt (build_stmt (DECL_EXPR, decl)); ;} + break; + + case 338: +#line 1501 "c-parse.y" + { (yyval.dtrtype) = (yyvsp[-2].ttype) ? build_attrs_declarator ((yyvsp[-2].ttype), (yyvsp[-1].dtrtype)) : (yyvsp[-1].dtrtype); ;} + break; + + case 339: +#line 1503 "c-parse.y" + { (yyval.dtrtype) = build_function_declarator ((yyvsp[0].arginfotype), (yyvsp[-2].dtrtype)); ;} + break; + + case 340: +#line 1505 "c-parse.y" + { (yyval.dtrtype) = set_array_declarator_inner ((yyvsp[0].dtrtype), (yyvsp[-1].dtrtype), false); ;} + break; + + case 341: +#line 1507 "c-parse.y" + { (yyval.dtrtype) = make_pointer_declarator ((yyvsp[-1].dsptype), (yyvsp[0].dtrtype)); ;} + break; + + case 342: +#line 1509 "c-parse.y" + { (yyval.dtrtype) = build_id_declarator ((yyvsp[0].ttype)); ;} + break; + + case 345: +#line 1523 "c-parse.y" + { (yyval.dtrtype) = build_function_declarator ((yyvsp[0].arginfotype), (yyvsp[-2].dtrtype)); ;} + break; + + case 346: +#line 1525 "c-parse.y" + { (yyval.dtrtype) = set_array_declarator_inner ((yyvsp[0].dtrtype), (yyvsp[-1].dtrtype), false); ;} + break; + + case 347: +#line 1527 "c-parse.y" + { (yyval.dtrtype) = build_id_declarator ((yyvsp[0].ttype)); ;} + break; + + case 348: +#line 1532 "c-parse.y" + { (yyval.dtrtype) = build_function_declarator ((yyvsp[0].arginfotype), (yyvsp[-2].dtrtype)); ;} + break; + + case 349: +#line 1534 "c-parse.y" + { (yyval.dtrtype) = set_array_declarator_inner ((yyvsp[0].dtrtype), (yyvsp[-1].dtrtype), false); ;} + break; + + case 350: +#line 1536 "c-parse.y" + { (yyval.dtrtype) = make_pointer_declarator ((yyvsp[-1].dsptype), (yyvsp[0].dtrtype)); ;} + break; + + case 351: +#line 1538 "c-parse.y" + { (yyval.dtrtype) = make_pointer_declarator ((yyvsp[-1].dsptype), (yyvsp[0].dtrtype)); ;} + break; + + case 352: +#line 1540 "c-parse.y" + { (yyval.dtrtype) = (yyvsp[-2].ttype) ? build_attrs_declarator ((yyvsp[-2].ttype), (yyvsp[-1].dtrtype)) : (yyvsp[-1].dtrtype); ;} + break; + + case 353: +#line 1548 "c-parse.y" + { (yyval.dtrtype) = build_function_declarator ((yyvsp[0].arginfotype), (yyvsp[-2].dtrtype)); ;} + break; + + case 354: +#line 1550 "c-parse.y" + { (yyval.dtrtype) = (yyvsp[-2].ttype) ? build_attrs_declarator ((yyvsp[-2].ttype), (yyvsp[-1].dtrtype)) : (yyvsp[-1].dtrtype); ;} + break; + + case 355: +#line 1552 "c-parse.y" + { (yyval.dtrtype) = make_pointer_declarator ((yyvsp[-1].dsptype), (yyvsp[0].dtrtype)); ;} + break; + + case 356: +#line 1554 "c-parse.y" + { (yyval.dtrtype) = set_array_declarator_inner ((yyvsp[0].dtrtype), (yyvsp[-1].dtrtype), false); ;} + break; + + case 357: +#line 1556 "c-parse.y" + { (yyval.dtrtype) = build_id_declarator ((yyvsp[0].ttype)); ;} + break; + + case 358: +#line 1561 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 359: +#line 1563 "c-parse.y" + { (yyval.ttype) = (yyvsp[0].ttype); ;} + break; + + case 360: +#line 1568 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 361: +#line 1570 "c-parse.y" + { (yyval.ttype) = (yyvsp[0].ttype); ;} + break; + + case 362: +#line 1575 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 363: +#line 1577 "c-parse.y" + { (yyval.ttype) = (yyvsp[0].ttype); ;} + break; + + case 364: +#line 1588 "c-parse.y" + { (yyval.ttype) = start_struct (RECORD_TYPE, (yyvsp[-1].ttype)); + /* Start scope of tag before parsing components. */ + ;} + break; + + case 365: +#line 1592 "c-parse.y" + { (yyval.tstype).spec = finish_struct ((yyvsp[-3].ttype), nreverse ((yyvsp[-2].ttype)), + chainon ((yyvsp[-6].ttype), (yyvsp[0].ttype))); + (yyval.tstype).kind = ctsk_tagdef; ;} + break; + + case 366: +#line 1596 "c-parse.y" + { (yyval.tstype).spec = finish_struct (start_struct (RECORD_TYPE, + NULL_TREE), + nreverse ((yyvsp[-2].ttype)), chainon ((yyvsp[-4].ttype), (yyvsp[0].ttype))); + (yyval.tstype).kind = ctsk_tagdef; + ;} + break; + + case 367: +#line 1602 "c-parse.y" + { (yyval.ttype) = start_struct (UNION_TYPE, (yyvsp[-1].ttype)); ;} + break; + + case 368: +#line 1604 "c-parse.y" + { (yyval.tstype).spec = finish_struct ((yyvsp[-3].ttype), nreverse ((yyvsp[-2].ttype)), + chainon ((yyvsp[-6].ttype), (yyvsp[0].ttype))); + (yyval.tstype).kind = ctsk_tagdef; ;} + break; + + case 369: +#line 1608 "c-parse.y" + { (yyval.tstype).spec = finish_struct (start_struct (UNION_TYPE, + NULL_TREE), + nreverse ((yyvsp[-2].ttype)), chainon ((yyvsp[-4].ttype), (yyvsp[0].ttype))); + (yyval.tstype).kind = ctsk_tagdef; + ;} + break; + + case 370: +#line 1614 "c-parse.y" + { (yyval.ttype) = start_enum ((yyvsp[-1].ttype)); ;} + break; + + case 371: +#line 1616 "c-parse.y" + { (yyval.tstype).spec = finish_enum ((yyvsp[-4].ttype), nreverse ((yyvsp[-3].ttype)), + chainon ((yyvsp[-7].ttype), (yyvsp[0].ttype))); + (yyval.tstype).kind = ctsk_tagdef; ;} + break; + + case 372: +#line 1620 "c-parse.y" + { (yyval.ttype) = start_enum (NULL_TREE); ;} + break; + + case 373: +#line 1622 "c-parse.y" + { (yyval.tstype).spec = finish_enum ((yyvsp[-4].ttype), nreverse ((yyvsp[-3].ttype)), + chainon ((yyvsp[-6].ttype), (yyvsp[0].ttype))); + (yyval.tstype).kind = ctsk_tagdef; ;} + break; + + case 374: +#line 1629 "c-parse.y" + { (yyval.tstype) = parser_xref_tag (RECORD_TYPE, (yyvsp[0].ttype)); ;} + break; + + case 375: +#line 1631 "c-parse.y" + { (yyval.tstype) = parser_xref_tag (UNION_TYPE, (yyvsp[0].ttype)); ;} + break; + + case 376: +#line 1633 "c-parse.y" + { (yyval.tstype) = parser_xref_tag (ENUMERAL_TYPE, (yyvsp[0].ttype)); + /* In ISO C, enumerated types can be referred to + only if already defined. */ + if (pedantic && !COMPLETE_TYPE_P ((yyval.tstype).spec)) + pedwarn ("ISO C forbids forward references to % types"); ;} + break; + + case 380: +#line 1648 "c-parse.y" + { if (pedantic && !flag_isoc99) + pedwarn ("comma at end of enumerator list"); ;} + break; + + case 381: +#line 1666 "c-parse.y" + { (yyval.ttype) = (yyvsp[0].ttype); ;} + break; + + case 382: +#line 1668 "c-parse.y" + { (yyval.ttype) = chainon ((yyvsp[0].ttype), (yyvsp[-1].ttype)); + pedwarn ("no semicolon at end of struct or union"); ;} + break; + + case 383: +#line 1673 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 384: +#line 1675 "c-parse.y" + { (yyval.ttype) = chainon ((yyvsp[-1].ttype), (yyvsp[-2].ttype)); ;} + break; + + case 385: +#line 1677 "c-parse.y" + { if (pedantic) + pedwarn ("extra semicolon in struct or union specified"); ;} + break; + + case 386: +#line 1683 "c-parse.y" + { (yyval.ttype) = (yyvsp[0].ttype); + POP_DECLSPEC_STACK; ;} + break; + + case 387: +#line 1686 "c-parse.y" + { + /* Support for unnamed structs or unions as members of + structs or unions (which is [a] useful and [b] supports + MS P-SDK). */ + (yyval.ttype) = grokfield (build_id_declarator (NULL_TREE), + current_declspecs, NULL_TREE); + POP_DECLSPEC_STACK; ;} + break; + + case 388: +#line 1694 "c-parse.y" + { (yyval.ttype) = (yyvsp[0].ttype); + POP_DECLSPEC_STACK; ;} + break; + + case 389: +#line 1697 "c-parse.y" + { if (pedantic) + pedwarn ("ISO C forbids member declarations with no members"); + shadow_tag_warned (finish_declspecs ((yyvsp[0].dsptype)), pedantic); + (yyval.ttype) = NULL_TREE; ;} + break; + + case 390: +#line 1702 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 391: +#line 1704 "c-parse.y" + { (yyval.ttype) = (yyvsp[0].ttype); + RESTORE_EXT_FLAGS ((yyvsp[-1].itype)); ;} + break; + + case 393: +#line 1711 "c-parse.y" + { TREE_CHAIN ((yyvsp[0].ttype)) = (yyvsp[-3].ttype); (yyval.ttype) = (yyvsp[0].ttype); ;} + break; + + case 395: +#line 1717 "c-parse.y" + { TREE_CHAIN ((yyvsp[0].ttype)) = (yyvsp[-3].ttype); (yyval.ttype) = (yyvsp[0].ttype); ;} + break; + + case 396: +#line 1722 "c-parse.y" + { (yyval.ttype) = grokfield ((yyvsp[-1].dtrtype), current_declspecs, NULL_TREE); + decl_attributes (&(yyval.ttype), + chainon ((yyvsp[0].ttype), all_prefix_attributes), 0); ;} + break; + + case 397: +#line 1726 "c-parse.y" + { (yyval.ttype) = grokfield ((yyvsp[-3].dtrtype), current_declspecs, (yyvsp[-1].exprtype).value); + decl_attributes (&(yyval.ttype), + chainon ((yyvsp[0].ttype), all_prefix_attributes), 0); ;} + break; + + case 398: +#line 1730 "c-parse.y" + { (yyval.ttype) = grokfield (build_id_declarator (NULL_TREE), + current_declspecs, (yyvsp[-1].exprtype).value); + decl_attributes (&(yyval.ttype), + chainon ((yyvsp[0].ttype), all_prefix_attributes), 0); ;} + break; + + case 399: +#line 1738 "c-parse.y" + { (yyval.ttype) = grokfield ((yyvsp[-1].dtrtype), current_declspecs, NULL_TREE); + decl_attributes (&(yyval.ttype), + chainon ((yyvsp[0].ttype), all_prefix_attributes), 0); ;} + break; + + case 400: +#line 1742 "c-parse.y" + { (yyval.ttype) = grokfield ((yyvsp[-3].dtrtype), current_declspecs, (yyvsp[-1].exprtype).value); + decl_attributes (&(yyval.ttype), + chainon ((yyvsp[0].ttype), all_prefix_attributes), 0); ;} + break; + + case 401: +#line 1746 "c-parse.y" + { (yyval.ttype) = grokfield (build_id_declarator (NULL_TREE), + current_declspecs, (yyvsp[-1].exprtype).value); + decl_attributes (&(yyval.ttype), + chainon ((yyvsp[0].ttype), all_prefix_attributes), 0); ;} + break; + + case 403: +#line 1758 "c-parse.y" + { if ((yyvsp[-2].ttype) == error_mark_node) + (yyval.ttype) = (yyvsp[-2].ttype); + else + TREE_CHAIN ((yyvsp[0].ttype)) = (yyvsp[-2].ttype), (yyval.ttype) = (yyvsp[0].ttype); ;} + break; + + case 404: +#line 1763 "c-parse.y" + { (yyval.ttype) = error_mark_node; ;} + break; + + case 405: +#line 1769 "c-parse.y" + { (yyval.ttype) = build_enumerator ((yyvsp[0].ttype), NULL_TREE); ;} + break; + + case 406: +#line 1771 "c-parse.y" + { (yyval.ttype) = build_enumerator ((yyvsp[-2].ttype), (yyvsp[0].exprtype).value); ;} + break; + + case 407: +#line 1776 "c-parse.y" + { pending_xref_error (); + (yyval.dsptype) = finish_declspecs ((yyvsp[0].dsptype)); ;} + break; + + case 408: +#line 1779 "c-parse.y" + { (yyval.typenametype) = XOBNEW (&parser_obstack, struct c_type_name); + (yyval.typenametype)->specs = (yyvsp[-1].dsptype); + (yyval.typenametype)->declarator = (yyvsp[0].dtrtype); ;} + break; + + case 409: +#line 1786 "c-parse.y" + { (yyval.dtrtype) = build_id_declarator (NULL_TREE); ;} + break; + + case 411: +#line 1792 "c-parse.y" + { (yyval.parmtype) = build_c_parm (current_declspecs, all_prefix_attributes, + build_id_declarator (NULL_TREE)); ;} + break; + + case 412: +#line 1795 "c-parse.y" + { (yyval.parmtype) = build_c_parm (current_declspecs, all_prefix_attributes, + (yyvsp[0].dtrtype)); ;} + break; + + case 413: +#line 1798 "c-parse.y" + { (yyval.parmtype) = build_c_parm (current_declspecs, + chainon ((yyvsp[0].ttype), all_prefix_attributes), + (yyvsp[-1].dtrtype)); ;} + break; + + case 417: +#line 1811 "c-parse.y" + { (yyval.dtrtype) = make_pointer_declarator ((yyvsp[-1].dsptype), (yyvsp[0].dtrtype)); ;} + break; + + case 418: +#line 1816 "c-parse.y" + { (yyval.dtrtype) = make_pointer_declarator + ((yyvsp[0].dsptype), build_id_declarator (NULL_TREE)); ;} + break; + + case 419: +#line 1819 "c-parse.y" + { (yyval.dtrtype) = make_pointer_declarator ((yyvsp[-1].dsptype), (yyvsp[0].dtrtype)); ;} + break; + + case 420: +#line 1824 "c-parse.y" + { (yyval.dtrtype) = (yyvsp[-2].ttype) ? build_attrs_declarator ((yyvsp[-2].ttype), (yyvsp[-1].dtrtype)) : (yyvsp[-1].dtrtype); ;} + break; + + case 421: +#line 1826 "c-parse.y" + { (yyval.dtrtype) = build_function_declarator ((yyvsp[0].arginfotype), (yyvsp[-2].dtrtype)); ;} + break; + + case 422: +#line 1828 "c-parse.y" + { (yyval.dtrtype) = set_array_declarator_inner ((yyvsp[0].dtrtype), (yyvsp[-1].dtrtype), true); ;} + break; + + case 423: +#line 1830 "c-parse.y" + { (yyval.dtrtype) = build_function_declarator + ((yyvsp[0].arginfotype), build_id_declarator (NULL_TREE)); ;} + break; + + case 424: +#line 1833 "c-parse.y" + { (yyval.dtrtype) = set_array_declarator_inner + ((yyvsp[0].dtrtype), build_id_declarator (NULL_TREE), true); ;} + break; + + case 425: +#line 1841 "c-parse.y" + { (yyval.dtrtype) = build_array_declarator ((yyvsp[-1].exprtype).value, (yyvsp[-2].dsptype), false, false); ;} + break; + + case 426: +#line 1843 "c-parse.y" + { (yyval.dtrtype) = build_array_declarator (NULL_TREE, (yyvsp[-1].dsptype), false, false); ;} + break; + + case 427: +#line 1845 "c-parse.y" + { (yyval.dtrtype) = build_array_declarator (NULL_TREE, (yyvsp[-2].dsptype), false, true); ;} + break; + + case 428: +#line 1847 "c-parse.y" + { (yyval.dtrtype) = build_array_declarator ((yyvsp[-1].exprtype).value, (yyvsp[-2].dsptype), true, false); ;} + break; + + case 429: +#line 1850 "c-parse.y" + { (yyval.dtrtype) = build_array_declarator ((yyvsp[-1].exprtype).value, (yyvsp[-3].dsptype), true, false); ;} + break; + + case 432: +#line 1863 "c-parse.y" + { + error ("label at end of compound statement"); + ;} + break; + + case 440: +#line 1880 "c-parse.y" + { + if ((pedantic && !flag_isoc99) + || warn_declaration_after_statement) + pedwarn_c90 ("ISO C90 forbids mixed declarations and code"); + ;} + break; + + case 455: +#line 1914 "c-parse.y" + { (yyval.ttype) = c_begin_compound_stmt (flag_isoc99); ;} + break; + + case 457: +#line 1922 "c-parse.y" + { if (pedantic) + pedwarn ("ISO C forbids label declarations"); ;} + break; + + case 460: +#line 1933 "c-parse.y" + { tree link; + for (link = (yyvsp[-1].ttype); link; link = TREE_CHAIN (link)) + { + tree label = declare_label (TREE_VALUE (link)); + C_DECLARED_LABEL_FLAG (label) = 1; + add_stmt (build_stmt (DECL_EXPR, label)); + } + ;} + break; + + case 461: +#line 1947 "c-parse.y" + { add_stmt ((yyvsp[0].ttype)); ;} + break; + + case 463: +#line 1951 "c-parse.y" + { (yyval.ttype) = c_begin_compound_stmt (true); ;} + break; + + case 468: +#line 1965 "c-parse.y" + { if (cur_stmt_list == NULL) + { + error ("braced-group within expression allowed " + "only inside a function"); + YYERROR; + } + (yyval.ttype) = c_begin_stmt_expr (); + ;} + break; + + case 469: +#line 1976 "c-parse.y" + { (yyval.ttype) = c_end_compound_stmt ((yyvsp[-1].ttype), true); ;} + break; + + case 470: +#line 1984 "c-parse.y" + { if (yychar == YYEMPTY) + yychar = YYLEX; + (yyval.location) = input_location; ;} + break; + + case 473: +#line 1997 "c-parse.y" + { (yyval.ttype) = c_end_compound_stmt ((yyvsp[-2].ttype), flag_isoc99); ;} + break; + + case 474: +#line 2002 "c-parse.y" + { + /* Two cases cannot and do not have line numbers associated: + If stmt is degenerate, such as "2;", then stmt is an + INTEGER_CST, which cannot hold line numbers. But that's + ok because the statement will either be changed to a + MODIFY_EXPR during gimplification of the statement expr, + or discarded. If stmt was compound, but without new + variables, we will have skipped the creation of a BIND + and will have a bare STATEMENT_LIST. But that's ok + because (recursively) all of the component statments + should already have line numbers assigned. */ + if ((yyvsp[0].ttype) && EXPR_P ((yyvsp[0].ttype))) + SET_EXPR_LOCATION ((yyvsp[0].ttype), (yyvsp[-1].location)); + ;} + break; + + case 475: +#line 2020 "c-parse.y" + { if ((yyvsp[0].ttype)) SET_EXPR_LOCATION ((yyvsp[0].ttype), (yyvsp[-1].location)); ;} + break; + + case 476: +#line 2024 "c-parse.y" + { (yyval.ttype) = lang_hooks.truthvalue_conversion ((yyvsp[0].exprtype).value); + if (EXPR_P ((yyval.ttype))) + SET_EXPR_LOCATION ((yyval.ttype), (yyvsp[-1].location)); ;} + break; + + case 477: +#line 2037 "c-parse.y" + { (yyval.ttype) = c_end_compound_stmt ((yyvsp[-2].ttype), flag_isoc99); ;} + break; + + case 478: +#line 2042 "c-parse.y" + { if (extra_warnings) + add_stmt (build (NOP_EXPR, NULL_TREE, NULL_TREE)); + (yyval.ttype) = c_end_compound_stmt ((yyvsp[-2].ttype), flag_isoc99); ;} + break; + + case 480: +#line 2051 "c-parse.y" + { c_finish_if_stmt ((yyvsp[-6].location), (yyvsp[-4].ttype), (yyvsp[-2].ttype), (yyvsp[0].ttype), true); + add_stmt (c_end_compound_stmt ((yyvsp[-7].ttype), flag_isoc99)); ;} + break; + + case 481: +#line 2055 "c-parse.y" + { c_finish_if_stmt ((yyvsp[-6].location), (yyvsp[-4].ttype), (yyvsp[-2].ttype), (yyvsp[0].ttype), false); + add_stmt (c_end_compound_stmt ((yyvsp[-7].ttype), flag_isoc99)); ;} + break; + + case 482: +#line 2059 "c-parse.y" + { c_finish_if_stmt ((yyvsp[-4].location), (yyvsp[-2].ttype), (yyvsp[0].ttype), NULL, true); + add_stmt (c_end_compound_stmt ((yyvsp[-5].ttype), flag_isoc99)); ;} + break; + + case 483: +#line 2063 "c-parse.y" + { c_finish_if_stmt ((yyvsp[-4].location), (yyvsp[-2].ttype), (yyvsp[0].ttype), NULL, false); + add_stmt (c_end_compound_stmt ((yyvsp[-5].ttype), flag_isoc99)); ;} + break; + + case 484: +#line 2068 "c-parse.y" + { (yyval.ttype) = c_break_label; c_break_label = NULL; ;} + break; + + case 485: +#line 2072 "c-parse.y" + { (yyval.ttype) = c_cont_label; c_cont_label = NULL; ;} + break; + + case 486: +#line 2078 "c-parse.y" + { c_finish_loop ((yyvsp[-6].location), (yyvsp[-4].ttype), NULL, (yyvsp[0].ttype), c_break_label, + c_cont_label, true); + add_stmt (c_end_compound_stmt ((yyvsp[-7].ttype), flag_isoc99)); + c_break_label = (yyvsp[-2].ttype); c_cont_label = (yyvsp[-1].ttype); ;} + break; + + case 487: +#line 2087 "c-parse.y" + { (yyval.ttype) = c_break_label; c_break_label = (yyvsp[-3].ttype); ;} + break; + + case 488: +#line 2088 "c-parse.y" + { (yyval.ttype) = c_cont_label; c_cont_label = (yyvsp[-3].ttype); ;} + break; + + case 489: +#line 2090 "c-parse.y" + { c_finish_loop ((yyvsp[-10].location), (yyvsp[-2].ttype), NULL, (yyvsp[-7].ttype), (yyvsp[-5].ttype), + (yyvsp[-4].ttype), false); + add_stmt (c_end_compound_stmt ((yyvsp[-11].ttype), flag_isoc99)); ;} + break; + + case 490: +#line 2097 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 491: +#line 2099 "c-parse.y" + { (yyval.ttype) = (yyvsp[0].exprtype).value; ;} + break; + + case 492: +#line 2104 "c-parse.y" + { c_finish_expr_stmt ((yyvsp[-1].ttype)); ;} + break; + + case 493: +#line 2106 "c-parse.y" + { check_for_loop_decls (); ;} + break; + + case 494: +#line 2110 "c-parse.y" + { if ((yyvsp[0].ttype)) + { + (yyval.ttype) = lang_hooks.truthvalue_conversion ((yyvsp[0].ttype)); + if (EXPR_P ((yyval.ttype))) + SET_EXPR_LOCATION ((yyval.ttype), (yyvsp[-1].location)); + } + else + (yyval.ttype) = NULL; + ;} + break; + + case 495: +#line 2122 "c-parse.y" + { (yyval.ttype) = c_process_expr_stmt ((yyvsp[0].ttype)); ;} + break; + + case 496: +#line 2129 "c-parse.y" + { c_finish_loop ((yyvsp[-7].location), (yyvsp[-6].ttype), (yyvsp[-4].ttype), (yyvsp[0].ttype), c_break_label, + c_cont_label, true); + add_stmt (c_end_compound_stmt ((yyvsp[-10].ttype), flag_isoc99)); + c_break_label = (yyvsp[-2].ttype); c_cont_label = (yyvsp[-1].ttype); ;} + break; + + case 497: +#line 2137 "c-parse.y" + { (yyval.ttype) = c_start_case ((yyvsp[-1].exprtype).value); ;} + break; + + case 498: +#line 2139 "c-parse.y" + { c_finish_case ((yyvsp[0].ttype)); + if (c_break_label) + add_stmt (build (LABEL_EXPR, void_type_node, + c_break_label)); + c_break_label = (yyvsp[-1].ttype); + add_stmt (c_end_compound_stmt ((yyvsp[-6].ttype), flag_isoc99)); ;} + break; + + case 499: +#line 2150 "c-parse.y" + { (yyval.ttype) = c_finish_expr_stmt ((yyvsp[-1].exprtype).value); ;} + break; + + case 500: +#line 2152 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 501: +#line 2154 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 502: +#line 2156 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 503: +#line 2158 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 504: +#line 2160 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 505: +#line 2162 "c-parse.y" + { (yyval.ttype) = c_finish_bc_stmt (&c_break_label, true); ;} + break; + + case 506: +#line 2164 "c-parse.y" + { (yyval.ttype) = c_finish_bc_stmt (&c_cont_label, false); ;} + break; + + case 507: +#line 2166 "c-parse.y" + { (yyval.ttype) = c_finish_return (NULL_TREE); ;} + break; + + case 508: +#line 2168 "c-parse.y" + { (yyval.ttype) = c_finish_return ((yyvsp[-1].exprtype).value); ;} + break; + + case 510: +#line 2171 "c-parse.y" + { (yyval.ttype) = c_finish_goto_label ((yyvsp[-1].ttype)); ;} + break; + + case 511: +#line 2173 "c-parse.y" + { (yyval.ttype) = c_finish_goto_ptr ((yyvsp[-1].exprtype).value); ;} + break; + + case 512: +#line 2175 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 513: +#line 2181 "c-parse.y" + { add_stmt ((yyvsp[0].ttype)); (yyval.ttype) = NULL_TREE; ;} + break; + + case 515: +#line 2190 "c-parse.y" + { (yyval.ttype) = do_case ((yyvsp[-1].exprtype).value, NULL_TREE); ;} + break; + + case 516: +#line 2192 "c-parse.y" + { (yyval.ttype) = do_case ((yyvsp[-3].exprtype).value, (yyvsp[-1].exprtype).value); ;} + break; + + case 517: +#line 2194 "c-parse.y" + { (yyval.ttype) = do_case (NULL_TREE, NULL_TREE); ;} + break; + + case 518: +#line 2196 "c-parse.y" + { tree label = define_label ((yyvsp[-2].location), (yyvsp[-3].ttype)); + if (label) + { + decl_attributes (&label, (yyvsp[0].ttype), 0); + (yyval.ttype) = add_stmt (build_stmt (LABEL_EXPR, label)); + } + else + (yyval.ttype) = NULL_TREE; + ;} + break; + + case 519: +#line 2214 "c-parse.y" + { (yyval.ttype) = (yyvsp[-2].ttype); ;} + break; + + case 520: +#line 2220 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 522: +#line 2227 "c-parse.y" + { assemble_asm ((yyvsp[-1].ttype)); ;} + break; + + case 523: +#line 2229 "c-parse.y" + {;} + break; + + case 524: +#line 2237 "c-parse.y" + { (yyval.ttype) = build_asm_stmt ((yyvsp[-6].ttype), (yyvsp[-3].ttype)); ;} + break; + + case 525: +#line 2243 "c-parse.y" + { (yyval.ttype) = build_asm_expr ((yyvsp[0].ttype), 0, 0, 0, true); ;} + break; + + case 526: +#line 2246 "c-parse.y" + { (yyval.ttype) = build_asm_expr ((yyvsp[-2].ttype), (yyvsp[0].ttype), 0, 0, false); ;} + break; + + case 527: +#line 2249 "c-parse.y" + { (yyval.ttype) = build_asm_expr ((yyvsp[-4].ttype), (yyvsp[-2].ttype), (yyvsp[0].ttype), 0, false); ;} + break; + + case 528: +#line 2252 "c-parse.y" + { (yyval.ttype) = build_asm_expr ((yyvsp[-6].ttype), (yyvsp[-4].ttype), (yyvsp[-2].ttype), (yyvsp[0].ttype), false); ;} + break; + + case 529: +#line 2259 "c-parse.y" + { (yyval.ttype) = 0; ;} + break; + + case 530: +#line 2261 "c-parse.y" + { if ((yyvsp[0].ttype) != ridpointers[RID_VOLATILE]) + { + warning ("%E qualifier ignored on asm", (yyvsp[0].ttype)); + (yyval.ttype) = 0; + } + else + (yyval.ttype) = (yyvsp[0].ttype); + ;} + break; + + case 531: +#line 2274 "c-parse.y" + { (yyval.ttype) = NULL_TREE; ;} + break; + + case 534: +#line 2281 "c-parse.y" + { (yyval.ttype) = chainon ((yyvsp[-2].ttype), (yyvsp[0].ttype)); ;} + break; + + case 535: +#line 2287 "c-parse.y" + { (yyval.ttype) = build_tree_list (build_tree_list (NULL_TREE, (yyvsp[-5].ttype)), + (yyvsp[-2].exprtype).value); ;} + break; + + case 536: +#line 2291 "c-parse.y" + { (yyvsp[-7].ttype) = build_string (IDENTIFIER_LENGTH ((yyvsp[-7].ttype)), + IDENTIFIER_POINTER ((yyvsp[-7].ttype))); + (yyval.ttype) = build_tree_list (build_tree_list ((yyvsp[-7].ttype), (yyvsp[-5].ttype)), (yyvsp[-2].exprtype).value); ;} + break; + + case 537: +#line 2298 "c-parse.y" + { (yyval.ttype) = tree_cons (NULL_TREE, (yyvsp[0].ttype), NULL_TREE); ;} + break; + + case 538: +#line 2300 "c-parse.y" + { (yyval.ttype) = tree_cons (NULL_TREE, (yyvsp[0].ttype), (yyvsp[-2].ttype)); ;} + break; + + case 539: +#line 2306 "c-parse.y" + { if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE ((yyvsp[0].ttype)))) + != char_type_node) + { + error ("wide string literal in %"); + (yyval.ttype) = build_string (1, ""); + } + else + (yyval.ttype) = (yyvsp[0].ttype); ;} + break; + + case 540: +#line 2317 "c-parse.y" + { c_lex_string_translate = 0; ;} + break; + + case 541: +#line 2321 "c-parse.y" + { c_lex_string_translate = 1; ;} + break; + + case 542: +#line 2332 "c-parse.y" + { push_scope (); + declare_parm_level (); ;} + break; + + case 543: +#line 2335 "c-parse.y" + { (yyval.arginfotype) = (yyvsp[0].arginfotype); + pop_scope (); ;} + break; + + case 545: +#line 2342 "c-parse.y" + { mark_forward_parm_decls (); ;} + break; + + case 546: +#line 2344 "c-parse.y" + { /* Dummy action so attributes are in known place + on parser stack. */ ;} + break; + + case 547: +#line 2347 "c-parse.y" + { (yyval.arginfotype) = (yyvsp[0].arginfotype); ;} + break; + + case 548: +#line 2349 "c-parse.y" + { (yyval.arginfotype) = XOBNEW (&parser_obstack, struct c_arg_info); + (yyval.arginfotype)->parms = 0; + (yyval.arginfotype)->tags = 0; + (yyval.arginfotype)->types = 0; + (yyval.arginfotype)->others = 0; ;} + break; + + case 549: +#line 2359 "c-parse.y" + { (yyval.arginfotype) = XOBNEW (&parser_obstack, struct c_arg_info); + (yyval.arginfotype)->parms = 0; + (yyval.arginfotype)->tags = 0; + (yyval.arginfotype)->types = 0; + (yyval.arginfotype)->others = 0; ;} + break; + + case 550: +#line 2365 "c-parse.y" + { (yyval.arginfotype) = XOBNEW (&parser_obstack, struct c_arg_info); + (yyval.arginfotype)->parms = 0; + (yyval.arginfotype)->tags = 0; + (yyval.arginfotype)->others = 0; + /* Suppress -Wold-style-definition for this case. */ + (yyval.arginfotype)->types = error_mark_node; + error ("ISO C requires a named argument before %<...%>"); + ;} + break; + + case 551: +#line 2374 "c-parse.y" + { (yyval.arginfotype) = get_parm_info (/*ellipsis=*/false); ;} + break; + + case 552: +#line 2376 "c-parse.y" + { (yyval.arginfotype) = get_parm_info (/*ellipsis=*/true); ;} + break; + + case 553: +#line 2381 "c-parse.y" + { push_parm_decl ((yyvsp[0].parmtype)); ;} + break; + + case 554: +#line 2383 "c-parse.y" + { push_parm_decl ((yyvsp[0].parmtype)); ;} + break; + + case 555: +#line 2390 "c-parse.y" + { (yyval.parmtype) = build_c_parm (current_declspecs, + chainon ((yyvsp[0].ttype), all_prefix_attributes), (yyvsp[-1].dtrtype)); + POP_DECLSPEC_STACK; ;} + break; + + case 556: +#line 2394 "c-parse.y" + { (yyval.parmtype) = build_c_parm (current_declspecs, + chainon ((yyvsp[0].ttype), all_prefix_attributes), (yyvsp[-1].dtrtype)); + POP_DECLSPEC_STACK; ;} + break; + + case 557: +#line 2398 "c-parse.y" + { (yyval.parmtype) = (yyvsp[0].parmtype); + POP_DECLSPEC_STACK; ;} + break; + + case 558: +#line 2401 "c-parse.y" + { (yyval.parmtype) = build_c_parm (current_declspecs, + chainon ((yyvsp[0].ttype), all_prefix_attributes), (yyvsp[-1].dtrtype)); + POP_DECLSPEC_STACK; ;} + break; + + case 559: +#line 2406 "c-parse.y" + { (yyval.parmtype) = (yyvsp[0].parmtype); + POP_DECLSPEC_STACK; ;} + break; + + case 560: +#line 2414 "c-parse.y" + { (yyval.parmtype) = build_c_parm (current_declspecs, + chainon ((yyvsp[0].ttype), all_prefix_attributes), (yyvsp[-1].dtrtype)); + POP_DECLSPEC_STACK; ;} + break; + + case 561: +#line 2418 "c-parse.y" + { (yyval.parmtype) = build_c_parm (current_declspecs, + chainon ((yyvsp[0].ttype), all_prefix_attributes), (yyvsp[-1].dtrtype)); + POP_DECLSPEC_STACK; ;} + break; + + case 562: +#line 2422 "c-parse.y" + { (yyval.parmtype) = (yyvsp[0].parmtype); + POP_DECLSPEC_STACK; ;} + break; + + case 563: +#line 2425 "c-parse.y" + { (yyval.parmtype) = build_c_parm (current_declspecs, + chainon ((yyvsp[0].ttype), all_prefix_attributes), (yyvsp[-1].dtrtype)); + POP_DECLSPEC_STACK; ;} + break; + + case 564: +#line 2430 "c-parse.y" + { (yyval.parmtype) = (yyvsp[0].parmtype); + POP_DECLSPEC_STACK; ;} + break; + + case 565: +#line 2436 "c-parse.y" + { prefix_attributes = chainon (prefix_attributes, (yyvsp[-3].ttype)); + all_prefix_attributes = prefix_attributes; ;} + break; + + case 566: +#line 2445 "c-parse.y" + { push_scope (); + declare_parm_level (); ;} + break; + + case 567: +#line 2448 "c-parse.y" + { (yyval.arginfotype) = (yyvsp[0].arginfotype); + pop_scope (); ;} + break; + + case 569: +#line 2455 "c-parse.y" + { (yyval.arginfotype) = XOBNEW (&parser_obstack, struct c_arg_info); + (yyval.arginfotype)->parms = 0; + (yyval.arginfotype)->tags = 0; + (yyval.arginfotype)->types = (yyvsp[-1].ttype); + (yyval.arginfotype)->others = 0; + + /* Make sure we have a parmlist after attributes. */ + if ((yyvsp[-3].ttype) != 0) + YYERROR1; + ;} + break; + + case 570: +#line 2470 "c-parse.y" + { (yyval.ttype) = build_tree_list (NULL_TREE, (yyvsp[0].ttype)); ;} + break; + + case 571: +#line 2472 "c-parse.y" + { (yyval.ttype) = chainon ((yyvsp[-2].ttype), build_tree_list (NULL_TREE, (yyvsp[0].ttype))); ;} + break; + + case 572: +#line 2478 "c-parse.y" + { (yyval.ttype) = build_tree_list (NULL_TREE, (yyvsp[0].ttype)); ;} + break; + + case 573: +#line 2480 "c-parse.y" + { (yyval.ttype) = chainon ((yyvsp[-2].ttype), build_tree_list (NULL_TREE, (yyvsp[0].ttype))); ;} + break; + + case 574: +#line 2485 "c-parse.y" + { (yyval.itype) = SAVE_EXT_FLAGS (); + pedantic = 0; + warn_pointer_arith = 0; + warn_traditional = 0; + flag_iso = 0; ;} + break; + + + } + +/* Line 1037 of yacc.c. */ +#line 5293 "c-parse.c" + + yyvsp -= yylen; + yyssp -= yylen; + + + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (YYPACT_NINF < yyn && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + const char* yyprefix; + char *yymsg; + int yyx; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 0; + + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); + yycount += 1; + if (yycount == 5) + { + yysize = 0; + break; + } + } + yysize += (sizeof ("syntax error, unexpected ") + + yystrlen (yytname[yytype])); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); + + if (yycount < 5) + { + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yyp = yystpcpy (yyp, yyprefix); + yyp = yystpcpy (yyp, yytname[yyx]); + yyprefix = " or "; + } + } + yyerror (yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror ("syntax error; also virtual memory exhausted"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror ("syntax error"); + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse look-ahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* If at end of input, pop the error token, + then the rest of the stack, then return failure. */ + if (yychar == YYEOF) + for (;;) + { + + YYPOPSTACK; + if (yyssp == yyss) + YYABORT; + yydestruct ("Error: popping", + yystos[*yyssp], yyvsp); + } + } + else + { + yydestruct ("Error: discarding", yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse look-ahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + +#ifdef __GNUC__ + /* Pacify GCC when the user code never invokes YYERROR and the label + yyerrorlab therefore never appears in user code. */ + if (0) + goto yyerrorlab; +#endif + +yyvsp -= yylen; + yyssp -= yylen; + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", yystos[yystate], yyvsp); + YYPOPSTACK; + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + if (yyn == YYFINAL) + YYACCEPT; + + *++yyvsp = yylval; + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yydestruct ("Error: discarding lookahead", + yytoken, &yylval); + yychar = YYEMPTY; + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + return yyresult; +} + + +#line 2492 "c-parse.y" + + +/* yylex() is a thin wrapper around c_lex(), all it does is translate + cpplib.h's token codes into yacc's token codes. */ + +static enum cpp_ttype last_token; + +/* The reserved keyword table. */ +struct resword +{ + const char *word; + ENUM_BITFIELD(rid) rid : 16; + unsigned int disable : 16; +}; + +/* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is + _true_. */ +#define D_C89 0x01 /* not in C89 */ +#define D_EXT 0x02 /* GCC extension */ +#define D_EXT89 0x04 /* GCC extension incorporated in C99 */ +#define D_OBJC 0x08 /* Objective C only */ + +static const struct resword reswords[] = +{ + { "_Bool", RID_BOOL, 0 }, + { "_Complex", RID_COMPLEX, 0 }, + { "__FUNCTION__", RID_FUNCTION_NAME, 0 }, + { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 }, + { "__alignof", RID_ALIGNOF, 0 }, + { "__alignof__", RID_ALIGNOF, 0 }, + { "__asm", RID_ASM, 0 }, + { "__asm__", RID_ASM, 0 }, + { "__attribute", RID_ATTRIBUTE, 0 }, + { "__attribute__", RID_ATTRIBUTE, 0 }, + { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 }, + { "__builtin_offsetof", RID_OFFSETOF, 0 }, + { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 }, + { "__builtin_va_arg", RID_VA_ARG, 0 }, + { "__complex", RID_COMPLEX, 0 }, + { "__complex__", RID_COMPLEX, 0 }, + { "__const", RID_CONST, 0 }, + { "__const__", RID_CONST, 0 }, + { "__extension__", RID_EXTENSION, 0 }, + { "__func__", RID_C99_FUNCTION_NAME, 0 }, + { "__imag", RID_IMAGPART, 0 }, + { "__imag__", RID_IMAGPART, 0 }, + { "__inline", RID_INLINE, 0 }, + { "__inline__", RID_INLINE, 0 }, + { "__label__", RID_LABEL, 0 }, + { "__real", RID_REALPART, 0 }, + { "__real__", RID_REALPART, 0 }, + { "__restrict", RID_RESTRICT, 0 }, + { "__restrict__", RID_RESTRICT, 0 }, + { "__signed", RID_SIGNED, 0 }, + { "__signed__", RID_SIGNED, 0 }, + { "__thread", RID_THREAD, 0 }, + { "__typeof", RID_TYPEOF, 0 }, + { "__typeof__", RID_TYPEOF, 0 }, + { "__volatile", RID_VOLATILE, 0 }, + { "__volatile__", RID_VOLATILE, 0 }, + { "asm", RID_ASM, D_EXT }, + { "auto", RID_AUTO, 0 }, + { "break", RID_BREAK, 0 }, + { "case", RID_CASE, 0 }, + { "char", RID_CHAR, 0 }, + { "const", RID_CONST, 0 }, + { "continue", RID_CONTINUE, 0 }, + { "default", RID_DEFAULT, 0 }, + { "do", RID_DO, 0 }, + { "double", RID_DOUBLE, 0 }, + { "else", RID_ELSE, 0 }, + { "enum", RID_ENUM, 0 }, + { "extern", RID_EXTERN, 0 }, + { "float", RID_FLOAT, 0 }, + { "for", RID_FOR, 0 }, + { "goto", RID_GOTO, 0 }, + { "if", RID_IF, 0 }, + { "inline", RID_INLINE, D_EXT89 }, + { "int", RID_INT, 0 }, + { "long", RID_LONG, 0 }, + { "register", RID_REGISTER, 0 }, + { "restrict", RID_RESTRICT, D_C89 }, + { "return", RID_RETURN, 0 }, + { "short", RID_SHORT, 0 }, + { "signed", RID_SIGNED, 0 }, + { "sizeof", RID_SIZEOF, 0 }, + { "static", RID_STATIC, 0 }, + { "struct", RID_STRUCT, 0 }, + { "switch", RID_SWITCH, 0 }, + { "typedef", RID_TYPEDEF, 0 }, + { "typeof", RID_TYPEOF, D_EXT }, + { "union", RID_UNION, 0 }, + { "unsigned", RID_UNSIGNED, 0 }, + { "void", RID_VOID, 0 }, + { "volatile", RID_VOLATILE, 0 }, + { "while", RID_WHILE, 0 }, + +}; +#define N_reswords (sizeof reswords / sizeof (struct resword)) + +/* Table mapping from RID_* constants to yacc token numbers. + Unfortunately we have to have entries for all the keywords in all + three languages. */ +static const short rid_to_yy[RID_MAX] = +{ + /* RID_STATIC */ STATIC, + /* RID_UNSIGNED */ TYPESPEC, + /* RID_LONG */ TYPESPEC, + /* RID_CONST */ TYPE_QUAL, + /* RID_EXTERN */ SCSPEC, + /* RID_REGISTER */ SCSPEC, + /* RID_TYPEDEF */ SCSPEC, + /* RID_SHORT */ TYPESPEC, + /* RID_INLINE */ SCSPEC, + /* RID_VOLATILE */ TYPE_QUAL, + /* RID_SIGNED */ TYPESPEC, + /* RID_AUTO */ SCSPEC, + /* RID_RESTRICT */ TYPE_QUAL, + + /* C extensions */ + /* RID_COMPLEX */ TYPESPEC, + /* RID_THREAD */ SCSPEC, + + /* C++ */ + /* RID_FRIEND */ 0, + /* RID_VIRTUAL */ 0, + /* RID_EXPLICIT */ 0, + /* RID_EXPORT */ 0, + /* RID_MUTABLE */ 0, + + /* ObjC */ + /* RID_IN */ OBJC_TYPE_QUAL, + /* RID_OUT */ OBJC_TYPE_QUAL, + /* RID_INOUT */ OBJC_TYPE_QUAL, + /* RID_BYCOPY */ OBJC_TYPE_QUAL, + /* RID_BYREF */ OBJC_TYPE_QUAL, + /* RID_ONEWAY */ OBJC_TYPE_QUAL, + + /* C */ + /* RID_INT */ TYPESPEC, + /* RID_CHAR */ TYPESPEC, + /* RID_FLOAT */ TYPESPEC, + /* RID_DOUBLE */ TYPESPEC, + /* RID_VOID */ TYPESPEC, + /* RID_ENUM */ ENUM, + /* RID_STRUCT */ STRUCT, + /* RID_UNION */ UNION, + /* RID_IF */ IF, + /* RID_ELSE */ ELSE, + /* RID_WHILE */ WHILE, + /* RID_DO */ DO, + /* RID_FOR */ FOR, + /* RID_SWITCH */ SWITCH, + /* RID_CASE */ CASE, + /* RID_DEFAULT */ DEFAULT, + /* RID_BREAK */ BREAK, + /* RID_CONTINUE */ CONTINUE, + /* RID_RETURN */ RETURN, + /* RID_GOTO */ GOTO, + /* RID_SIZEOF */ SIZEOF, + + /* C extensions */ + /* RID_ASM */ ASM_KEYWORD, + /* RID_TYPEOF */ TYPEOF, + /* RID_ALIGNOF */ ALIGNOF, + /* RID_ATTRIBUTE */ ATTRIBUTE, + /* RID_VA_ARG */ VA_ARG, + /* RID_EXTENSION */ EXTENSION, + /* RID_IMAGPART */ IMAGPART, + /* RID_REALPART */ REALPART, + /* RID_LABEL */ LABEL, + + /* RID_CHOOSE_EXPR */ CHOOSE_EXPR, + /* RID_TYPES_COMPATIBLE_P */ TYPES_COMPATIBLE_P, + + /* RID_FUNCTION_NAME */ FUNC_NAME, + /* RID_PRETTY_FUNCTION_NAME */ FUNC_NAME, + /* RID_C99_FUNCTION_NAME */ FUNC_NAME, + + /* C++ */ + /* RID_BOOL */ TYPESPEC, + /* RID_WCHAR */ 0, + /* RID_CLASS */ 0, + /* RID_PUBLIC */ 0, + /* RID_PRIVATE */ 0, + /* RID_PROTECTED */ 0, + /* RID_TEMPLATE */ 0, + /* RID_NULL */ 0, + /* RID_CATCH */ 0, + /* RID_DELETE */ 0, + /* RID_FALSE */ 0, + /* RID_NAMESPACE */ 0, + /* RID_NEW */ 0, + /* RID_OFFSETOF */ OFFSETOF, + /* RID_OPERATOR */ 0, + /* RID_THIS */ 0, + /* RID_THROW */ 0, + /* RID_TRUE */ 0, + /* RID_TRY */ 0, + /* RID_TYPENAME */ 0, + /* RID_TYPEID */ 0, + /* RID_USING */ 0, + + /* casts */ + /* RID_CONSTCAST */ 0, + /* RID_DYNCAST */ 0, + /* RID_REINTCAST */ 0, + /* RID_STATCAST */ 0, + + /* Objective C */ + /* RID_AT_ENCODE */ AT_ENCODE, + /* RID_AT_END */ AT_END, + /* RID_AT_CLASS */ AT_CLASS, + /* RID_AT_ALIAS */ AT_ALIAS, + /* RID_AT_DEFS */ AT_DEFS, + /* RID_AT_PRIVATE */ AT_PRIVATE, + /* RID_AT_PROTECTED */ AT_PROTECTED, + /* RID_AT_PUBLIC */ AT_PUBLIC, + /* RID_AT_PROTOCOL */ AT_PROTOCOL, + /* RID_AT_SELECTOR */ AT_SELECTOR, + /* RID_AT_THROW */ AT_THROW, + /* RID_AT_TRY */ AT_TRY, + /* RID_AT_CATCH */ AT_CATCH, + /* RID_AT_FINALLY */ AT_FINALLY, + /* RID_AT_SYNCHRONIZED */ AT_SYNCHRONIZED, + /* RID_AT_INTERFACE */ AT_INTERFACE, + /* RID_AT_IMPLEMENTATION */ AT_IMPLEMENTATION +}; + +static void +init_reswords (void) +{ + unsigned int i; + tree id; + int mask = (flag_isoc99 ? 0 : D_C89) + | (flag_no_asm ? (flag_isoc99 ? D_EXT : D_EXT|D_EXT89) : 0); + + if (!c_dialect_objc ()) + mask |= D_OBJC; + + ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX); + for (i = 0; i < N_reswords; i++) + { + /* If a keyword is disabled, do not enter it into the table + and so create a canonical spelling that isn't a keyword. */ + if (reswords[i].disable & mask) + continue; + + id = get_identifier (reswords[i].word); + C_RID_CODE (id) = reswords[i].rid; + C_IS_RESERVED_WORD (id) = 1; + ridpointers [(int) reswords[i].rid] = id; + } +} + +#define NAME(type) cpp_type2name (type) + +static void +yyerror (const char *msgid) +{ + c_parse_error (msgid, last_token, yylval.ttype); +} + +static int +yylexname (void) +{ + tree decl; + + + if (C_IS_RESERVED_WORD (yylval.ttype)) + { + enum rid rid_code = C_RID_CODE (yylval.ttype); + + { + /* Return the canonical spelling for this keyword. */ + yylval.ttype = ridpointers[(int) rid_code]; + return rid_to_yy[(int) rid_code]; + } + } + + decl = lookup_name (yylval.ttype); + if (decl) + { + if (TREE_CODE (decl) == TYPE_DECL) + return TYPENAME; + } + + return IDENTIFIER; +} + +static inline int +_yylex (void) +{ + get_next: + last_token = c_lex (&yylval.ttype); + switch (last_token) + { + case CPP_EQ: return '='; + case CPP_NOT: return '!'; + case CPP_GREATER: yylval.code = GT_EXPR; return ARITHCOMPARE; + case CPP_LESS: yylval.code = LT_EXPR; return ARITHCOMPARE; + case CPP_PLUS: yylval.code = PLUS_EXPR; return '+'; + case CPP_MINUS: yylval.code = MINUS_EXPR; return '-'; + case CPP_MULT: yylval.code = MULT_EXPR; return '*'; + case CPP_DIV: yylval.code = TRUNC_DIV_EXPR; return '/'; + case CPP_MOD: yylval.code = TRUNC_MOD_EXPR; return '%'; + case CPP_AND: yylval.code = BIT_AND_EXPR; return '&'; + case CPP_OR: yylval.code = BIT_IOR_EXPR; return '|'; + case CPP_XOR: yylval.code = BIT_XOR_EXPR; return '^'; + case CPP_RSHIFT: yylval.code = RSHIFT_EXPR; return RSHIFT; + case CPP_LSHIFT: yylval.code = LSHIFT_EXPR; return LSHIFT; + + case CPP_COMPL: return '~'; + case CPP_AND_AND: return ANDAND; + case CPP_OR_OR: return OROR; + case CPP_QUERY: return '?'; + case CPP_OPEN_PAREN: return '('; + case CPP_EQ_EQ: yylval.code = EQ_EXPR; return EQCOMPARE; + case CPP_NOT_EQ: yylval.code = NE_EXPR; return EQCOMPARE; + case CPP_GREATER_EQ:yylval.code = GE_EXPR; return ARITHCOMPARE; + case CPP_LESS_EQ: yylval.code = LE_EXPR; return ARITHCOMPARE; + + case CPP_PLUS_EQ: yylval.code = PLUS_EXPR; return ASSIGN; + case CPP_MINUS_EQ: yylval.code = MINUS_EXPR; return ASSIGN; + case CPP_MULT_EQ: yylval.code = MULT_EXPR; return ASSIGN; + case CPP_DIV_EQ: yylval.code = TRUNC_DIV_EXPR; return ASSIGN; + case CPP_MOD_EQ: yylval.code = TRUNC_MOD_EXPR; return ASSIGN; + case CPP_AND_EQ: yylval.code = BIT_AND_EXPR; return ASSIGN; + case CPP_OR_EQ: yylval.code = BIT_IOR_EXPR; return ASSIGN; + case CPP_XOR_EQ: yylval.code = BIT_XOR_EXPR; return ASSIGN; + case CPP_RSHIFT_EQ: yylval.code = RSHIFT_EXPR; return ASSIGN; + case CPP_LSHIFT_EQ: yylval.code = LSHIFT_EXPR; return ASSIGN; + + case CPP_OPEN_SQUARE: return '['; + case CPP_CLOSE_SQUARE: return ']'; + case CPP_OPEN_BRACE: return '{'; + case CPP_CLOSE_BRACE: return '}'; + case CPP_ELLIPSIS: return ELLIPSIS; + + case CPP_PLUS_PLUS: return PLUSPLUS; + case CPP_MINUS_MINUS: return MINUSMINUS; + case CPP_DEREF: return POINTSAT; + case CPP_DOT: return '.'; + + /* The following tokens may affect the interpretation of any + identifiers following, if doing Objective-C. */ + case CPP_COLON: OBJC_NEED_RAW_IDENTIFIER (0); return ':'; + case CPP_COMMA: OBJC_NEED_RAW_IDENTIFIER (0); return ','; + case CPP_CLOSE_PAREN: OBJC_NEED_RAW_IDENTIFIER (0); return ')'; + case CPP_SEMICOLON: OBJC_NEED_RAW_IDENTIFIER (0); return ';'; + + case CPP_EOF: + return 0; + + case CPP_NAME: + return yylexname (); + + case CPP_AT_NAME: + /* This only happens in Objective-C; it must be a keyword. */ + return rid_to_yy [(int) C_RID_CODE (yylval.ttype)]; + + case CPP_NUMBER: + case CPP_CHAR: + case CPP_WCHAR: + return CONSTANT; + + case CPP_STRING: + case CPP_WSTRING: + return STRING; + + case CPP_OBJC_STRING: + return OBJC_STRING; + + /* These tokens are C++ specific (and will not be generated + in C mode, but let's be cautious). */ + case CPP_SCOPE: + case CPP_DEREF_STAR: + case CPP_DOT_STAR: + case CPP_MIN_EQ: + case CPP_MAX_EQ: + case CPP_MIN: + case CPP_MAX: + /* These tokens should not survive translation phase 4. */ + case CPP_HASH: + case CPP_PASTE: + error ("syntax error at %qs token", NAME(last_token)); + goto get_next; + + default: + abort (); + } + /* NOTREACHED */ +} + +static int +yylex (void) +{ + int r; + timevar_push (TV_LEX); + r = _yylex(); + timevar_pop (TV_LEX); + return r; +} + +/* Function used when yydebug is set, to print a token in more detail. */ + +static void +yyprint (FILE *file, int yychar, YYSTYPE yyl) +{ + tree t = yyl.ttype; + + fprintf (file, " [%s]", NAME(last_token)); + + switch (yychar) + { + case IDENTIFIER: + case TYPENAME: + case TYPESPEC: + case TYPE_QUAL: + case SCSPEC: + case STATIC: + if (IDENTIFIER_POINTER (t)) + fprintf (file, " '%s'", IDENTIFIER_POINTER (t)); + break; + + case CONSTANT: + fprintf (file, " %s", GET_MODE_NAME (TYPE_MODE (TREE_TYPE (t)))); + if (TREE_CODE (t) == INTEGER_CST) + { + fputs (" ", file); + fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX, + TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t)); + } + break; + } +} + +/* This is not the ideal place to put this, but we have to get it out + of c-lex.c because cp/lex.c has its own version. */ + +/* Parse the file. */ +void +c_parse_file (void) +{ + yyparse (); + + if (malloced_yyss) + { + free (malloced_yyss); + free (malloced_yyvs); + malloced_yyss = 0; + } +} + +#ifdef __XGETTEXT__ +/* Depending on the version of Bison used to compile this grammar, + it may issue generic diagnostics spelled "syntax error" or + "parse error". To prevent this from changing the translation + template randomly, we list all the variants of this particular + diagnostic here. Translators: there is no fine distinction + between diagnostics with "syntax error" in them, and diagnostics + with "parse error" in them. It's okay to give them both the same + translation. */ +const char d1[] = N_("syntax error"); +const char d2[] = N_("parse error"); +const char d3[] = N_("syntax error; also virtual memory exhausted"); +const char d4[] = N_("parse error; also virtual memory exhausted"); +const char d5[] = N_("syntax error: cannot back up"); +const char d6[] = N_("parse error: cannot back up"); +#endif + +#include "gt-c-parse.h" + + diff --git a/contrib/gcc-4.0/gcc/c-pragma.c b/contrib/gcc-4.0/gcc/c-pragma.c index cc1dd28035..67fe8d2d85 100644 --- a/contrib/gcc-4.0/gcc/c-pragma.c +++ b/contrib/gcc-4.0/gcc/c-pragma.c @@ -36,8 +36,9 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "tm_p.h" #include "target.h" -#define GCC_BAD(msgid) do { warning (msgid); return; } while (0) -#define GCC_BAD2(msgid, arg) do { warning (msgid, arg); return; } while (0) +#define GCC_BAD(gmsgid) do { warning (gmsgid); return; } while (0) +#define GCC_BAD2(gmsgid, arg) \ + do { warning (gmsgid, arg); return; } while (0) typedef struct align_stack GTY(()) { diff --git a/contrib/gcc-4.0/gcc/c-tree.h b/contrib/gcc-4.0/gcc/c-tree.h index 5394093f80..f57bc0039d 100644 --- a/contrib/gcc-4.0/gcc/c-tree.h +++ b/contrib/gcc-4.0/gcc/c-tree.h @@ -93,7 +93,13 @@ struct lang_type GTY(()) /* For FUNCTION_DECLs, evaluates true if the decl is built-in but has been declared. */ -#define C_DECL_DECLARED_BUILTIN(EXP) DECL_LANG_FLAG_3 (EXP) +#define C_DECL_DECLARED_BUILTIN(EXP) \ + DECL_LANG_FLAG_3 (FUNCTION_DECL_CHECK (EXP)) + +/* For FUNCTION_DECLs, evaluates true if the decl is built-in, has a + built-in prototype and does not have a non-built-in prototype. */ +#define C_DECL_BUILTIN_PROTOTYPE(EXP) \ + DECL_LANG_FLAG_6 (FUNCTION_DECL_CHECK (EXP)) /* Record whether a decl was declared register. This is strictly a front-end flag, whereas DECL_REGISTER is used for code generation; @@ -104,7 +110,7 @@ struct lang_type GTY(()) unevaluated operand of sizeof / typeof / alignof. This is only used for functions declared static but not defined, though outside sizeof and typeof it is set for other function decls as well. */ -#define C_DECL_USED(EXP) DECL_LANG_FLAG_5 (EXP) +#define C_DECL_USED(EXP) DECL_LANG_FLAG_5 (FUNCTION_DECL_CHECK (EXP)) /* Record whether a label was defined in a statement expression which has finished and so can no longer be jumped to. */ @@ -117,6 +123,18 @@ struct lang_type GTY(()) #define C_DECL_UNDEFINABLE_STMT_EXPR(EXP) \ DECL_LANG_FLAG_7 (LABEL_DECL_CHECK (EXP)) +/* Record whether a label was defined in the scope of an identifier + with variably modified type which has finished and so can no longer + be jumped to. */ +#define C_DECL_UNJUMPABLE_VM(EXP) \ + DECL_LANG_FLAG_3 (LABEL_DECL_CHECK (EXP)) + +/* Record whether a label was the subject of a goto from outside the + current level of scopes of identifiers with variably modified type + and so cannot be defined right now. */ +#define C_DECL_UNDEFINABLE_VM(EXP) \ + DECL_LANG_FLAG_5 (LABEL_DECL_CHECK (EXP)) + /* Nonzero for a decl which either doesn't exist or isn't a prototype. N.B. Could be simplified if all built-in decls had complete prototypes (but this is presently difficult because some of them need FILE*). */ @@ -356,8 +374,8 @@ struct language_function GTY(()) int extern_inline; }; -/* Save lists of labels used or defined in particular statement - expression contexts. Allocated on the parser obstack. */ +/* Save lists of labels used or defined in particular contexts. + Allocated on the parser obstack. */ struct c_label_list { @@ -367,14 +385,32 @@ struct c_label_list struct c_label_list *next; }; -struct c_label_context +/* Statement expression context. */ + +struct c_label_context_se +{ + /* The labels defined at this level of nesting. */ + struct c_label_list *labels_def; + /* The labels used at this level of nesting. */ + struct c_label_list *labels_used; + /* The next outermost context. */ + struct c_label_context_se *next; +}; + +/* Context of variably modified declarations. */ + +struct c_label_context_vm { /* The labels defined at this level of nesting. */ struct c_label_list *labels_def; /* The labels used at this level of nesting. */ struct c_label_list *labels_used; + /* The scope of this context. Multiple contexts may be at the same + numbered scope, since each variably modified declaration starts a + new context. */ + unsigned scope; /* The next outermost context. */ - struct c_label_context *next; + struct c_label_context_vm *next; }; @@ -479,7 +515,8 @@ extern int in_sizeof; extern int in_typeof; extern struct c_switch *c_switch_stack; -extern struct c_label_context *label_context_stack; +extern struct c_label_context_se *label_context_stack_se; +extern struct c_label_context_vm *label_context_stack_vm; extern tree require_complete_type (tree); extern int same_translation_unit_p (tree, tree); @@ -533,6 +570,8 @@ extern tree c_finish_return (tree); extern tree c_finish_bc_stmt (tree *, bool); extern tree c_finish_goto_label (tree); extern tree c_finish_goto_ptr (tree); +extern void c_begin_vm_scope (unsigned int); +extern void c_end_vm_scope (unsigned int); /* Set to 0 at beginning of a function definition, set to 1 if a return statement that specifies a return value is seen. */ diff --git a/contrib/gcc-4.0/gcc/c-typeck.c b/contrib/gcc-4.0/gcc/c-typeck.c index 7f98575937..e30e216122 100644 --- a/contrib/gcc-4.0/gcc/c-typeck.c +++ b/contrib/gcc-4.0/gcc/c-typeck.c @@ -64,7 +64,8 @@ int in_sizeof; /* The level of nesting inside "typeof". */ int in_typeof; -struct c_label_context *label_context_stack; +struct c_label_context_se *label_context_stack_se; +struct c_label_context_vm *label_context_stack_vm; /* Nonzero if we've already printed a "missing braces around initializer" message within this initializer. */ @@ -1248,10 +1249,18 @@ decl_constant_value (tree decl) static tree decl_constant_value_for_broken_optimization (tree decl) { + tree ret; + if (pedantic || DECL_MODE (decl) == BLKmode) return decl; - else - return decl_constant_value (decl); + + ret = decl_constant_value (decl); + /* Avoid unwanted tree sharing between the initializer and current + function's body where the tree can be modified e.g. by the + gimplifier. */ + if (ret != decl && TREE_STATIC (decl)) + ret = unshare_expr (ret); + return ret; } @@ -2805,20 +2814,20 @@ readonly_error (tree arg, enum lvalue_use use) if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) readonly_error (TREE_OPERAND (arg, 0), use); else - error (READONLY_MSG (N_("assignment of read-only member %qs"), - N_("increment of read-only member %qs"), - N_("decrement of read-only member %qs")), + error (READONLY_MSG (G_("assignment of read-only member %qs"), + G_("increment of read-only member %qs"), + G_("decrement of read-only member %qs")), IDENTIFIER_POINTER (DECL_NAME (TREE_OPERAND (arg, 1)))); } else if (TREE_CODE (arg) == VAR_DECL) - error (READONLY_MSG (N_("assignment of read-only variable %qs"), - N_("increment of read-only variable %qs"), - N_("decrement of read-only variable %qs")), + error (READONLY_MSG (G_("assignment of read-only variable %qs"), + G_("increment of read-only variable %qs"), + G_("decrement of read-only variable %qs")), IDENTIFIER_POINTER (DECL_NAME (arg))); else - error (READONLY_MSG (N_("assignment of read-only location"), - N_("increment of read-only location"), - N_("decrement of read-only location"))); + error (READONLY_MSG (G_("assignment of read-only location"), + G_("increment of read-only location"), + G_("decrement of read-only location"))); } /* Mark EXP saying that we need to be able to take the @@ -3072,10 +3081,18 @@ build_compound_expr (tree expr1, tree expr2) /* The left-hand operand of a comma expression is like an expression statement: with -Wextra or -Wunused, we should warn if it doesn't have any side-effects, unless it was explicitly cast to (void). */ - if (warn_unused_value - && !(TREE_CODE (expr1) == CONVERT_EXPR - && VOID_TYPE_P (TREE_TYPE (expr1)))) - warning ("left-hand operand of comma expression has no effect"); + if (warn_unused_value) + { + if (VOID_TYPE_P (TREE_TYPE (expr1)) + && TREE_CODE (expr1) == CONVERT_EXPR) + ; /* (void) a, b */ + else if (VOID_TYPE_P (TREE_TYPE (expr1)) + && TREE_CODE (expr1) == COMPOUND_EXPR + && TREE_CODE (TREE_OPERAND (expr1, 1)) == CONVERT_EXPR) + ; /* (void) a, (void) b, c */ + else + warning ("left-hand operand of comma expression has no effect"); + } } /* With -Wunused, we should also warn if the left-hand operand does have @@ -3645,26 +3662,26 @@ convert_for_assignment (tree type, tree rhs, enum impl_conv errtype, function where an ordinary one is wanted, but not vice-versa. */ if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) - WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE " + WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE " "makes qualified function " "pointer from unqualified"), - N_("assignment makes qualified " + G_("assignment makes qualified " "function pointer from " "unqualified"), - N_("initialization makes qualified " + G_("initialization makes qualified " "function pointer from " "unqualified"), - N_("return makes qualified function " + G_("return makes qualified function " "pointer from unqualified")); } else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) - WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards " + WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " "qualifiers from pointer target type"), - N_("assignment discards qualifiers " + G_("assignment discards qualifiers " "from pointer target type"), - N_("initialization discards qualifiers " + G_("initialization discards qualifiers " "from pointer target type"), - N_("return discards qualifiers from " + G_("return discards qualifiers from " "pointer target type")); } @@ -3713,14 +3730,14 @@ convert_for_assignment (tree type, tree rhs, enum impl_conv errtype, which are not ANSI null ptr constants. */ && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR) && TREE_CODE (ttl) == FUNCTION_TYPE))) - WARN_FOR_ASSIGNMENT (N_("ISO C forbids passing argument %d of " + WARN_FOR_ASSIGNMENT (G_("ISO C forbids passing argument %d of " "%qE between function pointer " "and %"), - N_("ISO C forbids assignment between " + G_("ISO C forbids assignment between " "function pointer and %"), - N_("ISO C forbids initialization between " + G_("ISO C forbids initialization between " "function pointer and %"), - N_("ISO C forbids return between function " + G_("ISO C forbids return between function " "pointer and %")); /* Const and volatile mean something different for function types, so the usual warnings are not appropriate. */ @@ -3728,13 +3745,13 @@ convert_for_assignment (tree type, tree rhs, enum impl_conv errtype, && TREE_CODE (ttl) != FUNCTION_TYPE) { if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) - WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE discards " + WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " "qualifiers from pointer target type"), - N_("assignment discards qualifiers " + G_("assignment discards qualifiers " "from pointer target type"), - N_("initialization discards qualifiers " + G_("initialization discards qualifiers " "from pointer target type"), - N_("return discards qualifiers from " + G_("return discards qualifiers from " "pointer target type")); /* If this is not a case of ignoring a mismatch in signedness, no warning. */ @@ -3743,13 +3760,13 @@ convert_for_assignment (tree type, tree rhs, enum impl_conv errtype, ; /* If there is a mismatch, do warn. */ else if (warn_pointer_sign) - WARN_FOR_ASSIGNMENT (N_("pointer targets in passing argument " + WARN_FOR_ASSIGNMENT (G_("pointer targets in passing argument " "%d of %qE differ in signedness"), - N_("pointer targets in assignment " + G_("pointer targets in assignment " "differ in signedness"), - N_("pointer targets in initialization " + G_("pointer targets in initialization " "differ in signedness"), - N_("pointer targets in return differ " + G_("pointer targets in return differ " "in signedness")); } else if (TREE_CODE (ttl) == FUNCTION_TYPE @@ -3760,24 +3777,24 @@ convert_for_assignment (tree type, tree rhs, enum impl_conv errtype, it is okay to use a const or volatile function where an ordinary one is wanted, but not vice-versa. */ if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) - WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes " + WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " "qualified function pointer " "from unqualified"), - N_("assignment makes qualified function " + G_("assignment makes qualified function " "pointer from unqualified"), - N_("initialization makes qualified " + G_("initialization makes qualified " "function pointer from unqualified"), - N_("return makes qualified function " + G_("return makes qualified function " "pointer from unqualified")); } } else - WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE from " + WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE from " "incompatible pointer type"), - N_("assignment from incompatible pointer type"), - N_("initialization from incompatible " + G_("assignment from incompatible pointer type"), + G_("initialization from incompatible " "pointer type"), - N_("return from incompatible pointer type")); + G_("return from incompatible pointer type")); return convert (type, rhs); } else if (codel == POINTER_TYPE && coder == ARRAY_TYPE) @@ -3798,26 +3815,26 @@ convert_for_assignment (tree type, tree rhs, enum impl_conv errtype, && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST && integer_zerop (TREE_OPERAND (rhs, 0)))) - WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes " + WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " "pointer from integer without a cast"), - N_("assignment makes pointer from integer " + G_("assignment makes pointer from integer " "without a cast"), - N_("initialization makes pointer from " + G_("initialization makes pointer from " "integer without a cast"), - N_("return makes pointer from integer " + G_("return makes pointer from integer " "without a cast")); return convert (type, rhs); } else if (codel == INTEGER_TYPE && coder == POINTER_TYPE) { - WARN_FOR_ASSIGNMENT (N_("passing argument %d of %qE makes integer " + WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes integer " "from pointer without a cast"), - N_("assignment makes integer from pointer " + G_("assignment makes integer from pointer " "without a cast"), - N_("initialization makes integer from pointer " + G_("initialization makes integer from pointer " "without a cast"), - N_("return makes integer from pointer " + G_("return makes integer from pointer " "without a cast")); return convert (type, rhs); } @@ -4757,19 +4774,27 @@ push_init_level (int implicit) tree value = NULL_TREE; /* If we've exhausted any levels that didn't have braces, - pop them now. */ - while (constructor_stack->implicit) + pop them now. If implicit == 1, this will have been done in + process_init_element; do not repeat it here because in the case + of excess initializers for an empty aggregate this leads to an + infinite cycle of popping a level and immediately recreating + it. */ + if (implicit != 1) { - if ((TREE_CODE (constructor_type) == RECORD_TYPE - || TREE_CODE (constructor_type) == UNION_TYPE) - && constructor_fields == 0) - process_init_element (pop_init_level (1)); - else if (TREE_CODE (constructor_type) == ARRAY_TYPE - && constructor_max_index - && tree_int_cst_lt (constructor_max_index, constructor_index)) - process_init_element (pop_init_level (1)); - else - break; + while (constructor_stack->implicit) + { + if ((TREE_CODE (constructor_type) == RECORD_TYPE + || TREE_CODE (constructor_type) == UNION_TYPE) + && constructor_fields == 0) + process_init_element (pop_init_level (1)); + else if (TREE_CODE (constructor_type) == ARRAY_TYPE + && constructor_max_index + && tree_int_cst_lt (constructor_max_index, + constructor_index)) + process_init_element (pop_init_level (1)); + else + break; + } } /* Unless this is an explicit brace, we need to preserve previous @@ -6487,15 +6512,33 @@ c_finish_goto_label (tree label) return NULL_TREE; } + if (C_DECL_UNJUMPABLE_VM (decl)) + { + error ("jump into scope of identifier with variably modified type"); + return NULL_TREE; + } + if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl)) { /* No jump from outside this statement expression context, so record that there is a jump from within this context. */ struct c_label_list *nlist; nlist = XOBNEW (&parser_obstack, struct c_label_list); - nlist->next = label_context_stack->labels_used; + nlist->next = label_context_stack_se->labels_used; + nlist->label = decl; + label_context_stack_se->labels_used = nlist; + } + + if (!C_DECL_UNDEFINABLE_VM (decl)) + { + /* No jump from outside this context context of identifiers with + variably modified type, so record that there is a jump from + within this context. */ + struct c_label_list *nlist; + nlist = XOBNEW (&parser_obstack, struct c_label_list); + nlist->next = label_context_stack_vm->labels_used; nlist->label = decl; - label_context_stack->labels_used = nlist; + label_context_stack_vm->labels_used = nlist; } TREE_USED (decl) = 1; @@ -6629,6 +6672,11 @@ struct c_switch { appear. */ unsigned int blocked_stmt_expr; + /* Scope of outermost declarations of identifiers with variably + modified type within this switch statement; if nonzero, case and + default labels may not appear. */ + unsigned int blocked_vm; + /* The next node on the stack. */ struct c_switch *next; }; @@ -6684,6 +6732,7 @@ c_start_case (tree exp) cs->orig_type = orig_type; cs->cases = splay_tree_new (case_compare, NULL, NULL); cs->blocked_stmt_expr = 0; + cs->blocked_vm = 0; cs->next = c_switch_stack; c_switch_stack = cs; @@ -6697,7 +6746,8 @@ do_case (tree low_value, tree high_value) { tree label = NULL_TREE; - if (c_switch_stack && !c_switch_stack->blocked_stmt_expr) + if (c_switch_stack && !c_switch_stack->blocked_stmt_expr + && !c_switch_stack->blocked_vm) { label = c_add_case_label (c_switch_stack->cases, SWITCH_STMT_COND (c_switch_stack->switch_stmt), @@ -6715,6 +6765,15 @@ do_case (tree low_value, tree high_value) error ("% label in statement expression not containing " "enclosing switch statement"); } + else if (c_switch_stack && c_switch_stack->blocked_vm) + { + if (low_value) + error ("case label in scope of identifier with variably modified " + "type not containing enclosing switch statement"); + else + error ("% label in scope of identifier with variably " + "modified type not containing enclosing switch statement"); + } else if (low_value) error ("case label not within a switch statement"); else @@ -6732,6 +6791,9 @@ c_finish_case (tree body) SWITCH_STMT_BODY (cs->switch_stmt) = body; + /* We must not be within a statement expression nested in the switch + at this point; we might, however, be within the scope of an + identifier with variably modified type nested in the switch. */ gcc_assert (!cs->blocked_stmt_expr); /* Emit warnings as needed. */ @@ -7000,7 +7062,7 @@ tree c_begin_stmt_expr (void) { tree ret; - struct c_label_context *nstack; + struct c_label_context_se *nstack; struct c_label_list *glist; /* We must force a BLOCK for this level so that, if it is not expanded @@ -7013,17 +7075,17 @@ c_begin_stmt_expr (void) c_switch_stack->blocked_stmt_expr++; gcc_assert (c_switch_stack->blocked_stmt_expr != 0); } - for (glist = label_context_stack->labels_used; + for (glist = label_context_stack_se->labels_used; glist != NULL; glist = glist->next) { C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1; } - nstack = XOBNEW (&parser_obstack, struct c_label_context); + nstack = XOBNEW (&parser_obstack, struct c_label_context_se); nstack->labels_def = NULL; nstack->labels_used = NULL; - nstack->next = label_context_stack; - label_context_stack = nstack; + nstack->next = label_context_stack_se; + label_context_stack_se = nstack; /* Mark the current statement list as belonging to a statement list. */ STATEMENT_LIST_STMT_EXPR (ret) = 1; @@ -7046,7 +7108,7 @@ c_finish_stmt_expr (tree body) } /* It is no longer possible to jump to labels defined within this statement expression. */ - for (dlist = label_context_stack->labels_def; + for (dlist = label_context_stack_se->labels_def; dlist != NULL; dlist = dlist->next) { @@ -7054,7 +7116,7 @@ c_finish_stmt_expr (tree body) } /* It is again possible to define labels with a goto just outside this statement expression. */ - for (glist = label_context_stack->next->labels_used; + for (glist = label_context_stack_se->next->labels_used; glist != NULL; glist = glist->next) { @@ -7062,10 +7124,11 @@ c_finish_stmt_expr (tree body) glist_prev = glist; } if (glist_prev != NULL) - glist_prev->next = label_context_stack->labels_used; + glist_prev->next = label_context_stack_se->labels_used; else - label_context_stack->next->labels_used = label_context_stack->labels_used; - label_context_stack = label_context_stack->next; + label_context_stack_se->next->labels_used + = label_context_stack_se->labels_used; + label_context_stack_se = label_context_stack_se->next; /* Locate the last statement in BODY. See c_end_compound_stmt about always returning a BIND_EXPR. */ @@ -7136,6 +7199,75 @@ c_finish_stmt_expr (tree body) return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE); } + +/* Begin the scope of an identifier of variably modified type, scope + number SCOPE. Jumping from outside this scope to inside it is not + permitted. */ + +void +c_begin_vm_scope (unsigned int scope) +{ + struct c_label_context_vm *nstack; + struct c_label_list *glist; + + gcc_assert (scope > 0); + if (c_switch_stack && !c_switch_stack->blocked_vm) + c_switch_stack->blocked_vm = scope; + for (glist = label_context_stack_vm->labels_used; + glist != NULL; + glist = glist->next) + { + C_DECL_UNDEFINABLE_VM (glist->label) = 1; + } + nstack = XOBNEW (&parser_obstack, struct c_label_context_vm); + nstack->labels_def = NULL; + nstack->labels_used = NULL; + nstack->scope = scope; + nstack->next = label_context_stack_vm; + label_context_stack_vm = nstack; +} + +/* End a scope which may contain identifiers of variably modified + type, scope number SCOPE. */ + +void +c_end_vm_scope (unsigned int scope) +{ + if (label_context_stack_vm == NULL) + return; + if (c_switch_stack && c_switch_stack->blocked_vm == scope) + c_switch_stack->blocked_vm = 0; + /* We may have a number of nested scopes of identifiers with + variably modified type, all at this depth. Pop each in turn. */ + while (label_context_stack_vm->scope == scope) + { + struct c_label_list *dlist, *glist, *glist_prev = NULL; + + /* It is no longer possible to jump to labels defined within this + scope. */ + for (dlist = label_context_stack_vm->labels_def; + dlist != NULL; + dlist = dlist->next) + { + C_DECL_UNJUMPABLE_VM (dlist->label) = 1; + } + /* It is again possible to define labels with a goto just outside + this scope. */ + for (glist = label_context_stack_vm->next->labels_used; + glist != NULL; + glist = glist->next) + { + C_DECL_UNDEFINABLE_VM (glist->label) = 0; + glist_prev = glist; + } + if (glist_prev != NULL) + glist_prev->next = label_context_stack_vm->labels_used; + else + label_context_stack_vm->next->labels_used + = label_context_stack_vm->labels_used; + label_context_stack_vm = label_context_stack_vm->next; + } +} /* Begin and end compound statements. This is as simple as pushing and popping new statement lists from the tree. */ diff --git a/contrib/gcc-4.0/gcc/c.opt b/contrib/gcc-4.0/gcc/c.opt index ab0d5a6555..2081d9b663 100644 --- a/contrib/gcc-4.0/gcc/c.opt +++ b/contrib/gcc-4.0/gcc/c.opt @@ -386,6 +386,10 @@ Wsign-promo C++ ObjC++ Var(warn_sign_promo) Warn when overload promotes from unsigned to signed +Wstrict-null-sentinel +C++ ObjC++ +Warn about uncasted NULL used as sentinel + Wstrict-prototypes C ObjC Var(warn_strict_prototypes) Warn about unprototyped function declarations diff --git a/contrib/gcc-4.0/gcc/cfgcleanup.c b/contrib/gcc-4.0/gcc/cfgcleanup.c index 4cf2577309..392e1dec33 100644 --- a/contrib/gcc-4.0/gcc/cfgcleanup.c +++ b/contrib/gcc-4.0/gcc/cfgcleanup.c @@ -1686,6 +1686,8 @@ try_crossjump_to_edge (int mode, edge e1, edge e2) delete_basic_block (to_remove); update_forwarder_flag (redirect_from); + if (redirect_to != src2) + update_forwarder_flag (src2); return true; } diff --git a/contrib/gcc-4.0/gcc/cgraph.h b/contrib/gcc-4.0/gcc/cgraph.h index eae162ec17..b468ea9fc7 100644 --- a/contrib/gcc-4.0/gcc/cgraph.h +++ b/contrib/gcc-4.0/gcc/cgraph.h @@ -51,6 +51,10 @@ struct cgraph_local_info GTY(()) /* True if statics_read_for_function and statics_written_for_function contain valid data. */ bool for_functions_valid; + + /* True if the function is going to be emitted in some other translation + unit, referenced from vtable. */ + bool vtable_method; }; /* Information about the function that needs to be computed globally diff --git a/contrib/gcc-4.0/gcc/collect2.c b/contrib/gcc-4.0/gcc/collect2.c index 90ad456b5f..c05be80b7c 100644 --- a/contrib/gcc-4.0/gcc/collect2.c +++ b/contrib/gcc-4.0/gcc/collect2.c @@ -337,26 +337,26 @@ collect_exit (int status) /* Notify user of a non-error. */ void -notice (const char *msgid, ...) +notice (const char *cmsgid, ...) { va_list ap; - va_start (ap, msgid); - vfprintf (stderr, _(msgid), ap); + va_start (ap, cmsgid); + vfprintf (stderr, _(cmsgid), ap); va_end (ap); } /* Die when sys call fails. */ void -fatal_perror (const char * msgid, ...) +fatal_perror (const char * cmsgid, ...) { int e = errno; va_list ap; - va_start (ap, msgid); + va_start (ap, cmsgid); fprintf (stderr, "collect2: "); - vfprintf (stderr, _(msgid), ap); + vfprintf (stderr, _(cmsgid), ap); fprintf (stderr, ": %s\n", xstrerror (e)); va_end (ap); @@ -366,13 +366,13 @@ fatal_perror (const char * msgid, ...) /* Just die. */ void -fatal (const char * msgid, ...) +fatal (const char * cmsgid, ...) { va_list ap; - va_start (ap, msgid); + va_start (ap, cmsgid); fprintf (stderr, "collect2: "); - vfprintf (stderr, _(msgid), ap); + vfprintf (stderr, _(cmsgid), ap); fprintf (stderr, "\n"); va_end (ap); @@ -382,13 +382,13 @@ fatal (const char * msgid, ...) /* Write error message. */ void -error (const char * msgid, ...) +error (const char * gmsgid, ...) { va_list ap; - va_start (ap, msgid); + va_start (ap, gmsgid); fprintf (stderr, "collect2: "); - vfprintf (stderr, _(msgid), ap); + vfprintf (stderr, _(gmsgid), ap); fprintf (stderr, "\n"); va_end(ap); } @@ -837,6 +837,9 @@ main (int argc, char **argv) signal (SIGCHLD, SIG_DFL); #endif + /* Unlock the stdio streams. */ + unlock_std_streams (); + gcc_init_libintl (); /* Do not invoke xcalloc before this point, since locale needs to be diff --git a/contrib/gcc-4.0/gcc/combine.c b/contrib/gcc-4.0/gcc/combine.c index 58c82a674a..ad8289ebfa 100644 --- a/contrib/gcc-4.0/gcc/combine.c +++ b/contrib/gcc-4.0/gcc/combine.c @@ -4719,7 +4719,7 @@ combine_simplify_rtx (rtx x, enum machine_mode op0_mode, int in_dest) if (GET_CODE (op0) == VEC_CONCAT) { HOST_WIDE_INT op0_size = GET_MODE_SIZE (GET_MODE (XEXP (op0, 0))); - if (op0_size < offset) + if (offset < op0_size) op0 = XEXP (op0, 0); else { diff --git a/contrib/gcc-4.0/gcc/config/i386/emmintrin.h b/contrib/gcc-4.0/gcc/config/i386/emmintrin.h index 45624d2019..81a9b15113 100644 --- a/contrib/gcc-4.0/gcc/config/i386/emmintrin.h +++ b/contrib/gcc-4.0/gcc/config/i386/emmintrin.h @@ -51,14 +51,14 @@ typedef __v2df __m128d; static __inline __m128d _mm_set_sd (double __F) { - return (__m128d){ __F, 0 }; + return __extension__ (__m128d){ __F, 0 }; } /* Create a vector with both elements equal to F. */ static __inline __m128d _mm_set1_pd (double __F) { - return (__m128d){ __F, __F }; + return __extension__ (__m128d){ __F, __F }; } static __inline __m128d @@ -71,21 +71,21 @@ _mm_set_pd1 (double __F) static __inline __m128d _mm_set_pd (double __W, double __X) { - return (__m128d){ __X, __W }; + return __extension__ (__m128d){ __X, __W }; } /* Create a vector with the lower value W and upper value X. */ static __inline __m128d _mm_setr_pd (double __W, double __X) { - return (__m128d){ __W, __X }; + return __extension__ (__m128d){ __W, __X }; } /* Create a vector of zeros. */ static __inline __m128d _mm_setzero_pd (void) { - return (__m128d){ 0.0, 0.0 }; + return __extension__ (__m128d){ 0.0, 0.0 }; } /* Sets the low DPFP value of A from the low value of B. */ @@ -553,7 +553,7 @@ _mm_ucomineq_sd (__m128d __A, __m128d __B) static __inline __m128i _mm_set_epi64x (long long __q1, long long __q0) { - return (__m128i)(__v2di){ __q0, __q1 }; + return __extension__ (__m128i)(__v2di){ __q0, __q1 }; } static __inline __m128i @@ -565,14 +565,15 @@ _mm_set_epi64 (__m64 __q1, __m64 __q0) static __inline __m128i _mm_set_epi32 (int __q3, int __q2, int __q1, int __q0) { - return (__m128i)(__v4si){ __q0, __q1, __q2, __q3 }; + return __extension__ (__m128i)(__v4si){ __q0, __q1, __q2, __q3 }; } static __inline __m128i _mm_set_epi16 (short __q7, short __q6, short __q5, short __q4, short __q3, short __q2, short __q1, short __q0) { - return (__m128i)(__v8hi){ __q0, __q1, __q2, __q3, __q4, __q5, __q6, __q7 }; + return __extension__ (__m128i)(__v8hi){ + __q0, __q1, __q2, __q3, __q4, __q5, __q6, __q7 }; } static __inline __m128i @@ -581,7 +582,7 @@ _mm_set_epi8 (char __q15, char __q14, char __q13, char __q12, char __q07, char __q06, char __q05, char __q04, char __q03, char __q02, char __q01, char __q00) { - return (__m128i)(__v16qi){ + return __extension__ (__m128i)(__v16qi){ __q00, __q01, __q02, __q03, __q04, __q05, __q06, __q07, __q08, __q09, __q10, __q11, __q12, __q13, __q14, __q15 }; @@ -712,7 +713,7 @@ _mm_move_epi64 (__m128i __A) static __inline __m128i _mm_setzero_si128 (void) { - return (__m128i)(__v4si){ 0, 0, 0, 0 }; + return __extension__ (__m128i)(__v4si){ 0, 0, 0, 0 }; } static __inline __m128d @@ -1356,7 +1357,7 @@ _mm_stream_pd (double *__A, __m128d __B) static __inline void _mm_clflush (void const *__A) { - return __builtin_ia32_clflush (__A); + __builtin_ia32_clflush (__A); } static __inline void @@ -1387,37 +1388,37 @@ _mm_cvtsi64x_si128 (long long __A) /* Casts between various SP, DP, INT vector types. Note that these do no conversion of values, they just change the type. */ -static inline __m128 +static __inline __m128 _mm_castpd_ps(__m128d __A) { return (__m128) __A; } -static inline __m128i +static __inline __m128i _mm_castpd_si128(__m128d __A) { return (__m128i) __A; } -static inline __m128d +static __inline __m128d _mm_castps_pd(__m128 __A) { return (__m128d) __A; } -static inline __m128i +static __inline __m128i _mm_castps_si128(__m128 __A) { return (__m128i) __A; } -static inline __m128 +static __inline __m128 _mm_castsi128_ps(__m128i __A) { return (__m128) __A; } -static inline __m128d +static __inline __m128d _mm_castsi128_pd(__m128i __A) { return (__m128d) __A; diff --git a/contrib/gcc-4.0/gcc/config/i386/i386-protos.h b/contrib/gcc-4.0/gcc/config/i386/i386-protos.h index 53edfd1610..0b766c49dc 100644 --- a/contrib/gcc-4.0/gcc/config/i386/i386-protos.h +++ b/contrib/gcc-4.0/gcc/config/i386/i386-protos.h @@ -186,6 +186,8 @@ extern int ix86_register_move_cost (enum machine_mode, enum reg_class, enum reg_class); extern int ix86_secondary_memory_needed (enum reg_class, enum reg_class, enum machine_mode, int); +extern bool ix86_cannot_change_mode_class (enum machine_mode, + enum machine_mode, enum reg_class); extern enum reg_class ix86_preferred_reload_class (rtx, enum reg_class); extern int ix86_memory_move_cost (enum machine_mode, enum reg_class, int); extern void emit_i387_cw_initialization (rtx, rtx, int); diff --git a/contrib/gcc-4.0/gcc/config/i386/i386.c b/contrib/gcc-4.0/gcc/config/i386/i386.c index 24a025ecbd..12e270f9ad 100644 --- a/contrib/gcc-4.0/gcc/config/i386/i386.c +++ b/contrib/gcc-4.0/gcc/config/i386/i386.c @@ -5751,9 +5751,10 @@ legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED, enum machine_mode mode) /* Canonicalize shifts by 0, 1, 2, 3 into multiply */ if (GET_CODE (x) == ASHIFT && GET_CODE (XEXP (x, 1)) == CONST_INT - && (log = (unsigned) exact_log2 (INTVAL (XEXP (x, 1)))) < 4) + && (unsigned HOST_WIDE_INT) INTVAL (XEXP (x, 1)) < 4) { changed = 1; + log = INTVAL (XEXP (x, 1)); x = gen_rtx_MULT (Pmode, force_reg (Pmode, XEXP (x, 0)), GEN_INT (1 << log)); } @@ -5764,9 +5765,10 @@ legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED, enum machine_mode mode) if (GET_CODE (XEXP (x, 0)) == ASHIFT && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT - && (log = (unsigned) exact_log2 (INTVAL (XEXP (XEXP (x, 0), 1)))) < 4) + && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (x, 0), 1)) < 4) { changed = 1; + log = INTVAL (XEXP (XEXP (x, 0), 1)); XEXP (x, 0) = gen_rtx_MULT (Pmode, force_reg (Pmode, XEXP (XEXP (x, 0), 0)), GEN_INT (1 << log)); @@ -5774,9 +5776,10 @@ legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED, enum machine_mode mode) if (GET_CODE (XEXP (x, 1)) == ASHIFT && GET_CODE (XEXP (XEXP (x, 1), 1)) == CONST_INT - && (log = (unsigned) exact_log2 (INTVAL (XEXP (XEXP (x, 1), 1)))) < 4) + && (unsigned HOST_WIDE_INT) INTVAL (XEXP (XEXP (x, 1), 1)) < 4) { changed = 1; + log = INTVAL (XEXP (XEXP (x, 1), 1)); XEXP (x, 1) = gen_rtx_MULT (Pmode, force_reg (Pmode, XEXP (XEXP (x, 1), 0)), GEN_INT (1 << log)); @@ -10315,7 +10318,10 @@ ix86_split_to_parts (rtx operand, rtx *parts, enum machine_mode mode) if (GET_CODE (operand) == CONST_VECTOR) { enum machine_mode imode = int_mode_for_mode (mode); - operand = simplify_subreg (imode, operand, mode, 0); + /* Caution: if we looked through a constant pool memory above, + the operand may actually have a different mode now. That's + ok, since we want to pun this all the way back to an integer. */ + operand = simplify_subreg (imode, operand, GET_MODE (operand), 0); gcc_assert (operand != NULL); mode = imode; } @@ -14996,6 +15002,41 @@ ix86_secondary_memory_needed (enum reg_class class1, enum reg_class class2, return false; } +/* Return true if the registers in CLASS cannot represent the change from + modes FROM to TO. */ + +bool +ix86_cannot_change_mode_class (enum machine_mode from, enum machine_mode to, + enum reg_class class) +{ + if (from == to) + return false; + + /* x87 registers can't do subreg at all, as all values are reformated + to extended precision. */ + if (MAYBE_FLOAT_CLASS_P (class)) + return true; + + if (MAYBE_SSE_CLASS_P (class) || MAYBE_MMX_CLASS_P (class)) + { + /* Vector registers do not support QI or HImode loads. If we don't + disallow a change to these modes, reload will assume it's ok to + drop the subreg from (subreg:SI (reg:HI 100) 0). This affects + the vec_dupv4hi pattern. */ + if (GET_MODE_SIZE (from) < 4) + return true; + + /* Vector registers do not support subreg with nonzero offsets, which + are otherwise valid for integer registers. Since we can't see + whether we have a nonzero offset from here, prohibit all + nonparadoxical subregs changing size. */ + if (GET_MODE_SIZE (to) < GET_MODE_SIZE (from)) + return true; + } + + return false; +} + /* Return the cost of moving data from a register in class CLASS1 to one in class CLASS2. @@ -16690,32 +16731,35 @@ ix86_expand_vector_set (bool mmx_ok, rtx target, rtx val, int elt) break; case 1: - /* tmp = op0 = A B C D */ + /* tmp = target = A B C D */ tmp = copy_to_reg (target); - - /* op0 = C C D D */ + /* target = A A B B */ emit_insn (gen_sse_unpcklps (target, target, target)); - - /* op0 = C C D X */ + /* target = X A B B */ ix86_expand_vector_set (false, target, val, 0); - - /* op0 = A B X D */ + /* target = A X C D */ emit_insn (gen_sse_shufps_1 (target, target, tmp, GEN_INT (1), GEN_INT (0), GEN_INT (2+4), GEN_INT (3+4))); return; case 2: + /* tmp = target = A B C D */ tmp = copy_to_reg (target); - ix86_expand_vector_set (false, target, val, 0); + /* tmp = X B C D */ + ix86_expand_vector_set (false, tmp, val, 0); + /* target = A B X D */ emit_insn (gen_sse_shufps_1 (target, target, tmp, GEN_INT (0), GEN_INT (1), GEN_INT (0+4), GEN_INT (3+4))); return; case 3: + /* tmp = target = A B C D */ tmp = copy_to_reg (target); - ix86_expand_vector_set (false, target, val, 0); + /* tmp = X B C D */ + ix86_expand_vector_set (false, tmp, val, 0); + /* target = A B X D */ emit_insn (gen_sse_shufps_1 (target, target, tmp, GEN_INT (0), GEN_INT (1), GEN_INT (2+4), GEN_INT (0+4))); diff --git a/contrib/gcc-4.0/gcc/config/i386/i386.h b/contrib/gcc-4.0/gcc/config/i386/i386.h index de22587474..5781b2b6be 100644 --- a/contrib/gcc-4.0/gcc/config/i386/i386.h +++ b/contrib/gcc-4.0/gcc/config/i386/i386.h @@ -1031,14 +1031,14 @@ do { \ int i; \ for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) \ if (TEST_HARD_REG_BIT (reg_class_contents[(int)MMX_REGS], i)) \ - fixed_regs[i] = call_used_regs[i] = 1; \ + fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = ""; \ } \ if (! TARGET_SSE) \ { \ int i; \ for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) \ if (TEST_HARD_REG_BIT (reg_class_contents[(int)SSE_REGS], i)) \ - fixed_regs[i] = call_used_regs[i] = 1; \ + fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = ""; \ } \ if (! TARGET_80387 && ! TARGET_FLOAT_RETURNS_IN_80387) \ { \ @@ -1047,7 +1047,15 @@ do { \ COPY_HARD_REG_SET (x, reg_class_contents[(int)FLOAT_REGS]); \ for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) \ if (TEST_HARD_REG_BIT (x, i)) \ - fixed_regs[i] = call_used_regs[i] = 1; \ + fixed_regs[i] = call_used_regs[i] = 1, reg_names[i] = ""; \ + } \ + if (! TARGET_64BIT) \ + { \ + int i; \ + for (i = FIRST_REX_INT_REG; i <= LAST_REX_INT_REG; i++) \ + reg_names[i] = ""; \ + for (i = FIRST_REX_SSE_REG; i <= LAST_REX_SSE_REG; i++) \ + reg_names[i] = ""; \ } \ } while (0) @@ -1589,19 +1597,10 @@ enum reg_class || ((CLASS) == FP_TOP_REG) \ || ((CLASS) == FP_SECOND_REG)) -/* Return a class of registers that cannot change FROM mode to TO mode. - - x87 registers can't do subreg as all values are reformated to extended - precision. XMM registers does not support with nonzero offsets equal - to 4, 8 and 12 otherwise valid for integer registers. Since we can't - determine these, prohibit all nonparadoxical subregs changing size. */ +/* Return a class of registers that cannot change FROM mode to TO mode. */ -#define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \ - (GET_MODE_SIZE (TO) < GET_MODE_SIZE (FROM) \ - ? reg_classes_intersect_p (FLOAT_SSE_REGS, (CLASS)) \ - || MAYBE_MMX_CLASS_P (CLASS) \ - : GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO) \ - ? reg_classes_intersect_p (FLOAT_REGS, (CLASS)) : 0) +#define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \ + ix86_cannot_change_mode_class (FROM, TO, CLASS) /* Stack layout; function entry, exit and calling. */ @@ -2198,7 +2197,7 @@ do { \ /* How to refer to registers in assembler output. This sequence is indexed by compiler's hard-register-number (see above). */ -/* In order to refer to the first 8 regs as 32 bit regs prefix an "e" +/* In order to refer to the first 8 regs as 32 bit regs, prefix an "e". For non floating point regs, the following are the HImode names. For float regs, the stack top is sometimes referred to as "%st(0)" @@ -2223,9 +2222,7 @@ do { \ { "rax", 0 }, { "rdx", 1 }, { "rcx", 2 }, { "rbx", 3 }, \ { "rsi", 4 }, { "rdi", 5 }, { "rbp", 6 }, { "rsp", 7 }, \ { "al", 0 }, { "dl", 1 }, { "cl", 2 }, { "bl", 3 }, \ - { "ah", 0 }, { "dh", 1 }, { "ch", 2 }, { "bh", 3 }, \ - { "mm0", 8}, { "mm1", 9}, { "mm2", 10}, { "mm3", 11}, \ - { "mm4", 12}, { "mm5", 13}, { "mm6", 14}, { "mm7", 15} } + { "ah", 0 }, { "dh", 1 }, { "ch", 2 }, { "bh", 3 } } /* Note we are omitting these since currently I don't know how to get gcc to use these, since they want the same but different diff --git a/contrib/gcc-4.0/gcc/config/i386/i386.md b/contrib/gcc-4.0/gcc/config/i386/i386.md index d859ddfcc7..40004a2b04 100644 --- a/contrib/gcc-4.0/gcc/config/i386/i386.md +++ b/contrib/gcc-4.0/gcc/config/i386/i386.md @@ -16660,7 +16660,7 @@ (use (match_operand:BLK 1 "memory_operand" "")) (use (match_operand:SI 2 "nonmemory_operand" "")) (use (match_operand:SI 3 "const_int_operand" ""))] - "! optimize_size" + "! optimize_size || TARGET_INLINE_ALL_STRINGOPS" { if (ix86_expand_movmem (operands[0], operands[1], operands[2], operands[3])) DONE; diff --git a/contrib/gcc-4.0/gcc/config/i386/mmx.md b/contrib/gcc-4.0/gcc/config/i386/mmx.md index 403501bf4d..ceb520c008 100644 --- a/contrib/gcc-4.0/gcc/config/i386/mmx.md +++ b/contrib/gcc-4.0/gcc/config/i386/mmx.md @@ -177,7 +177,7 @@ (define_expand "push1" [(match_operand:MMXMODE 0 "register_operand" "")] - "TARGET_SSE" + "TARGET_MMX" { ix86_expand_push (mode, operands[0]); DONE; diff --git a/contrib/gcc-4.0/gcc/config/i386/xmmintrin.h b/contrib/gcc-4.0/gcc/config/i386/xmmintrin.h index a22b809085..311ecba581 100644 --- a/contrib/gcc-4.0/gcc/config/i386/xmmintrin.h +++ b/contrib/gcc-4.0/gcc/config/i386/xmmintrin.h @@ -90,7 +90,7 @@ enum _mm_hint static __inline __m128 _mm_setzero_ps (void) { - return (__m128){ 0.0f, 0.0f, 0.0f, 0.0f }; + return __extension__ (__m128){ 0.0f, 0.0f, 0.0f, 0.0f }; } /* Perform the respective operation on the lower SPFP (single-precision @@ -832,14 +832,14 @@ _MM_SET_FLUSH_ZERO_MODE (unsigned int __mode) static __inline __m128 _mm_set_ss (float __F) { - return (__m128)(__v4sf){ __F, 0, 0, 0 }; + return __extension__ (__m128)(__v4sf){ __F, 0, 0, 0 }; } /* Create a vector with all four elements equal to F. */ static __inline __m128 _mm_set1_ps (float __F) { - return (__m128)(__v4sf){ __F, __F, __F, __F }; + return __extension__ (__m128)(__v4sf){ __F, __F, __F, __F }; } static __inline __m128 @@ -894,14 +894,14 @@ _mm_loadr_ps (float const *__P) static __inline __m128 _mm_set_ps (const float __Z, const float __Y, const float __X, const float __W) { - return (__m128)(__v4sf){ __W, __X, __Y, __Z }; + return __extension__ (__m128)(__v4sf){ __W, __X, __Y, __Z }; } /* Create the vector [W X Y Z]. */ static __inline __m128 _mm_setr_ps (float __Z, float __Y, float __X, float __W) { - return (__m128)(__v4sf){ __Z, __Y, __X, __W }; + return __extension__ (__m128)(__v4sf){ __Z, __Y, __X, __W }; } /* Stores the lower SPFP value. */ diff --git a/contrib/gcc-4.0/gcc/cp/call.c b/contrib/gcc-4.0/gcc/cp/call.c index 131e175631..b8762d02d3 100644 --- a/contrib/gcc-4.0/gcc/cp/call.c +++ b/contrib/gcc-4.0/gcc/cp/call.c @@ -4035,7 +4035,7 @@ build_op_delete_call (enum tree_code code, tree addr, tree size, if (placement) return NULL_TREE; - error ("no suitable % for %qT", + error ("no suitable % for %qT", operator_name_info[(int)code].name, type); return error_mark_node; } @@ -6084,10 +6084,9 @@ joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn) if (cand1->template_decl && cand2->template_decl) { - winner = more_specialized + winner = more_specialized_fn (TI_TEMPLATE (cand1->template_decl), TI_TEMPLATE (cand2->template_decl), - DEDUCE_ORDER, /* Tell the deduction code how many real function arguments we saw, not counting the implicit 'this' argument. But, add_function_candidate() suppresses the "this" argument diff --git a/contrib/gcc-4.0/gcc/cp/class.c b/contrib/gcc-4.0/gcc/cp/class.c index 89346d6cf4..1388d0efe6 100644 --- a/contrib/gcc-4.0/gcc/cp/class.c +++ b/contrib/gcc-4.0/gcc/cp/class.c @@ -35,6 +35,7 @@ Boston, MA 02111-1307, USA. */ #include "toplev.h" #include "target.h" #include "convert.h" +#include "cgraph.h" /* The number of nested classes being processed. If we are not in the scope of any class, this is zero. */ @@ -7719,6 +7720,8 @@ cp_fold_obj_type_ref (tree ref, tree known_type) DECL_VINDEX (fndecl))); #endif + cgraph_node (fndecl)->local.vtable_method = true; + return build_address (fndecl); } diff --git a/contrib/gcc-4.0/gcc/cp/cp-tree.h b/contrib/gcc-4.0/gcc/cp/cp-tree.h index bbd821674a..0f913ba092 100644 --- a/contrib/gcc-4.0/gcc/cp/cp-tree.h +++ b/contrib/gcc-4.0/gcc/cp/cp-tree.h @@ -513,7 +513,6 @@ enum cp_tree_index CPTI_LANG_NAME_JAVA, CPTI_EMPTY_EXCEPT_SPEC, - CPTI_NULL, CPTI_JCLASS, CPTI_TERMINATE, CPTI_CALL_UNEXPECTED, @@ -609,9 +608,6 @@ extern GTY(()) tree cp_global_trees[CPTI_MAX]; /* Exception specifier used for throw(). */ #define empty_except_spec cp_global_trees[CPTI_EMPTY_EXCEPT_SPEC] -/* The node for `__null'. */ -#define null_node cp_global_trees[CPTI_NULL] - /* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */ #define jclass_node cp_global_trees[CPTI_JCLASS] @@ -1794,6 +1790,12 @@ struct lang_decl GTY(()) #define DECL_HAS_IN_CHARGE_PARM_P(NODE) \ (DECL_LANG_SPECIFIC (NODE)->decl_flags.has_in_charge_parm_p) +/* Nonzero if DECL is a declaration of __builtin_constant_p. */ +#define DECL_IS_BUILTIN_CONSTANT_P(NODE) \ + (TREE_CODE (NODE) == FUNCTION_DECL \ + && DECL_BUILT_IN_CLASS (NODE) == BUILT_IN_NORMAL \ + && DECL_FUNCTION_CODE (NODE) == BUILT_IN_CONSTANT_P) + /* Nonzero if NODE is an overloaded `operator delete[]' function. */ #define DECL_ARRAY_DELETE_OPERATOR_P(NODE) \ (DECL_OVERLOADED_OPERATOR_P (NODE) == VEC_DELETE_EXPR) @@ -3113,8 +3115,7 @@ extern int function_depth; typedef enum unification_kind_t { DEDUCE_CALL, DEDUCE_CONV, - DEDUCE_EXACT, - DEDUCE_ORDER + DEDUCE_EXACT } unification_kind_t; /* Macros for operating on a template instantiation level node. */ @@ -3763,7 +3764,7 @@ extern void maybe_push_cleanup_level (tree); extern void finish_scope (void); extern void push_switch (tree); extern void pop_switch (void); -extern tree pushtag (tree, tree, int); +extern tree pushtag (tree, tree, tag_scope); extern tree make_anon_name (void); extern int decls_match (tree, tree); extern tree duplicate_decls (tree, tree); @@ -3797,7 +3798,7 @@ extern int copy_fn_p (tree); extern tree get_scope_of_declarator (const cp_declarator *); extern void grok_special_member_properties (tree); extern int grok_ctor_properties (tree, tree); -extern bool grok_op_properties (tree, int, bool); +extern bool grok_op_properties (tree, bool); extern tree xref_tag (enum tag_types, tree, tag_scope, bool); extern tree xref_tag_from_type (tree, tree, tag_scope); extern void xref_basetypes (tree, tree); @@ -4000,7 +4001,7 @@ extern tree instantiate_class_template (tree); extern tree instantiate_template (tree, tree, tsubst_flags_t); extern int fn_type_unification (tree, tree, tree, tree, tree, unification_kind_t, int); extern void mark_decl_instantiated (tree, int); -extern int more_specialized (tree, tree, int, int); +extern int more_specialized_fn (tree, tree, int); extern void mark_class_instantiated (tree, int); extern void do_decl_instantiation (tree, tree); extern void do_type_instantiation (tree, tree, tsubst_flags_t); diff --git a/contrib/gcc-4.0/gcc/cp/decl.c b/contrib/gcc-4.0/gcc/cp/decl.c index 48b12f97af..127c83214d 100644 --- a/contrib/gcc-4.0/gcc/cp/decl.c +++ b/contrib/gcc-4.0/gcc/cp/decl.c @@ -1675,13 +1675,14 @@ duplicate_decls (tree newdecl, tree olddecl) DECL_COMDAT (newdecl) |= DECL_COMDAT (olddecl); DECL_TEMPLATE_INSTANTIATED (newdecl) |= DECL_TEMPLATE_INSTANTIATED (olddecl); - /* If the OLDDECL is an implicit instantiation, then the NEWDECL - must be too. But, it may not yet be marked as such if the - caller has created NEWDECL, but has not yet figured out that - it is a redeclaration. */ - if (DECL_IMPLICIT_INSTANTIATION (olddecl) - && !DECL_USE_TEMPLATE (newdecl)) - SET_DECL_IMPLICIT_INSTANTIATION (newdecl); + + /* If the OLDDECL is an instantiation and/or specialization, + then the NEWDECL must be too. But, it may not yet be marked + as such if the caller has created NEWDECL, but has not yet + figured out that it is a redeclaration. */ + if (!DECL_USE_TEMPLATE (newdecl)) + DECL_USE_TEMPLATE (newdecl) = DECL_USE_TEMPLATE (olddecl); + /* Don't really know how much of the language-specific values we should copy from old to new. */ DECL_IN_AGGR_P (newdecl) = DECL_IN_AGGR_P (olddecl); @@ -3933,6 +3934,8 @@ maybe_deduce_size_from_array_init (tree decl, tree init) if (failure == 3) error ("zero-size array %qD", decl); + cp_apply_type_quals_to_decl (cp_type_quals (TREE_TYPE (decl)), decl); + layout_decl (decl, 0); } } @@ -5584,7 +5587,7 @@ grokfndecl (tree ctype, } if (IDENTIFIER_OPNAME_P (DECL_NAME (decl))) - grok_op_properties (decl, friendp, /*complain=*/true); + grok_op_properties (decl, /*complain=*/true); if (ctype && decl_function_context (decl)) DECL_NO_STATIC_CHAIN (decl) = 1; @@ -6964,30 +6967,7 @@ grokdeclarator (const cp_declarator *declarator, else { if (decl_context == FIELD) - { - tree tmp = NULL_TREE; - int op = 0; - - if (declarator) - { - /* Avoid trying to get an operand off an identifier node. */ - if (declarator->kind != cdk_id) - tmp = declarator->declarator->u.id.unqualified_name; - else - tmp = declarator->u.id.unqualified_name; - op = IDENTIFIER_OPNAME_P (tmp); - if (IDENTIFIER_TYPENAME_P (tmp)) - { - if (is_typename_at_global_scope (tmp)) - name = IDENTIFIER_POINTER (tmp); - else - name = ""; - } - } - error ("storage class specified for %s %qs", - op ? "member operator" : "field", - name); - } + error ("storage class specified for %qs", name); else { if (decl_context == PARM || decl_context == CATCHPARM) @@ -8606,7 +8586,7 @@ unary_op_p (enum tree_code code) errors are issued for invalid declarations. */ bool -grok_op_properties (tree decl, int friendp, bool complain) +grok_op_properties (tree decl, bool complain) { tree argtypes = TYPE_ARG_TYPES (TREE_TYPE (decl)); tree argtype; @@ -8615,6 +8595,7 @@ grok_op_properties (tree decl, int friendp, bool complain) enum tree_code operator_code; int arity; bool ok; + tree class_type; /* Assume that the declaration is valid. */ ok = true; @@ -8625,8 +8606,9 @@ grok_op_properties (tree decl, int friendp, bool complain) argtype = TREE_CHAIN (argtype)) ++arity; - if (current_class_type == NULL_TREE) - friendp = 1; + class_type = DECL_CONTEXT (decl); + if (class_type && !CLASS_TYPE_P (class_type)) + class_type = NULL_TREE; if (DECL_CONV_FN_P (decl)) operator_code = TYPE_EXPR; @@ -8655,30 +8637,28 @@ grok_op_properties (tree decl, int friendp, bool complain) gcc_assert (operator_code != LAST_CPLUS_TREE_CODE); SET_OVERLOADED_OPERATOR_CODE (decl, operator_code); - if (! friendp) - { - switch (operator_code) - { - case NEW_EXPR: - TYPE_HAS_NEW_OPERATOR (current_class_type) = 1; - break; + if (class_type) + switch (operator_code) + { + case NEW_EXPR: + TYPE_HAS_NEW_OPERATOR (class_type) = 1; + break; - case DELETE_EXPR: - TYPE_GETS_DELETE (current_class_type) |= 1; - break; + case DELETE_EXPR: + TYPE_GETS_DELETE (class_type) |= 1; + break; - case VEC_NEW_EXPR: - TYPE_HAS_ARRAY_NEW_OPERATOR (current_class_type) = 1; - break; + case VEC_NEW_EXPR: + TYPE_HAS_ARRAY_NEW_OPERATOR (class_type) = 1; + break; - case VEC_DELETE_EXPR: - TYPE_GETS_DELETE (current_class_type) |= 2; - break; + case VEC_DELETE_EXPR: + TYPE_GETS_DELETE (class_type) |= 2; + break; - default: - break; - } - } + default: + break; + } /* [basic.std.dynamic.allocation]/1: @@ -8752,32 +8732,37 @@ grok_op_properties (tree decl, int friendp, bool complain) if (operator_code == CALL_EXPR) return ok; - if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl)) + if (IDENTIFIER_TYPENAME_P (name) + && ! DECL_TEMPLATE_INFO (decl) + && warn_conversion + /* Warn only declaring the function; there is no need to + warn again about out-of-class definitions. */ + && class_type == current_class_type) { tree t = TREE_TYPE (name); - if (! friendp) - { - int ref = (TREE_CODE (t) == REFERENCE_TYPE); - const char *what = 0; + int ref = (TREE_CODE (t) == REFERENCE_TYPE); + const char *what = 0; - if (ref) - t = TYPE_MAIN_VARIANT (TREE_TYPE (t)); + if (ref) + t = TYPE_MAIN_VARIANT (TREE_TYPE (t)); - if (TREE_CODE (t) == VOID_TYPE) - what = "void"; - else if (t == current_class_type) + if (TREE_CODE (t) == VOID_TYPE) + what = "void"; + else if (class_type) + { + if (t == current_class_type) what = "the same type"; /* Don't force t to be complete here. */ else if (IS_AGGR_TYPE (t) && COMPLETE_TYPE_P (t) - && DERIVED_FROM_P (t, current_class_type)) + && DERIVED_FROM_P (t, class_type)) what = "a base class"; - - if (what && warn_conversion) - warning ("conversion to %s%s will never use a type " - "conversion operator", - ref ? "a reference to " : "", what); } + + if (what) + warning ("conversion to %s%s will never use a type " + "conversion operator", + ref ? "a reference to " : "", what); } if (operator_code == COND_EXPR) { @@ -9035,7 +9020,6 @@ check_elaborated_type_specifier (enum tag_types tag_code, void f(class C); // No template header here then the required template argument is missing. */ - error ("template argument required for %<%s %T%>", tag_name (tag_code), DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))); @@ -9057,7 +9041,19 @@ lookup_and_check_tag (enum tag_types tag_code, tree name, tree t; tree decl; if (scope == ts_global) - decl = lookup_name (name, 2); + { + /* First try ordinary name lookup, ignoring hidden class name + injected via friend declaration. */ + decl = lookup_name (name, 2); + /* If that fails, the name will be placed in the smallest + non-class, non-function-prototype scope according to 3.3.1/5. + We may already have a hidden name declared as friend in this + scope. So lookup again but not ignoring hidden name. + If we find one, that name will be made visible rather than + creating a new tag. */ + if (!decl) + decl = lookup_type_scope (name, ts_within_enclosing_non_class); + } else decl = lookup_type_scope (name, scope); @@ -9217,8 +9213,7 @@ xref_tag (enum tag_types tag_code, tree name, { t = make_aggr_type (code); TYPE_CONTEXT (t) = context; - /* pushtag only cares whether SCOPE is zero or not. */ - t = pushtag (name, t, scope != ts_current); + t = pushtag (name, t, scope); } } else @@ -9232,6 +9227,20 @@ xref_tag (enum tag_types tag_code, tree name, error ("redeclaration of %qT as a non-template", t); t = error_mark_node; } + + /* Make injected friend class visible. */ + if (scope != ts_within_enclosing_non_class + && hidden_name_p (TYPE_NAME (t))) + { + DECL_ANTICIPATED (TYPE_NAME (t)) = 0; + DECL_FRIEND_P (TYPE_NAME (t)) = 0; + + if (TYPE_TEMPLATE_INFO (t)) + { + DECL_ANTICIPATED (TYPE_TI_TEMPLATE (t)) = 0; + DECL_FRIEND_P (TYPE_TI_TEMPLATE (t)) = 0; + } + } } POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t); @@ -9473,7 +9482,7 @@ start_enum (tree name) name = make_anon_name (); enumtype = make_node (ENUMERAL_TYPE); - enumtype = pushtag (name, enumtype, 0); + enumtype = pushtag (name, enumtype, /*tag_scope=*/ts_current); } return enumtype; @@ -9853,7 +9862,8 @@ start_preparsed_function (tree decl1, tree attrs, int flags) int doing_friend = 0; struct cp_binding_level *bl; tree current_function_parms; - struct c_fileinfo *finfo = get_fileinfo (lbasename (input_filename)); + struct c_fileinfo *finfo + = get_fileinfo (lbasename (LOCATION_FILE (DECL_SOURCE_LOCATION (decl1)))); /* Sanity check. */ gcc_assert (TREE_CODE (TREE_VALUE (void_list_node)) == VOID_TYPE); diff --git a/contrib/gcc-4.0/gcc/cp/decl2.c b/contrib/gcc-4.0/gcc/cp/decl2.c index edad147765..3579204129 100644 --- a/contrib/gcc-4.0/gcc/cp/decl2.c +++ b/contrib/gcc-4.0/gcc/cp/decl2.c @@ -2908,6 +2908,10 @@ cp_finish_file (void) finish_function doesn't clean things up, and we end up with CURRENT_FUNCTION_DECL set. */ push_to_top_level (); + /* The decl's location will mark where it was first + needed. Save that so synthesize method can indicate + where it was needed from, in case of error */ + input_location = DECL_SOURCE_LOCATION (decl); synthesize_method (decl); pop_from_top_level (); reconsider = true; @@ -3178,6 +3182,14 @@ mark_used (tree decl) { if (DECL_DEFERRED_FN (decl)) return; + + /* Remember the current location for a function we will end up + synthesizing. Then we can inform the user where it was + required in the case of error. */ + if (DECL_ARTIFICIAL (decl) && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl) + && !DECL_THUNK_P (decl)) + DECL_SOURCE_LOCATION (decl) = input_location; + note_vague_linkage_fn (decl); } @@ -3195,14 +3207,6 @@ mark_used (tree decl) pointing to the class location. */ && current_function_decl) { - /* Put the function definition at the position where it is needed, - rather than within the body of the class. That way, an error - during the generation of the implicit body points at the place - where the attempt to generate the function occurs, giving the - user a hint as to why we are attempting to generate the - function. */ - DECL_SOURCE_LOCATION (decl) = input_location; - synthesize_method (decl); /* If we've already synthesized the method we don't need to instantiate it, so we can return right away. */ diff --git a/contrib/gcc-4.0/gcc/cp/error.c b/contrib/gcc-4.0/gcc/cp/error.c index c53e0328cd..3039800a09 100644 --- a/contrib/gcc-4.0/gcc/cp/error.c +++ b/contrib/gcc-4.0/gcc/cp/error.c @@ -2319,13 +2319,13 @@ cp_printer (pretty_printer *pp, text_info *text) behavior of cp_*_at. */ static tree -locate_error (const char *msgid, va_list ap) +locate_error (const char *gmsgid, va_list ap) { tree here = 0, t; int plus = 0; const char *f; - for (f = msgid; *f; f++) + for (f = gmsgid; *f; f++) { plus = 0; if (*f == '%') @@ -2381,57 +2381,57 @@ locate_error (const char *msgid, va_list ap) void -cp_error_at (const char *msgid, ...) +cp_error_at (const char *gmsgid, ...) { tree here; diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - here = locate_error (msgid, ap); + va_start (ap, gmsgid); + here = locate_error (gmsgid, ap); va_end (ap); - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_ERROR); cp_diagnostic_starter (global_dc, &diagnostic); - diagnostic_set_info (&diagnostic, msgid, &ap, + diagnostic_set_info (&diagnostic, gmsgid, &ap, location_of (here), DK_ERROR); report_diagnostic (&diagnostic); va_end (ap); } void -cp_warning_at (const char *msgid, ...) +cp_warning_at (const char *gmsgid, ...) { tree here; diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - here = locate_error (msgid, ap); + va_start (ap, gmsgid); + here = locate_error (gmsgid, ap); va_end (ap); - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, location_of (here), DK_WARNING); report_diagnostic (&diagnostic); va_end (ap); } void -cp_pedwarn_at (const char *msgid, ...) +cp_pedwarn_at (const char *gmsgid, ...) { tree here; diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - here = locate_error (msgid, ap); + va_start (ap, gmsgid); + here = locate_error (gmsgid, ap); va_end (ap); - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, location_of (here), pedantic_error_kind()); report_diagnostic (&diagnostic); va_end (ap); diff --git a/contrib/gcc-4.0/gcc/cp/init.c b/contrib/gcc-4.0/gcc/cp/init.c index 39555c8cb9..514de0086b 100644 --- a/contrib/gcc-4.0/gcc/cp/init.c +++ b/contrib/gcc-4.0/gcc/cp/init.c @@ -1573,7 +1573,7 @@ integral_constant_value (tree decl) && DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node && TREE_TYPE (DECL_INITIAL (decl)) - && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (decl))) + && INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (DECL_INITIAL (decl)))) decl = DECL_INITIAL (decl); return decl; } diff --git a/contrib/gcc-4.0/gcc/cp/lex.c b/contrib/gcc-4.0/gcc/cp/lex.c index 6074fef9ea..e0626f7e56 100644 --- a/contrib/gcc-4.0/gcc/cp/lex.c +++ b/contrib/gcc-4.0/gcc/cp/lex.c @@ -348,11 +348,6 @@ cxx_init (void) cxx_init_decl_processing (); - /* Create the built-in __null node. It is important that this is - not shared. */ - null_node = make_node (INTEGER_CST); - TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0); - /* The fact that G++ uses COMDAT for many entities (inline functions, template instantiations, virtual tables, etc.) mean that it is fundamentally unreliable to try to make decisions diff --git a/contrib/gcc-4.0/gcc/cp/method.c b/contrib/gcc-4.0/gcc/cp/method.c index 7a99c26247..36c6701eb0 100644 --- a/contrib/gcc-4.0/gcc/cp/method.c +++ b/contrib/gcc-4.0/gcc/cp/method.c @@ -36,6 +36,7 @@ Boston, MA 02111-1307, USA. */ #include "toplev.h" #include "tm_p.h" #include "target.h" +#include "diagnostic.h" /* Various flags to control the mangling process. */ @@ -702,6 +703,8 @@ do_build_assign_ref (tree fndecl) finish_compound_stmt (compound_stmt); } +/* Synthesize FNDECL, a non-static member function. */ + void synthesize_method (tree fndecl) { @@ -710,17 +713,19 @@ synthesize_method (tree fndecl) bool need_body = true; tree stmt; location_t save_input_location = input_location; + int error_count = errorcount; + int warning_count = warningcount; + /* Reset the source location, we might have been previously + deferred, and thus have saved where we were first needed. */ + DECL_SOURCE_LOCATION (fndecl) + = DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl))); + /* If we've been asked to synthesize a clone, just synthesize the cloned function instead. Doing so will automatically fill in the body for the clone. */ if (DECL_CLONED_FUNCTION_P (fndecl)) - { - DECL_SOURCE_LOCATION (DECL_CLONED_FUNCTION (fndecl)) = - DECL_SOURCE_LOCATION (fndecl); - synthesize_method (DECL_CLONED_FUNCTION (fndecl)); - return; - } + fndecl = DECL_CLONED_FUNCTION (fndecl); /* We may be in the middle of deferred access check. Disable it now. */ @@ -770,6 +775,10 @@ synthesize_method (tree fndecl) pop_function_context_from (context); pop_deferring_access_checks (); + + if (error_count != errorcount || warning_count != warningcount) + warning ("%Hsynthesized method %qD first required here ", + &input_location, fndecl); } /* Use EXTRACTOR to locate the relevant function called for each base & @@ -939,6 +948,19 @@ implicitly_declare_fn (special_function_kind kind, tree type, bool const_p) tree raises = empty_except_spec; tree rhs_parm_type = NULL_TREE; tree name; + HOST_WIDE_INT saved_processing_template_decl; + + /* Because we create declarations for implictly declared functions + lazily, we may be creating the declaration for a member of TYPE + while in some completely different context. However, TYPE will + never be a dependent class (because we never want to do lookups + for implicitly defined functions in a dependent class). + Furthermore, we must set PROCESSING_TEMPLATE_DECL to zero here + because we only create clones for constructors and destructors + when not in a template. */ + gcc_assert (!dependent_type_p (type)); + saved_processing_template_decl = processing_template_decl; + processing_template_decl = 0; type = TYPE_MAIN_VARIANT (type); @@ -1037,6 +1059,9 @@ implicitly_declare_fn (special_function_kind kind, tree type, bool const_p) DECL_INLINE (fn) = 1; gcc_assert (!TREE_USED (fn)); + /* Restore PROCESSING_TEMPLATE_DECL. */ + processing_template_decl = saved_processing_template_decl; + return fn; } diff --git a/contrib/gcc-4.0/gcc/cp/name-lookup.c b/contrib/gcc-4.0/gcc/cp/name-lookup.c index accd35210e..3e6f44959e 100644 --- a/contrib/gcc-4.0/gcc/cp/name-lookup.c +++ b/contrib/gcc-4.0/gcc/cp/name-lookup.c @@ -1883,6 +1883,13 @@ push_overloaded_decl (tree decl, int flags) if (duplicate_decls (decl, fn) == fn) POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fn); } + + /* We don't overload implicit built-ins. duplicate_decls() + may fail to merge the decls if the new decl is e.g. a + template function. */ + if (TREE_CODE (old) == FUNCTION_DECL + && DECL_ANTICIPATED (old)) + old = NULL; } else if (old == error_mark_node) /* Ignore the undefined symbol marker. */ @@ -2025,6 +2032,14 @@ do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype, return; } + /* It is impossible to overload a built-in function; any explicit + declaration eliminates the built-in declaration. So, if OLDVAL + is a built-in, then we can just pretend it isn't there. */ + if (oldval + && TREE_CODE (oldval) == FUNCTION_DECL + && DECL_ANTICIPATED (oldval)) + oldval = NULL_TREE; + /* Check for using functions. */ if (decls.value && is_overloaded_fn (decls.value)) { @@ -2037,15 +2052,6 @@ do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype, oldval = NULL_TREE; } - /* It is impossible to overload a built-in function; any - explicit declaration eliminates the built-in declaration. - So, if OLDVAL is a built-in, then we can just pretend it - isn't there. */ - if (oldval - && TREE_CODE (oldval) == FUNCTION_DECL - && DECL_ANTICIPATED (oldval)) - oldval = NULL_TREE; - *newval = oldval; for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp)) { @@ -3296,12 +3302,13 @@ ambiguous_decl (tree name, struct scope_binding *old, cxx_binding *new, case TEMPLATE_DECL: /* If we expect types or namespaces, and not templates, or this is not a template class. */ - if (LOOKUP_QUALIFIERS_ONLY (flags) - && !DECL_CLASS_TEMPLATE_P (val)) + if ((LOOKUP_QUALIFIERS_ONLY (flags) + && !DECL_CLASS_TEMPLATE_P (val)) + || hidden_name_p (val)) val = NULL_TREE; break; case TYPE_DECL: - if (LOOKUP_NAMESPACES_ONLY (flags)) + if (LOOKUP_NAMESPACES_ONLY (flags) || hidden_name_p (val)) val = NULL_TREE; break; case NAMESPACE_DECL: @@ -3310,7 +3317,7 @@ ambiguous_decl (tree name, struct scope_binding *old, cxx_binding *new, break; case FUNCTION_DECL: /* Ignore built-in functions that are still anticipated. */ - if (LOOKUP_QUALIFIERS_ONLY (flags) || DECL_ANTICIPATED (val)) + if (LOOKUP_QUALIFIERS_ONLY (flags) || hidden_name_p (val)) val = NULL_TREE; break; default: @@ -3382,21 +3389,35 @@ lookup_flags (int prefer_type, int namespaces_only) } /* Given a lookup that returned VAL, use FLAGS to decide if we want to - ignore it or not. Subroutine of lookup_name_real. */ + ignore it or not. Subroutine of lookup_name_real and + lookup_type_scope. */ -static tree +static bool qualify_lookup (tree val, int flags) { if (val == NULL_TREE) - return val; + return false; if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL) - return val; + return true; if ((flags & LOOKUP_PREFER_TYPES) && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL)) - return val; + return true; if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES)) - return NULL_TREE; - return val; + return false; + return true; +} + +/* Given a lookup that returned VAL, decide if we want to ignore it or + not based on DECL_ANTICIPATED_P. */ + +bool +hidden_name_p (tree val) +{ + if (DECL_P (val) + && DECL_LANG_SPECIFIC (val) + && DECL_ANTICIPATED (val)) + return true; + return false; } /* Look up NAME in the NAMESPACE. */ @@ -3467,10 +3488,9 @@ lookup_namespace_name (tree namespace, tree name) if (TREE_CODE (val) == OVERLOAD && ! really_overloaded_fn (val)) val = OVL_FUNCTION (val); - /* Ignore built-in functions that haven't been prototyped yet. */ - if (!val || !DECL_P(val) - || !DECL_LANG_SPECIFIC(val) - || !DECL_ANTICIPATED (val)) + /* Ignore built-in functions and friends that haven't been declared + yet. */ + if (!val || !hidden_name_p (val)) POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val); } @@ -3529,10 +3549,8 @@ unqualified_namespace_lookup (tree name, int flags) if (b) { - if (b->value && DECL_P (b->value) - && DECL_LANG_SPECIFIC (b->value) - && DECL_ANTICIPATED (b->value)) - /* Ignore anticipated built-in functions. */ + if (b->value && hidden_name_p (b->value)) + /* Ignore anticipated built-in functions and friends. */ ; else binding.value = b->value; @@ -3773,6 +3791,8 @@ innermost_non_namespace_value (tree name) node of some kind representing its definition if there is only one such declaration, or return a TREE_LIST with all the overloaded definitions if there are many, or return 0 if it is undefined. + Hidden name, either friend declaration or built-in function, are + not ignored. If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces. If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces). @@ -3837,10 +3857,12 @@ lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p, continue; /* If this is the kind of thing we're looking for, we're done. */ - if (qualify_lookup (iter->value, flags)) + if (qualify_lookup (iter->value, flags) + && !hidden_name_p (iter->value)) binding = iter->value; else if ((flags & LOOKUP_PREFER_TYPES) - && qualify_lookup (iter->type, flags)) + && qualify_lookup (iter->type, flags) + && !hidden_name_p (iter->type)) binding = iter->type; else binding = NULL_TREE; @@ -3898,7 +3920,8 @@ lookup_name (tree name, int prefer_type) Unlike lookup_name_real, we make sure that NAME is actually declared in the desired scope, not from inheritance, nor using directive. For using declaration, there is DR138 still waiting - to be resolved. + to be resolved. Hidden name coming from earlier an friend + declaration is also returned. A TYPE_DECL best matching the NAME is returned. Catching error and issuing diagnostics are caller's responsibility. */ @@ -3948,9 +3971,7 @@ lookup_type_scope (tree name, tag_scope scope) if (iter) { - /* If this is the kind of thing we're looking for, we're done. - Ignore names found via using declaration. See DR138 for - current status. */ + /* If this is the kind of thing we're looking for, we're done. */ if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)) val = iter->type; else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES)) @@ -4500,7 +4521,7 @@ push_using_directive (tree used) processing. */ static tree -maybe_process_template_type_declaration (tree type, int globalize, +maybe_process_template_type_declaration (tree type, int is_friend, cxx_scope *b) { tree decl = TYPE_NAME (type); @@ -4523,7 +4544,7 @@ maybe_process_template_type_declaration (tree type, int globalize, push_template_decl_real, but we want the original value. */ tree name = DECL_NAME (decl); - decl = push_template_decl_real (decl, globalize); + decl = push_template_decl_real (decl, is_friend); /* If the current binding level is the binding level for the template parameters (see the comment in begin_template_parm_list) and the enclosing level is a class @@ -4532,7 +4553,7 @@ maybe_process_template_type_declaration (tree type, int globalize, friend case, push_template_decl will already have put the friend into global scope, if appropriate. */ if (TREE_CODE (type) != ENUMERAL_TYPE - && !globalize && b->kind == sk_template_parms + && !is_friend && b->kind == sk_template_parms && b->level_chain->kind == sk_class) { finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type)); @@ -4563,7 +4584,7 @@ maybe_process_template_type_declaration (tree type, int globalize, Returns TYPE upon success and ERROR_MARK_NODE otherwise. */ tree -pushtag (tree name, tree type, int globalize) +pushtag (tree name, tree type, tag_scope scope) { struct cp_binding_level *b; @@ -4580,7 +4601,7 @@ pushtag (tree name, tree type, int globalize) template is instantiated. */ || (b->kind == sk_template_parms && b->explicit_spec_p) || (b->kind == sk_class - && (globalize + && (scope != ts_current /* We may be defining a new type in the initializer of a static member variable. We allow this when not pedantic, and it is particularly useful for @@ -4601,7 +4622,7 @@ pushtag (tree name, tree type, int globalize) { tree cs = current_scope (); - if (! globalize) + if (scope == ts_current) context = cs; else if (cs != NULL_TREE && TYPE_P (cs)) /* When declaring a friend class of a local class, we want @@ -4622,11 +4643,21 @@ pushtag (tree name, tree type, int globalize) d = create_implicit_typedef (name, type); DECL_CONTEXT (d) = FROB_CONTEXT (context); + if (scope == ts_within_enclosing_non_class) + { + /* This is a friend. Make this TYPE_DECL node hidden from + ordinary name lookup. Its corresponding TEMPLATE_DECL + will be marked in push_template_decl_real. */ + retrofit_lang_decl (d); + DECL_ANTICIPATED (d) = 1; + DECL_FRIEND_P (d) = 1; + } + if (! in_class) set_identifier_type_value_with_scope (name, d, b); - d = maybe_process_template_type_declaration (type, - globalize, b); + d = maybe_process_template_type_declaration + (type, scope == ts_within_enclosing_non_class, b); if (d == error_mark_node) POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node); @@ -4656,8 +4687,7 @@ pushtag (tree name, tree type, int globalize) way. (It's otherwise tricky to find a member function definition it's only pointed to from within a local class.) */ if (TYPE_CONTEXT (type) - && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL - && !processing_template_decl) + && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL) VARRAY_PUSH_TREE (local_classes, type); } if (b->kind == sk_class diff --git a/contrib/gcc-4.0/gcc/cp/name-lookup.h b/contrib/gcc-4.0/gcc/cp/name-lookup.h index e443319177..451e6ecffa 100644 --- a/contrib/gcc-4.0/gcc/cp/name-lookup.h +++ b/contrib/gcc-4.0/gcc/cp/name-lookup.h @@ -315,6 +315,7 @@ extern tree lookup_name_real (tree, int, int, bool, int, int); extern tree lookup_type_scope (tree, tag_scope); extern tree namespace_binding (tree, tree); extern void set_namespace_binding (tree, tree, tree); +extern bool hidden_name_p (tree); extern tree lookup_namespace_name (tree, tree); extern tree lookup_qualified_name (tree, tree, bool, bool); extern tree lookup_name_nonclass (tree); diff --git a/contrib/gcc-4.0/gcc/cp/parser.c b/contrib/gcc-4.0/gcc/cp/parser.c index 944efe185a..3507546adc 100644 --- a/contrib/gcc-4.0/gcc/cp/parser.c +++ b/contrib/gcc-4.0/gcc/cp/parser.c @@ -4049,10 +4049,34 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p) /* postfix-expression ( expression-list [opt] ) */ { bool koenig_p; - tree args = (cp_parser_parenthesized_expression_list - (parser, false, - /*cast_p=*/false, - /*non_constant_p=*/NULL)); + bool is_builtin_constant_p; + bool saved_integral_constant_expression_p = false; + bool saved_non_integral_constant_expression_p = false; + tree args; + + is_builtin_constant_p + = DECL_IS_BUILTIN_CONSTANT_P (postfix_expression); + if (is_builtin_constant_p) + { + /* The whole point of __builtin_constant_p is to allow + non-constant expressions to appear as arguments. */ + saved_integral_constant_expression_p + = parser->integral_constant_expression_p; + saved_non_integral_constant_expression_p + = parser->non_integral_constant_expression_p; + parser->integral_constant_expression_p = false; + } + args = (cp_parser_parenthesized_expression_list + (parser, /*is_attribute_list=*/false, + /*cast_p=*/false, + /*non_constant_p=*/NULL)); + if (is_builtin_constant_p) + { + parser->integral_constant_expression_p + = saved_integral_constant_expression_p; + parser->non_integral_constant_expression_p + = saved_non_integral_constant_expression_p; + } if (args == error_mark_node) { @@ -14440,10 +14464,7 @@ cp_parser_lookup_name (cp_parser *parser, tree name, } /* If the lookup failed, let our caller know. */ - if (!decl - || decl == error_mark_node - || (TREE_CODE (decl) == FUNCTION_DECL - && DECL_ANTICIPATED (decl))) + if (!decl || decl == error_mark_node) return error_mark_node; /* If it's a TREE_LIST, the result of the lookup was ambiguous. */ @@ -15353,6 +15374,7 @@ cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function) if (function_scope) push_function_context_to (function_scope); + /* Push the body of the function onto the lexer stack. */ cp_parser_push_lexer_for_tokens (parser, tokens); @@ -15361,10 +15383,17 @@ cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function) start_preparsed_function (member_function, NULL_TREE, SF_PRE_PARSED | SF_INCLASS_INLINE); + /* Don't do access checking if it is a templated function. */ + if (processing_template_decl) + push_deferring_access_checks (dk_no_check); + /* Now, parse the body of the function. */ cp_parser_function_definition_after_declarator (parser, /*inline_p=*/true); + if (processing_template_decl) + pop_deferring_access_checks (); + /* Leave the scope of the containing function. */ if (function_scope) pop_function_context_from (function_scope); diff --git a/contrib/gcc-4.0/gcc/cp/pt.c b/contrib/gcc-4.0/gcc/cp/pt.c index 6c61833acd..b5b4f9eaa5 100644 --- a/contrib/gcc-4.0/gcc/cp/pt.c +++ b/contrib/gcc-4.0/gcc/cp/pt.c @@ -3132,6 +3132,13 @@ push_template_decl_real (tree decl, int is_friend) tmpl = pushdecl_namespace_level (tmpl); if (tmpl == error_mark_node) return error_mark_node; + + /* Hide template friend classes that haven't been declared yet. */ + if (is_friend && TREE_CODE (decl) == TYPE_DECL) + { + DECL_ANTICIPATED (tmpl) = 1; + DECL_FRIEND_P (tmpl) = 1; + } } if (primary) @@ -3219,10 +3226,9 @@ redeclare_class_template (tree type, tree parms) if (TREE_VEC_LENGTH (parms) != TREE_VEC_LENGTH (tmpl_parms)) { cp_error_at ("previous declaration %qD", tmpl); - error ("used %d template parameter%s instead of %d", - TREE_VEC_LENGTH (tmpl_parms), - TREE_VEC_LENGTH (tmpl_parms) == 1 ? "" : "s", - TREE_VEC_LENGTH (parms)); + error ("used %d template parameter(s) instead of %d", + TREE_VEC_LENGTH (tmpl_parms), + TREE_VEC_LENGTH (parms)); return; } @@ -4582,7 +4588,7 @@ lookup_template_class (tree d1, /* A local class. Make sure the decl gets registered properly. */ if (context == current_function_decl) - pushtag (DECL_NAME (template), t, 0); + pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current); } /* If we called start_enum or pushtag above, this information @@ -5640,7 +5646,7 @@ instantiate_class_template (tree type) tsubst_enum. */ if (name) SET_IDENTIFIER_TYPE_VALUE (name, newtag); - pushtag (name, newtag, /*globalize=*/0); + pushtag (name, newtag, /*tag_scope=*/ts_current); } } else if (TREE_CODE (t) == FUNCTION_DECL @@ -6464,8 +6470,7 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain) clone_function_decl (r, /*update_method_vec_p=*/0); } else if (IDENTIFIER_OPNAME_P (DECL_NAME (r))) - grok_op_properties (r, DECL_FRIEND_P (r), - (complain & tf_error) != 0); + grok_op_properties (r, (complain & tf_error) != 0); if (DECL_FRIEND_P (t) && DECL_FRIEND_CONTEXT (t)) SET_DECL_FRIEND_CONTEXT (r, @@ -9039,11 +9044,6 @@ instantiate_template (tree tmpl, tree targ_ptr, tsubst_flags_t complain) as in [temp.expl.spec], or when taking the address of a function template, as in [temp.deduct.funcaddr]. - DEDUCE_ORDER: - We are deducing arguments when calculating the partial - ordering between specializations of function or class - templates, as in [temp.func.order] and [temp.class.order]. - LEN is the number of parms to consider before returning success, or -1 for all. This is used in partial ordering to avoid comparing parms for which no actual argument was passed, since they are not considered in @@ -9191,28 +9191,6 @@ maybe_adjust_types_for_deduction (unification_kind_t strict, /* There is nothing to do in this case. */ return 0; - case DEDUCE_ORDER: - /* DR 214. [temp.func.order] is underspecified, and leads to no - ordering between things like `T *' and `T const &' for `U *'. - The former has T=U and the latter T=U*. The former looks more - specialized and John Spicer considers it well-formed (the EDG - compiler accepts it). - - John also confirms that deduction should proceed as in a function - call. Which implies the usual ARG and PARM conversions as DEDUCE_CALL. - However, in ordering, ARG can have REFERENCE_TYPE, but no argument - to an actual call can have such a type. - - If both ARG and PARM are REFERENCE_TYPE, we change neither. - If only ARG is a REFERENCE_TYPE, we look through that and then - proceed as with DEDUCE_CALL (which could further convert it). */ - if (TREE_CODE (*arg) == REFERENCE_TYPE) - { - if (TREE_CODE (*parm) == REFERENCE_TYPE) - return 0; - *arg = TREE_TYPE (*arg); - } - break; default: gcc_unreachable (); } @@ -9308,10 +9286,6 @@ type_unification_real (tree tparms, sub_strict = UNIFY_ALLOW_NONE; break; - case DEDUCE_ORDER: - sub_strict = UNIFY_ALLOW_NONE; - break; - default: gcc_unreachable (); } @@ -9354,7 +9328,7 @@ type_unification_real (tree tparms, else type = arg; - if (strict == DEDUCE_EXACT || strict == DEDUCE_ORDER) + if (strict == DEDUCE_EXACT) { if (same_type_p (parm, type)) continue; @@ -10401,36 +10375,164 @@ mark_decl_instantiated (tree result, int extern_p) /* Given two function templates PAT1 and PAT2, return: - DEDUCE should be DEDUCE_EXACT or DEDUCE_ORDER. - 1 if PAT1 is more specialized than PAT2 as described in [temp.func.order]. -1 if PAT2 is more specialized than PAT1. 0 if neither is more specialized. - LEN is passed through to fn_type_unification. */ + LEN indicates the number of parameters we should consider + (defaulted parameters should not be considered). + + The 1998 std underspecified function template partial ordering, and + DR214 addresses the issue. We take pairs of arguments, one from + each of the templates, and deduce them against eachother. One of + the templates will be more specialized if all the *other* + template's arguments deduce against its arguments and at least one + of its arguments *does* *not* deduce against the other template's + corresponding argument. Deduction is done as for class templates. + The arguments used in deduction have reference and top level cv + qualifiers removed. Iff both arguments were originally reference + types *and* deduction succeeds in both directions, the template + with the more cv-qualified argument wins for that pairing (if + neither is more cv-qualified, they both are equal). Unlike regular + deduction, after all the arguments have been deduced in this way, + we do *not* verify the deduced template argument values can be + substituted into non-deduced contexts, nor do we have to verify + that all template arguments have been deduced. */ int -more_specialized (tree pat1, tree pat2, int deduce, int len) -{ - tree targs; - int winner = 0; +more_specialized_fn (tree pat1, tree pat2, int len) +{ + tree decl1 = DECL_TEMPLATE_RESULT (pat1); + tree decl2 = DECL_TEMPLATE_RESULT (pat2); + tree targs1 = make_tree_vec (DECL_NTPARMS (pat1)); + tree targs2 = make_tree_vec (DECL_NTPARMS (pat2)); + tree tparms1 = DECL_INNERMOST_TEMPLATE_PARMS (pat1); + tree tparms2 = DECL_INNERMOST_TEMPLATE_PARMS (pat2); + tree args1 = TYPE_ARG_TYPES (TREE_TYPE (decl1)); + tree args2 = TYPE_ARG_TYPES (TREE_TYPE (decl2)); + int better1 = 0; + int better2 = 0; + + /* If only one is a member function, they are unordered. */ + if (DECL_FUNCTION_MEMBER_P (decl1) != DECL_FUNCTION_MEMBER_P (decl2)) + return 0; + + /* Don't consider 'this' parameter. */ + if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl1)) + args1 = TREE_CHAIN (args1); + if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl2)) + args2 = TREE_CHAIN (args2); + + /* If only one is a conversion operator, they are unordered. */ + if (DECL_CONV_FN_P (decl1) != DECL_CONV_FN_P (decl2)) + return 0; + + /* Consider the return type for a conversion function */ + if (DECL_CONV_FN_P (decl1)) + { + args1 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl1)), args1); + args2 = tree_cons (NULL_TREE, TREE_TYPE (TREE_TYPE (decl2)), args2); + len++; + } + + processing_template_decl++; + + while (len--) + { + tree arg1 = TREE_VALUE (args1); + tree arg2 = TREE_VALUE (args2); + int deduce1, deduce2; + int quals1 = -1; + int quals2 = -1; - /* If template argument deduction succeeds, we substitute the - resulting arguments into non-deduced contexts. While doing that, - we must be aware that we may encounter dependent types. */ - ++processing_template_decl; - targs = get_bindings_real (pat1, DECL_TEMPLATE_RESULT (pat2), - NULL_TREE, 0, deduce, len); - if (targs) - --winner; + if (TREE_CODE (arg1) == REFERENCE_TYPE) + { + arg1 = TREE_TYPE (arg1); + quals1 = cp_type_quals (arg1); + } + + if (TREE_CODE (arg2) == REFERENCE_TYPE) + { + arg2 = TREE_TYPE (arg2); + quals2 = cp_type_quals (arg2); + } - targs = get_bindings_real (pat2, DECL_TEMPLATE_RESULT (pat1), - NULL_TREE, 0, deduce, len); - if (targs) - ++winner; - --processing_template_decl; + if ((quals1 < 0) != (quals2 < 0)) + { + /* Only of the args is a reference, see if we should apply + array/function pointer decay to it. This is not part of + DR214, but is, IMHO, consistent with the deduction rules + for the function call itself, and with our earlier + implementation of the underspecified partial ordering + rules. (nathan). */ + if (quals1 >= 0) + { + switch (TREE_CODE (arg1)) + { + case ARRAY_TYPE: + arg1 = TREE_TYPE (arg1); + /* FALLTHROUGH. */ + case FUNCTION_TYPE: + arg1 = build_pointer_type (arg1); + break; + + default: + break; + } + } + else + { + switch (TREE_CODE (arg2)) + { + case ARRAY_TYPE: + arg2 = TREE_TYPE (arg2); + /* FALLTHROUGH. */ + case FUNCTION_TYPE: + arg2 = build_pointer_type (arg2); + break; + + default: + break; + } + } + } + + arg1 = TYPE_MAIN_VARIANT (arg1); + arg2 = TYPE_MAIN_VARIANT (arg2); + + deduce1 = !unify (tparms1, targs1, arg1, arg2, UNIFY_ALLOW_NONE); + deduce2 = !unify (tparms2, targs2, arg2, arg1, UNIFY_ALLOW_NONE); + + if (!deduce1) + better2 = -1; + if (!deduce2) + better1 = -1; + if (better1 < 0 && better2 < 0) + /* We've failed to deduce something in either direction. + These must be unordered. */ + break; + + if (deduce1 && deduce2 && quals1 >= 0 && quals2 >= 0) + { + /* Deduces in both directions, see if quals can + disambiguate. Pretend the worse one failed to deduce. */ + if ((quals1 & quals2) == quals2) + deduce1 = 0; + if ((quals1 & quals2) == quals1) + deduce2 = 0; + } + if (deduce1 && !deduce2 && !better2) + better2 = 1; + if (deduce2 && !deduce1 && !better1) + better1 = 1; + + args1 = TREE_CHAIN (args1); + args2 = TREE_CHAIN (args2); + } - return winner; + processing_template_decl--; + + return (better1 > 0) - (better2 > 0); } /* Given two class template specialization list nodes PAT1 and PAT2, return: @@ -10594,37 +10696,56 @@ tree most_specialized_instantiation (tree instantiations) { tree fn, champ; - int fate; if (!instantiations) return NULL_TREE; - + + ++processing_template_decl; + champ = instantiations; for (fn = TREE_CHAIN (instantiations); fn; fn = TREE_CHAIN (fn)) { - fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn), - DEDUCE_EXACT, -1); - if (fate == 1) - ; - else + int fate = 0; + + if (get_bindings_real (TREE_VALUE (champ), + DECL_TEMPLATE_RESULT (TREE_VALUE (fn)), + NULL_TREE, 0, DEDUCE_EXACT, -1)) + fate--; + + if (get_bindings_real (TREE_VALUE (fn), + DECL_TEMPLATE_RESULT (TREE_VALUE (champ)), + NULL_TREE, 0, DEDUCE_EXACT, -1)) + fate++; + + if (fate != 1) { - if (fate == 0) - { - fn = TREE_CHAIN (fn); - if (! fn) - return error_mark_node; - } + if (!fate) + /* Equally specialized, move to next function. If there + is no next function, nothing's most specialized. */ + fn = TREE_CHAIN (fn); champ = fn; } } - - for (fn = instantiations; fn && fn != champ; fn = TREE_CHAIN (fn)) - { - fate = more_specialized (TREE_VALUE (champ), TREE_VALUE (fn), - DEDUCE_EXACT, -1); - if (fate != 1) - return error_mark_node; - } + + if (champ) + /* Now verify that champ is better than everything earlier in the + instantiation list. */ + for (fn = instantiations; fn != champ; fn = TREE_CHAIN (fn)) + if (get_bindings_real (TREE_VALUE (champ), + DECL_TEMPLATE_RESULT (TREE_VALUE (fn)), + NULL_TREE, 0, DEDUCE_EXACT, -1) + || !get_bindings_real (TREE_VALUE (fn), + DECL_TEMPLATE_RESULT (TREE_VALUE (champ)), + NULL_TREE, 0, DEDUCE_EXACT, -1)) + { + champ = NULL_TREE; + break; + } + + processing_template_decl--; + + if (!champ) + return error_mark_node; return TREE_PURPOSE (champ) ? TREE_PURPOSE (champ) : TREE_VALUE (champ); } @@ -12399,10 +12520,7 @@ build_non_dependent_expr (tree expr) types. */ inner_expr = (TREE_CODE (expr) == ADDR_EXPR ? TREE_OPERAND (expr, 0) : expr); - if (TREE_CODE (inner_expr) == OVERLOAD - || TREE_CODE (inner_expr) == FUNCTION_DECL - || TREE_CODE (inner_expr) == TEMPLATE_DECL - || TREE_CODE (inner_expr) == TEMPLATE_ID_EXPR + if (is_overloaded_fn (inner_expr) || TREE_CODE (inner_expr) == OFFSET_REF) return expr; /* There is no need to return a proxy for a variable. */ diff --git a/contrib/gcc-4.0/gcc/cp/rtti.c b/contrib/gcc-4.0/gcc/cp/rtti.c index a08a3ee5cb..45f0b087a8 100644 --- a/contrib/gcc-4.0/gcc/cp/rtti.c +++ b/contrib/gcc-4.0/gcc/cp/rtti.c @@ -113,7 +113,7 @@ init_rtti_processing (void) push_namespace (std_identifier); type_info_type = xref_tag (class_type, get_identifier ("type_info"), - /*tag_scope=*/ts_global, false); + /*tag_scope=*/ts_current, false); pop_namespace (); const_type_info_type_node = build_qualified_type (type_info_type, TYPE_QUAL_CONST); @@ -624,7 +624,7 @@ build_dynamic_cast_1 (tree type, tree expr) push_nested_namespace (ns); tinfo_ptr = xref_tag (class_type, get_identifier ("__class_type_info"), - /*tag_scope=*/ts_global, false); + /*tag_scope=*/ts_current, false); tinfo_ptr = build_pointer_type (build_qualified_type @@ -805,7 +805,7 @@ tinfo_base_init (tree desc, tree target) push_nested_namespace (abi_node); real_type = xref_tag (class_type, TINFO_REAL_NAME (desc), - /*tag_scope=*/ts_global, false); + /*tag_scope=*/ts_current, false); pop_nested_namespace (abi_node); if (!COMPLETE_TYPE_P (real_type)) @@ -1337,7 +1337,7 @@ emit_support_tinfos (void) push_nested_namespace (abi_node); bltn_type = xref_tag (class_type, get_identifier ("__fundamental_type_info"), - /*tag_scope=*/ts_global, false); + /*tag_scope=*/ts_current, false); pop_nested_namespace (abi_node); if (!COMPLETE_TYPE_P (bltn_type)) return; diff --git a/contrib/gcc-4.0/gcc/cp/semantics.c b/contrib/gcc-4.0/gcc/cp/semantics.c index 0ccceebf1c..e40f400745 100644 --- a/contrib/gcc-4.0/gcc/cp/semantics.c +++ b/contrib/gcc-4.0/gcc/cp/semantics.c @@ -2126,7 +2126,7 @@ begin_class_definition (tree t) if (t == error_mark_node || ! IS_AGGR_TYPE (t)) { t = make_aggr_type (RECORD_TYPE); - pushtag (make_anon_name (), t, 0); + pushtag (make_anon_name (), t, /*tag_scope=*/ts_current); } /* Update the location of the decl. */ @@ -2135,7 +2135,7 @@ begin_class_definition (tree t) if (TYPE_BEING_DEFINED (t)) { t = make_aggr_type (TREE_CODE (t)); - pushtag (TYPE_IDENTIFIER (t), t, 0); + pushtag (TYPE_IDENTIFIER (t), t, /*tag_scope=*/ts_current); } maybe_process_partial_specialization (t); pushclass (t); @@ -2749,9 +2749,9 @@ finish_id_expression (tree id_expression, if (context != NULL_TREE && context != current_function_decl && ! TREE_STATIC (decl)) { - error ("use of %s from containing function", - (TREE_CODE (decl) == VAR_DECL - ? "% variable" : "parameter")); + error (TREE_CODE (decl) == VAR_DECL + ? "use of % variable from containing function" + : "use of parameter from containing function"); cp_error_at (" %q#D declared here", decl); return error_mark_node; } diff --git a/contrib/gcc-4.0/gcc/cp/tree.c b/contrib/gcc-4.0/gcc/cp/tree.c index cbf68ee4ce..7a46577fc9 100644 --- a/contrib/gcc-4.0/gcc/cp/tree.c +++ b/contrib/gcc-4.0/gcc/cp/tree.c @@ -223,9 +223,7 @@ builtin_valid_in_constant_expr_p (tree decl) { /* At present BUILT_IN_CONSTANT_P is the only builtin we're allowing in constant-expressions. We may want to add other builtins later. */ - return TREE_CODE (decl) == FUNCTION_DECL - && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL - && DECL_FUNCTION_CODE (decl) == BUILT_IN_CONSTANT_P; + return DECL_IS_BUILTIN_CONSTANT_P (decl); } /* Build a TARGET_EXPR, initializing the DECL with the VALUE. */ diff --git a/contrib/gcc-4.0/gcc/cp/typeck.c b/contrib/gcc-4.0/gcc/cp/typeck.c index 6e5be0fdc2..706b37fc19 100644 --- a/contrib/gcc-4.0/gcc/cp/typeck.c +++ b/contrib/gcc-4.0/gcc/cp/typeck.c @@ -2354,14 +2354,23 @@ get_member_function_from_ptrfunc (tree *instance_ptrptr, tree function) gcc_unreachable (); } - /* Convert down to the right base before using the instance. First - use the type... */ + /* Convert down to the right base before using the instance. A + special case is that in a pointer to member of class C, C may + be incomplete. In that case, the function will of course be + a member of C, and no conversion is required. In fact, + lookup_base will fail in that case, because incomplete + classes do not have BINFOs. */ basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype)); - basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)), - basetype, ba_check, NULL); - instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype, 1); - if (instance_ptr == error_mark_node) - return error_mark_node; + if (!same_type_ignoring_top_level_qualifiers_p + (basetype, TREE_TYPE (TREE_TYPE (instance_ptr)))) + { + basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)), + basetype, ba_check, NULL); + instance_ptr = build_base_path (PLUS_EXPR, instance_ptr, basetype, + 1); + if (instance_ptr == error_mark_node) + return error_mark_node; + } /* ...and then the delta in the PMF. */ instance_ptr = build2 (PLUS_EXPR, TREE_TYPE (instance_ptr), instance_ptr, delta); @@ -5535,7 +5544,9 @@ get_delta_difference (tree from, tree to, error (" in pointer to member function conversion"); else if (!binfo) { - if (!allow_inverse_p) + if (!binfo && same_type_ignoring_top_level_qualifiers_p (from, to)) + /* Pointer to member of incomplete class is permitted*/; + else if (!allow_inverse_p) { error_not_base_type (from, to); error (" in pointer to member conversion"); @@ -6427,11 +6438,6 @@ casts_away_constness_r (tree *t1, tree *t2) and pointers to members (conv.qual), the "member" aspect of a pointer to member level is ignored when determining if a const cv-qualifier has been cast away. */ - if (TYPE_PTRMEM_P (*t1)) - *t1 = build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (*t1)); - if (TYPE_PTRMEM_P (*t2)) - *t2 = build_pointer_type (TYPE_PTRMEM_POINTED_TO_TYPE (*t2)); - /* [expr.const.cast] For two pointer types: @@ -6449,9 +6455,8 @@ casts_away_constness_r (tree *t1, tree *t2) to Tcv2,(M-K+1) * cv2,(M-K+2) * ... cv2,M *. */ - - if (TREE_CODE (*t1) != POINTER_TYPE - || TREE_CODE (*t2) != POINTER_TYPE) + if ((!TYPE_PTR_P (*t1) && !TYPE_PTRMEM_P (*t1)) + || (!TYPE_PTR_P (*t2) && !TYPE_PTRMEM_P (*t2))) { *t1 = cp_build_qualified_type (void_type_node, cp_type_quals (*t1)); @@ -6462,8 +6467,16 @@ casts_away_constness_r (tree *t1, tree *t2) quals1 = cp_type_quals (*t1); quals2 = cp_type_quals (*t2); - *t1 = TREE_TYPE (*t1); - *t2 = TREE_TYPE (*t2); + + if (TYPE_PTRMEM_P (*t1)) + *t1 = TYPE_PTRMEM_POINTED_TO_TYPE (*t1); + else + *t1 = TREE_TYPE (*t1); + if (TYPE_PTRMEM_P (*t2)) + *t2 = TYPE_PTRMEM_POINTED_TO_TYPE (*t2); + else + *t2 = TREE_TYPE (*t2); + casts_away_constness_r (t1, t2); *t1 = build_pointer_type (*t1); *t2 = build_pointer_type (*t2); diff --git a/contrib/gcc-4.0/gcc/dbxout.c b/contrib/gcc-4.0/gcc/dbxout.c index 271cc19840..30e47a5523 100644 --- a/contrib/gcc-4.0/gcc/dbxout.c +++ b/contrib/gcc-4.0/gcc/dbxout.c @@ -1390,14 +1390,14 @@ dbxout_type_fields (tree type) /* Omit here local type decls until we know how to support them. */ if (TREE_CODE (tem) == TYPE_DECL + /* Omit here the nameless fields that are used to skip bits. */ + || DECL_IGNORED_P (tem) /* Omit fields whose position or size are variable or too large to represent. */ || (TREE_CODE (tem) == FIELD_DECL && (! host_integerp (bit_position (tem), 0) || ! DECL_SIZE (tem) - || ! host_integerp (DECL_SIZE (tem), 1))) - /* Omit here the nameless fields that are used to skip bits. */ - || DECL_IGNORED_P (tem)) + || ! host_integerp (DECL_SIZE (tem), 1)))) continue; else if (TREE_CODE (tem) != CONST_DECL) diff --git a/contrib/gcc-4.0/gcc/diagnostic.c b/contrib/gcc-4.0/gcc/diagnostic.c index b047167bc4..bce47192e4 100644 --- a/contrib/gcc-4.0/gcc/diagnostic.c +++ b/contrib/gcc-4.0/gcc/diagnostic.c @@ -111,13 +111,13 @@ diagnostic_initialize (diagnostic_context *context) } void -diagnostic_set_info (diagnostic_info *diagnostic, const char *msgid, +diagnostic_set_info (diagnostic_info *diagnostic, const char *gmsgid, va_list *args, location_t location, diagnostic_t kind) { diagnostic->message.err_no = errno; diagnostic->message.args_ptr = args; - diagnostic->message.format_spec = _(msgid); + diagnostic->message.format_spec = _(gmsgid); diagnostic->location = location; diagnostic->kind = kind; } @@ -378,15 +378,15 @@ trim_filename (const char *name) /* Text to be emitted verbatim to the error message stream; this produces no prefix and disables line-wrapping. Use rarely. */ void -verbatim (const char *msgid, ...) +verbatim (const char *gmsgid, ...) { text_info text; va_list ap; - va_start (ap, msgid); + va_start (ap, gmsgid); text.err_no = errno; text.args_ptr = ≈ - text.format_spec = _(msgid); + text.format_spec = _(gmsgid); pp_format_verbatim (global_dc->printer, &text); pp_flush (global_dc->printer); va_end (ap); @@ -395,13 +395,13 @@ verbatim (const char *msgid, ...) /* An informative note. Use this for additional details on an error message. */ void -inform (const char *msgid, ...) +inform (const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_NOTE); + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_NOTE); report_diagnostic (&diagnostic); va_end (ap); } @@ -409,13 +409,13 @@ inform (const char *msgid, ...) /* A warning. Use this for code which is correct according to the relevant language specification but is likely to be buggy anyway. */ void -warning (const char *msgid, ...) +warning (const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_WARNING); + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_WARNING); report_diagnostic (&diagnostic); va_end (ap); } @@ -429,13 +429,13 @@ warning (const char *msgid, ...) of the -pedantic command-line switch. To get a warning enabled only with that switch, write "if (pedantic) pedwarn (...);" */ void -pedwarn (const char *msgid, ...) +pedwarn (const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, input_location, + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, pedantic_error_kind ()); report_diagnostic (&diagnostic); va_end (ap); @@ -444,13 +444,13 @@ pedwarn (const char *msgid, ...) /* A hard error: the code is definitely ill-formed, and an object file will not be produced. */ void -error (const char *msgid, ...) +error (const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_ERROR); + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_ERROR); report_diagnostic (&diagnostic); va_end (ap); } @@ -459,13 +459,13 @@ error (const char *msgid, ...) required by the relevant specification but not implemented by GCC. An object file will not be produced. */ void -sorry (const char *msgid, ...) +sorry (const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_SORRY); + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_SORRY); report_diagnostic (&diagnostic); va_end (ap); } @@ -474,13 +474,13 @@ sorry (const char *msgid, ...) continue. Do not use this for internal consistency checks; that's internal_error. Use of this function should be rare. */ void -fatal_error (const char *msgid, ...) +fatal_error (const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_FATAL); + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_FATAL); report_diagnostic (&diagnostic); va_end (ap); @@ -492,13 +492,13 @@ fatal_error (const char *msgid, ...) a more specific message, or some other good reason, you should use abort () instead of calling this function directly. */ void -internal_error (const char *msgid, ...) +internal_error (const char *gmsgid, ...) { diagnostic_info diagnostic; va_list ap; - va_start (ap, msgid); - diagnostic_set_info (&diagnostic, msgid, &ap, input_location, DK_ICE); + va_start (ap, gmsgid); + diagnostic_set_info (&diagnostic, gmsgid, &ap, input_location, DK_ICE); report_diagnostic (&diagnostic); va_end (ap); @@ -511,12 +511,12 @@ internal_error (const char *msgid, ...) /* Print a diagnostic MSGID on FILE. This is just fprintf, except it runs its second argument through gettext. */ void -fnotice (FILE *file, const char *msgid, ...) +fnotice (FILE *file, const char *cmsgid, ...) { va_list ap; - va_start (ap, msgid); - vfprintf (file, _(msgid), ap); + va_start (ap, cmsgid); + vfprintf (file, _(cmsgid), ap); va_end (ap); } diff --git a/contrib/gcc-4.0/gcc/doc/contrib.texi b/contrib/gcc-4.0/gcc/doc/contrib.texi index 209d32c119..beee30fb0f 100644 --- a/contrib/gcc-4.0/gcc/doc/contrib.texi +++ b/contrib/gcc-4.0/gcc/doc/contrib.texi @@ -317,6 +317,9 @@ the support for System V Release 4. He has also worked heavily on the Intel 386 and 860 support. @item +Mostafa Hagog for Swing Modulo Scheduling (SMS) and post reload GCSE@. + +@item Bruno Haible for improvements in the runtime overhead for EH, new warnings and assorted bug fixes. @@ -975,6 +978,9 @@ description for the Tron architecture (specifically, the Gmicro). Kevin Zachmann helped port GCC to the Tahoe. @item +Ayal Zaks for Swing Modulo Scheduling (SMS). + +@item Xiaoqiang Zhang for work on gfortran. @item diff --git a/contrib/gcc-4.0/gcc/doc/cpp.1 b/contrib/gcc-4.0/gcc/doc/cpp.1 index e6f1879b15..ba5e29e0bd 100644 --- a/contrib/gcc-4.0/gcc/doc/cpp.1 +++ b/contrib/gcc-4.0/gcc/doc/cpp.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "CPP 1" -.TH CPP 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH CPP 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" cpp \- The C Preprocessor .SH "SYNOPSIS" diff --git a/contrib/gcc-4.0/gcc/doc/cpp.info b/contrib/gcc-4.0/gcc/doc/cpp.info index bb69ae484a..433f1fc15d 100644 --- a/contrib/gcc-4.0/gcc/doc/cpp.info +++ b/contrib/gcc-4.0/gcc/doc/cpp.info @@ -1,5 +1,5 @@ -This is doc/cpp.info, produced by makeinfo version 4.7 from -/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/doc/cpp.texi. +This is doc/cpp.info, produced by makeinfo version 4.8 from +/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/doc/cpp.texi. Copyright (C) 1987, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software @@ -22,7 +22,7 @@ are (a) (see below), and the Back-Cover Texts are (b) (see below). You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise -funds for GNU development. man end +funds for GNU development. INFO-DIR-SECTION Programming START-INFO-DIR-ENTRY @@ -155,7 +155,7 @@ are (a) (see below), and the Back-Cover Texts are (b) (see below). You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise -funds for GNU development. man end +funds for GNU development.  File: cpp.info, Node: Overview, Next: Header Files, Prev: Top, Up: Top @@ -5110,80 +5110,80 @@ Concept Index  Tag Table: -Node: Top1094 -Node: Overview3787 -Node: Character sets6608 -Ref: Character sets-Footnote-19067 -Node: Initial processing9248 -Ref: trigraphs10807 -Node: Tokenization15009 -Ref: Tokenization-Footnote-122064 -Node: The preprocessing language22175 -Node: Header Files25053 -Node: Include Syntax26933 -Node: Include Operation28570 -Node: Search Path30418 -Node: Once-Only Headers33608 -Node: Computed Includes35253 -Node: Wrapper Headers38397 -Node: System Headers40823 -Node: Macros42873 -Node: Object-like Macros44014 -Node: Function-like Macros47604 -Node: Macro Arguments49220 -Node: Stringification53365 -Node: Concatenation56571 -Node: Variadic Macros59679 -Node: Predefined Macros64466 -Node: Standard Predefined Macros65054 -Node: Common Predefined Macros70990 -Node: System-specific Predefined Macros78943 -Node: C++ Named Operators80964 -Node: Undefining and Redefining Macros81928 -Node: Directives Within Macro Arguments84032 -Node: Macro Pitfalls85580 -Node: Misnesting86113 -Node: Operator Precedence Problems87225 -Node: Swallowing the Semicolon89091 -Node: Duplication of Side Effects91114 -Node: Self-Referential Macros93297 -Node: Argument Prescan95706 -Node: Newlines in Arguments99460 -Node: Conditionals100411 -Node: Conditional Uses102241 -Node: Conditional Syntax103599 -Node: Ifdef103919 -Node: If107080 -Node: Defined109384 -Node: Else110667 -Node: Elif111237 -Node: Deleted Code112526 -Node: Diagnostics113773 -Node: Line Control115390 -Node: Pragmas119194 -Node: Other Directives123464 -Node: Preprocessor Output124657 -Node: Traditional Mode127858 -Node: Traditional lexical analysis128916 -Node: Traditional macros131419 -Node: Traditional miscellany135221 -Node: Traditional warnings136218 -Node: Implementation Details138415 -Node: Implementation-defined behavior139036 -Ref: Identifier characters139773 -Node: Implementation limits142694 -Node: Obsolete Features145368 -Node: Assertions145823 -Node: Obsolete once-only headers148364 -Node: Differences from previous versions150099 -Node: Invocation154307 -Ref: Wtrigraphs158638 -Ref: dashMF163422 -Ref: fdollars-in-identifiers171182 -Node: Environment Variables178640 -Node: GNU Free Documentation License181606 -Node: Index of Directives204029 -Node: Option Index205958 -Node: Concept Index211850 +Node: Top1085 +Node: Overview3769 +Node: Character sets6590 +Ref: Character sets-Footnote-19049 +Node: Initial processing9230 +Ref: trigraphs10789 +Node: Tokenization14991 +Ref: Tokenization-Footnote-122046 +Node: The preprocessing language22157 +Node: Header Files25035 +Node: Include Syntax26915 +Node: Include Operation28552 +Node: Search Path30400 +Node: Once-Only Headers33590 +Node: Computed Includes35235 +Node: Wrapper Headers38379 +Node: System Headers40805 +Node: Macros42855 +Node: Object-like Macros43996 +Node: Function-like Macros47586 +Node: Macro Arguments49202 +Node: Stringification53347 +Node: Concatenation56553 +Node: Variadic Macros59661 +Node: Predefined Macros64448 +Node: Standard Predefined Macros65036 +Node: Common Predefined Macros70972 +Node: System-specific Predefined Macros78925 +Node: C++ Named Operators80946 +Node: Undefining and Redefining Macros81910 +Node: Directives Within Macro Arguments84014 +Node: Macro Pitfalls85562 +Node: Misnesting86095 +Node: Operator Precedence Problems87207 +Node: Swallowing the Semicolon89073 +Node: Duplication of Side Effects91096 +Node: Self-Referential Macros93279 +Node: Argument Prescan95688 +Node: Newlines in Arguments99442 +Node: Conditionals100393 +Node: Conditional Uses102223 +Node: Conditional Syntax103581 +Node: Ifdef103901 +Node: If107062 +Node: Defined109366 +Node: Else110649 +Node: Elif111219 +Node: Deleted Code112508 +Node: Diagnostics113755 +Node: Line Control115372 +Node: Pragmas119176 +Node: Other Directives123446 +Node: Preprocessor Output124639 +Node: Traditional Mode127840 +Node: Traditional lexical analysis128898 +Node: Traditional macros131401 +Node: Traditional miscellany135203 +Node: Traditional warnings136200 +Node: Implementation Details138397 +Node: Implementation-defined behavior139018 +Ref: Identifier characters139755 +Node: Implementation limits142676 +Node: Obsolete Features145350 +Node: Assertions145805 +Node: Obsolete once-only headers148346 +Node: Differences from previous versions150081 +Node: Invocation154289 +Ref: Wtrigraphs158620 +Ref: dashMF163404 +Ref: fdollars-in-identifiers171164 +Node: Environment Variables178622 +Node: GNU Free Documentation License181588 +Node: Index of Directives204011 +Node: Option Index205940 +Node: Concept Index211832  End Tag Table diff --git a/contrib/gcc-4.0/gcc/doc/cppinternals.info b/contrib/gcc-4.0/gcc/doc/cppinternals.info index 12c306d46b..0de50135fd 100644 --- a/contrib/gcc-4.0/gcc/doc/cppinternals.info +++ b/contrib/gcc-4.0/gcc/doc/cppinternals.info @@ -1,5 +1,5 @@ -This is doc/cppinternals.info, produced by makeinfo version 4.7 from -/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/doc/cppinternals.texi. +This is doc/cppinternals.info, produced by makeinfo version 4.8 from +/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/doc/cppinternals.texi. INFO-DIR-SECTION Programming START-INFO-DIR-ENTRY diff --git a/contrib/gcc-4.0/gcc/doc/extend.texi b/contrib/gcc-4.0/gcc/doc/extend.texi index f7ca9e4922..5c272d1025 100644 --- a/contrib/gcc-4.0/gcc/doc/extend.texi +++ b/contrib/gcc-4.0/gcc/doc/extend.texi @@ -1723,6 +1723,13 @@ on data in the eight bit data area. Note the eight bit data area is limited to You must use GAS and GLD from GNU binutils version 2.7 or later for this attribute to work correctly. +@item exception_handler +@cindex exception handler functions on the Blackfin processor +Use this attribute on the Blackfin to indicate that the specified function +is an exception handler. The compiler will generate function entry and +exit sequences suitable for use in an exception handler when this +attribute is present. + @item far @cindex functions which handle memory bank switching On 68HC11 and 68HC12 the @code{far} attribute causes the compiler to @@ -1871,8 +1878,8 @@ that the specified function is an interrupt handler. The compiler will generate function entry and exit sequences suitable for use in an interrupt handler when this attribute is present. -Note, interrupt handlers for the m68k, H8/300, H8/300H, H8S, and SH processors -can be specified via the @code{interrupt_handler} attribute. +Note, interrupt handlers for the Blackfin, m68k, H8/300, H8/300H, H8S, and +SH processors can be specified via the @code{interrupt_handler} attribute. Note, on the AVR, interrupts will be enabled inside the function. @@ -1886,11 +1893,17 @@ void f () __attribute__ ((interrupt ("IRQ"))); Permissible values for this parameter are: IRQ, FIQ, SWI, ABORT and UNDEF@. @item interrupt_handler -@cindex interrupt handler functions on the m68k, H8/300 and SH processors -Use this attribute on the m68k, H8/300, H8/300H, H8S, and SH to indicate that -the specified function is an interrupt handler. The compiler will generate -function entry and exit sequences suitable for use in an interrupt -handler when this attribute is present. +@cindex interrupt handler functions on the Blackfin, m68k, H8/300 and SH processors +Use this attribute on the Blackfin, m68k, H8/300, H8/300H, H8S, and SH to +indicate that the specified function is an interrupt handler. The compiler +will generate function entry and exit sequences suitable for use in an +interrupt handler when this attribute is present. + +@item kspisusp +@cindex User stack pointer in interrupts on the Blackfin +When used together with @code{interrupt_handler}, @code{exception_handler} +or @code{nmi_handler}, code will be generated to load the stack pointer +from the USP register in the function prologue. @item long_call/short_call @cindex indirect calls on ARM @@ -1970,6 +1983,19 @@ use the normal calling convention based on @code{jsr} and @code{rts}. This attribute can be used to cancel the effect of the @option{-mlong-calls} option. +@item nesting +@cindex Allow nesting in an interrupt handler on the Blackfin processor. +Use this attribute together with @code{interrupt_handler}, +@code{exception_handler} or @code{nmi_handler} to indicate that the function +entry code should enable nested interrupts or exceptions. + +@item nmi_handler +@cindex NMI handler functions on the Blackfin processor +Use this attribute on the Blackfin to indicate that the specified function +is an NMI handler. The compiler will generate function entry and +exit sequences suitable for use in an NMI handler when this +attribute is present. + @item no_instrument_function @cindex @code{no_instrument_function} function attribute @opindex finstrument-functions @@ -2114,8 +2140,8 @@ disabled with the linker or the loader if desired, to avoid the problem.) @item saveall -@cindex save all registers on the H8/300, H8/300H, and H8S -Use this attribute on the H8/300, H8/300H, and H8S to indicate that +@cindex save all registers on the Blackfin, H8/300, H8/300H, and H8S +Use this attribute on the Blackfin, H8/300, H8/300H, and H8S to indicate that all registers except the stack pointer should be saved in the prologue regardless of whether they are used or not. @@ -3195,7 +3221,7 @@ struct my_unpacked_struct int i; @}; -struct my_packed_struct __attribute__ ((__packed__)) +struct __attribute__ ((__packed__)) my_packed_struct @{ char c; int i; diff --git a/contrib/gcc-4.0/gcc/doc/fsf-funding.7 b/contrib/gcc-4.0/gcc/doc/fsf-funding.7 index 935fc14ea2..9f19876da8 100644 --- a/contrib/gcc-4.0/gcc/doc/fsf-funding.7 +++ b/contrib/gcc-4.0/gcc/doc/fsf-funding.7 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "FSF-FUNDING 7" -.TH FSF-FUNDING 7 "2005-04-21" "gcc-4.0.0" "GNU" +.TH FSF-FUNDING 7 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" fsf\-funding \- Funding Free Software .SH "DESCRIPTION" diff --git a/contrib/gcc-4.0/gcc/doc/g++.1 b/contrib/gcc-4.0/gcc/doc/g++.1 index 2f2eac94fe..a29b0cad41 100644 --- a/contrib/gcc-4.0/gcc/doc/g++.1 +++ b/contrib/gcc-4.0/gcc/doc/g++.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "GCC 1" -.TH GCC 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH GCC 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" gcc \- GNU project C and C++ compiler .SH "SYNOPSIS" @@ -214,7 +214,7 @@ in the following sections. \&\-fno\-default\-inline \-fvisibility\-inlines\-hidden \&\-Wabi \-Wctor\-dtor\-privacy \&\-Wnon\-virtual\-dtor \-Wreorder -\&\-Weffc++ \-Wno\-deprecated +\&\-Weffc++ \-Wno\-deprecated \-Wstrict\-null\-sentinel \&\-Wno\-non\-template\-friend \-Wold\-style\-cast \&\-Woverloaded\-virtual \-Wno\-pmf\-conversions \&\-Wsign\-promo\fR @@ -410,6 +410,11 @@ in the following sections. \&\fB\-mmcu=\fR\fImcu\fR \fB\-msize \-minit\-stack=\fR\fIn\fR \fB\-mno\-interrupts \&\-mcall\-prologues \-mno\-tablejump \-mtiny\-stack \-mint8\fR .Sp +\&\fIBlackfin Options\fR +\&\fB\-momit\-leaf\-frame\-pointer \-mno\-omit\-leaf\-frame\-pointer \-mcsync +\&\-mno\-csync \-mlow\-64k \-mno\-low64k \-mid\-shared\-library +\&\-mno\-id\-shared\-library \-mshared\-library\-id=\fR\fIn\fR\fB \fR +.Sp \&\fI\s-1CRIS\s0 Options\fR \&\fB\-mcpu=\fR\fIcpu\fR \fB\-march=\fR\fIcpu\fR \fB\-mtune=\fR\fIcpu\fR \&\fB\-mmax\-stack\-frame=\fR\fIn\fR \fB\-melinux\-stacksize=\fR\fIn\fR @@ -1471,7 +1476,7 @@ compatible with code generated by other compilers. .Sp The known incompatibilities at this point include: .RS 4 -.IP "\(bu" 4 +.IP "*" 4 Incorrect handling of tail-padding for bit\-fields. G++ may attempt to pack data into the same byte as a base class. For example: .Sp @@ -1485,7 +1490,7 @@ as\f(CW\*(C`A::f1\*(C'\fR; other compilers will not. You can avoid this problem by explicitly padding \f(CW\*(C`A\*(C'\fR so that its size is a multiple of the byte size on your platform; that will cause G++ and other compilers to layout \f(CW\*(C`B\*(C'\fR identically. -.IP "\(bu" 4 +.IP "*" 4 Incorrect handling of tail-padding for virtual bases. G++ does not use tail padding when laying out virtual bases. For example: .Sp @@ -1500,7 +1505,7 @@ In this case, G++ will not place \f(CW\*(C`B\*(C'\fR into the tail-padding for explicitly padding \f(CW\*(C`A\*(C'\fR so that its size is a multiple of its alignment (ignoring virtual base classes); that will cause G++ and other compilers to layout \f(CW\*(C`C\*(C'\fR identically. -.IP "\(bu" 4 +.IP "*" 4 Incorrect handling of bit-fields with declared widths greater than that of their underlying types, when the bit-fields appear in a union. For example: @@ -1511,7 +1516,7 @@ example: .Sp Assuming that an \f(CW\*(C`int\*(C'\fR does not have 4096 bits, G++ will make the union too small by the number of bits in an \f(CW\*(C`int\*(C'\fR. -.IP "\(bu" 4 +.IP "*" 4 Empty classes can be placed at incorrect offsets. For example: .Sp .Vb 1 @@ -1532,7 +1537,7 @@ Empty classes can be placed at incorrect offsets. For example: G++ will place the \f(CW\*(C`A\*(C'\fR base class of \f(CW\*(C`C\*(C'\fR at a nonzero offset; it should be placed at offset zero. G++ mistakenly believes that the \&\f(CW\*(C`A\*(C'\fR data member of \f(CW\*(C`B\*(C'\fR is already at offset zero. -.IP "\(bu" 4 +.IP "*" 4 Names of template functions whose types involve \f(CW\*(C`typename\*(C'\fR or template template parameters can be mangled incorrectly. .Sp @@ -1583,26 +1588,26 @@ The following \fB\-W...\fR options are not affected by \fB\-Wall\fR. Warn about violations of the following style guidelines from Scott Meyers' \&\fIEffective \*(C+\fR book: .RS 4 -.IP "\(bu" 4 +.IP "*" 4 Item 11: Define a copy constructor and an assignment operator for classes with dynamically allocated memory. -.IP "\(bu" 4 +.IP "*" 4 Item 12: Prefer initialization to assignment in constructors. -.IP "\(bu" 4 +.IP "*" 4 Item 14: Make destructors virtual in base classes. -.IP "\(bu" 4 +.IP "*" 4 Item 15: Have \f(CW\*(C`operator=\*(C'\fR return a reference to \f(CW*this\fR. -.IP "\(bu" 4 +.IP "*" 4 Item 23: Don't try to return a reference when you must return an object. .RE .RS 4 .Sp Also warn about violations of the following style guidelines from Scott Meyers' \fIMore Effective \*(C+\fR book: -.IP "\(bu" 4 +.IP "*" 4 Item 6: Distinguish between prefix and postfix forms of increment and decrement operators. -.IP "\(bu" 4 +.IP "*" 4 Item 7: Never overload \f(CW\*(C`&&\*(C'\fR, \f(CW\*(C`||\*(C'\fR, or \f(CW\*(C`,\*(C'\fR. .RE .RS 4 @@ -1614,6 +1619,13 @@ to filter out those warnings. .IP "\fB\-Wno\-deprecated\fR (\*(C+ only)" 4 .IX Item "-Wno-deprecated ( only)" Do not warn about usage of deprecated features. +.IP "\fB\-Wstrict\-null\-sentinel\fR (\*(C+ only)" 4 +.IX Item "-Wstrict-null-sentinel ( only)" +Warn also about the use of an uncasted \f(CW\*(C`NULL\*(C'\fR as sentinel. When +compiling only with \s-1GCC\s0 this is a valid sentinel, as \f(CW\*(C`NULL\*(C'\fR is defined +to \f(CW\*(C`_\|_null\*(C'\fR. Although it is a null pointer constant not a null pointer, +it is guaranteed to of the same size as a pointer. But this use is +not portable across different compilers. .IP "\fB\-Wno\-non\-template\-friend\fR (\*(C+ only)" 4 .IX Item "-Wno-non-template-friend ( only)" Disable warnings when non-templatized friend functions are declared @@ -1793,13 +1805,13 @@ of the \f(CW\*(C`finally\*(C'\fR clause in Java. .Sp There are several caveats to using the new exception mechanism: .RS 4 -.IP "\(bu" 4 +.IP "*" 4 Although currently designed to be binary compatible with \f(CW\*(C`NS_HANDLER\*(C'\fR\-style idioms provided by the \f(CW\*(C`NSException\*(C'\fR class, the new exceptions can only be used on Mac \s-1OS\s0 X 10.3 (Panther) and later systems, due to additional functionality needed in the (NeXT) Objective-C runtime. -.IP "\(bu" 4 +.IP "*" 4 As mentioned above, the new exceptions do not support handling types other than Objective-C objects. Furthermore, when used from Objective\-\*(C+, the Objective-C exception model does not interoperate with \*(C+ @@ -2327,11 +2339,13 @@ get these warnings. If you want to warn about code which uses the uninitialized value of the variable in its own initializer, use the \fB\-Winit\-self\fR option. .Sp -These warnings occur only for variables that are candidates for -register allocation. Therefore, they do not occur for a variable that -is declared \f(CW\*(C`volatile\*(C'\fR, or whose address is taken, or whose size -is other than 1, 2, 4 or 8 bytes. Also, they do not occur for -structures, unions or arrays, even when they are in registers. +These warnings occur for individual uninitialized or clobbered +elements of structure, union or array variables as well as for +variables which are uninitialized or clobbered as a whole. They do +not occur for variables or elements declared \f(CW\*(C`volatile\*(C'\fR. Because +these warnings depend on optimization, the exact variables or elements +for which there are warnings will depend on the precise optimization +options and version of \s-1GCC\s0 used. .Sp Note that there may be no warning about a variable that is used only to compute a value that itself is never used, because such @@ -2427,7 +2441,7 @@ the warning. supported, but the newer name is more descriptive.) Print extra warning messages for these events: .RS 4 -.IP "\(bu" 4 +.IP "*" 4 A function can return either with or without a value. (Falling off the end of the function body is considered returning without a value.) For example, this function would evoke such a @@ -2440,43 +2454,43 @@ warning: \& return a; \& } .Ve -.IP "\(bu" 4 +.IP "*" 4 An expression-statement or the left-hand side of a comma expression contains no side effects. To suppress the warning, cast the unused expression to void. For example, an expression such as \fBx[i,j]\fR will cause a warning, but \fBx[(void)i,j]\fR will not. -.IP "\(bu" 4 +.IP "*" 4 An unsigned value is compared against zero with \fB<\fR or \fB>=\fR. -.IP "\(bu" 4 +.IP "*" 4 Storage-class specifiers like \f(CW\*(C`static\*(C'\fR are not the first things in a declaration. According to the C Standard, this usage is obsolescent. -.IP "\(bu" 4 +.IP "*" 4 If \fB\-Wall\fR or \fB\-Wunused\fR is also specified, warn about unused arguments. -.IP "\(bu" 4 +.IP "*" 4 A comparison between signed and unsigned values could produce an incorrect result when the signed value is converted to unsigned. (But don't warn if \fB\-Wno\-sign\-compare\fR is also specified.) -.IP "\(bu" 4 +.IP "*" 4 An aggregate has an initializer which does not initialize all members. This warning can be independently controlled by \&\fB\-Wmissing\-field\-initializers\fR. -.IP "\(bu" 4 +.IP "*" 4 A function parameter is declared without a type specifier in K&R\-style functions: .Sp .Vb 1 \& void foo(bar) { } .Ve -.IP "\(bu" 4 +.IP "*" 4 An empty body occurs in an \fBif\fR or \fBelse\fR statement. -.IP "\(bu" 4 +.IP "*" 4 A pointer is compared against integer zero with \fB<\fR, \fB<=\fR, \&\fB>\fR, or \fB>=\fR. -.IP "\(bu" 4 +.IP "*" 4 A variable might be changed by \fBlongjmp\fR or \fBvfork\fR. -.IP "\(bu" 4 +.IP "*" 4 Any of several floating-point events that often indicate errors, such as overflow, underflow, loss of precision, etc. .IP "*<(\*(C+ only)>" 4 @@ -2536,11 +2550,11 @@ Warn about certain constructs that behave differently in traditional and \&\s-1ISO\s0 C. Also warn about \s-1ISO\s0 C constructs that have no traditional C equivalent, and/or problematic constructs which should be avoided. .RS 4 -.IP "\(bu" 4 +.IP "*" 4 Macro parameters that appear within string literals in the macro body. In traditional C macro replacement takes place within string literals, but does not in \s-1ISO\s0 C. -.IP "\(bu" 4 +.IP "*" 4 In traditional C, some preprocessor directives did not exist. Traditional preprocessors would only consider a line to be a directive if the \fB#\fR appeared in column 1 on the line. Therefore @@ -2550,11 +2564,11 @@ first character on the line. It also suggests you hide directives like \&\fB#pragma\fR not understood by traditional C by indenting them. Some traditional implementations would not recognize \fB#elif\fR, so it suggests avoiding it altogether. -.IP "\(bu" 4 +.IP "*" 4 A function-like macro that appears without arguments. -.IP "\(bu" 4 +.IP "*" 4 The unary plus operator. -.IP "\(bu" 4 +.IP "*" 4 The \fBU\fR integer constant suffix, or the \fBF\fR or \fBL\fR floating point constant suffixes. (Traditional C does support the \fBL\fR suffix on integer constants.) Note, these suffixes appear in macros defined in the system @@ -2562,38 +2576,38 @@ headers of most modern systems, e.g. the \fB_MIN\fR/\fB_MAX\fR macros in \f(CW\* Use of these macros in user code might normally lead to spurious warnings, however \s-1GCC\s0's integrated preprocessor has enough context to avoid warning in these cases. -.IP "\(bu" 4 +.IP "*" 4 A function declared external in one block and then used after the end of the block. -.IP "\(bu" 4 +.IP "*" 4 A \f(CW\*(C`switch\*(C'\fR statement has an operand of type \f(CW\*(C`long\*(C'\fR. -.IP "\(bu" 4 +.IP "*" 4 A non\-\f(CW\*(C`static\*(C'\fR function declaration follows a \f(CW\*(C`static\*(C'\fR one. This construct is not accepted by some traditional C compilers. -.IP "\(bu" 4 +.IP "*" 4 The \s-1ISO\s0 type of an integer constant has a different width or signedness from its traditional type. This warning is only issued if the base of the constant is ten. I.e. hexadecimal or octal values, which typically represent bit patterns, are not warned about. -.IP "\(bu" 4 +.IP "*" 4 Usage of \s-1ISO\s0 string concatenation is detected. -.IP "\(bu" 4 +.IP "*" 4 Initialization of automatic aggregates. -.IP "\(bu" 4 +.IP "*" 4 Identifier conflicts with labels. Traditional C lacks a separate namespace for labels. -.IP "\(bu" 4 +.IP "*" 4 Initialization of unions. If the initializer is zero, the warning is omitted. This is done under the assumption that the zero initializer in user code appears conditioned on e.g. \f(CW\*(C`_\|_STDC_\|_\*(C'\fR to avoid missing initializer warnings and relies on default initialization to zero in the traditional C case. -.IP "\(bu" 4 +.IP "*" 4 Conversions by prototypes between fixed/floating point values and vice versa. The absence of these prototypes when compiling with traditional C would cause serious problems. This is a subset of the possible conversion warnings, for the full set use \fB\-Wconversion\fR. -.IP "\(bu" 4 +.IP "*" 4 Use of \s-1ISO\s0 C style function definitions. This warning intentionally is \&\fInot\fR issued for prototype declarations or variadic functions because these \s-1ISO\s0 C features will appear in your code when using @@ -4603,13 +4617,13 @@ This allows some extra optimizations to take place but consumes more memory (in general). There are some compatibility issues with \fIunit-at-at-time\fR mode: .RS 4 -.IP "\(bu" 4 +.IP "*" 4 enabling \fIunit-at-a-time\fR mode may change the order in which functions, variables, and top-level \f(CW\*(C`asm\*(C'\fR statements are emitted, and will likely break code relying on some particular ordering. The majority of such top-level \f(CW\*(C`asm\*(C'\fR statements, though, can be replaced by \f(CW\*(C`section\*(C'\fR attributes. -.IP "\(bu" 4 +.IP "*" 4 \&\fIunit-at-a-time\fR mode removes unreferenced static variables and functions are removed. This may result in undefined references when an \f(CW\*(C`asm\*(C'\fR statement refers directly to variables or functions @@ -4617,7 +4631,7 @@ that are otherwise unused. In that case either the variable/function shall be listed as an operand of the \f(CW\*(C`asm\*(C'\fR statement operand or, in the case of top-level \f(CW\*(C`asm\*(C'\fR statements the attribute \f(CW\*(C`used\*(C'\fR shall be used on the declaration. -.IP "\(bu" 4 +.IP "*" 4 Static functions now can use non-standard passing conventions that may break \f(CW\*(C`asm\*(C'\fR statements calling functions directly. Again, attribute \f(CW\*(C`used\*(C'\fR will prevent this behavior. @@ -5144,6 +5158,10 @@ induction variable uses. If number of candidates in the set is smaller than this value, we always try to remove unnecessary ivs from the set during its optimization when a new iv is added to the set. +.IP "\fBscev-max-expr-size\fR" 4 +.IX Item "scev-max-expr-size" +Bound on size of expressions used in the scalar evolutions analyzer. +Large expressions slow the analyzer. .IP "\fBmax-iterations-to-track\fR" 4 .IX Item "max-iterations-to-track" The maximum number of iterations of a loop the brute force algorithm @@ -6652,6 +6670,46 @@ and long long will be 4 bytes. Please note that this option does not comply to the C standards, but it will provide you with smaller code size. .PP +\fIBlackfin Options\fR +.IX Subsection "Blackfin Options" +.IP "\fB\-momit\-leaf\-frame\-pointer\fR" 4 +.IX Item "-momit-leaf-frame-pointer" +Don't keep the frame pointer in a register for leaf functions. This +avoids the instructions to save, set up and restore frame pointers and +makes an extra register available in leaf functions. The option +\&\fB\-fomit\-frame\-pointer\fR removes the frame pointer for all functions +which might make debugging harder. +.IP "\fB\-mcsync\fR" 4 +.IX Item "-mcsync" +When enabled, the compiler will ensure that the generated code does not +contain speculative loads after jump instructions. This option is enabled +by default. +.IP "\fB\-mno\-csync\fR" 4 +.IX Item "-mno-csync" +Don't generate extra code to prevent speculative loads from occurring. +.IP "\fB\-mlow\-64k\fR" 4 +.IX Item "-mlow-64k" +When enabled, the compiler is free to take advantage of the knowledge that +the entire program fits into the low 64k of memory. +.IP "\fB\-mno\-low\-64k\fR" 4 +.IX Item "-mno-low-64k" +Assume that the program is arbitrarily large. This is the default. +.IP "\fB\-mid\-shared\-library\fR" 4 +.IX Item "-mid-shared-library" +Generate code that supports shared libraries via the library \s-1ID\s0 method. +This allows for execute in place and shared libraries in an environment +without virtual memory management. This option implies \fB\-fPIC\fR. +.IP "\fB\-mno\-id\-shared\-library\fR" 4 +.IX Item "-mno-id-shared-library" +Generate code that doesn't assume \s-1ID\s0 based shared libraries are being used. +This is the default. +.IP "\fB\-mshared\-library\-id=n\fR" 4 +.IX Item "-mshared-library-id=n" +Specified the identification number of the \s-1ID\s0 based shared library being +compiled. Specifying a value of 0 will generate more compact code, specifying +other values will force the allocation of that number to the current +library but is no more space or time efficient than omitting this option. +.PP \fI\s-1CRIS\s0 Options\fR .IX Subsection "CRIS Options" .PP diff --git a/contrib/gcc-4.0/gcc/doc/gcc.1 b/contrib/gcc-4.0/gcc/doc/gcc.1 index 2f2eac94fe..a29b0cad41 100644 --- a/contrib/gcc-4.0/gcc/doc/gcc.1 +++ b/contrib/gcc-4.0/gcc/doc/gcc.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "GCC 1" -.TH GCC 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH GCC 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" gcc \- GNU project C and C++ compiler .SH "SYNOPSIS" @@ -214,7 +214,7 @@ in the following sections. \&\-fno\-default\-inline \-fvisibility\-inlines\-hidden \&\-Wabi \-Wctor\-dtor\-privacy \&\-Wnon\-virtual\-dtor \-Wreorder -\&\-Weffc++ \-Wno\-deprecated +\&\-Weffc++ \-Wno\-deprecated \-Wstrict\-null\-sentinel \&\-Wno\-non\-template\-friend \-Wold\-style\-cast \&\-Woverloaded\-virtual \-Wno\-pmf\-conversions \&\-Wsign\-promo\fR @@ -410,6 +410,11 @@ in the following sections. \&\fB\-mmcu=\fR\fImcu\fR \fB\-msize \-minit\-stack=\fR\fIn\fR \fB\-mno\-interrupts \&\-mcall\-prologues \-mno\-tablejump \-mtiny\-stack \-mint8\fR .Sp +\&\fIBlackfin Options\fR +\&\fB\-momit\-leaf\-frame\-pointer \-mno\-omit\-leaf\-frame\-pointer \-mcsync +\&\-mno\-csync \-mlow\-64k \-mno\-low64k \-mid\-shared\-library +\&\-mno\-id\-shared\-library \-mshared\-library\-id=\fR\fIn\fR\fB \fR +.Sp \&\fI\s-1CRIS\s0 Options\fR \&\fB\-mcpu=\fR\fIcpu\fR \fB\-march=\fR\fIcpu\fR \fB\-mtune=\fR\fIcpu\fR \&\fB\-mmax\-stack\-frame=\fR\fIn\fR \fB\-melinux\-stacksize=\fR\fIn\fR @@ -1471,7 +1476,7 @@ compatible with code generated by other compilers. .Sp The known incompatibilities at this point include: .RS 4 -.IP "\(bu" 4 +.IP "*" 4 Incorrect handling of tail-padding for bit\-fields. G++ may attempt to pack data into the same byte as a base class. For example: .Sp @@ -1485,7 +1490,7 @@ as\f(CW\*(C`A::f1\*(C'\fR; other compilers will not. You can avoid this problem by explicitly padding \f(CW\*(C`A\*(C'\fR so that its size is a multiple of the byte size on your platform; that will cause G++ and other compilers to layout \f(CW\*(C`B\*(C'\fR identically. -.IP "\(bu" 4 +.IP "*" 4 Incorrect handling of tail-padding for virtual bases. G++ does not use tail padding when laying out virtual bases. For example: .Sp @@ -1500,7 +1505,7 @@ In this case, G++ will not place \f(CW\*(C`B\*(C'\fR into the tail-padding for explicitly padding \f(CW\*(C`A\*(C'\fR so that its size is a multiple of its alignment (ignoring virtual base classes); that will cause G++ and other compilers to layout \f(CW\*(C`C\*(C'\fR identically. -.IP "\(bu" 4 +.IP "*" 4 Incorrect handling of bit-fields with declared widths greater than that of their underlying types, when the bit-fields appear in a union. For example: @@ -1511,7 +1516,7 @@ example: .Sp Assuming that an \f(CW\*(C`int\*(C'\fR does not have 4096 bits, G++ will make the union too small by the number of bits in an \f(CW\*(C`int\*(C'\fR. -.IP "\(bu" 4 +.IP "*" 4 Empty classes can be placed at incorrect offsets. For example: .Sp .Vb 1 @@ -1532,7 +1537,7 @@ Empty classes can be placed at incorrect offsets. For example: G++ will place the \f(CW\*(C`A\*(C'\fR base class of \f(CW\*(C`C\*(C'\fR at a nonzero offset; it should be placed at offset zero. G++ mistakenly believes that the \&\f(CW\*(C`A\*(C'\fR data member of \f(CW\*(C`B\*(C'\fR is already at offset zero. -.IP "\(bu" 4 +.IP "*" 4 Names of template functions whose types involve \f(CW\*(C`typename\*(C'\fR or template template parameters can be mangled incorrectly. .Sp @@ -1583,26 +1588,26 @@ The following \fB\-W...\fR options are not affected by \fB\-Wall\fR. Warn about violations of the following style guidelines from Scott Meyers' \&\fIEffective \*(C+\fR book: .RS 4 -.IP "\(bu" 4 +.IP "*" 4 Item 11: Define a copy constructor and an assignment operator for classes with dynamically allocated memory. -.IP "\(bu" 4 +.IP "*" 4 Item 12: Prefer initialization to assignment in constructors. -.IP "\(bu" 4 +.IP "*" 4 Item 14: Make destructors virtual in base classes. -.IP "\(bu" 4 +.IP "*" 4 Item 15: Have \f(CW\*(C`operator=\*(C'\fR return a reference to \f(CW*this\fR. -.IP "\(bu" 4 +.IP "*" 4 Item 23: Don't try to return a reference when you must return an object. .RE .RS 4 .Sp Also warn about violations of the following style guidelines from Scott Meyers' \fIMore Effective \*(C+\fR book: -.IP "\(bu" 4 +.IP "*" 4 Item 6: Distinguish between prefix and postfix forms of increment and decrement operators. -.IP "\(bu" 4 +.IP "*" 4 Item 7: Never overload \f(CW\*(C`&&\*(C'\fR, \f(CW\*(C`||\*(C'\fR, or \f(CW\*(C`,\*(C'\fR. .RE .RS 4 @@ -1614,6 +1619,13 @@ to filter out those warnings. .IP "\fB\-Wno\-deprecated\fR (\*(C+ only)" 4 .IX Item "-Wno-deprecated ( only)" Do not warn about usage of deprecated features. +.IP "\fB\-Wstrict\-null\-sentinel\fR (\*(C+ only)" 4 +.IX Item "-Wstrict-null-sentinel ( only)" +Warn also about the use of an uncasted \f(CW\*(C`NULL\*(C'\fR as sentinel. When +compiling only with \s-1GCC\s0 this is a valid sentinel, as \f(CW\*(C`NULL\*(C'\fR is defined +to \f(CW\*(C`_\|_null\*(C'\fR. Although it is a null pointer constant not a null pointer, +it is guaranteed to of the same size as a pointer. But this use is +not portable across different compilers. .IP "\fB\-Wno\-non\-template\-friend\fR (\*(C+ only)" 4 .IX Item "-Wno-non-template-friend ( only)" Disable warnings when non-templatized friend functions are declared @@ -1793,13 +1805,13 @@ of the \f(CW\*(C`finally\*(C'\fR clause in Java. .Sp There are several caveats to using the new exception mechanism: .RS 4 -.IP "\(bu" 4 +.IP "*" 4 Although currently designed to be binary compatible with \f(CW\*(C`NS_HANDLER\*(C'\fR\-style idioms provided by the \f(CW\*(C`NSException\*(C'\fR class, the new exceptions can only be used on Mac \s-1OS\s0 X 10.3 (Panther) and later systems, due to additional functionality needed in the (NeXT) Objective-C runtime. -.IP "\(bu" 4 +.IP "*" 4 As mentioned above, the new exceptions do not support handling types other than Objective-C objects. Furthermore, when used from Objective\-\*(C+, the Objective-C exception model does not interoperate with \*(C+ @@ -2327,11 +2339,13 @@ get these warnings. If you want to warn about code which uses the uninitialized value of the variable in its own initializer, use the \fB\-Winit\-self\fR option. .Sp -These warnings occur only for variables that are candidates for -register allocation. Therefore, they do not occur for a variable that -is declared \f(CW\*(C`volatile\*(C'\fR, or whose address is taken, or whose size -is other than 1, 2, 4 or 8 bytes. Also, they do not occur for -structures, unions or arrays, even when they are in registers. +These warnings occur for individual uninitialized or clobbered +elements of structure, union or array variables as well as for +variables which are uninitialized or clobbered as a whole. They do +not occur for variables or elements declared \f(CW\*(C`volatile\*(C'\fR. Because +these warnings depend on optimization, the exact variables or elements +for which there are warnings will depend on the precise optimization +options and version of \s-1GCC\s0 used. .Sp Note that there may be no warning about a variable that is used only to compute a value that itself is never used, because such @@ -2427,7 +2441,7 @@ the warning. supported, but the newer name is more descriptive.) Print extra warning messages for these events: .RS 4 -.IP "\(bu" 4 +.IP "*" 4 A function can return either with or without a value. (Falling off the end of the function body is considered returning without a value.) For example, this function would evoke such a @@ -2440,43 +2454,43 @@ warning: \& return a; \& } .Ve -.IP "\(bu" 4 +.IP "*" 4 An expression-statement or the left-hand side of a comma expression contains no side effects. To suppress the warning, cast the unused expression to void. For example, an expression such as \fBx[i,j]\fR will cause a warning, but \fBx[(void)i,j]\fR will not. -.IP "\(bu" 4 +.IP "*" 4 An unsigned value is compared against zero with \fB<\fR or \fB>=\fR. -.IP "\(bu" 4 +.IP "*" 4 Storage-class specifiers like \f(CW\*(C`static\*(C'\fR are not the first things in a declaration. According to the C Standard, this usage is obsolescent. -.IP "\(bu" 4 +.IP "*" 4 If \fB\-Wall\fR or \fB\-Wunused\fR is also specified, warn about unused arguments. -.IP "\(bu" 4 +.IP "*" 4 A comparison between signed and unsigned values could produce an incorrect result when the signed value is converted to unsigned. (But don't warn if \fB\-Wno\-sign\-compare\fR is also specified.) -.IP "\(bu" 4 +.IP "*" 4 An aggregate has an initializer which does not initialize all members. This warning can be independently controlled by \&\fB\-Wmissing\-field\-initializers\fR. -.IP "\(bu" 4 +.IP "*" 4 A function parameter is declared without a type specifier in K&R\-style functions: .Sp .Vb 1 \& void foo(bar) { } .Ve -.IP "\(bu" 4 +.IP "*" 4 An empty body occurs in an \fBif\fR or \fBelse\fR statement. -.IP "\(bu" 4 +.IP "*" 4 A pointer is compared against integer zero with \fB<\fR, \fB<=\fR, \&\fB>\fR, or \fB>=\fR. -.IP "\(bu" 4 +.IP "*" 4 A variable might be changed by \fBlongjmp\fR or \fBvfork\fR. -.IP "\(bu" 4 +.IP "*" 4 Any of several floating-point events that often indicate errors, such as overflow, underflow, loss of precision, etc. .IP "*<(\*(C+ only)>" 4 @@ -2536,11 +2550,11 @@ Warn about certain constructs that behave differently in traditional and \&\s-1ISO\s0 C. Also warn about \s-1ISO\s0 C constructs that have no traditional C equivalent, and/or problematic constructs which should be avoided. .RS 4 -.IP "\(bu" 4 +.IP "*" 4 Macro parameters that appear within string literals in the macro body. In traditional C macro replacement takes place within string literals, but does not in \s-1ISO\s0 C. -.IP "\(bu" 4 +.IP "*" 4 In traditional C, some preprocessor directives did not exist. Traditional preprocessors would only consider a line to be a directive if the \fB#\fR appeared in column 1 on the line. Therefore @@ -2550,11 +2564,11 @@ first character on the line. It also suggests you hide directives like \&\fB#pragma\fR not understood by traditional C by indenting them. Some traditional implementations would not recognize \fB#elif\fR, so it suggests avoiding it altogether. -.IP "\(bu" 4 +.IP "*" 4 A function-like macro that appears without arguments. -.IP "\(bu" 4 +.IP "*" 4 The unary plus operator. -.IP "\(bu" 4 +.IP "*" 4 The \fBU\fR integer constant suffix, or the \fBF\fR or \fBL\fR floating point constant suffixes. (Traditional C does support the \fBL\fR suffix on integer constants.) Note, these suffixes appear in macros defined in the system @@ -2562,38 +2576,38 @@ headers of most modern systems, e.g. the \fB_MIN\fR/\fB_MAX\fR macros in \f(CW\* Use of these macros in user code might normally lead to spurious warnings, however \s-1GCC\s0's integrated preprocessor has enough context to avoid warning in these cases. -.IP "\(bu" 4 +.IP "*" 4 A function declared external in one block and then used after the end of the block. -.IP "\(bu" 4 +.IP "*" 4 A \f(CW\*(C`switch\*(C'\fR statement has an operand of type \f(CW\*(C`long\*(C'\fR. -.IP "\(bu" 4 +.IP "*" 4 A non\-\f(CW\*(C`static\*(C'\fR function declaration follows a \f(CW\*(C`static\*(C'\fR one. This construct is not accepted by some traditional C compilers. -.IP "\(bu" 4 +.IP "*" 4 The \s-1ISO\s0 type of an integer constant has a different width or signedness from its traditional type. This warning is only issued if the base of the constant is ten. I.e. hexadecimal or octal values, which typically represent bit patterns, are not warned about. -.IP "\(bu" 4 +.IP "*" 4 Usage of \s-1ISO\s0 string concatenation is detected. -.IP "\(bu" 4 +.IP "*" 4 Initialization of automatic aggregates. -.IP "\(bu" 4 +.IP "*" 4 Identifier conflicts with labels. Traditional C lacks a separate namespace for labels. -.IP "\(bu" 4 +.IP "*" 4 Initialization of unions. If the initializer is zero, the warning is omitted. This is done under the assumption that the zero initializer in user code appears conditioned on e.g. \f(CW\*(C`_\|_STDC_\|_\*(C'\fR to avoid missing initializer warnings and relies on default initialization to zero in the traditional C case. -.IP "\(bu" 4 +.IP "*" 4 Conversions by prototypes between fixed/floating point values and vice versa. The absence of these prototypes when compiling with traditional C would cause serious problems. This is a subset of the possible conversion warnings, for the full set use \fB\-Wconversion\fR. -.IP "\(bu" 4 +.IP "*" 4 Use of \s-1ISO\s0 C style function definitions. This warning intentionally is \&\fInot\fR issued for prototype declarations or variadic functions because these \s-1ISO\s0 C features will appear in your code when using @@ -4603,13 +4617,13 @@ This allows some extra optimizations to take place but consumes more memory (in general). There are some compatibility issues with \fIunit-at-at-time\fR mode: .RS 4 -.IP "\(bu" 4 +.IP "*" 4 enabling \fIunit-at-a-time\fR mode may change the order in which functions, variables, and top-level \f(CW\*(C`asm\*(C'\fR statements are emitted, and will likely break code relying on some particular ordering. The majority of such top-level \f(CW\*(C`asm\*(C'\fR statements, though, can be replaced by \f(CW\*(C`section\*(C'\fR attributes. -.IP "\(bu" 4 +.IP "*" 4 \&\fIunit-at-a-time\fR mode removes unreferenced static variables and functions are removed. This may result in undefined references when an \f(CW\*(C`asm\*(C'\fR statement refers directly to variables or functions @@ -4617,7 +4631,7 @@ that are otherwise unused. In that case either the variable/function shall be listed as an operand of the \f(CW\*(C`asm\*(C'\fR statement operand or, in the case of top-level \f(CW\*(C`asm\*(C'\fR statements the attribute \f(CW\*(C`used\*(C'\fR shall be used on the declaration. -.IP "\(bu" 4 +.IP "*" 4 Static functions now can use non-standard passing conventions that may break \f(CW\*(C`asm\*(C'\fR statements calling functions directly. Again, attribute \f(CW\*(C`used\*(C'\fR will prevent this behavior. @@ -5144,6 +5158,10 @@ induction variable uses. If number of candidates in the set is smaller than this value, we always try to remove unnecessary ivs from the set during its optimization when a new iv is added to the set. +.IP "\fBscev-max-expr-size\fR" 4 +.IX Item "scev-max-expr-size" +Bound on size of expressions used in the scalar evolutions analyzer. +Large expressions slow the analyzer. .IP "\fBmax-iterations-to-track\fR" 4 .IX Item "max-iterations-to-track" The maximum number of iterations of a loop the brute force algorithm @@ -6652,6 +6670,46 @@ and long long will be 4 bytes. Please note that this option does not comply to the C standards, but it will provide you with smaller code size. .PP +\fIBlackfin Options\fR +.IX Subsection "Blackfin Options" +.IP "\fB\-momit\-leaf\-frame\-pointer\fR" 4 +.IX Item "-momit-leaf-frame-pointer" +Don't keep the frame pointer in a register for leaf functions. This +avoids the instructions to save, set up and restore frame pointers and +makes an extra register available in leaf functions. The option +\&\fB\-fomit\-frame\-pointer\fR removes the frame pointer for all functions +which might make debugging harder. +.IP "\fB\-mcsync\fR" 4 +.IX Item "-mcsync" +When enabled, the compiler will ensure that the generated code does not +contain speculative loads after jump instructions. This option is enabled +by default. +.IP "\fB\-mno\-csync\fR" 4 +.IX Item "-mno-csync" +Don't generate extra code to prevent speculative loads from occurring. +.IP "\fB\-mlow\-64k\fR" 4 +.IX Item "-mlow-64k" +When enabled, the compiler is free to take advantage of the knowledge that +the entire program fits into the low 64k of memory. +.IP "\fB\-mno\-low\-64k\fR" 4 +.IX Item "-mno-low-64k" +Assume that the program is arbitrarily large. This is the default. +.IP "\fB\-mid\-shared\-library\fR" 4 +.IX Item "-mid-shared-library" +Generate code that supports shared libraries via the library \s-1ID\s0 method. +This allows for execute in place and shared libraries in an environment +without virtual memory management. This option implies \fB\-fPIC\fR. +.IP "\fB\-mno\-id\-shared\-library\fR" 4 +.IX Item "-mno-id-shared-library" +Generate code that doesn't assume \s-1ID\s0 based shared libraries are being used. +This is the default. +.IP "\fB\-mshared\-library\-id=n\fR" 4 +.IX Item "-mshared-library-id=n" +Specified the identification number of the \s-1ID\s0 based shared library being +compiled. Specifying a value of 0 will generate more compact code, specifying +other values will force the allocation of that number to the current +library but is no more space or time efficient than omitting this option. +.PP \fI\s-1CRIS\s0 Options\fR .IX Subsection "CRIS Options" .PP diff --git a/contrib/gcc-4.0/gcc/doc/gcc.info b/contrib/gcc-4.0/gcc/doc/gcc.info index 6380b8cf56..9129ad061d 100644 --- a/contrib/gcc-4.0/gcc/doc/gcc.info +++ b/contrib/gcc-4.0/gcc/doc/gcc.info @@ -1,5 +1,5 @@ -This is doc/gcc.info, produced by makeinfo version 4.7 from -/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/doc/gcc.texi. +This is doc/gcc.info, produced by makeinfo version 4.8 from +/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/doc/gcc.texi. Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. @@ -58,7 +58,7 @@ Introduction This manual documents how to use the GNU compilers, as well as their features and incompatibilities, and how to report bugs. It corresponds -to GCC version 4.0.0. The internals of the GNU compilers, including +to GCC version 4.0.1. The internals of the GNU compilers, including how to port them to new targets and some information about how to write front ends for new languages, are documented in a separate manual. *Note Introduction: (gccint)Top. @@ -387,7 +387,7 @@ _C++ Language Options_ -fno-default-inline -fvisibility-inlines-hidden -Wabi -Wctor-dtor-privacy -Wnon-virtual-dtor -Wreorder - -Weffc++ -Wno-deprecated + -Weffc++ -Wno-deprecated -Wstrict-null-sentinel -Wno-non-template-friend -Wold-style-cast -Woverloaded-virtual -Wno-pmf-conversions -Wsign-promo @@ -597,6 +597,11 @@ _Machine Dependent Options_ -mmcu=MCU -msize -minit-stack=N -mno-interrupts -mcall-prologues -mno-tablejump -mtiny-stack -mint8 + _Blackfin Options_ + -momit-leaf-frame-pointer -mno-omit-leaf-frame-pointer -mcsync + -mno-csync -mlow-64k -mno-low64k -mid-shared-library + -mno-id-shared-library -mshared-library-id=N + _CRIS Options_ -mcpu=CPU -march=CPU -mtune=CPU -mmax-stack-frame=N -melinux-stacksize=N @@ -1791,6 +1796,13 @@ have meanings only for C++ programs: Do not warn about usage of deprecated features. *Note Deprecated Features::. +`-Wstrict-null-sentinel (C++ only)' + Warn also about the use of an uncasted `NULL' as sentinel. When + compiling only with GCC this is a valid sentinel, as `NULL' is + defined to `__null'. Although it is a null pointer constant not a + null pointer, it is guaranteed to of the same size as a pointer. + But this use is not portable across different compilers. + `-Wno-non-template-friend (C++ only)' Disable warnings when non-templatized friend functions are declared within a template. Since the advent of explicit template @@ -2511,11 +2523,13 @@ Options::. of the variable in its own initializer, use the `-Winit-self' option. - These warnings occur only for variables that are candidates for - register allocation. Therefore, they do not occur for a variable - that is declared `volatile', or whose address is taken, or whose - size is other than 1, 2, 4 or 8 bytes. Also, they do not occur for - structures, unions or arrays, even when they are in registers. + These warnings occur for individual uninitialized or clobbered + elements of structure, union or array variables as well as for + variables which are uninitialized or clobbered as a whole. They do + not occur for variables or elements declared `volatile'. Because + these warnings depend on optimization, the exact variables or + elements for which there are warnings will depend on the precise + optimization options and version of GCC used. Note that there may be no warning about a variable that is used only to compute a value that itself is never used, because such @@ -5240,6 +5254,10 @@ includes experimental options that may produce broken code. we always try to remove unnecessary ivs from the set during its optimization when a new iv is added to the set. + `scev-max-expr-size' + Bound on size of expressions used in the scalar evolutions + analyzer. Large expressions slow the analyzer. + `max-iterations-to-track' The maximum number of iterations of a loop the brute force algorithm for analysis of # of iterations of the loop tries @@ -6846,6 +6864,7 @@ that macro, which enables you to change the defaults. * ARC Options:: * ARM Options:: * AVR Options:: +* Blackfin Options:: * CRIS Options:: * Darwin Options:: * DEC Alpha Options:: @@ -7161,7 +7180,7 @@ architectures:  -File: gcc.info, Node: AVR Options, Next: CRIS Options, Prev: ARM Options, Up: Submodel Options +File: gcc.info, Node: AVR Options, Next: Blackfin Options, Prev: ARM Options, Up: Submodel Options 3.17.3 AVR Options ------------------ @@ -7220,9 +7239,55 @@ These options are defined for AVR implementations: with smaller code size.  -File: gcc.info, Node: CRIS Options, Next: Darwin Options, Prev: AVR Options, Up: Submodel Options +File: gcc.info, Node: Blackfin Options, Next: CRIS Options, Prev: AVR Options, Up: Submodel Options + +3.17.4 Blackfin Options +----------------------- + +`-momit-leaf-frame-pointer' + Don't keep the frame pointer in a register for leaf functions. + This avoids the instructions to save, set up and restore frame + pointers and makes an extra register available in leaf functions. + The option `-fomit-frame-pointer' removes the frame pointer for + all functions which might make debugging harder. + +`-mcsync' + When enabled, the compiler will ensure that the generated code + does not contain speculative loads after jump instructions. This + option is enabled by default. + +`-mno-csync' + Don't generate extra code to prevent speculative loads from + occurring. + +`-mlow-64k' + When enabled, the compiler is free to take advantage of the + knowledge that the entire program fits into the low 64k of memory. -3.17.4 CRIS Options +`-mno-low-64k' + Assume that the program is arbitrarily large. This is the default. + +`-mid-shared-library' + Generate code that supports shared libraries via the library ID + method. This allows for execute in place and shared libraries in + an environment without virtual memory management. This option + implies `-fPIC'. + +`-mno-id-shared-library' + Generate code that doesn't assume ID based shared libraries are + being used. This is the default. + +`-mshared-library-id=n' + Specified the identification number of the ID based shared library + being compiled. Specifying a value of 0 will generate more + compact code, specifying other values will force the allocation of + that number to the current library but is no more space or time + efficient than omitting this option. + + +File: gcc.info, Node: CRIS Options, Next: Darwin Options, Prev: Blackfin Options, Up: Submodel Options + +3.17.5 CRIS Options ------------------- These options are defined specifically for the CRIS ports. @@ -7339,7 +7404,7 @@ These options are defined specifically for the CRIS ports.  File: gcc.info, Node: Darwin Options, Next: DEC Alpha Options, Prev: CRIS Options, Up: Submodel Options -3.17.5 Darwin Options +3.17.6 Darwin Options --------------------- These options are defined for all architectures running the Darwin @@ -7516,7 +7581,7 @@ its input files.  File: gcc.info, Node: DEC Alpha Options, Next: DEC Alpha/VMS Options, Prev: Darwin Options, Up: Submodel Options -3.17.6 DEC Alpha Options +3.17.7 DEC Alpha Options ------------------------ These `-m' options are defined for the DEC Alpha implementations: @@ -7802,7 +7867,7 @@ These `-m' options are defined for the DEC Alpha implementations:  File: gcc.info, Node: DEC Alpha/VMS Options, Next: FRV Options, Prev: DEC Alpha Options, Up: Submodel Options -3.17.7 DEC Alpha/VMS Options +3.17.8 DEC Alpha/VMS Options ---------------------------- These `-m' options are defined for the DEC Alpha/VMS implementations: @@ -7814,7 +7879,7 @@ These `-m' options are defined for the DEC Alpha/VMS implementations:  File: gcc.info, Node: FRV Options, Next: H8/300 Options, Prev: DEC Alpha/VMS Options, Up: Submodel Options -3.17.8 FRV Options +3.17.9 FRV Options ------------------ `-mgpr-32' @@ -8023,8 +8088,8 @@ File: gcc.info, Node: FRV Options, Next: H8/300 Options, Prev: DEC Alpha/VMS  File: gcc.info, Node: H8/300 Options, Next: HPPA Options, Prev: FRV Options, Up: Submodel Options -3.17.9 H8/300 Options ---------------------- +3.17.10 H8/300 Options +---------------------- These `-m' options are defined for the H8/300 implementations: @@ -8060,7 +8125,7 @@ These `-m' options are defined for the H8/300 implementations:  File: gcc.info, Node: HPPA Options, Next: i386 and x86-64 Options, Prev: H8/300 Options, Up: Submodel Options -3.17.10 HPPA Options +3.17.11 HPPA Options -------------------- These `-m' options are defined for the HPPA family of computers: @@ -8267,7 +8332,7 @@ These `-m' options are defined for the HPPA family of computers:  File: gcc.info, Node: i386 and x86-64 Options, Next: IA-64 Options, Prev: HPPA Options, Up: Submodel Options -3.17.11 Intel 386 and AMD x86-64 Options +3.17.12 Intel 386 and AMD x86-64 Options ---------------------------------------- These `-m' options are defined for the i386 and x86-64 family of @@ -8695,7 +8760,7 @@ x86-64 processors in 64-bit environments.  File: gcc.info, Node: IA-64 Options, Next: M32R/D Options, Prev: i386 and x86-64 Options, Up: Submodel Options -3.17.12 IA-64 Options +3.17.13 IA-64 Options --------------------- These are the `-m' options defined for the Intel IA-64 architecture. @@ -8815,7 +8880,7 @@ These are the `-m' options defined for the Intel IA-64 architecture.  File: gcc.info, Node: M32R/D Options, Next: M680x0 Options, Prev: IA-64 Options, Up: Submodel Options -3.17.13 M32R/D Options +3.17.14 M32R/D Options ---------------------- These `-m' options are defined for Renesas M32R/D architectures: @@ -8917,7 +8982,7 @@ These `-m' options are defined for Renesas M32R/D architectures:  File: gcc.info, Node: M680x0 Options, Next: M68hc1x Options, Prev: M32R/D Options, Up: Submodel Options -3.17.14 M680x0 Options +3.17.15 M680x0 Options ---------------------- These are the `-m' options defined for the 68000 series. The default @@ -9096,7 +9161,7 @@ choices are given below.  File: gcc.info, Node: M68hc1x Options, Next: MCore Options, Prev: M680x0 Options, Up: Submodel Options -3.17.15 M68hc1x Options +3.17.16 M68hc1x Options ----------------------- These are the `-m' options defined for the 68hc11 and 68hc12 @@ -9145,7 +9210,7 @@ configured; the defaults for the most common choices are given below.  File: gcc.info, Node: MCore Options, Next: MIPS Options, Prev: M68hc1x Options, Up: Submodel Options -3.17.16 MCore Options +3.17.17 MCore Options --------------------- These are the `-m' options defined for the Motorola M*Core processors. @@ -9190,7 +9255,7 @@ These are the `-m' options defined for the Motorola M*Core processors.  File: gcc.info, Node: MIPS Options, Next: MMIX Options, Prev: MCore Options, Up: Submodel Options -3.17.17 MIPS Options +3.17.18 MIPS Options -------------------- `-EB' @@ -9566,7 +9631,7 @@ File: gcc.info, Node: MIPS Options, Next: MMIX Options, Prev: MCore Options,  File: gcc.info, Node: MMIX Options, Next: MN10300 Options, Prev: MIPS Options, Up: Submodel Options -3.17.18 MMIX Options +3.17.19 MMIX Options -------------------- These options are defined for the MMIX: @@ -9635,7 +9700,7 @@ These options are defined for the MMIX:  File: gcc.info, Node: MN10300 Options, Next: NS32K Options, Prev: MMIX Options, Up: Submodel Options -3.17.19 MN10300 Options +3.17.20 MN10300 Options ----------------------- These `-m' options are defined for Matsushita MN10300 architectures: @@ -9669,7 +9734,7 @@ These `-m' options are defined for Matsushita MN10300 architectures:  File: gcc.info, Node: NS32K Options, Next: PDP-11 Options, Prev: MN10300 Options, Up: Submodel Options -3.17.20 NS32K Options +3.17.21 NS32K Options --------------------- These are the `-m' options defined for the 32000 series. The default @@ -9791,7 +9856,7 @@ choices are given below.  File: gcc.info, Node: PDP-11 Options, Next: PowerPC Options, Prev: NS32K Options, Up: Submodel Options -3.17.21 PDP-11 Options +3.17.22 PDP-11 Options ---------------------- These options are defined for the PDP-11: @@ -9872,7 +9937,7 @@ These options are defined for the PDP-11:  File: gcc.info, Node: PowerPC Options, Next: RS/6000 and PowerPC Options, Prev: PDP-11 Options, Up: Submodel Options -3.17.22 PowerPC Options +3.17.23 PowerPC Options ----------------------- These are listed under *Note RS/6000 and PowerPC Options::. @@ -9880,7 +9945,7 @@ These are listed under *Note RS/6000 and PowerPC Options::.  File: gcc.info, Node: RS/6000 and PowerPC Options, Next: S/390 and zSeries Options, Prev: PowerPC Options, Up: Submodel Options -3.17.23 IBM RS/6000 and PowerPC Options +3.17.24 IBM RS/6000 and PowerPC Options --------------------------------------- These `-m' options are defined for the IBM RS/6000 and PowerPC: @@ -10465,7 +10530,7 @@ These `-m' options are defined for the IBM RS/6000 and PowerPC:  File: gcc.info, Node: S/390 and zSeries Options, Next: SH Options, Prev: RS/6000 and PowerPC Options, Up: Submodel Options -3.17.24 S/390 and zSeries Options +3.17.25 S/390 and zSeries Options --------------------------------- These are the `-m' options defined for the S/390 and zSeries @@ -10619,7 +10684,7 @@ architecture.  File: gcc.info, Node: SH Options, Next: SPARC Options, Prev: S/390 and zSeries Options, Up: Submodel Options -3.17.25 SH Options +3.17.26 SH Options ------------------ These `-m' options are defined for the SH implementations: @@ -10738,7 +10803,7 @@ These `-m' options are defined for the SH implementations:  File: gcc.info, Node: SPARC Options, Next: System V Options, Prev: SH Options, Up: Submodel Options -3.17.26 SPARC Options +3.17.27 SPARC Options --------------------- These `-m' options are supported on the SPARC: @@ -10975,7 +11040,7 @@ processors in 64-bit environments:  File: gcc.info, Node: System V Options, Next: TMS320C3x/C4x Options, Prev: SPARC Options, Up: Submodel Options -3.17.27 Options for System V +3.17.28 Options for System V ---------------------------- These additional options are available on System V Release 4 for @@ -11004,7 +11069,7 @@ compatibility with other compilers on those systems:  File: gcc.info, Node: TMS320C3x/C4x Options, Next: V850 Options, Prev: System V Options, Up: Submodel Options -3.17.28 TMS320C3x/C4x Options +3.17.29 TMS320C3x/C4x Options ----------------------------- These `-m' options are defined for TMS320C3x/C4x implementations: @@ -11130,7 +11195,7 @@ These `-m' options are defined for TMS320C3x/C4x implementations:  File: gcc.info, Node: V850 Options, Next: VAX Options, Prev: TMS320C3x/C4x Options, Up: Submodel Options -3.17.29 V850 Options +3.17.30 V850 Options -------------------- These `-m' options are defined for V850 implementations: @@ -11216,7 +11281,7 @@ These `-m' options are defined for V850 implementations:  File: gcc.info, Node: VAX Options, Next: x86-64 Options, Prev: V850 Options, Up: Submodel Options -3.17.30 VAX Options +3.17.31 VAX Options ------------------- These `-m' options are defined for the VAX: @@ -11236,7 +11301,7 @@ These `-m' options are defined for the VAX:  File: gcc.info, Node: x86-64 Options, Next: Xstormy16 Options, Prev: VAX Options, Up: Submodel Options -3.17.31 x86-64 Options +3.17.32 x86-64 Options ---------------------- These are listed under *Note i386 and x86-64 Options::. @@ -11244,7 +11309,7 @@ These are listed under *Note i386 and x86-64 Options::.  File: gcc.info, Node: Xstormy16 Options, Next: Xtensa Options, Prev: x86-64 Options, Up: Submodel Options -3.17.32 Xstormy16 Options +3.17.33 Xstormy16 Options ------------------------- These options are defined for Xstormy16: @@ -11255,7 +11320,7 @@ These options are defined for Xstormy16:  File: gcc.info, Node: Xtensa Options, Next: zSeries Options, Prev: Xstormy16 Options, Up: Submodel Options -3.17.33 Xtensa Options +3.17.34 Xtensa Options ---------------------- These options are supported for Xtensa targets: @@ -11330,7 +11395,7 @@ These options are supported for Xtensa targets:  File: gcc.info, Node: zSeries Options, Prev: Xtensa Options, Up: Submodel Options -3.17.34 zSeries Options +3.17.35 zSeries Options ----------------------- These are listed under *Note S/390 and zSeries Options::. @@ -14223,6 +14288,12 @@ attributes. You must use GAS and GLD from GNU binutils version 2.7 or later for this attribute to work correctly. +`exception_handler' + Use this attribute on the Blackfin to indicate that the specified + function is an exception handler. The compiler will generate + function entry and exit sequences suitable for use in an exception + handler when this attribute is present. + `far' On 68HC11 and 68HC12 the `far' attribute causes the compiler to use a calling convention that takes care of switching memory banks @@ -14356,9 +14427,9 @@ attributes. sequences suitable for use in an interrupt handler when this attribute is present. - Note, interrupt handlers for the m68k, H8/300, H8/300H, H8S, and - SH processors can be specified via the `interrupt_handler' - attribute. + Note, interrupt handlers for the Blackfin, m68k, H8/300, H8/300H, + H8S, and SH processors can be specified via the + `interrupt_handler' attribute. Note, on the AVR, interrupts will be enabled inside the function. @@ -14372,10 +14443,16 @@ attributes. and UNDEF. `interrupt_handler' - Use this attribute on the m68k, H8/300, H8/300H, H8S, and SH to - indicate that the specified function is an interrupt handler. The - compiler will generate function entry and exit sequences suitable - for use in an interrupt handler when this attribute is present. + Use this attribute on the Blackfin, m68k, H8/300, H8/300H, H8S, + and SH to indicate that the specified function is an interrupt + handler. The compiler will generate function entry and exit + sequences suitable for use in an interrupt handler when this + attribute is present. + +`kspisusp' + When used together with `interrupt_handler', `exception_handler' + or `nmi_handler', code will be generated to load the stack pointer + from the USP register in the function prologue. `long_call/short_call' This attribute specifies how a particular function is called on @@ -14448,6 +14525,17 @@ attributes. attribute can be used to cancel the effect of the `-mlong-calls' option. +`nesting' + Use this attribute together with `interrupt_handler', + `exception_handler' or `nmi_handler' to indicate that the function + entry code should enable nested interrupts or exceptions. + +`nmi_handler' + Use this attribute on the Blackfin to indicate that the specified + function is an NMI handler. The compiler will generate function + entry and exit sequences suitable for use in an NMI handler when + this attribute is present. + `no_instrument_function' If `-finstrument-functions' is given, profiling function calls will be generated at entry and exit of most user-compiled functions. @@ -14570,9 +14658,9 @@ attributes. loader if desired, to avoid the problem.) `saveall' - Use this attribute on the H8/300, H8/300H, and H8S to indicate that - all registers except the stack pointer should be saved in the - prologue regardless of whether they are used or not. + Use this attribute on the Blackfin, H8/300, H8/300H, and H8S to + indicate that all registers except the stack pointer should be + saved in the prologue regardless of whether they are used or not. `section ("SECTION-NAME")' Normally, the compiler places the code it generates in the `text' @@ -15541,7 +15629,7 @@ attributes. int i; }; - struct my_packed_struct __attribute__ ((__packed__)) + struct __attribute__ ((__packed__)) my_packed_struct { char c; int i; @@ -16998,6 +17086,104 @@ _FRV--`frv.h'_ zero--i.e. in the range of 1 to 2047. +_Blackfin family--`bfin.h'_ + + `a' + P register + + `d' + D register + + `z' + A call clobbered P register. + + `D' + Even-numbered D register + + `W' + Odd-numbered D register + + `e' + Accumulator register. + + `A' + Even-numbered accumulator register. + + `B' + Odd-numbered accumulator register. + + `b' + I register + + `B' + B register + + `f' + M register + + `c' + Registers used for circular buffering, i.e. I, B, or L + registers. + + `C' + The CC register. + + `x' + Any D, P, B, M, I or L register. + + `y' + Additional registers typically used only in prologues and + epilogues: RETS, RETN, RETI, RETX, RETE, ASTAT, SEQSTAT and + USP. + + `w' + Any register except accumulators or CC. + + `Ksh' + Signed 16 bit integer (in the range -32768 to 32767) + + `Kuh' + Unsigned 16 bit integer (in the range 0 to 65535) + + `Ks7' + Signed 7 bit integer (in the range -64 to 63) + + `Ku7' + Unsigned 7 bit integer (in the range 0 to 127) + + `Ku5' + Unsigned 5 bit integer (in the range 0 to 31) + + `Ks4' + Signed 4 bit integer (in the range -8 to 7) + + `Ks3' + Signed 3 bit integer (in the range -3 to 4) + + `Ku3' + Unsigned 3 bit integer (in the range 0 to 7) + + `PN' + Constant N, where N is a single-digit constant in the range 0 + to 4. + + `M1' + Constant 255. + + `M2' + Constant 65535. + + `J' + An integer constant with exactly a single bit set. + + `L' + An integer constant with all bits set except exactly one. + + `H' + + `Q' + Any SYMBOL_REF. + _IP2K--`ip2k.h'_ `a' @@ -26029,6 +26215,9 @@ alphabetical order. the support for System V Release 4. He has also worked heavily on the Intel 386 and 860 support. + * Mostafa Hagog for Swing Modulo Scheduling (SMS) and post reload + GCSE. + * Bruno Haible for improvements in the runtime overhead for EH, new warnings and assorted bug fixes. @@ -26532,6 +26721,8 @@ alphabetical order. * Kevin Zachmann helped port GCC to the Tahoe. + * Ayal Zaks for Swing Modulo Scheduling (SMS). + * Xiaoqiang Zhang for work on gfortran. * Gilles Zunino for help porting Java to Irix. @@ -27033,7 +27224,7 @@ look up both forms. * fforce-addr: Optimize Options. (line 156) * fforce-mem: Optimize Options. (line 147) * ffreestanding <1>: Function Attributes. - (line 255) + (line 261) * ffreestanding <2>: Warning Options. (line 94) * ffreestanding <3>: C Dialect Options. (line 169) * ffreestanding: Standards. (line 81) @@ -27054,7 +27245,7 @@ look up both forms. * finput-charset: Preprocessor Options. (line 467) * finstrument-functions <1>: Function Attributes. - (line 424) + (line 447) * finstrument-functions: Code Gen Options. (line 260) * fkeep-inline-functions <1>: Inline. (line 51) * fkeep-inline-functions: Optimize Options. (line 237) @@ -27083,7 +27274,7 @@ look up both forms. * fno-branch-count-reg: Optimize Options. (line 278) * fno-builtin <1>: Other Builtins. (line 14) * fno-builtin <2>: Function Attributes. - (line 255) + (line 261) * fno-builtin <3>: Warning Options. (line 94) * fno-builtin: C Dialect Options. (line 128) * fno-common <1>: Variable Attributes. @@ -27544,6 +27735,7 @@ look up both forms. * mcpu <8>: ARM Options. (line 84) * mcpu: ARC Options. (line 23) * mcpu32: M680x0 Options. (line 51) +* mcsync: Blackfin Options. (line 14) * MD: Preprocessor Options. (line 261) * mdalign: SH Options. (line 64) @@ -27663,6 +27855,7 @@ look up both forms. * mhardlit: MCore Options. (line 10) * mhimem: NS32K Options. (line 111) * mhitachi: SH Options. (line 81) +* mid-shared-library: Blackfin Options. (line 30) * mieee <1>: SH Options. (line 96) * mieee: DEC Alpha Options. (line 39) * mieee-compare: NS32K Options. (line 55) @@ -27734,6 +27927,7 @@ look up both forms. * mlongcalls: Xtensa Options. (line 60) * mloop-unsigned: TMS320C3x/C4x Options. (line 94) +* mlow-64k: Blackfin Options. (line 23) * mlp64: IA-64 Options. (line 114) * MM: Preprocessor Options. (line 197) @@ -27809,6 +28003,7 @@ look up both forms. * mno-const-align: CRIS Options. (line 60) * mno-const16: Xtensa Options. (line 10) * mno-crt0: MN10300 Options. (line 24) +* mno-csync: Blackfin Options. (line 19) * mno-data-align: CRIS Options. (line 60) * mno-db: TMS320C3x/C4x Options. (line 32) @@ -27855,6 +28050,7 @@ look up both forms. * mno-gnu-ld: IA-64 Options. (line 23) * mno-gotplt: CRIS Options. (line 86) * mno-hardlit: MCore Options. (line 10) +* mno-id-shared-library: Blackfin Options. (line 36) * mno-ieee-compare: NS32K Options. (line 55) * mno-ieee-fp: i386 and x86-64 Options. (line 164) @@ -27873,6 +28069,7 @@ look up both forms. * mno-longcalls: Xtensa Options. (line 60) * mno-loop-unsigned: TMS320C3x/C4x Options. (line 94) +* mno-low-64k: Blackfin Options. (line 27) * mno-mad: MIPS Options. (line 268) * mno-max: DEC Alpha Options. (line 171) * mno-media: FRV Options. (line 47) @@ -27991,8 +28188,9 @@ look up both forms. * mnosb: NS32K Options. (line 105) * mold-mnemonics: RS/6000 and PowerPC Options. (line 67) -* momit-leaf-frame-pointer: i386 and x86-64 Options. +* momit-leaf-frame-pointer <1>: i386 and x86-64 Options. (line 370) +* momit-leaf-frame-pointer: Blackfin Options. (line 7) * MP: Preprocessor Options. (line 226) * mpa-risc-1-0: HPPA Options. (line 19) @@ -28096,6 +28294,7 @@ look up both forms. * msdata=sysv: RS/6000 and PowerPC Options. (line 509) * msdata=use: M32R/D Options. (line 53) +* mshared-library-id: Blackfin Options. (line 40) * mshort <1>: M68hc1x Options. (line 40) * mshort: M680x0 Options. (line 90) * msim <1>: Xstormy16 Options. (line 9) @@ -28381,19 +28580,19 @@ look up both forms. * W: Incompatibilities. (line 64) * w: Preprocessor Options. (line 159) -* W: Warning Options. (line 511) +* W: Warning Options. (line 513) * w: Warning Options. (line 73) * Wa: Assembler Options. (line 9) * Wabi: C++ Dialect Options. (line 212) -* Waggregate-return: Warning Options. (line 765) +* Waggregate-return: Warning Options. (line 767) * Wall <1>: Standard Libraries. (line 6) * Wall <2>: Preprocessor Options. (line 78) -* Wall: Warning Options. (line 495) -* Wbad-function-cast: Warning Options. (line 719) -* Wcast-align: Warning Options. (line 728) -* Wcast-qual: Warning Options. (line 723) +* Wall: Warning Options. (line 497) +* Wbad-function-cast: Warning Options. (line 721) +* Wcast-align: Warning Options. (line 730) +* Wcast-qual: Warning Options. (line 725) * Wchar-subscripts: Warning Options. (line 79) * Wcomment <1>: Preprocessor Options. (line 86) @@ -28401,30 +28600,30 @@ look up both forms. * Wcomments: Preprocessor Options. (line 86) * Wconversion <1>: Protoize Caveats. (line 31) -* Wconversion: Warning Options. (line 745) +* Wconversion: Warning Options. (line 747) * Wctor-dtor-privacy: C++ Dialect Options. (line 290) -* Wdeclaration-after-statement: Warning Options. (line 691) -* Wdisabled-optimization: Warning Options. (line 937) -* Wdiv-by-zero: Warning Options. (line 583) +* Wdeclaration-after-statement: Warning Options. (line 693) +* Wdisabled-optimization: Warning Options. (line 939) +* Wdiv-by-zero: Warning Options. (line 585) * weak_reference_mismatches: Darwin Options. (line 174) * Weffc++: C++ Dialect Options. (line 316) * Wendif-labels <1>: Preprocessor Options. (line 136) -* Wendif-labels: Warning Options. (line 701) +* Wendif-labels: Warning Options. (line 703) * Werror <1>: Preprocessor Options. (line 149) -* Werror: Warning Options. (line 952) +* Werror: Warning Options. (line 954) * Werror-implicit-function-declaration: Warning Options. (line 198) -* Wextra: Warning Options. (line 511) +* Wextra: Warning Options. (line 513) * Wfatal-errors: Warning Options. (line 89) -* Wfloat-equal: Warning Options. (line 599) +* Wfloat-equal: Warning Options. (line 601) * Wformat <1>: Function Attributes. - (line 222) + (line 228) * Wformat: Warning Options. (line 94) * Wformat-nonliteral <1>: Function Attributes. - (line 275) + (line 281) * Wformat-nonliteral: Warning Options. (line 151) * Wformat-security: Warning Options. (line 156) * Wformat-y2k: Warning Options. (line 129) @@ -28438,80 +28637,82 @@ look up both forms. (line 109) * Winit-self: Warning Options. (line 179) * Winline <1>: Inline. (line 35) -* Winline: Warning Options. (line 894) -* Winvalid-pch: Warning Options. (line 921) +* Winline: Warning Options. (line 896) +* Winvalid-pch: Warning Options. (line 923) * Wl: Link Options. (line 168) -* Wlarger-than: Warning Options. (line 710) -* Wlong-long: Warning Options. (line 925) +* Wlarger-than: Warning Options. (line 712) +* Wlong-long: Warning Options. (line 927) * Wmain: Warning Options. (line 208) * Wmissing-braces: Warning Options. (line 214) -* Wmissing-declarations: Warning Options. (line 786) -* Wmissing-field-initializers: Warning Options. (line 792) -* Wmissing-format-attribute: Warning Options. (line 818) +* Wmissing-declarations: Warning Options. (line 788) +* Wmissing-field-initializers: Warning Options. (line 794) +* Wmissing-format-attribute: Warning Options. (line 820) * Wmissing-include-dirs: Warning Options. (line 224) -* Wmissing-noreturn: Warning Options. (line 810) -* Wmissing-prototypes: Warning Options. (line 780) -* Wmultichar: Warning Options. (line 828) -* Wnested-externs: Warning Options. (line 869) +* Wmissing-noreturn: Warning Options. (line 812) +* Wmissing-prototypes: Warning Options. (line 782) +* Wmultichar: Warning Options. (line 830) +* Wnested-externs: Warning Options. (line 871) * Wno-deprecated: C++ Dialect Options. (line 346) -* Wno-deprecated-declarations: Warning Options. (line 834) -* Wno-div-by-zero: Warning Options. (line 583) -* Wno-endif-labels: Warning Options. (line 701) +* Wno-deprecated-declarations: Warning Options. (line 836) +* Wno-div-by-zero: Warning Options. (line 585) +* Wno-endif-labels: Warning Options. (line 703) * Wno-format-extra-args: Warning Options. (line 133) * Wno-format-zero-length: Warning Options. (line 147) * Wno-import: Warning Options. (line 76) -* Wno-invalid-offsetof: Warning Options. (line 907) -* Wno-long-long: Warning Options. (line 925) -* Wno-multichar: Warning Options. (line 828) +* Wno-invalid-offsetof: Warning Options. (line 909) +* Wno-long-long: Warning Options. (line 927) +* Wno-multichar: Warning Options. (line 830) * Wno-non-template-friend: C++ Dialect Options. - (line 350) + (line 357) * Wno-pmf-conversions <1>: Bound member functions. (line 35) * Wno-pmf-conversions: C++ Dialect Options. - (line 391) -* Wno-pointer-sign: Warning Options. (line 946) + (line 398) +* Wno-pointer-sign: Warning Options. (line 948) * Wno-protocol: Objective-C and Objective-C++ Dialect Options. (line 165) -* Wno-variadic-macros: Warning Options. (line 931) +* Wno-variadic-macros: Warning Options. (line 933) * Wnon-virtual-dtor: C++ Dialect Options. (line 295) * Wnonnull: Warning Options. (line 172) * Wold-style-cast: C++ Dialect Options. - (line 366) -* Wold-style-definition: Warning Options. (line 776) + (line 373) +* Wold-style-definition: Warning Options. (line 778) * Woverloaded-virtual: C++ Dialect Options. - (line 372) + (line 379) * Wp: Preprocessor Options. (line 13) -* Wpacked: Warning Options. (line 840) -* Wpadded: Warning Options. (line 857) +* Wpacked: Warning Options. (line 842) +* Wpadded: Warning Options. (line 859) * Wparentheses: Warning Options. (line 227) * Wpointer-arith <1>: Pointer Arith. (line 13) -* Wpointer-arith: Warning Options. (line 713) -* Wredundant-decls: Warning Options. (line 864) +* Wpointer-arith: Warning Options. (line 715) +* Wredundant-decls: Warning Options. (line 866) * Wreorder: C++ Dialect Options. (line 300) * Wreturn-type: Warning Options. (line 322) * Wselector: Objective-C and Objective-C++ Dialect Options. (line 175) * Wsequence-point: Warning Options. (line 273) -* Wshadow: Warning Options. (line 705) -* Wsign-compare: Warning Options. (line 758) +* Wshadow: Warning Options. (line 707) +* Wsign-compare: Warning Options. (line 760) * Wsign-promo: C++ Dialect Options. - (line 395) -* Wstrict-aliasing: Warning Options. (line 481) -* Wstrict-aliasing=2: Warning Options. (line 488) -* Wstrict-prototypes: Warning Options. (line 770) + (line 402) +* Wstrict-aliasing: Warning Options. (line 483) +* Wstrict-aliasing=2: Warning Options. (line 490) +* Wstrict-null-sentinel: C++ Dialect Options. + (line 350) +* Wstrict-prototypes: Warning Options. (line 772) * Wswitch: Warning Options. (line 341) * Wswitch-enum: Warning Options. (line 352) * Wswitch-switch: Warning Options. (line 349) * Wsystem-headers <1>: Preprocessor Options. (line 153) -* Wsystem-headers: Warning Options. (line 588) +* Wsystem-headers: Warning Options. (line 590) * Wtraditional <1>: Preprocessor Options. (line 103) -* Wtraditional: Warning Options. (line 614) +* Wtraditional: Warning Options. (line 616) * Wtrigraphs <1>: Preprocessor Options. (line 91) * Wtrigraphs: Warning Options. (line 358) @@ -28519,10 +28720,10 @@ look up both forms. (line 187) * Wundef <1>: Preprocessor Options. (line 112) -* Wundef: Warning Options. (line 698) +* Wundef: Warning Options. (line 700) * Wuninitialized: Warning Options. (line 403) -* Wunknown-pragmas: Warning Options. (line 474) -* Wunreachable-code: Warning Options. (line 872) +* Wunknown-pragmas: Warning Options. (line 476) +* Wunreachable-code: Warning Options. (line 874) * Wunused: Warning Options. (line 396) * Wunused-function: Warning Options. (line 363) * Wunused-label: Warning Options. (line 368) @@ -28531,8 +28732,8 @@ look up both forms. * Wunused-parameter: Warning Options. (line 375) * Wunused-value: Warning Options. (line 390) * Wunused-variable: Warning Options. (line 382) -* Wvariadic-macros: Warning Options. (line 931) -* Wwrite-strings: Warning Options. (line 734) +* Wvariadic-macros: Warning Options. (line 933) +* Wwrite-strings: Warning Options. (line 736) * x <1>: Preprocessor Options. (line 308) * x: Overall Options. (line 101) @@ -28556,7 +28757,7 @@ Keyword Index * #pragma implementation: C++ Interface. (line 39) * #pragma implementation, implied: C++ Interface. (line 46) * #pragma interface: C++ Interface. (line 20) -* #pragma, reason for not using: Function Attributes. (line 713) +* #pragma, reason for not using: Function Attributes. (line 736) * $: Dollar Signs. (line 6) * % in constraint: Modifiers. (line 45) * %include: Spec Files. (line 27) @@ -28663,6 +28864,8 @@ Keyword Index * alignment: Alignment. (line 6) * alloca: Other Builtins. (line 6) * alloca vs variable-length arrays: Variable Length. (line 27) +* Allow nesting in an interrupt handler on the Blackfin processor.: Function Attributes. + (line 436) * alternate keywords: Alternate Keywords. (line 6) * always_inline function attribute: Function Attributes. (line 44) * AMD x86-64 Options: i386 and x86-64 Options. @@ -28714,6 +28917,7 @@ Keyword Index * bcmp: Other Builtins. (line 6) * below100 attribute: Variable Attributes. (line 313) * binary compatibility: Compatibility. (line 6) +* Blackfin Options: Blackfin Options. (line 6) * bound pointer to member function: Bound member functions. (line 6) * bounds checking: Optimize Options. (line 319) @@ -28761,7 +28965,7 @@ Keyword Index * cacoshl: Other Builtins. (line 6) * cacosl: Other Builtins. (line 6) * calling functions through the function vector on the H8/300 processors: Function Attributes. - (line 314) + (line 320) * calloc: Other Builtins. (line 6) * carg: Other Builtins. (line 6) * cargf: Other Builtins. (line 6) @@ -28813,7 +29017,7 @@ Keyword Index * comments, C++ style: C++ Comments. (line 6) * common attribute: Variable Attributes. (line 92) * comparison of signed and unsigned values, warning: Warning Options. - (line 758) + (line 760) * compiler bugs, reporting: Bug Reporting. (line 6) * compiler compared to C++ preprocessor: G++ and GCC. (line 35) * compiler options, C++: C++ Dialect Options. (line 6) @@ -28932,6 +29136,8 @@ Keyword Index * erfl: Other Builtins. (line 6) * error messages: Warnings and Errors. (line 6) * escaped newlines: Escaped Newlines. (line 6) +* exception handler functions on the Blackfin processor: Function Attributes. + (line 199) * exclamation point: Multi-Alternative. (line 33) * exit: Other Builtins. (line 6) * exp: Other Builtins. (line 6) @@ -28987,8 +29193,8 @@ Keyword Index * fmod: Other Builtins. (line 6) * fmodf: Other Builtins. (line 6) * fmodl: Other Builtins. (line 6) -* format function attribute: Function Attributes. (line 222) -* format_arg function attribute: Function Attributes. (line 275) +* format function attribute: Function Attributes. (line 228) +* format_arg function attribute: Function Attributes. (line 281) * Fortran: G++ and GCC. (line 6) * forwarding calls: Constructing Calls. (line 6) * fprintf: Other Builtins. (line 6) @@ -29003,15 +29209,15 @@ Keyword Index * FRV Options: FRV Options. (line 6) * fscanf: Other Builtins. (line 6) * fscanf, and constant strings: Incompatibilities. (line 17) -* function addressability on the M32R/D: Function Attributes. (line 384) +* function addressability on the M32R/D: Function Attributes. (line 396) * function attributes: Function Attributes. (line 6) * function pointers, arithmetic: Pointer Arith. (line 6) * function prototype declarations: Function Prototypes. (line 6) * function without a prologue/epilogue code: Function Attributes. - (line 412) + (line 424) * function, size of pointer to: Pointer Arith. (line 6) * functions called via pointer on the RS/6000 and PowerPC: Function Attributes. - (line 363) + (line 375) * functions in arbitrary sections: Function Attributes. (line 6) * functions that are passed arguments in registers on the 386: Function Attributes. (line 6) @@ -29025,9 +29231,9 @@ Keyword Index * functions that pop the argument stack on the 386: Function Attributes. (line 6) * functions which do not handle memory bank switching on 68HC11/68HC12: Function Attributes. - (line 418) + (line 430) * functions which handle memory bank switching: Function Attributes. - (line 199) + (line 205) * functions with non-null pointer arguments: Function Attributes. (line 6) * functions with printf, scanf, strftime or strfmon style arguments: Function Attributes. @@ -29086,7 +29292,7 @@ Keyword Index * incompatibilities of GCC: Incompatibilities. (line 6) * increment operators: Bug Criteria. (line 17) * index: Other Builtins. (line 6) -* indirect calls on ARM: Function Attributes. (line 353) +* indirect calls on ARM: Function Attributes. (line 365) * init_priority attribute: C++ Attributes. (line 9) * initializations in expressions: Compound Literals. (line 6) * initializers with labeled elements: Designated Inits. (line 6) @@ -29101,9 +29307,9 @@ Keyword Index (line 6) * interface and implementation headers, C++: C++ Interface. (line 6) * intermediate C version, nonexistent: G++ and GCC. (line 35) -* interrupt handler functions: Function Attributes. (line 325) -* interrupt handler functions on the m68k, H8/300 and SH processors: Function Attributes. - (line 347) +* interrupt handler functions: Function Attributes. (line 331) +* interrupt handler functions on the Blackfin, m68k, H8/300 and SH processors: Function Attributes. + (line 353) * introduction: Top. (line 6) * invalid assembly code: Bug Criteria. (line 12) * invalid input: Bug Criteria. (line 42) @@ -29213,7 +29419,7 @@ Keyword Index * long long data types: Long Long. (line 6) * longjmp: Global Reg Vars. (line 66) * longjmp incompatibilities: Incompatibilities. (line 39) -* longjmp warnings: Warning Options. (line 457) +* longjmp warnings: Warning Options. (line 459) * lrint: Other Builtins. (line 6) * lrintf: Other Builtins. (line 6) * lrintl: Other Builtins. (line 6) @@ -29236,7 +29442,7 @@ Keyword Index * make: Preprocessor Options. (line 173) * malloc: Other Builtins. (line 6) -* malloc attribute: Function Attributes. (line 374) +* malloc attribute: Function Attributes. (line 386) * matching constraint: Simple Constraints. (line 127) * MCore options: MCore Options. (line 6) * member fns, automatically inline: Inline. (line 46) @@ -29282,15 +29488,17 @@ Keyword Index * nexttoward: Other Builtins. (line 6) * nexttowardf: Other Builtins. (line 6) * nexttowardl: Other Builtins. (line 6) +* NMI handler functions on the Blackfin processor: Function Attributes. + (line 441) * no_instrument_function function attribute: Function Attributes. - (line 424) + (line 447) * nocommon attribute: Variable Attributes. (line 92) -* noinline function attribute: Function Attributes. (line 429) +* noinline function attribute: Function Attributes. (line 452) * non-constant initializers: Initializers. (line 6) * non-static inline function: Inline. (line 63) -* nonnull function attribute: Function Attributes. (line 433) -* noreturn function attribute: Function Attributes. (line 456) -* nothrow function attribute: Function Attributes. (line 498) +* nonnull function attribute: Function Attributes. (line 456) +* noreturn function attribute: Function Attributes. (line 479) +* nothrow function attribute: Function Attributes. (line 521) * NS32K options: NS32K Options. (line 6) * o in constraint: Simple Constraints. (line 21) * OBJC_INCLUDE_PATH: Environment Variables. @@ -29328,7 +29536,7 @@ Keyword Index * order of options: Invoking GCC. (line 30) * other register constraints: Simple Constraints. (line 151) * output file option: Overall Options. (line 166) -* overloaded virtual fn, warning: C++ Dialect Options. (line 372) +* overloaded virtual fn, warning: C++ Dialect Options. (line 379) * p in constraint: Simple Constraints. (line 142) * packed attribute: Variable Attributes. (line 129) * parameter forward declaration: Variable Length. (line 60) @@ -29361,7 +29569,7 @@ Keyword Index * pragma, mark: Darwin Pragmas. (line 11) * pragma, no_long_calls: ARM Pragmas. (line 14) * pragma, options align: Darwin Pragmas. (line 14) -* pragma, reason for not using: Function Attributes. (line 713) +* pragma, reason for not using: Function Attributes. (line 736) * pragma, redefine_extname: Symbol-Renaming Pragmas. (line 14) * pragma, segment: Darwin Pragmas. (line 21) @@ -29370,7 +29578,7 @@ Keyword Index * pragmas: Pragmas. (line 6) * pragmas in C++, effect on inlining: C++ Interface. (line 66) * pragmas, interface and implementation: C++ Interface. (line 6) -* pragmas, warning of unknown: Warning Options. (line 474) +* pragmas, warning of unknown: Warning Options. (line 476) * precompiled headers: Precompiled Headers. (line 6) * preprocessing numbers: Incompatibilities. (line 173) * preprocessing tokens: Incompatibilities. (line 173) @@ -29380,7 +29588,7 @@ Keyword Index * printf_unlocked: Other Builtins. (line 6) * prof: Debugging Options. (line 121) * promotion of formal parameters: Function Prototypes. (line 6) -* pure function attribute: Function Attributes. (line 506) +* pure function attribute: Function Attributes. (line 529) * push address instruction: Simple Constraints. (line 142) * putchar: Other Builtins. (line 6) * puts: Other Builtins. (line 6) @@ -29395,7 +29603,7 @@ Keyword Index * registers in constraints: Simple Constraints. (line 54) * registers, global allocation: Explicit Reg Vars. (line 6) * registers, global variables in: Global Reg Vars. (line 6) -* regparm attribute: Function Attributes. (line 528) +* regparm attribute: Function Attributes. (line 551) * relocation truncated to fit (MIPS): MIPS Options. (line 111) * remainder: Other Builtins. (line 6) * remainderf: Other Builtins. (line 6) @@ -29423,8 +29631,8 @@ Keyword Index * s in constraint: Simple Constraints. (line 90) * S/390 and zSeries Options: S/390 and zSeries Options. (line 6) -* save all registers on the H8/300, H8/300H, and H8S: Function Attributes. - (line 545) +* save all registers on the Blackfin, H8/300, H8/300H, and H8S: Function Attributes. + (line 568) * scalb: Other Builtins. (line 6) * scalbf: Other Builtins. (line 6) * scalbl: Other Builtins. (line 6) @@ -29438,9 +29646,9 @@ Keyword Index * scope of declaration: Disappointments. (line 21) * scope of external declarations: Incompatibilities. (line 80) * search path: Directory Options. (line 6) -* section function attribute: Function Attributes. (line 550) +* section function attribute: Function Attributes. (line 573) * section variable attribute: Variable Attributes. (line 144) -* sentinel function attribute: Function Attributes. (line 566) +* sentinel function attribute: Function Attributes. (line 589) * setjmp: Global Reg Vars. (line 66) * setjmp incompatibilities: Incompatibilities. (line 39) * shared strings: Incompatibilities. (line 9) @@ -29449,12 +29657,12 @@ Keyword Index * side effects, macro argument: Statement Exprs. (line 35) * side effects, order of evaluation: Non-bugs. (line 199) * signal handler functions on the AVR processors: Function Attributes. - (line 597) + (line 620) * signbit: Other Builtins. (line 6) * signbitf: Other Builtins. (line 6) * signbitl: Other Builtins. (line 6) * signed and unsigned values, comparison warning: Warning Options. - (line 758) + (line 760) * significand: Other Builtins. (line 6) * significandf: Other Builtins. (line 6) * significandl: Other Builtins. (line 6) @@ -29523,7 +29731,7 @@ Keyword Index * surprises in C++: C++ Misunderstandings. (line 6) * syntax checking: Warning Options. (line 22) -* system headers, warnings from: Warning Options. (line 588) +* system headers, warnings from: Warning Options. (line 590) * tan: Other Builtins. (line 6) * tanf: Other Builtins. (line 6) * tanh: Other Builtins. (line 6) @@ -29546,7 +29754,7 @@ Keyword Index * Thread-Local Storage: Thread-Local. (line 6) * thunks: Nested Functions. (line 6) * tiny data section on the H8/300H and H8S: Function Attributes. - (line 619) + (line 642) * TLS: Thread-Local. (line 6) * tls_model attribute: Variable Attributes. (line 213) * TMPDIR: Environment Variables. @@ -29578,16 +29786,18 @@ Keyword Index * union: Unnamed Fields. (line 6) * union, casting to a: Cast to Union. (line 6) * unions: Incompatibilities. (line 146) -* unknown pragmas, warning: Warning Options. (line 474) +* unknown pragmas, warning: Warning Options. (line 476) * unresolved references and -nodefaultlibs: Link Options. (line 79) * unresolved references and -nostdlib: Link Options. (line 79) -* unused attribute.: Function Attributes. (line 631) -* used attribute.: Function Attributes. (line 636) +* unused attribute.: Function Attributes. (line 654) +* used attribute.: Function Attributes. (line 659) +* User stack pointer in interrupts on the Blackfin: Function Attributes. + (line 360) * V in constraint: Simple Constraints. (line 41) * V850 Options: V850 Options. (line 6) * vague linkage: Vague Linkage. (line 6) * value after longjmp: Global Reg Vars. (line 66) -* variable addressability on the IA-64: Function Attributes. (line 384) +* variable addressability on the IA-64: Function Attributes. (line 396) * variable addressability on the M32R/D: Variable Attributes. (line 277) * variable alignment: Alignment. (line 6) * variable attributes: Variable Attributes. (line 6) @@ -29601,7 +29811,7 @@ Keyword Index * VAX options: VAX Options. (line 6) * vfprintf: Other Builtins. (line 6) * vfscanf: Other Builtins. (line 6) -* visibility attribute: Function Attributes. (line 642) +* visibility attribute: Function Attributes. (line 665) * VLAs: Variable Length. (line 6) * void pointers, arithmetic: Pointer Arith. (line 6) * void, size of pointer to: Pointer Arith. (line 6) @@ -29615,17 +29825,17 @@ Keyword Index * vsprintf: Other Builtins. (line 6) * vsscanf: Other Builtins. (line 6) * vtable: Vague Linkage. (line 28) -* warn_unused_result attribute: Function Attributes. (line 684) +* warn_unused_result attribute: Function Attributes. (line 707) * warning for comparison of signed and unsigned values: Warning Options. - (line 758) -* warning for overloaded virtual fn: C++ Dialect Options. (line 372) + (line 760) +* warning for overloaded virtual fn: C++ Dialect Options. (line 379) * warning for reordering of member initializers: C++ Dialect Options. (line 300) -* warning for unknown pragmas: Warning Options. (line 474) +* warning for unknown pragmas: Warning Options. (line 476) * warning messages: Warning Options. (line 6) -* warnings from system headers: Warning Options. (line 588) +* warnings from system headers: Warning Options. (line 590) * warnings vs errors: Warnings and Errors. (line 6) -* weak attribute: Function Attributes. (line 701) +* weak attribute: Function Attributes. (line 724) * whitespace: Incompatibilities. (line 112) * X in constraint: Simple Constraints. (line 112) * X3.159-1989: Standards. (line 6) @@ -29655,218 +29865,219 @@ Node: G++ and GCC3740 Node: Standards5805 Node: Invoking GCC12932 Node: Option Summary16702 -Node: Overall Options42658 -Node: Invoking G++50960 -Node: C Dialect Options52582 -Node: C++ Dialect Options63592 -Node: Objective-C and Objective-C++ Dialect Options80803 -Node: Language Independent Options90253 -Node: Warning Options92064 -Node: Debugging Options133461 -Node: Optimize Options162726 -Node: Preprocessor Options231352 -Ref: Wtrigraphs235316 -Ref: dashMF240073 -Ref: fdollars-in-identifiers248969 -Node: Assembler Options256830 -Node: Link Options257535 -Ref: Link Options-Footnote-1265787 -Node: Directory Options266121 -Node: Spec Files271488 -Node: Target Options290776 -Node: Submodel Options292082 -Node: ARC Options293810 -Node: ARM Options295000 -Node: AVR Options306208 -Node: CRIS Options308337 -Node: Darwin Options312554 -Node: DEC Alpha Options318867 -Node: DEC Alpha/VMS Options330345 -Node: FRV Options330730 -Node: H8/300 Options337114 -Node: HPPA Options338173 -Node: i386 and x86-64 Options347552 -Node: IA-64 Options365305 -Node: M32R/D Options369303 -Node: M680x0 Options372891 -Node: M68hc1x Options380124 -Node: MCore Options381692 -Node: MIPS Options382713 -Node: MMIX Options396775 -Node: MN10300 Options399257 -Node: NS32K Options400317 -Node: PDP-11 Options404862 -Node: PowerPC Options406699 -Node: RS/6000 and PowerPC Options406933 -Node: S/390 and zSeries Options432763 -Node: SH Options439811 -Node: SPARC Options443073 -Node: System V Options453704 -Node: TMS320C3x/C4x Options454538 -Node: V850 Options460063 -Node: VAX Options463208 -Node: x86-64 Options463755 -Node: Xstormy16 Options463969 -Node: Xtensa Options464258 -Node: zSeries Options468098 -Node: Code Gen Options468294 -Node: Environment Variables487553 -Node: Precompiled Headers495225 -Node: Running Protoize501776 -Node: C Implementation508113 -Node: Translation implementation509776 -Node: Environment implementation510350 -Node: Identifiers implementation510900 -Node: Characters implementation511954 -Node: Integers implementation514760 -Node: Floating point implementation516585 -Node: Arrays and pointers implementation519514 -Ref: Arrays and pointers implementation-Footnote-1520949 -Node: Hints implementation521073 -Node: Structures unions enumerations and bit-fields implementation522539 -Node: Qualifiers implementation524502 -Node: Declarators implementation524885 -Node: Statements implementation525227 -Node: Preprocessing directives implementation525554 -Node: Library functions implementation527659 -Node: Architecture implementation528299 -Node: Locale-specific behavior implementation529002 -Node: C Extensions529307 -Node: Statement Exprs533486 -Node: Local Labels537999 -Node: Labels as Values540978 -Ref: Labels as Values-Footnote-1543032 -Node: Nested Functions543215 -Node: Constructing Calls547109 -Node: Typeof549445 -Node: Conditionals552611 -Node: Long Long553502 -Node: Complex555003 -Node: Hex Floats557569 -Node: Zero Length558604 -Node: Empty Structures561881 -Node: Variable Length562297 -Node: Variadic Macros565064 -Node: Escaped Newlines567446 -Node: Subscripting568285 -Node: Pointer Arith569008 -Node: Initializers569576 -Node: Compound Literals570072 -Node: Designated Inits572234 -Node: Case Ranges575889 -Node: Cast to Union576572 -Node: Mixed Declarations577668 -Node: Function Attributes578174 -Node: Attribute Syntax611743 -Node: Function Prototypes622827 -Node: C++ Comments624608 -Node: Dollar Signs625127 -Node: Character Escapes625592 -Node: Alignment625886 -Node: Variable Attributes627203 -Node: Type Attributes640650 -Node: Inline654068 -Node: Extended Asm658772 -Ref: Example of asm with clobbered asm reg664858 -Node: Constraints678954 -Node: Simple Constraints679804 -Node: Multi-Alternative686332 -Node: Modifiers688049 -Node: Machine Constraints690737 -Node: Asm Labels712895 -Node: Explicit Reg Vars714571 -Node: Global Reg Vars716179 -Node: Local Reg Vars720729 -Node: Alternate Keywords723170 -Node: Incomplete Enums724598 -Node: Function Names725355 -Node: Return Address727545 -Node: Vector Extensions730342 -Node: Offsetof733844 -Node: Other Builtins734629 -Node: Target Builtins755734 -Node: Alpha Built-in Functions756403 -Node: ARM Built-in Functions759395 -Node: FR-V Built-in Functions766098 -Node: Argument Types766923 -Node: Directly-mapped Integer Functions768679 -Node: Directly-mapped Media Functions769761 -Node: Other Built-in Functions776793 -Node: X86 Built-in Functions777989 -Node: MIPS Paired-Single Support788381 -Node: Paired-Single Arithmetic789986 -Node: Paired-Single Built-in Functions790926 -Node: MIPS-3D Built-in Functions793590 -Node: PowerPC AltiVec Built-in Functions798959 -Node: SPARC VIS Built-in Functions900263 -Node: Target Format Checks901922 -Node: Solaris Format Checks902329 -Node: Pragmas902726 -Node: ARM Pragmas903293 -Node: RS/6000 and PowerPC Pragmas903911 -Node: Darwin Pragmas904652 -Node: Solaris Pragmas905719 -Node: Symbol-Renaming Pragmas906880 -Node: Structure-Packing Pragmas909502 -Node: Weak Pragmas910731 -Node: Unnamed Fields911506 -Node: Thread-Local913016 -Node: C99 Thread-Local Edits915100 -Node: C++98 Thread-Local Edits917112 -Node: C++ Extensions920557 -Node: Volatiles922129 -Node: Restricted Pointers925475 -Node: Vague Linkage927069 -Node: C++ Interface930725 -Ref: C++ Interface-Footnote-1935022 -Node: Template Instantiation935159 -Node: Bound member functions942171 -Node: C++ Attributes943714 -Node: Strong Using945354 -Node: Java Exceptions946603 -Node: Deprecated Features947999 -Node: Backwards Compatibility950978 -Node: Objective-C952333 -Node: Executing code before main952914 -Node: What you can and what you cannot do in +load955520 -Node: Type encoding957687 -Node: Garbage Collection960930 -Node: Constant string objects963554 -Node: compatibility_alias966062 -Node: Compatibility966940 -Node: Gcov973507 -Node: Gcov Intro973977 -Node: Invoking Gcov976693 -Node: Gcov and Optimization988544 -Node: Gcov Data Files991197 -Node: Trouble992311 -Node: Actual Bugs993851 -Node: Cross-Compiler Problems994591 -Node: Interoperation995005 -Node: Incompatibilities1002603 -Node: Fixed Headers1010753 -Node: Standard Libraries1012416 -Node: Disappointments1013788 -Node: C++ Misunderstandings1018146 -Node: Static Definitions1018965 -Node: Name lookup1020018 -Ref: Name lookup-Footnote-11024796 -Node: Temporaries1024983 -Node: Copy Assignment1026959 -Node: Protoize Caveats1028766 -Node: Non-bugs1032728 -Node: Warnings and Errors1043351 -Node: Bugs1045115 -Node: Bug Criteria1045679 -Node: Bug Reporting1047889 -Node: Service1048281 -Node: Contributing1049100 -Node: Funding1049840 -Node: GNU Project1052329 -Node: Copying1052975 -Node: GNU Free Documentation License1072125 -Node: Contributors1094521 -Node: Option Index1124568 -Node: Keyword Index1249198 +Node: Overall Options42898 +Node: Invoking G++51200 +Node: C Dialect Options52822 +Node: C++ Dialect Options63832 +Node: Objective-C and Objective-C++ Dialect Options81422 +Node: Language Independent Options90872 +Node: Warning Options92683 +Node: Debugging Options134197 +Node: Optimize Options163462 +Node: Preprocessor Options232241 +Ref: Wtrigraphs236205 +Ref: dashMF240962 +Ref: fdollars-in-identifiers249858 +Node: Assembler Options257719 +Node: Link Options258424 +Ref: Link Options-Footnote-1266676 +Node: Directory Options267010 +Node: Spec Files272377 +Node: Target Options291665 +Node: Submodel Options292971 +Node: ARC Options294720 +Node: ARM Options295910 +Node: AVR Options307118 +Node: Blackfin Options309251 +Node: CRIS Options311017 +Node: Darwin Options315239 +Node: DEC Alpha Options321552 +Node: DEC Alpha/VMS Options333030 +Node: FRV Options333415 +Node: H8/300 Options339799 +Node: HPPA Options340860 +Node: i386 and x86-64 Options350239 +Node: IA-64 Options367992 +Node: M32R/D Options371990 +Node: M680x0 Options375578 +Node: M68hc1x Options382811 +Node: MCore Options384379 +Node: MIPS Options385400 +Node: MMIX Options399462 +Node: MN10300 Options401944 +Node: NS32K Options403004 +Node: PDP-11 Options407549 +Node: PowerPC Options409386 +Node: RS/6000 and PowerPC Options409620 +Node: S/390 and zSeries Options435450 +Node: SH Options442498 +Node: SPARC Options445760 +Node: System V Options456391 +Node: TMS320C3x/C4x Options457225 +Node: V850 Options462750 +Node: VAX Options465895 +Node: x86-64 Options466442 +Node: Xstormy16 Options466656 +Node: Xtensa Options466945 +Node: zSeries Options470785 +Node: Code Gen Options470981 +Node: Environment Variables490240 +Node: Precompiled Headers497912 +Node: Running Protoize504463 +Node: C Implementation510800 +Node: Translation implementation512463 +Node: Environment implementation513037 +Node: Identifiers implementation513587 +Node: Characters implementation514641 +Node: Integers implementation517447 +Node: Floating point implementation519272 +Node: Arrays and pointers implementation522201 +Ref: Arrays and pointers implementation-Footnote-1523636 +Node: Hints implementation523760 +Node: Structures unions enumerations and bit-fields implementation525226 +Node: Qualifiers implementation527189 +Node: Declarators implementation527572 +Node: Statements implementation527914 +Node: Preprocessing directives implementation528241 +Node: Library functions implementation530346 +Node: Architecture implementation530986 +Node: Locale-specific behavior implementation531689 +Node: C Extensions531994 +Node: Statement Exprs536173 +Node: Local Labels540686 +Node: Labels as Values543665 +Ref: Labels as Values-Footnote-1545719 +Node: Nested Functions545902 +Node: Constructing Calls549796 +Node: Typeof552132 +Node: Conditionals555298 +Node: Long Long556189 +Node: Complex557690 +Node: Hex Floats560256 +Node: Zero Length561291 +Node: Empty Structures564568 +Node: Variable Length564984 +Node: Variadic Macros567751 +Node: Escaped Newlines570133 +Node: Subscripting570972 +Node: Pointer Arith571695 +Node: Initializers572263 +Node: Compound Literals572759 +Node: Designated Inits574921 +Node: Case Ranges578576 +Node: Cast to Union579259 +Node: Mixed Declarations580355 +Node: Function Attributes580861 +Node: Attribute Syntax615411 +Node: Function Prototypes626495 +Node: C++ Comments628276 +Node: Dollar Signs628795 +Node: Character Escapes629260 +Node: Alignment629554 +Node: Variable Attributes630871 +Node: Type Attributes644318 +Node: Inline657736 +Node: Extended Asm662440 +Ref: Example of asm with clobbered asm reg668526 +Node: Constraints682622 +Node: Simple Constraints683472 +Node: Multi-Alternative690000 +Node: Modifiers691717 +Node: Machine Constraints694405 +Node: Asm Labels718333 +Node: Explicit Reg Vars720009 +Node: Global Reg Vars721617 +Node: Local Reg Vars726167 +Node: Alternate Keywords728608 +Node: Incomplete Enums730036 +Node: Function Names730793 +Node: Return Address732983 +Node: Vector Extensions735780 +Node: Offsetof739282 +Node: Other Builtins740067 +Node: Target Builtins761172 +Node: Alpha Built-in Functions761841 +Node: ARM Built-in Functions764833 +Node: FR-V Built-in Functions771536 +Node: Argument Types772361 +Node: Directly-mapped Integer Functions774117 +Node: Directly-mapped Media Functions775199 +Node: Other Built-in Functions782231 +Node: X86 Built-in Functions783427 +Node: MIPS Paired-Single Support793819 +Node: Paired-Single Arithmetic795424 +Node: Paired-Single Built-in Functions796364 +Node: MIPS-3D Built-in Functions799028 +Node: PowerPC AltiVec Built-in Functions804397 +Node: SPARC VIS Built-in Functions905701 +Node: Target Format Checks907360 +Node: Solaris Format Checks907767 +Node: Pragmas908164 +Node: ARM Pragmas908731 +Node: RS/6000 and PowerPC Pragmas909349 +Node: Darwin Pragmas910090 +Node: Solaris Pragmas911157 +Node: Symbol-Renaming Pragmas912318 +Node: Structure-Packing Pragmas914940 +Node: Weak Pragmas916169 +Node: Unnamed Fields916944 +Node: Thread-Local918454 +Node: C99 Thread-Local Edits920538 +Node: C++98 Thread-Local Edits922550 +Node: C++ Extensions925995 +Node: Volatiles927567 +Node: Restricted Pointers930913 +Node: Vague Linkage932507 +Node: C++ Interface936163 +Ref: C++ Interface-Footnote-1940460 +Node: Template Instantiation940597 +Node: Bound member functions947609 +Node: C++ Attributes949152 +Node: Strong Using950792 +Node: Java Exceptions952041 +Node: Deprecated Features953437 +Node: Backwards Compatibility956416 +Node: Objective-C957771 +Node: Executing code before main958352 +Node: What you can and what you cannot do in +load960958 +Node: Type encoding963125 +Node: Garbage Collection966368 +Node: Constant string objects968992 +Node: compatibility_alias971500 +Node: Compatibility972378 +Node: Gcov978945 +Node: Gcov Intro979415 +Node: Invoking Gcov982131 +Node: Gcov and Optimization993982 +Node: Gcov Data Files996635 +Node: Trouble997749 +Node: Actual Bugs999289 +Node: Cross-Compiler Problems1000029 +Node: Interoperation1000443 +Node: Incompatibilities1008041 +Node: Fixed Headers1016191 +Node: Standard Libraries1017854 +Node: Disappointments1019226 +Node: C++ Misunderstandings1023584 +Node: Static Definitions1024403 +Node: Name lookup1025456 +Ref: Name lookup-Footnote-11030234 +Node: Temporaries1030421 +Node: Copy Assignment1032397 +Node: Protoize Caveats1034204 +Node: Non-bugs1038166 +Node: Warnings and Errors1048789 +Node: Bugs1050553 +Node: Bug Criteria1051117 +Node: Bug Reporting1053327 +Node: Service1053719 +Node: Contributing1054538 +Node: Funding1055278 +Node: GNU Project1057767 +Node: Copying1058413 +Node: GNU Free Documentation License1077563 +Node: Contributors1099959 +Node: Option Index1130138 +Node: Keyword Index1255487  End Tag Table diff --git a/contrib/gcc-4.0/gcc/doc/gccinstall.info b/contrib/gcc-4.0/gcc/doc/gccinstall.info index 1d59efecbd..3b3b8383c3 100644 --- a/contrib/gcc-4.0/gcc/doc/gccinstall.info +++ b/contrib/gcc-4.0/gcc/doc/gccinstall.info @@ -1,5 +1,5 @@ -This is doc/gccinstall.info, produced by makeinfo version 4.7 from -/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/doc/install.texi. +This is doc/gccinstall.info, produced by makeinfo version 4.8 from +/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/doc/install.texi. Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. @@ -207,7 +207,7 @@ automake versions 1.9.3 a directory to a newer version, please update all the directories using an older 1.9.x to the latest released version. -gettext version 0.12 (or later) +gettext version 0.14.5 (or later) Needed to regenerate `gcc.pot'. gperf version 2.7.2 (or later) @@ -879,13 +879,14 @@ option. LANGN you can issue the following command in the `gcc' directory of your GCC source tree: grep language= */config-lang.in - Currently, you can use any of the following: `ada', `c', `c++', - `f77', `f95', `java', `objc', `obj-c++'. Building the Ada - compiler has special requirements, see below. - If you do not pass this flag, all languages available in the `gcc' - sub-tree will be configured. Re-defining `LANGUAGES' when calling - `make bootstrap' *does not* work anymore, as those language - sub-directories might not have been configured! + Currently, you can use any of the following: `all', `ada', `c', + `c++', `f95', `java', `objc', `treelang'. Building the Ada + compiler has special requirements, see below. If you do not pass + this flag, or specify the option `all', then all default languages + available in the `gcc' sub-tree will be configured. Ada and + treelang are not default languages; the rest are. Re-defining + `LANGUAGES' when calling `make bootstrap' *does not* work anymore, + as those language sub-directories might not have been configured! `--disable-libada' Specify that the run-time libraries and tools used by GNAT should @@ -1731,8 +1732,8 @@ can also buy printed manuals from the Free Software Foundation, though such manuals may not be for the most recent version of GCC. If you would like to generate online HTML documentation, do `cd -OBJDIR; make html' and HTML will be generated for the manuals in -`OBJDIR/HTML'. +OBJDIR; make html' and HTML will be generated for the gcc manuals in +`OBJDIR/gcc/HTML'.  File: gccinstall.info, Node: Binaries, Next: Specific, Prev: Installing GCC, Up: Top @@ -1968,6 +1969,15 @@ tools can also be obtained from: indicates that you should upgrade to a newer version of the binutils. +Blackfin +======== + +The Blackfin processor, an Analog Devices DSP. *Note Blackfin Options: +(gcc)Blackfin Options, + + More information, and a version of binutils with support for this +processor, is available at `http://blackfin.uclinux.org' + c4x === @@ -2343,6 +2353,16 @@ Development Tools" package. See the SCO web and ftp sites for details. That package also contains the currently "officially supported" version of GCC, version 2.95.3. It is useful for bootstrapping this version. +i?86-*-solaris2.10 +================== + +Use this for Solaris 10 or later on x86 and x86-64 systems. This +configuration is supported by GCC 4.0 and later versions only. + + It is recommended that you configure GCC to use the GNU assembler in +`/usr/sfw/bin/gas' but the Sun linker, using the options `--with-gnu-as +--with-as=/usr/sfw/bin/gas --without-gnu-ld --with-ld=/usr/ccs/bin/ld'. + i?86-*-udk ========== @@ -2927,11 +2947,12 @@ by the Sun compiler. This is Sun bug 4974440. This is fixed with patch 112760-07. GCC 3.4 changed the default debugging format from STABS to DWARF-2 -for 32-bit code on Solaris 7 and later. If you are using the Sun -assembler, this change apparently runs afoul of Sun bug 4910101, for -which (as of 2004-05-23) there is no fix. A symptom of the problem is -that you cannot compile C++ programs like `groff' 1.19.1 without -getting messages similar to the following: +for 32-bit code on Solaris 7 and later. If you use the Sun assembler, +this change apparently runs afoul of Sun bug 4910101 (which is +referenced as a x86-only problem by Sun, probably because they do not +use DWARF-2). A symptom of the problem is that you cannot compile C++ +programs like `groff' 1.19.1 without getting messages similar to the +following: ld: warning: relocation error: R_SPARC_UA32: ... external symbolic relocation against non-allocatable section @@ -2988,6 +3009,15 @@ shared version of libgcc. A typical error message is: This bug has been fixed in the final 5.0 version of the assembler. + A similar problem was reported for version Sun WorkShop 6 99/08/18 +of the Sun assembler, which causes a bootstrap failure with GCC 4.0.0: + + ld: fatal: relocation error: R_SPARC_DISP32: + file .libs/libstdc++.lax/libsupc++convenience.a/vterminate.o: + symbol : offset 0xfccd33ad is non-aligned + + This bug has been fixed in more recent revisions of the assembler. + sparc-*-linux* ============== @@ -3803,82 +3833,84 @@ Tag Table: Node: Top1924 Node: Installing GCC2482 Node: Prerequisites3997 -Node: Downloading the source10600 -Node: Configuration12281 -Ref: with-gnu-as25110 -Ref: with-as26297 -Ref: with-gnu-ld27302 -Node: Building50722 -Node: Testing61084 -Node: Final install68962 -Node: Binaries73817 -Node: Specific75630 -Ref: alpha-x-x75917 -Ref: alpha-dec-osf76406 -Ref: alphaev5-cray-unicosmk79983 -Ref: arc-x-elf80930 -Ref: arm-x-elf81030 -Ref: xscale-x-x81051 -Ref: arm-x-coff81287 -Ref: arm-x-aout81489 -Ref: avr81611 -Ref: c4x82291 -Ref: cris82889 -Ref: dos83871 -Ref: x-x-freebsd84194 -Ref: h8300-hms86577 -Ref: hppa-hp-hpux86929 -Ref: hppa-hp-hpux1088869 -Ref: hppa-hp-hpux1189926 -Ref: x-x-linux-gnu96781 -Ref: ix86-x-linuxaout96973 -Ref: ix86-x-linux97132 -Ref: ix86-x-sco3.2v597445 -Ref: ix86-x-udk99614 -Ref: ia64-x-linux100978 -Ref: ia64-x-hpux101748 -Ref: x-ibm-aix102303 -Ref: ip2k-x-elf108159 -Ref: iq2000-x-elf108390 -Ref: m32r-x-elf108530 -Ref: m6811-elf108632 -Ref: m6812-elf108782 -Ref: m68k-hp-hpux108932 -Ref: mips-x-x110671 -Ref: mips-sgi-irix5112340 -Ref: mips-sgi-irix6113288 -Ref: powerpc-x-x115980 -Ref: powerpc-x-darwin116125 -Ref: powerpc-x-elf116714 -Ref: powerpc-x-linux-gnu116833 -Ref: powerpc-x-netbsd116935 -Ref: powerpc-x-eabisim117131 -Ref: powerpc-x-eabi117257 -Ref: powerpcle-x-elf117333 -Ref: powerpcle-x-eabisim117463 -Ref: powerpcle-x-eabi117596 -Ref: s390-x-linux117679 -Ref: s390x-x-linux117751 -Ref: s390x-ibm-tpf117838 -Ref: x-x-solaris2117969 -Ref: sparc-sun-solaris2121552 -Ref: sparc-sun-solaris2.7124500 -Ref: sparc-x-linux126571 -Ref: sparc64-x-solaris2126796 -Ref: sparcv9-x-solaris2127172 -Ref: x-x-sysv127257 -Ref: vax-dec-ultrix128218 -Ref: x-x-vxworks128370 -Ref: x86_64-x-x129892 -Ref: xtensa-x-elf130220 -Ref: xtensa-x-linux130889 -Ref: windows131227 -Ref: os2131551 -Ref: older131874 -Ref: elf_targets133999 -Node: Old134257 -Node: Configurations137394 -Node: GNU Free Documentation License141376 -Node: Concept Index163782 +Node: Downloading the source10602 +Node: Configuration12283 +Ref: with-gnu-as25112 +Ref: with-as26299 +Ref: with-gnu-ld27304 +Node: Building50832 +Node: Testing61194 +Node: Final install69072 +Node: Binaries73935 +Node: Specific75748 +Ref: alpha-x-x76035 +Ref: alpha-dec-osf76524 +Ref: alphaev5-cray-unicosmk80101 +Ref: arc-x-elf81048 +Ref: arm-x-elf81148 +Ref: xscale-x-x81169 +Ref: arm-x-coff81405 +Ref: arm-x-aout81607 +Ref: avr81729 +Ref: bfin82409 +Ref: c4x82651 +Ref: cris83249 +Ref: dos84231 +Ref: x-x-freebsd84554 +Ref: h8300-hms86937 +Ref: hppa-hp-hpux87289 +Ref: hppa-hp-hpux1089229 +Ref: hppa-hp-hpux1190286 +Ref: x-x-linux-gnu97141 +Ref: ix86-x-linuxaout97333 +Ref: ix86-x-linux97492 +Ref: ix86-x-sco32v597805 +Ref: ix86-x-solaris21099974 +Ref: ix86-x-udk100360 +Ref: ia64-x-linux101724 +Ref: ia64-x-hpux102494 +Ref: x-ibm-aix103049 +Ref: ip2k-x-elf108905 +Ref: iq2000-x-elf109136 +Ref: m32r-x-elf109276 +Ref: m6811-elf109378 +Ref: m6812-elf109528 +Ref: m68k-hp-hpux109678 +Ref: mips-x-x111417 +Ref: mips-sgi-irix5113086 +Ref: mips-sgi-irix6114034 +Ref: powerpc-x-x116726 +Ref: powerpc-x-darwin116871 +Ref: powerpc-x-elf117460 +Ref: powerpc-x-linux-gnu117579 +Ref: powerpc-x-netbsd117681 +Ref: powerpc-x-eabisim117877 +Ref: powerpc-x-eabi118003 +Ref: powerpcle-x-elf118079 +Ref: powerpcle-x-eabisim118209 +Ref: powerpcle-x-eabi118342 +Ref: s390-x-linux118425 +Ref: s390x-x-linux118497 +Ref: s390x-ibm-tpf118584 +Ref: x-x-solaris2118715 +Ref: sparc-sun-solaris2122298 +Ref: sparc-sun-solaris27125287 +Ref: sparc-x-linux127751 +Ref: sparc64-x-solaris2127976 +Ref: sparcv9-x-solaris2128352 +Ref: x-x-sysv128437 +Ref: vax-dec-ultrix129398 +Ref: x-x-vxworks129550 +Ref: x86-64-x-x131072 +Ref: xtensa-x-elf131400 +Ref: xtensa-x-linux132069 +Ref: windows132407 +Ref: os2132731 +Ref: older133054 +Ref: elf135179 +Node: Old135437 +Node: Configurations138574 +Node: GNU Free Documentation License142556 +Node: Concept Index164962  End Tag Table diff --git a/contrib/gcc-4.0/gcc/doc/gccint.info b/contrib/gcc-4.0/gcc/doc/gccint.info index e2fc0759d9..ed0a515b74 100644 --- a/contrib/gcc-4.0/gcc/doc/gccint.info +++ b/contrib/gcc-4.0/gcc/doc/gccint.info @@ -1,5 +1,5 @@ -This is doc/gccint.info, produced by makeinfo version 4.7 from -/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/doc/gccint.texi. +This is doc/gccint.info, produced by makeinfo version 4.8 from +/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/doc/gccint.texi. Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. @@ -58,7 +58,7 @@ Introduction This manual documents the internals of the GNU compilers, including how to port them to new targets and some information about how to write -front ends for new languages. It corresponds to GCC version 4.0.0. +front ends for new languages. It corresponds to GCC version 4.0.1. The use of the GNU compilers is documented in a separate manual. *Note Introduction: (gcc)Top. @@ -2888,6 +2888,21 @@ run after gimplification and what source files they are located in. `tree-ssa-loop-manip.c', `cfgloop.c', `cfgloopanal.c' and `cfgloopmanip.c'. + Vectorization. This pass transforms loops to operate on vector + types instead of scalar types. Data parallelism across loop + iterations is exploited to group data elements from consecutive + iterations into a vector and operate on them in parallel. + Depending on available target support the loop is conceptually + unrolled by a factor `VF' (vectorization factor), which is the + number of elements operated upon in parallel in each iteration, + and the `VF' copies of each scalar operation are fused to form a + vector operation. Additional loop transformations such as peeling + and versioning may take place to align the number of iterations, + and to align the memory accesses in the loop. The pass is + implemented in `tree-vectorizer.c' (the main driver and general + utilities), `tree-vect-analyze.c' and `tree-vect-tranform.c'. + Analysis of data references is in `tree-data-ref.c'. + * Tree level if-conversion for vectorizer This pass applies if-conversion to simple loops to help vectorizer. @@ -11994,6 +12009,104 @@ _FRV--`frv.h'_ zero--i.e. in the range of 1 to 2047. +_Blackfin family--`bfin.h'_ + + `a' + P register + + `d' + D register + + `z' + A call clobbered P register. + + `D' + Even-numbered D register + + `W' + Odd-numbered D register + + `e' + Accumulator register. + + `A' + Even-numbered accumulator register. + + `B' + Odd-numbered accumulator register. + + `b' + I register + + `B' + B register + + `f' + M register + + `c' + Registers used for circular buffering, i.e. I, B, or L + registers. + + `C' + The CC register. + + `x' + Any D, P, B, M, I or L register. + + `y' + Additional registers typically used only in prologues and + epilogues: RETS, RETN, RETI, RETX, RETE, ASTAT, SEQSTAT and + USP. + + `w' + Any register except accumulators or CC. + + `Ksh' + Signed 16 bit integer (in the range -32768 to 32767) + + `Kuh' + Unsigned 16 bit integer (in the range 0 to 65535) + + `Ks7' + Signed 7 bit integer (in the range -64 to 63) + + `Ku7' + Unsigned 7 bit integer (in the range 0 to 127) + + `Ku5' + Unsigned 5 bit integer (in the range 0 to 31) + + `Ks4' + Signed 4 bit integer (in the range -8 to 7) + + `Ks3' + Signed 3 bit integer (in the range -3 to 4) + + `Ku3' + Unsigned 3 bit integer (in the range 0 to 7) + + `PN' + Constant N, where N is a single-digit constant in the range 0 + to 4. + + `M1' + Constant 255. + + `M2' + Constant 65535. + + `J' + An integer constant with exactly a single bit set. + + `L' + An integer constant with all bits set except exactly one. + + `H' + + `Q' + Any SYMBOL_REF. + _IP2K--`ip2k.h'_ `a' @@ -26903,6 +27016,9 @@ alphabetical order. the support for System V Release 4. He has also worked heavily on the Intel 386 and 860 support. + * Mostafa Hagog for Swing Modulo Scheduling (SMS) and post reload + GCSE. + * Bruno Haible for improvements in the runtime overhead for EH, new warnings and assorted bug fixes. @@ -27406,6 +27522,8 @@ alphabetical order. * Kevin Zachmann helped port GCC to the Tahoe. + * Ayal Zaks for Swing Modulo Scheduling (SMS). + * Xiaoqiang Zhang for work on gfortran. * Gilles Zunino for help porting Java to Irix. @@ -30641,208 +30759,208 @@ Node: Parsing pass105062 Node: Gimplification pass108590 Node: Pass manager110417 Node: Tree-SSA passes111745 -Node: RTL passes126100 -Node: Trees137762 -Node: Deficiencies140488 -Node: Tree overview140725 -Node: Macros and Functions144848 -Node: Identifiers144994 -Node: Containers146519 -Node: Types147674 -Node: Scopes160282 -Node: Namespaces161044 -Node: Classes163856 -Node: Declarations168613 -Node: Functions174664 -Node: Function Basics177067 -Node: Function Bodies184232 -Node: Attributes196208 -Node: Expression trees197449 -Node: Tree SSA226472 -Node: GENERIC228327 -Node: GIMPLE229935 -Node: Interfaces231280 -Node: Temporaries233156 -Ref: Temporaries-Footnote-1234474 -Node: GIMPLE Expressions234537 -Node: Compound Expressions235307 -Node: Compound Lvalues235553 -Node: Conditional Expressions236331 -Node: Logical Operators237006 -Node: Statements237497 -Node: Blocks238203 -Node: Statement Sequences239618 -Node: Empty Statements239953 -Node: Loops240529 -Node: Selection Statements240771 -Node: Jumps241622 -Node: Cleanups242265 -Node: GIMPLE Exception Handling242915 -Node: GIMPLE Example244084 -Node: Rough GIMPLE Grammar245493 -Node: Annotations250424 -Node: Statement Operands251088 -Node: SSA262295 -Node: Alias analysis268791 -Node: RTL274865 -Node: RTL Objects276969 -Node: RTL Classes280843 -Node: Accessors285795 -Node: Special Accessors288189 -Node: Flags292059 -Node: Machine Modes307513 -Node: Constants316231 -Node: Regs and Memory322344 -Node: Arithmetic335399 -Node: Comparisons343532 -Node: Bit-Fields347824 -Node: Vector Operations349376 -Node: Conversions351002 -Node: RTL Declarations354317 -Node: Side Effects355138 -Node: Incdec371254 -Node: Assembler374594 -Node: Insns376126 -Node: Calls401953 -Node: Sharing404546 -Node: Reading RTL407656 -Node: Control Flow408646 -Node: Basic Blocks409617 -Node: Edges414185 -Node: Profile information422747 -Node: Maintaining the CFG427433 -Node: Liveness information434448 -Node: Machine Desc436868 -Node: Overview439323 -Node: Patterns441364 -Node: Example444802 -Node: RTL Template446237 -Node: Output Template456892 -Node: Output Statement460858 -Node: Predicates464820 -Node: Machine-Independent Predicates467738 -Node: Defining Predicates472370 -Node: Constraints477019 -Node: Simple Constraints478048 -Node: Multi-Alternative490436 -Node: Class Preferences493277 -Node: Modifiers494169 -Node: Machine Constraints498089 -Node: Standard Names520250 -Ref: shift patterns531456 -Ref: prologue instruction pattern566546 -Ref: epilogue instruction pattern567039 -Node: Pattern Ordering569490 -Node: Dependent Patterns570726 -Node: Jump Patterns573540 -Node: Looping Patterns579273 -Node: Insn Canonicalizations583875 -Node: Expander Definitions588037 -Node: Insn Splitting596155 -Node: Including Patterns605742 -Node: Peephole Definitions607522 -Node: define_peephole608775 -Node: define_peephole2615106 -Node: Insn Attributes618173 -Node: Defining Attributes619279 -Node: Expressions621296 -Node: Tagging Insns627898 -Node: Attr Example632251 -Node: Insn Lengths634625 -Node: Constant Attributes637684 -Node: Delay Slots638853 -Node: Processor pipeline description642077 -Ref: Processor pipeline description-Footnote-1659414 -Node: Conditional Execution659744 -Node: Constant Definitions662597 -Node: Macros664189 -Node: Mode Macros664618 -Node: Defining Mode Macros665570 -Node: String Substitutions667055 -Node: Examples668851 -Node: Code Macros670294 -Node: Target Macros672509 -Node: Target Structure675315 -Node: Driver676584 -Node: Run-time Target698844 -Node: Per-Function Data709434 -Node: Storage Layout712197 -Node: Type Layout736672 -Node: Registers747548 -Node: Register Basics748471 -Node: Allocation Order754038 -Node: Values in Registers755483 -Node: Leaf Functions761159 -Node: Stack Registers764017 -Node: Register Classes765133 -Node: Stack and Calling791306 -Node: Frame Layout791809 -Node: Exception Handling800992 -Node: Stack Checking807340 -Node: Frame Registers810969 -Node: Elimination817573 -Node: Stack Arguments821602 -Node: Register Arguments828177 -Node: Scalar Return842404 -Node: Aggregate Return847175 -Node: Caller Saves850626 -Node: Function Entry851802 -Node: Profiling864418 -Node: Tail Calls866074 -Node: Varargs866906 -Node: Trampolines874866 -Node: Library Calls881641 -Node: Addressing Modes886061 -Node: Condition Code900111 -Node: Costs908398 -Node: Scheduling920398 -Node: Sections933453 -Node: PIC944549 -Node: Assembler Format947395 -Node: File Framework948474 -Node: Data Output954037 -Node: Uninitialized Data961468 -Node: Label Output967000 -Node: Initialization988075 -Node: Macros for Initialization994037 -Node: Instruction Output1000100 -Node: Dispatch Tables1009094 -Node: Exception Region Output1012579 -Node: Alignment Output1017626 -Node: Debugging Info1021770 -Node: All Debuggers1022440 -Node: DBX Options1025295 -Node: DBX Hooks1030744 -Node: File Names and DBX1032670 -Node: SDB and DWARF1034781 -Node: VMS Debug1038478 -Node: Floating Point1039048 -Node: Mode Switching1043870 -Node: Target Attributes1047796 -Node: MIPS Coprocessors1052285 -Node: PCH Target1053859 -Node: C++ ABI1055120 -Node: Misc1057995 -Ref: TARGET_SHIFT_TRUNCATION_MASK1066898 -Node: Host Config1098466 -Node: Host Common1099526 -Node: Filesystem1101905 -Node: Host Misc1106020 -Node: Fragments1108380 -Node: Target Fragment1109575 -Node: Host Fragment1115003 -Node: Collect21116445 -Node: Header Dirs1118988 -Node: Type Information1120411 -Node: GTY Options1122599 -Node: GGC Roots1132733 -Node: Files1133453 -Node: Funding1136117 -Node: GNU Project1138613 -Node: Copying1139262 -Node: GNU Free Documentation License1158415 -Node: Contributors1180814 -Node: Option Index1210864 -Node: Concept Index1211449 +Node: RTL passes127043 +Node: Trees138705 +Node: Deficiencies141431 +Node: Tree overview141668 +Node: Macros and Functions145791 +Node: Identifiers145937 +Node: Containers147462 +Node: Types148617 +Node: Scopes161225 +Node: Namespaces161987 +Node: Classes164799 +Node: Declarations169556 +Node: Functions175607 +Node: Function Basics178010 +Node: Function Bodies185175 +Node: Attributes197151 +Node: Expression trees198392 +Node: Tree SSA227415 +Node: GENERIC229270 +Node: GIMPLE230878 +Node: Interfaces232223 +Node: Temporaries234099 +Ref: Temporaries-Footnote-1235417 +Node: GIMPLE Expressions235480 +Node: Compound Expressions236250 +Node: Compound Lvalues236496 +Node: Conditional Expressions237274 +Node: Logical Operators237949 +Node: Statements238440 +Node: Blocks239146 +Node: Statement Sequences240561 +Node: Empty Statements240896 +Node: Loops241472 +Node: Selection Statements241714 +Node: Jumps242565 +Node: Cleanups243208 +Node: GIMPLE Exception Handling243858 +Node: GIMPLE Example245027 +Node: Rough GIMPLE Grammar246436 +Node: Annotations251367 +Node: Statement Operands252031 +Node: SSA263238 +Node: Alias analysis269734 +Node: RTL275808 +Node: RTL Objects277912 +Node: RTL Classes281786 +Node: Accessors286738 +Node: Special Accessors289132 +Node: Flags293002 +Node: Machine Modes308456 +Node: Constants317174 +Node: Regs and Memory323287 +Node: Arithmetic336342 +Node: Comparisons344475 +Node: Bit-Fields348767 +Node: Vector Operations350319 +Node: Conversions351945 +Node: RTL Declarations355260 +Node: Side Effects356081 +Node: Incdec372197 +Node: Assembler375537 +Node: Insns377069 +Node: Calls402896 +Node: Sharing405489 +Node: Reading RTL408599 +Node: Control Flow409589 +Node: Basic Blocks410560 +Node: Edges415128 +Node: Profile information423690 +Node: Maintaining the CFG428376 +Node: Liveness information435391 +Node: Machine Desc437811 +Node: Overview440266 +Node: Patterns442307 +Node: Example445745 +Node: RTL Template447180 +Node: Output Template457835 +Node: Output Statement461801 +Node: Predicates465763 +Node: Machine-Independent Predicates468681 +Node: Defining Predicates473313 +Node: Constraints477962 +Node: Simple Constraints478991 +Node: Multi-Alternative491379 +Node: Class Preferences494220 +Node: Modifiers495112 +Node: Machine Constraints499032 +Node: Standard Names522963 +Ref: shift patterns534169 +Ref: prologue instruction pattern569259 +Ref: epilogue instruction pattern569752 +Node: Pattern Ordering572203 +Node: Dependent Patterns573439 +Node: Jump Patterns576253 +Node: Looping Patterns581986 +Node: Insn Canonicalizations586588 +Node: Expander Definitions590750 +Node: Insn Splitting598868 +Node: Including Patterns608455 +Node: Peephole Definitions610235 +Node: define_peephole611488 +Node: define_peephole2617819 +Node: Insn Attributes620886 +Node: Defining Attributes621992 +Node: Expressions624009 +Node: Tagging Insns630611 +Node: Attr Example634964 +Node: Insn Lengths637338 +Node: Constant Attributes640397 +Node: Delay Slots641566 +Node: Processor pipeline description644790 +Ref: Processor pipeline description-Footnote-1662127 +Node: Conditional Execution662457 +Node: Constant Definitions665310 +Node: Macros666902 +Node: Mode Macros667331 +Node: Defining Mode Macros668283 +Node: String Substitutions669768 +Node: Examples671564 +Node: Code Macros673007 +Node: Target Macros675222 +Node: Target Structure678028 +Node: Driver679297 +Node: Run-time Target701557 +Node: Per-Function Data712147 +Node: Storage Layout714910 +Node: Type Layout739385 +Node: Registers750261 +Node: Register Basics751184 +Node: Allocation Order756751 +Node: Values in Registers758196 +Node: Leaf Functions763872 +Node: Stack Registers766730 +Node: Register Classes767846 +Node: Stack and Calling794019 +Node: Frame Layout794522 +Node: Exception Handling803705 +Node: Stack Checking810053 +Node: Frame Registers813682 +Node: Elimination820286 +Node: Stack Arguments824315 +Node: Register Arguments830890 +Node: Scalar Return845117 +Node: Aggregate Return849888 +Node: Caller Saves853339 +Node: Function Entry854515 +Node: Profiling867131 +Node: Tail Calls868787 +Node: Varargs869619 +Node: Trampolines877579 +Node: Library Calls884354 +Node: Addressing Modes888774 +Node: Condition Code902824 +Node: Costs911111 +Node: Scheduling923111 +Node: Sections936166 +Node: PIC947262 +Node: Assembler Format950108 +Node: File Framework951187 +Node: Data Output956750 +Node: Uninitialized Data964181 +Node: Label Output969713 +Node: Initialization990788 +Node: Macros for Initialization996750 +Node: Instruction Output1002813 +Node: Dispatch Tables1011807 +Node: Exception Region Output1015292 +Node: Alignment Output1020339 +Node: Debugging Info1024483 +Node: All Debuggers1025153 +Node: DBX Options1028008 +Node: DBX Hooks1033457 +Node: File Names and DBX1035383 +Node: SDB and DWARF1037494 +Node: VMS Debug1041191 +Node: Floating Point1041761 +Node: Mode Switching1046583 +Node: Target Attributes1050509 +Node: MIPS Coprocessors1054998 +Node: PCH Target1056572 +Node: C++ ABI1057833 +Node: Misc1060708 +Ref: TARGET_SHIFT_TRUNCATION_MASK1069611 +Node: Host Config1101179 +Node: Host Common1102239 +Node: Filesystem1104618 +Node: Host Misc1108733 +Node: Fragments1111093 +Node: Target Fragment1112288 +Node: Host Fragment1117716 +Node: Collect21119158 +Node: Header Dirs1121701 +Node: Type Information1123124 +Node: GTY Options1125312 +Node: GGC Roots1135446 +Node: Files1136166 +Node: Funding1138830 +Node: GNU Project1141326 +Node: Copying1141975 +Node: GNU Free Documentation License1161128 +Node: Contributors1183527 +Node: Option Index1213709 +Node: Concept Index1214294  End Tag Table diff --git a/contrib/gcc-4.0/gcc/doc/gcj-dbtool.1 b/contrib/gcc-4.0/gcc/doc/gcj-dbtool.1 index a4bdedbfc5..405377bb4d 100644 --- a/contrib/gcc-4.0/gcc/doc/gcj-dbtool.1 +++ b/contrib/gcc-4.0/gcc/doc/gcj-dbtool.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "GCJ-DBTOOL 1" -.TH GCJ-DBTOOL 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH GCJ-DBTOOL 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" gcj\-dbtool \- Manipulate class file mapping databases for libgcj .SH "SYNOPSIS" diff --git a/contrib/gcc-4.0/gcc/doc/gcj.1 b/contrib/gcc-4.0/gcc/doc/gcj.1 index 018afea77e..e34d4bbdc8 100644 --- a/contrib/gcc-4.0/gcc/doc/gcj.1 +++ b/contrib/gcc-4.0/gcc/doc/gcj.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "GCJ 1" -.TH GCJ 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH GCJ 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" gcj \- Ahead\-of\-time compiler for the Java language .SH "SYNOPSIS" @@ -495,7 +495,7 @@ this because null pointer accesses are caught automatically by the processor. .SH "SEE ALSO" .IX Header "SEE ALSO" -\&\fIgcc\fR\|(1), \fIgcjh\fR\|(1), \fIgij\fR\|(1), \fIjv\-scan\fR\|(1), \fIjcf\-dump\fR\|(1), \fIgfdl\fR\|(7), +\&\fIgcc\fR\|(1), \fIgcjh\fR\|(1), \fIgjnih\fR\|(1), \fIgij\fR\|(1), \fIjv\-scan\fR\|(1), \fIjcf\-dump\fR\|(1), \fIgfdl\fR\|(7), and the Info entries for \fIgcj\fR and \fIgcc\fR. .SH "COPYRIGHT" .IX Header "COPYRIGHT" diff --git a/contrib/gcc-4.0/gcc/doc/gcj.info b/contrib/gcc-4.0/gcc/doc/gcj.info index fc7f424b0a..bbdf12d597 100644 --- a/contrib/gcc-4.0/gcc/doc/gcj.info +++ b/contrib/gcc-4.0/gcc/doc/gcj.info @@ -1,5 +1,5 @@ -This is doc/gcj.info, produced by makeinfo version 4.7 from -/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/java/gcj.texi. +This is doc/gcj.info, produced by makeinfo version 4.8 from +/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/java/gcj.texi. Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. @@ -20,7 +20,7 @@ texts being (a) (see below), and with the Back-Cover Texts being (b) You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise -funds for GNU development. man end +funds for GNU development. INFO-DIR-SECTION Programming START-INFO-DIR-ENTRY @@ -31,6 +31,8 @@ INFO-DIR-SECTION Individual utilities START-INFO-DIR-ENTRY * gcjh: (gcj)Invoking gcjh. Generate header files from Java class files +* gjnih: (gcj)Invoking gjnih. + Generate JNI header files from Java class files * jv-scan: (gcj)Invoking jv-scan. Print information about Java source files * jcf-dump: (gcj)Invoking jcf-dump. @@ -65,7 +67,7 @@ texts being (a) (see below), and with the Back-Cover Texts being (b) You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise -funds for GNU development. man end +funds for GNU development.  File: gcj.info, Node: Top, Next: Copying, Up: (dir) @@ -85,6 +87,7 @@ object files, and it can read both Java source code and `.class' files. * Invoking gcj:: Compiler options supported by `gcj' * Compatibility:: Compatibility between gcj and other tools for Java * Invoking gcjh:: Generate header files from class files +* Invoking gjnih:: Generate JNI header files from class files * Invoking jv-scan:: Print information about source files * Invoking jcf-dump:: Print information about class files * Invoking gij:: Interpreting Java bytecodes @@ -1382,7 +1385,7 @@ have been added are to facilitate this functionality.  -File: gcj.info, Node: Invoking gcjh, Next: Invoking jv-scan, Prev: Compatibility, Up: Top +File: gcj.info, Node: Invoking gcjh, Next: Invoking gjnih, Prev: Compatibility, Up: Top 3 Invoking gcjh *************** @@ -1402,6 +1405,18 @@ required native methods. This tells `gcjh' to generate a JNI header or stub. By default, CNI headers are generated. +`-force' + This option forces `gcjh' to write the output file. + +`-old' + This option is accepted but ignored for compatibility. + +`-trace' + This option is accepted but ignored for compatibility. + +`-J OPTION' + This option is accepted but ignored for compatibility. + `-add TEXT' Inserts TEXT into the class body. This is ignored in JNI mode. @@ -1419,6 +1434,7 @@ required native methods. `--classpath=PATH' `--CLASSPATH=PATH' +`--bootclasspath=PATH' `-IDIRECTORY' `-d DIRECTORY' `-o FILE' @@ -1456,9 +1472,93 @@ required native methods. All remaining options are considered to be names of classes.  -File: gcj.info, Node: Invoking jv-scan, Next: Invoking jcf-dump, Prev: Invoking gcjh, Up: Top +File: gcj.info, Node: Invoking gjnih, Next: Invoking jv-scan, Prev: Invoking gcjh, Up: Top + +4 Invoking gjnih +**************** + +The `gjnih' program is used to generate JNI header files from class +files. Running it is equivalent to running `gcjh -jni'. + +`-stubs' + This causes `gjnih' to generate stub files instead of header files. + By default the stub file will be named after the class, with a + suffix of `.c'. + +`-jni' + This option specifies the default behavior which is to generate a + JNI header or stub. + +`-force' + This option forces `gjnih' to write the output file. -4 Invoking jv-scan +`-old' + This option is accepted but ignored for compatibility. + +`-trace' + This option is accepted but ignored for compatibility. + +`-J OPTION' + This option is accepted but ignored for compatibility. + +`-add TEXT' + Inserts TEXT into the class body. This is ignored in by `gjnih'. + +`-append TEXT' + Inserts TEXT into the header file after the class declaration. + This is ignored in by `gjnih'. + +`-friend TEXT' + Inserts TEXT into the class as a `friend' declaration. This is + ignored by `gjnih'. + +`-prepend TEXT' + Inserts TEXT into the header file before the class declaration. + This is ignored in by `gjnih'. + +`--classpath=PATH' +`--CLASSPATH=PATH' +`--bootclasspath=PATH' +`-IDIRECTORY' +`-d DIRECTORY' +`-o FILE' + These options are all identical to the corresponding `gcj' options. + +`-o FILE' + Sets the output file name. This cannot be used if there is more + than one class on the command line. + +`-td DIRECTORY' + Sets the name of the directory to use for temporary files. + +`-M' + Print all dependencies to stdout; suppress ordinary output. + +`-MM' + Print non-system dependencies to stdout; suppress ordinary output. + +`-MD' + Print all dependencies to stdout. + +`-MMD' + Print non-system dependencies to stdout. + +`--help' + Print help about `gjnih' and exit. No further processing is done. + +`--version' + Print version information for `gjnih' and exit. No further + processing is done. + +`-v, --verbose' + Print extra information while running. + + All remaining options are considered to be names of classes. + + +File: gcj.info, Node: Invoking jv-scan, Next: Invoking jcf-dump, Prev: Invoking gjnih, Up: Top + +5 Invoking jv-scan ****************** The `jv-scan' program can be used to print information about a Java @@ -1498,7 +1598,7 @@ source file (`.java' file).  File: gcj.info, Node: Invoking jcf-dump, Next: Invoking gij, Prev: Invoking jv-scan, Up: Top -5 Invoking jcf-dump +6 Invoking jcf-dump ******************* This is a class file examiner, similar to `javap'. It will print @@ -1536,7 +1636,7 @@ or file name.  File: gcj.info, Node: Invoking gij, Next: Invoking gcj-dbtool, Prev: Invoking jcf-dump, Up: Top -6 Invoking gij +7 Invoking gij ************** `gij' is a Java bytecode interpreter included with `libgcj'. `gij' is @@ -1584,6 +1684,11 @@ been compiled and put into a shared library on the class path. `-mx=NUMBER' Equivalent to `-Xmx'. +`-noverify' + Do not verify compliance of bytecode with the VM specification. In + addition, this option disables type verification which is + otherwise performed on BC-ABI compiled code. + `-X' `-XARGUMENT' Supplying `-X' by itself will cause `gij' to list all the @@ -1623,12 +1728,13 @@ been compiled and put into a shared library on the class path. `gij' also recognizes and ignores the following options, for compatibility with existing application launch scripts: `-client', `-server', `-hotspot', `-jrockit', `-agentlib', `-agentpath', `-debug', -`-d32', `-d64', `-javaagent' and `-noclassgc'. +`-d32', `-d64', `-javaagent', `-noclassgc', `-verify', and +`-verifyremote'.  File: gcj.info, Node: Invoking gcj-dbtool, Next: Invoking jv-convert, Prev: Invoking gij, Up: Top -7 Invoking gcj-dbtool. +8 Invoking gcj-dbtool. ********************** `gcj-dbtool' is a tool for creating and manipulating class file mapping @@ -1694,7 +1800,7 @@ unexplored area. We welcome your comments.  File: gcj.info, Node: Invoking jv-convert, Next: Invoking grmic, Prev: Invoking gcj-dbtool, Up: Top -8 Invoking jv-convert +9 Invoking jv-convert ********************* `jv-convert' [`OPTION'] ... [INPUTFILE [OUTPUTFILE]] @@ -1733,8 +1839,8 @@ Currently there is no way to get a list of all supported encodings.  File: gcj.info, Node: Invoking grmic, Next: Invoking grmiregistry, Prev: Invoking jv-convert, Up: Top -9 Invoking grmic -**************** +10 Invoking grmic +***************** `grmic' [`OPTION'] ... CLASS ... @@ -1784,7 +1890,7 @@ instance, `--help' is accepted.  File: gcj.info, Node: Invoking grmiregistry, Next: About CNI, Prev: Invoking grmic, Up: Top -10 Invoking grmiregistry +11 Invoking grmiregistry ************************ `grmic' [`OPTION'] ... [PORT] @@ -1801,7 +1907,7 @@ If no port number is specified, then port 1099 is used.  File: gcj.info, Node: About CNI, Next: System properties, Prev: Invoking grmiregistry, Up: Top -11 About CNI +12 About CNI ************ This documents CNI, the Compiled Native Interface, which is is a @@ -1831,7 +1937,7 @@ standard JNI (Java Native Interface).  File: gcj.info, Node: Basic concepts, Next: Packages, Up: About CNI -11.1 Basic concepts +12.1 Basic concepts =================== In terms of languages features, Java is mostly a subset of C++. Java @@ -1880,7 +1986,7 @@ other libraries. Internal functions in CNI start with the prefix `_Jv_'. You should not call these; if you find a need to, let us know and we will try to come up with an alternate solution. -11.1.1 Limitations +12.1.1 Limitations ------------------ Whilst a Java class is just a C++ class that doesn't mean that you are @@ -1894,7 +2000,7 @@ member variable of some non-Java datatype.  File: gcj.info, Node: Packages, Next: Primitive types, Prev: Basic concepts, Up: About CNI -11.2 Packages +12.2 Packages ============= The only global names in Java are class names, and packages. A @@ -1927,7 +2033,7 @@ Here is how you could express this: The `gcjh' tool automatically generates the necessary namespace declarations. -11.2.1 Leaving out package names +12.2.1 Leaving out package names -------------------------------- Always using the fully-qualified name of a java class can be tiresomely @@ -1966,7 +2072,7 @@ The same effect can be achieved in C++ like this:  File: gcj.info, Node: Primitive types, Next: Interfaces, Prev: Packages, Up: About CNI -11.3 Primitive types +12.3 Primitive types ==================== Java provides 8 "primitives" types which represent integers, floats, @@ -1990,7 +2096,7 @@ type: When referring to a Java type You should always use these C++ typenames (e.g.: `jint') to avoid disappointment. -11.3.1 Reference types associated with primitive types +12.3.1 Reference types associated with primitive types ------------------------------------------------------ In Java each primitive type has an associated reference type, e.g.: @@ -2008,7 +2114,7 @@ make working with such classes easier GCJ provides the macro  File: gcj.info, Node: Interfaces, Next: Objects and Classes, Prev: Primitive types, Up: About CNI -11.4 Interfaces +12.4 Interfaces =============== A Java class can "implement" zero or more "interfaces", in addition to @@ -2041,10 +2147,10 @@ unless you cast it to an `A' first.  File: gcj.info, Node: Objects and Classes, Next: Class Initialization, Prev: Interfaces, Up: About CNI -11.5 Objects and Classes +12.5 Objects and Classes ======================== -11.5.1 Classes +12.5.1 Classes -------------- All Java classes are derived from `java.lang.Object'. C++ does not @@ -2056,7 +2162,7 @@ Java classes are mapped into corresponding C++ classes derived from Interface inheritance (the `implements' keyword) is currently not reflected in the C++ mapping. -11.5.2 Object fields +12.5.2 Object fields -------------------- Each object contains an object header, followed by the instance fields @@ -2096,7 +2202,7 @@ the following Java class: return new Int(p->i * k); } -11.5.3 Access specifiers +12.5.3 Access specifiers ------------------------ CNI does not strictly enforce the Java access specifiers, because Java @@ -2107,7 +2213,7 @@ but other fields and methods are mapped to public fields and methods.  File: gcj.info, Node: Class Initialization, Next: Object allocation, Prev: Objects and Classes, Up: About CNI -11.6 Class Initialization +12.6 Class Initialization ========================= Java requires that each class be automatically initialized at the time @@ -2153,7 +2259,7 @@ a static field from C++.  File: gcj.info, Node: Object allocation, Next: Memory allocation, Prev: Class Initialization, Up: About CNI -11.7 Object allocation +12.7 Object allocation ====================== New Java objects are allocated using a "class instance creation @@ -2176,7 +2282,7 @@ For example:  File: gcj.info, Node: Memory allocation, Next: Arrays, Prev: Object allocation, Up: About CNI -11.8 Memory allocation +12.8 Memory allocation ====================== When allocting memory in CNI methods it is best to handle out-of-memory @@ -2197,7 +2303,7 @@ for that purpose:  File: gcj.info, Node: Arrays, Next: Methods, Prev: Memory allocation, Up: About CNI -11.9 Arrays +12.9 Arrays =========== While in many ways Java is similar to C and C++, it is quite different @@ -2254,7 +2360,7 @@ type: Here `klass' is the type of elements of the array and `init' is the initial value put into every slot in the array. -11.9.1 Creating arrays +12.9.1 Creating arrays ---------------------- For each primitive type there is a function which can be used to create @@ -2280,7 +2386,7 @@ functions:  File: gcj.info, Node: Methods, Next: Strings, Prev: Arrays, Up: About CNI -11.10 Methods +12.10 Methods ============= Java methods are mapped directly into C++ methods. The header files @@ -2289,7 +2395,7 @@ Basically, the generated methods have the same names and _corresponding_ types as the Java methods, and are called in the natural manner. -11.10.1 Overloading +12.10.1 Overloading ------------------- Both Java and C++ provide method overloading, where multiple methods in @@ -2307,7 +2413,7 @@ mechanism is used to implement Java overloading. For C++/Java interoperability, it is important that both the Java and C++ compilers use the _same_ encoding scheme. -11.10.2 Static methods +12.10.2 Static methods ---------------------- Static Java methods are invoked in CNI using the standard C++ syntax, @@ -2327,7 +2433,7 @@ For example: ... } -11.10.3 Object Constructors +12.10.3 Object Constructors --------------------------- Constructors are called implicitly as part of object allocation using @@ -2341,7 +2447,7 @@ For example: limitation can be coded round however because a constructor can _call_ a native method. -11.10.4 Instance methods +12.10.4 Instance methods ------------------------ Calling a Java instance method from a C++ CNI method is done using the @@ -2364,7 +2470,7 @@ Defining a Java native instance method is also done the natural way: return (jdouble) value; } -11.10.5 Interface methods +12.10.5 Interface methods ------------------------- In Java you can call a method using an interface reference. This is @@ -2373,7 +2479,7 @@ supported, but not completely. *Note Interfaces::.  File: gcj.info, Node: Strings, Next: Mixing with C++, Prev: Methods, Up: About CNI -11.11 Strings +12.11 Strings ============= CNI provides a number of utility functions for working with Java Java @@ -2413,7 +2519,7 @@ JNI.  File: gcj.info, Node: Mixing with C++, Next: Exception Handling, Prev: Strings, Up: About CNI -11.12 Interoperating with C/C++ +12.12 Interoperating with C/C++ =============================== Because CNI is designed to represent Java classes and methods it cannot @@ -2451,7 +2557,7 @@ Of course, it is ok to use C/C++ types within the scope of a method: . } -11.12.1 RawData +12.12.1 RawData --------------- The above restriction can be problematic, so CNI includes the @@ -2493,7 +2599,7 @@ Here are some examples: printf("%s\n", (char*) string); } -11.12.2 RawDataManaged +12.12.2 RawDataManaged ---------------------- `gnu.gcj.RawDataManaged' is another type used to indicate special data @@ -2505,7 +2611,7 @@ for garbage collection. and stored in a `RawDataManaged' will be automatically freed when the Java object it is associated with becomes unreachable. -11.12.3 Native memory allocation +12.12.3 Native memory allocation -------------------------------- -- Function: void* JvAllocBytes (jsize SIZE) @@ -2519,7 +2625,7 @@ Java object it is associated with becomes unreachable. automatically freed when the Java object itself becomes unreachable. -11.12.4 Posix signals +12.12.4 Posix signals --------------------- On Posix based systems the `libgcj' library uses several signals @@ -2534,7 +2640,7 @@ and by `Thread.interrupt()'.  File: gcj.info, Node: Exception Handling, Next: Synchronization, Prev: Mixing with C++, Up: About CNI -11.13 Exception Handling +12.13 Exception Handling ======================== While C++ and Java share a common exception handling framework, things @@ -2579,7 +2685,7 @@ destructors when exceptions are thrown through them.  File: gcj.info, Node: Synchronization, Next: Invocation, Prev: Exception Handling, Up: About CNI -11.14 Synchronization +12.14 Synchronization ===================== Each Java object has an implicit monitor. The Java VM uses the @@ -2635,7 +2741,7 @@ manually add `JvSynchronize' in a `native synchronized' method.  File: gcj.info, Node: Invocation, Next: Reflection, Prev: Synchronization, Up: About CNI -11.15 Invocation +12.15 Invocation ================ CNI permits C++ applications to make calls into Java classes, in @@ -2707,7 +2813,7 @@ known as the "invocation API", are provided to support this. garbage collection. This function returns `0' upon success, or `-1' if the current thread is not attached. -11.15.1 Handling uncaught exceptions +12.15.1 Handling uncaught exceptions ------------------------------------ If an exception is thrown from Java code called using the invocation @@ -2716,7 +2822,7 @@ abort the application. In order to make the application more robust, it is recommended that code which uses the invocation API be wrapped by a top-level try/catch block that catches all Java exceptions. -11.15.2 Example +12.15.2 Example --------------- The following code demonstrates the use of the invocation API. In this @@ -2760,7 +2866,7 @@ handler for any uncaught exceptions.  File: gcj.info, Node: Reflection, Prev: Invocation, Up: About CNI -11.16 Reflection +12.16 Reflection ================ Reflection is possible with CNI code, it functions similarly to how it @@ -2783,7 +2889,7 @@ will be added shortly, as will other functions corresponding to JNI.  File: gcj.info, Node: System properties, Next: Resources, Prev: About CNI, Up: Top -12 System properties +13 System properties ******************** The runtime behavior of the `libgcj' library can be modified by setting @@ -2804,7 +2910,7 @@ calling the `java.lang.System.getProperty()' method.  File: gcj.info, Node: Standard Properties, Next: GNU Classpath Properties, Up: System properties -12.1 Standard Properties +13.1 Standard Properties ======================== The following properties are normally found in all implementations of @@ -2959,7 +3065,7 @@ the core libraries for the Java language.  File: gcj.info, Node: GNU Classpath Properties, Next: libgcj Runtime Properties, Prev: Standard Properties, Up: System properties -12.2 GNU Classpath Properties +13.2 GNU Classpath Properties ============================= `libgcj' is based on the GNU Classpath (Essential Libraries for Java) a @@ -2986,7 +3092,7 @@ are common to libraries based on GNU Classpath.  File: gcj.info, Node: libgcj Runtime Properties, Prev: GNU Classpath Properties, Up: System properties -12.3 libgcj Runtime Properties +13.3 libgcj Runtime Properties ============================== The following properties are specific to the `libgcj' runtime and will @@ -3078,7 +3184,7 @@ normally not be found in other core libraries for the java language.  File: gcj.info, Node: Resources, Prev: System properties, Up: Top -13 Resources +14 Resources ************ While writing `gcj' and `libgcj' we have, of course, relied heavily on @@ -3100,49 +3206,50 @@ for more information.  Tag Table: -Node: Top2749 -Node: Copying3973 -Node: GNU Free Documentation License23141 -Node: Invoking gcj45543 -Node: Input and output files46242 -Node: Input Options47768 -Node: Encodings50916 -Node: Warnings52122 -Node: Linking53235 -Node: Code Generation55468 -Node: Configure-time Options60485 -Node: Compatibility61908 -Node: Limitations62388 -Node: Extensions63970 -Node: Invoking gcjh66568 -Node: Invoking jv-scan68624 -Node: Invoking jcf-dump69665 -Node: Invoking gij70613 -Node: Invoking gcj-dbtool73584 -Node: Invoking jv-convert76050 -Node: Invoking grmic77129 -Node: Invoking grmiregistry78517 -Node: About CNI78930 -Node: Basic concepts80292 -Node: Packages83188 -Node: Primitive types85516 -Node: Interfaces87184 -Node: Objects and Classes88095 -Node: Class Initialization90295 -Node: Object allocation92638 -Node: Memory allocation93428 -Node: Arrays94059 -Node: Methods96663 -Node: Strings99484 -Node: Mixing with C++100968 -Node: Exception Handling104439 -Node: Synchronization106073 -Node: Invocation108063 -Node: Reflection112988 -Node: System properties113449 -Node: Standard Properties114326 -Node: GNU Classpath Properties118758 -Node: libgcj Runtime Properties119804 -Node: Resources123786 +Node: Top2837 +Node: Copying4128 +Node: GNU Free Documentation License23296 +Node: Invoking gcj45698 +Node: Input and output files46397 +Node: Input Options47923 +Node: Encodings51071 +Node: Warnings52277 +Node: Linking53390 +Node: Code Generation55623 +Node: Configure-time Options60640 +Node: Compatibility62063 +Node: Limitations62543 +Node: Extensions64125 +Node: Invoking gcjh66723 +Node: Invoking gjnih69078 +Node: Invoking jv-scan71266 +Node: Invoking jcf-dump72308 +Node: Invoking gij73256 +Node: Invoking gcj-dbtool76454 +Node: Invoking jv-convert78920 +Node: Invoking grmic79999 +Node: Invoking grmiregistry81389 +Node: About CNI81802 +Node: Basic concepts83164 +Node: Packages86060 +Node: Primitive types88388 +Node: Interfaces90056 +Node: Objects and Classes90967 +Node: Class Initialization93167 +Node: Object allocation95510 +Node: Memory allocation96300 +Node: Arrays96931 +Node: Methods99535 +Node: Strings102356 +Node: Mixing with C++103840 +Node: Exception Handling107311 +Node: Synchronization108945 +Node: Invocation110935 +Node: Reflection115860 +Node: System properties116321 +Node: Standard Properties117198 +Node: GNU Classpath Properties121630 +Node: libgcj Runtime Properties122676 +Node: Resources126658  End Tag Table diff --git a/contrib/gcc-4.0/gcc/doc/gcjh.1 b/contrib/gcc-4.0/gcc/doc/gcjh.1 index 2b74dae821..6e48643121 100644 --- a/contrib/gcc-4.0/gcc/doc/gcjh.1 +++ b/contrib/gcc-4.0/gcc/doc/gcjh.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,15 +129,17 @@ .\" ======================================================================== .\" .IX Title "GCJH 1" -.TH GCJH 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH GCJH 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" gcjh \- generate header files from Java class files .SH "SYNOPSIS" .IX Header "SYNOPSIS" gcjh [\fB\-stubs\fR] [\fB\-jni\fR] + [\fB\-force\fR] [\fB\-old\fR] [\fB\-trace\fR] [\fB\-J\fR \fIoption\fR] [\fB\-add\fR \fItext\fR] [\fB\-append\fR \fItext\fR] [\fB\-friend\fR \fItext\fR] [\fB\-preprend\fR \fItext\fR] [\fB\-\-classpath\fR=\fIpath\fR] [\fB\-\-CLASSPATH\fR=\fIpath\fR] + [\fB\-\-bootclasspath\fR=\fIpath\fR] [\fB\-I\fR\fIdir\fR...] [\fB\-d\fR \fIdir\fR...] [\fB\-o\fR \fIfile\fR] [\fB\-td\fR \fIdir\fR] [\fB\-M\fR] [\fB\-MM\fR] [\fB\-MD\fR] [\fB\-MMD\fR] @@ -161,6 +163,18 @@ By default the stub file will be named after the class, with a suffix of .IX Item "-jni" This tells \f(CW\*(C`gcjh\*(C'\fR to generate a \s-1JNI\s0 header or stub. By default, \&\s-1CNI\s0 headers are generated. +.IP "\fB\-force\fR" 4 +.IX Item "-force" +This option forces \f(CW\*(C`gcjh\*(C'\fR to write the output file. +.IP "\fB\-old\fR" 4 +.IX Item "-old" +This option is accepted but ignored for compatibility. +.IP "\fB\-trace\fR" 4 +.IX Item "-trace" +This option is accepted but ignored for compatibility. +.IP "\fB\-J\fR \fIoption\fR" 4 +.IX Item "-J option" +This option is accepted but ignored for compatibility. .IP "\fB\-add\fR \fItext\fR" 4 .IX Item "-add text" Inserts \fItext\fR into the class body. This is ignored in \s-1JNI\s0 mode. @@ -181,6 +195,8 @@ This is ignored in \s-1JNI\s0 mode. .PD 0 .IP "\fB\-\-CLASSPATH=\fR\fIpath\fR" 4 .IX Item "--CLASSPATH=path" +.IP "\fB\-\-bootclasspath=\fR\fIpath\fR" 4 +.IX Item "--bootclasspath=path" .IP "\fB\-I\fR\fIdirectory\fR" 4 .IX Item "-Idirectory" .IP "\fB\-d\fR \fIdirectory\fR" 4 diff --git a/contrib/gcc-4.0/gcc/doc/gcov.1 b/contrib/gcc-4.0/gcc/doc/gcov.1 index 2afc49c3b7..b1a6816aa4 100644 --- a/contrib/gcc-4.0/gcc/doc/gcov.1 +++ b/contrib/gcc-4.0/gcc/doc/gcov.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "GCOV 1" -.TH GCOV 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH GCOV 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" gcov \- coverage testing tool .SH "SYNOPSIS" diff --git a/contrib/gcc-4.0/gcc/doc/gfdl.7 b/contrib/gcc-4.0/gcc/doc/gfdl.7 index 2971a5bf0d..6d3b2f54f4 100644 --- a/contrib/gcc-4.0/gcc/doc/gfdl.7 +++ b/contrib/gcc-4.0/gcc/doc/gfdl.7 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "GFDL 7" -.TH GFDL 7 "2005-04-21" "gcc-4.0.0" "GNU" +.TH GFDL 7 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" gfdl \- GNU Free Documentation License .SH "DESCRIPTION" diff --git a/contrib/gcc-4.0/gcc/doc/gij.1 b/contrib/gcc-4.0/gcc/doc/gij.1 index 712c762b9e..9f2a7a7c39 100644 --- a/contrib/gcc-4.0/gcc/doc/gij.1 +++ b/contrib/gcc-4.0/gcc/doc/gij.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "GIJ 1" -.TH GIJ 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH GIJ 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" gij \- GNU interpreter for Java bytecode .SH "SYNOPSIS" @@ -193,6 +193,11 @@ Equivalent to \f(CW\*(C`\-Xms\*(C'\fR. .IP "\fB\-mx=\fR\fInumber\fR" 4 .IX Item "-mx=number" Equivalent to \f(CW\*(C`\-Xmx\*(C'\fR. +.IP "\fB\-noverify\fR" 4 +.IX Item "-noverify" +Do not verify compliance of bytecode with the \s-1VM\s0 specification. In addition, +this option disables type verification which is otherwise performed on BC-ABI +compiled code. .IP "\fB\-X\fR" 4 .IX Item "-X" .PD 0 @@ -246,7 +251,8 @@ Each time a class is initialized, print a short message on standard error. compatibility with existing application launch scripts: \&\f(CW\*(C`\-client\*(C'\fR, \f(CW\*(C`\-server\*(C'\fR, \f(CW\*(C`\-hotspot\*(C'\fR, \f(CW\*(C`\-jrockit\*(C'\fR, \&\f(CW\*(C`\-agentlib\*(C'\fR, \f(CW\*(C`\-agentpath\*(C'\fR, \f(CW\*(C`\-debug\*(C'\fR, \f(CW\*(C`\-d32\*(C'\fR, -\&\f(CW\*(C`\-d64\*(C'\fR, \f(CW\*(C`\-javaagent\*(C'\fR and \f(CW\*(C`\-noclassgc\*(C'\fR. +\&\f(CW\*(C`\-d64\*(C'\fR, \f(CW\*(C`\-javaagent\*(C'\fR, \f(CW\*(C`\-noclassgc\*(C'\fR, \f(CW\*(C`\-verify\*(C'\fR, +and \f(CW\*(C`\-verifyremote\*(C'\fR. .SH "SEE ALSO" .IX Header "SEE ALSO" \&\fIgcc\fR\|(1), \fIgcj\fR\|(1), \fIgcjh\fR\|(1), \fIjv\-scan\fR\|(1), \fIjcf\-dump\fR\|(1), \fIgfdl\fR\|(7), diff --git a/contrib/gcc-4.0/gcc/doc/gpl.7 b/contrib/gcc-4.0/gcc/doc/gpl.7 index d98e284d52..22a23ae22c 100644 --- a/contrib/gcc-4.0/gcc/doc/gpl.7 +++ b/contrib/gcc-4.0/gcc/doc/gpl.7 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "GPL 7" -.TH GPL 7 "2005-04-21" "gcc-4.0.0" "GNU" +.TH GPL 7 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" gpl \- GNU General Public License .SH "DESCRIPTION" diff --git a/contrib/gcc-4.0/gcc/doc/grmic.1 b/contrib/gcc-4.0/gcc/doc/grmic.1 index c9e2c8f7b0..2101254451 100644 --- a/contrib/gcc-4.0/gcc/doc/grmic.1 +++ b/contrib/gcc-4.0/gcc/doc/grmic.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "GRMIC 1" -.TH GRMIC 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH GRMIC 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" grmic \- Generate stubs for Remote Method Invocation .SH "SYNOPSIS" diff --git a/contrib/gcc-4.0/gcc/doc/grmiregistry.1 b/contrib/gcc-4.0/gcc/doc/grmiregistry.1 index 35a3c80d4b..08fd1a1cac 100644 --- a/contrib/gcc-4.0/gcc/doc/grmiregistry.1 +++ b/contrib/gcc-4.0/gcc/doc/grmiregistry.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "GRMIREGISTRY 1" -.TH GRMIREGISTRY 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH GRMIREGISTRY 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" grmiregistry \- Remote object registry .SH "SYNOPSIS" diff --git a/contrib/gcc-4.0/gcc/doc/include/gcc-common.texi b/contrib/gcc-4.0/gcc/doc/include/gcc-common.texi index 30fc8f10cc..4855fcc2f8 100644 --- a/contrib/gcc-4.0/gcc/doc/include/gcc-common.texi +++ b/contrib/gcc-4.0/gcc/doc/include/gcc-common.texi @@ -4,7 +4,7 @@ @c Common values used in the GCC manuals: -@set version-GCC 4.0.0 +@set version-GCC 4.0.1 @c DEVELOPMENT is set to indicate an in-development version, @c as compared to a release version. When making a release diff --git a/contrib/gcc-4.0/gcc/doc/install.texi b/contrib/gcc-4.0/gcc/doc/install.texi index cd6bfcd185..37b4c8d175 100644 --- a/contrib/gcc-4.0/gcc/doc/install.texi +++ b/contrib/gcc-4.0/gcc/doc/install.texi @@ -328,7 +328,7 @@ the 1.9.x series, which is currently 1.9.3. When regenerating a directory to a newer version, please update all the directories using an older 1.9.x to the latest released version. -@item gettext version 0.12 (or later) +@item gettext version 0.14.5 (or later) Needed to regenerate @file{gcc.pot}. @@ -1052,13 +1052,14 @@ their runtime libraries should be built. For a list of valid values for grep language= */config-lang.in @end smallexample Currently, you can use any of the following: -@code{ada}, @code{c}, @code{c++}, @code{f77}, @code{f95}, @code{java}, -@code{objc}, @code{obj-c++}. -Building the Ada compiler has special requirements, see below.@* -If you do not pass this flag, all languages available in the @file{gcc} -sub-tree will be configured. Re-defining @code{LANGUAGES} when calling -@samp{make bootstrap} @strong{does not} work anymore, as those -language sub-directories might not have been configured! +@code{all}, @code{ada}, @code{c}, @code{c++}, @code{f95}, @code{java}, +@code{objc}, @code{treelang}. +Building the Ada compiler has special requirements, see below. +If you do not pass this flag, or specify the option @code{all}, then all +default languages available in the @file{gcc} sub-tree will be configured. +Ada and treelang are not default languages; the rest are. Re-defining +@code{LANGUAGES} when calling @samp{make bootstrap} @strong{does not} work +anymore, as those language sub-directories might not have been configured! @item --disable-libada Specify that the run-time libraries and tools used by GNAT should not @@ -2026,8 +2027,8 @@ Free Software Foundation}, though such manuals may not be for the most recent version of GCC@. If you would like to generate online HTML documentation, do @samp{cd -@var{objdir}; make html} and HTML will be generated for the manuals in -@file{@var{objdir}/HTML}. +@var{objdir}; make html} and HTML will be generated for the gcc manuals in +@file{@var{objdir}/gcc/HTML}. @html
@@ -2183,6 +2184,8 @@ GNU Compiler Collection on your machine. @item @uref{#avr,,avr} @item +@uref{#bfin,,Blackfin} +@item @uref{#c4x,,c4x} @item @uref{#dos,,DOS} @@ -2203,7 +2206,9 @@ GNU Compiler Collection on your machine. @item @uref{#ix86-x-linux,,i?86-*-linux*} @item -@uref{#ix86-x-sco3.2v5,,i?86-*-sco3.2v5*} +@uref{#ix86-x-sco32v5,,i?86-*-sco3.2v5*} +@item +@uref{#ix86-x-solaris210,,i?86-*-solaris2.10} @item @uref{#ix86-x-udk,,i?86-*-udk} @item @@ -2261,7 +2266,7 @@ GNU Compiler Collection on your machine. @item @uref{#sparc-sun-solaris2,,sparc-sun-solaris2*} @item -@uref{#sparc-sun-solaris2.7,,sparc-sun-solaris2.7} +@uref{#sparc-sun-solaris27,,sparc-sun-solaris2.7} @item @uref{#sparc-x-linux,,sparc-*-linux*} @item @@ -2275,7 +2280,7 @@ GNU Compiler Collection on your machine. @item @uref{#x-x-vxworks,,*-*-vxworks*} @item -@uref{#x86_64-x-x,,x86_64-*-*, amd64-*-*} +@uref{#x86-64-x-x,,x86_64-*-*, amd64-*-*} @item @uref{#xtensa-x-elf,,xtensa-*-elf} @item @@ -2290,7 +2295,7 @@ GNU Compiler Collection on your machine. @itemize @item -@uref{#elf_targets,,all ELF targets} (SVR4, Solaris 2, etc.) +@uref{#elf,,all ELF targets} (SVR4, Solaris 2, etc.) @end itemize @end ifhtml @@ -2493,6 +2498,23 @@ indicates that you should upgrade to a newer version of the binutils. @html
@end html +@heading @anchor{bfin}Blackfin + +The Blackfin processor, an Analog Devices DSP. +@ifnothtml +@xref{Blackfin Options,, Blackfin Options, gcc, Using and Porting the GNU +Compiler Collection (GCC)}, +@end ifnothtml +@ifhtml +See ``Blackfin Options'' in the main manual +@end ifhtml + +More information, and a version of binutils with support for this processor, +is available at @uref{http://blackfin.uclinux.org} + +@html +
+@end html @heading @anchor{c4x}c4x Texas Instruments TMS320C3x and TMS320C4x Floating Point Digital Signal @@ -2874,7 +2896,7 @@ found on @uref{http://www.bitwizard.nl/sig11/,,www.bitwizard.nl}. @html
@end html -@heading @anchor{ix86-x-sco3.2v5}i?86-*-sco3.2v5* +@heading @anchor{ix86-x-sco32v5}i?86-*-sco3.2v5* Use this for the SCO OpenServer Release 5 family of operating systems. Unlike earlier versions of GCC, the ability to generate COFF with this @@ -2918,6 +2940,18 @@ GCC, version 2.95.3. It is useful for bootstrapping this version. @html
@end html +@heading @anchor{ix86-x-solaris210}i?86-*-solaris2.10 +Use this for Solaris 10 or later on x86 and x86-64 systems. This +configuration is supported by GCC 4.0 and later versions only. + +It is recommended that you configure GCC to use the GNU assembler in +@file{/usr/sfw/bin/gas} but the Sun linker, using the options +@option{--with-gnu-as --with-as=/usr/sfw/bin/gas --without-gnu-ld +--with-ld=/usr/ccs/bin/ld}. + +@html +
+@end html @heading @anchor{ix86-x-udk}i?86-*-udk This target emulates the SCO Universal Development Kit and requires that @@ -3588,11 +3622,11 @@ failure in form of a miscompilation of the stage1 compiler by the Sun compiler. This is Sun bug 4974440. This is fixed with patch 112760-07. GCC 3.4 changed the default debugging format from STABS to DWARF-2 for -32-bit code on Solaris 7 and later. If you are using the Sun -assembler, this change apparently runs afoul of Sun bug 4910101, for -which (as of 2004-05-23) there is no fix. A symptom of the problem is -that you cannot compile C++ programs like @command{groff} 1.19.1 -without getting messages similar to the following: +32-bit code on Solaris 7 and later. If you use the Sun assembler, this +change apparently runs afoul of Sun bug 4910101 (which is referenced as +a x86-only problem by Sun, probably because they do not use DWARF-2). +A symptom of the problem is that you cannot compile C++ programs like +@command{groff} 1.19.1 without getting messages similar to the following: @smallexample ld: warning: relocation error: R_SPARC_UA32: @dots{} @@ -3614,7 +3648,7 @@ or later system, the canonical target triplet must be specified as the @html
@end html -@heading @anchor{sparc-sun-solaris2.7}sparc-sun-solaris2.7 +@heading @anchor{sparc-sun-solaris27}sparc-sun-solaris2.7 Sun patch 107058-01 (1999-01-13) for Solaris 7/SPARC triggers a bug in the dynamic linker. This problem (Sun bug 4210064) affects GCC 2.8 @@ -3662,6 +3696,17 @@ ld: fatal: relocation error: R_SPARC_32: file libgcc/sparcv9/_muldi3.o: This bug has been fixed in the final 5.0 version of the assembler. +A similar problem was reported for version Sun WorkShop 6 99/08/18 of the +Sun assembler, which causes a bootstrap failure with GCC 4.0.0: + +@smallexample +ld: fatal: relocation error: R_SPARC_DISP32: + file .libs/libstdc++.lax/libsupc++convenience.a/vterminate.o: + symbol : offset 0xfccd33ad is non-aligned +@end smallexample + +This bug has been fixed in more recent revisions of the assembler. + @html
@end html @@ -3773,7 +3818,7 @@ VxWorks will incorporate this module.) @html
@end html -@heading @anchor{x86_64-x-x}x86_64-*-*, amd64-*-* +@heading @anchor{x86-64-x-x}x86_64-*-*, amd64-*-* GCC supports the x86-64 architecture implemented by the AMD64 processor (amd64-*-* is an alias for x86_64-*-*) on GNU/Linux, FreeBSD and NetBSD@. @@ -3886,7 +3931,7 @@ current GCC) is to be found in the GCC texinfo manual. @html
@end html -@heading @anchor{elf_targets}all ELF targets (SVR4, Solaris 2, etc.) +@heading @anchor{elf}all ELF targets (SVR4, Solaris 2, etc.) C++ support is significantly better on ELF targets if you use the @uref{./configure.html#with-gnu-ld,,GNU linker}; duplicate copies of diff --git a/contrib/gcc-4.0/gcc/doc/invoke.texi b/contrib/gcc-4.0/gcc/doc/invoke.texi index 09d8a9c033..d207c30d70 100644 --- a/contrib/gcc-4.0/gcc/doc/invoke.texi +++ b/contrib/gcc-4.0/gcc/doc/invoke.texi @@ -185,7 +185,7 @@ in the following sections. -fno-default-inline -fvisibility-inlines-hidden @gol -Wabi -Wctor-dtor-privacy @gol -Wnon-virtual-dtor -Wreorder @gol --Weffc++ -Wno-deprecated @gol +-Weffc++ -Wno-deprecated -Wstrict-null-sentinel @gol -Wno-non-template-friend -Wold-style-cast @gol -Woverloaded-virtual -Wno-pmf-conversions @gol -Wsign-promo} @@ -399,6 +399,11 @@ Objective-C and Objective-C++ Dialects}. @gccoptlist{-mmcu=@var{mcu} -msize -minit-stack=@var{n} -mno-interrupts @gol -mcall-prologues -mno-tablejump -mtiny-stack -mint8} +@emph{Blackfin Options} +@gccoptlist{-momit-leaf-frame-pointer -mno-omit-leaf-frame-pointer -mcsync @gol +-mno-csync -mlow-64k -mno-low64k -mid-shared-library @gol +-mno-id-shared-library -mshared-library-id=@var{n} @gol} + @emph{CRIS Options} @gccoptlist{-mcpu=@var{cpu} -march=@var{cpu} -mtune=@var{cpu} @gol -mmax-stack-frame=@var{n} -melinux-stacksize=@var{n} @gol @@ -1730,6 +1735,14 @@ to filter out those warnings. @opindex Wno-deprecated Do not warn about usage of deprecated features. @xref{Deprecated Features}. +@item -Wstrict-null-sentinel @r{(C++ only)} +@opindex Wstrict-null-sentinel +Warn also about the use of an uncasted @code{NULL} as sentinel. When +compiling only with GCC this is a valid sentinel, as @code{NULL} is defined +to @code{__null}. Although it is a null pointer constant not a null pointer, +it is guaranteed to of the same size as a pointer. But this use is +not portable across different compilers. + @item -Wno-non-template-friend @r{(C++ only)} @opindex Wno-non-template-friend Disable warnings when non-templatized friend functions are declared @@ -2533,11 +2546,13 @@ get these warnings. If you want to warn about code which uses the uninitialized value of the variable in its own initializer, use the @option{-Winit-self} option. -These warnings occur only for variables that are candidates for -register allocation. Therefore, they do not occur for a variable that -is declared @code{volatile}, or whose address is taken, or whose size -is other than 1, 2, 4 or 8 bytes. Also, they do not occur for -structures, unions or arrays, even when they are in registers. +These warnings occur for individual uninitialized or clobbered +elements of structure, union or array variables as well as for +variables which are uninitialized or clobbered as a whole. They do +not occur for variables or elements declared @code{volatile}. Because +these warnings depend on optimization, the exact variables or elements +for which there are warnings will depend on the precise optimization +options and version of GCC used. Note that there may be no warning about a variable that is used only to compute a value that itself is never used, because such @@ -5553,6 +5568,10 @@ If number of candidates in the set is smaller than this value, we always try to remove unnecessary ivs from the set during its optimization when a new iv is added to the set. +@item scev-max-expr-size +Bound on size of expressions used in the scalar evolutions analyzer. +Large expressions slow the analyzer. + @item max-iterations-to-track The maximum number of iterations of a loop the brute force algorithm @@ -6660,6 +6679,7 @@ that macro, which enables you to change the defaults. * ARC Options:: * ARM Options:: * AVR Options:: +* Blackfin Options:: * CRIS Options:: * Darwin Options:: * DEC Alpha Options:: @@ -7111,6 +7131,57 @@ comply to the C standards, but it will provide you with smaller code size. @end table +@node Blackfin Options +@subsection Blackfin Options +@cindex Blackfin Options + +@table @gcctabopt +@item -momit-leaf-frame-pointer +@opindex momit-leaf-frame-pointer +Don't keep the frame pointer in a register for leaf functions. This +avoids the instructions to save, set up and restore frame pointers and +makes an extra register available in leaf functions. The option +@option{-fomit-frame-pointer} removes the frame pointer for all functions +which might make debugging harder. + +@item -mcsync +@opindex mcsync +When enabled, the compiler will ensure that the generated code does not +contain speculative loads after jump instructions. This option is enabled +by default. + +@item -mno-csync +@opindex mno-csync +Don't generate extra code to prevent speculative loads from occurring. + +@item -mlow-64k +@opindex mlow-64k +When enabled, the compiler is free to take advantage of the knowledge that +the entire program fits into the low 64k of memory. + +@item -mno-low-64k +@opindex mno-low-64k +Assume that the program is arbitrarily large. This is the default. + +@item -mid-shared-library +@opindex mid-shared-library +Generate code that supports shared libraries via the library ID method. +This allows for execute in place and shared libraries in an environment +without virtual memory management. This option implies @option{-fPIC}. + +@item -mno-id-shared-library +@opindex mno-id-shared-library +Generate code that doesn't assume ID based shared libraries are being used. +This is the default. + +@item -mshared-library-id=n +@opindex mshared-library-id +Specified the identification number of the ID based shared library being +compiled. Specifying a value of 0 will generate more compact code, specifying +other values will force the allocation of that number to the current +library but is no more space or time efficient than omitting this option. +@end table + @node CRIS Options @subsection CRIS Options @cindex CRIS Options diff --git a/contrib/gcc-4.0/gcc/doc/jcf-dump.1 b/contrib/gcc-4.0/gcc/doc/jcf-dump.1 index 95ae22e420..8f21fc6c15 100644 --- a/contrib/gcc-4.0/gcc/doc/jcf-dump.1 +++ b/contrib/gcc-4.0/gcc/doc/jcf-dump.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "JCF-DUMP 1" -.TH JCF-DUMP 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH JCF-DUMP 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" jcf\-dump \- print information about Java class files .SH "SYNOPSIS" diff --git a/contrib/gcc-4.0/gcc/doc/jv-convert.1 b/contrib/gcc-4.0/gcc/doc/jv-convert.1 index 2d2c5aeb65..45a7ee67c1 100644 --- a/contrib/gcc-4.0/gcc/doc/jv-convert.1 +++ b/contrib/gcc-4.0/gcc/doc/jv-convert.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "JV-CONVERT 1" -.TH JV-CONVERT 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH JV-CONVERT 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" jv\-convert \- Convert file from one encoding to another .SH "SYNOPSIS" diff --git a/contrib/gcc-4.0/gcc/doc/jv-scan.1 b/contrib/gcc-4.0/gcc/doc/jv-scan.1 index 4c14cdd9a6..58c5c742cd 100644 --- a/contrib/gcc-4.0/gcc/doc/jv-scan.1 +++ b/contrib/gcc-4.0/gcc/doc/jv-scan.1 @@ -1,4 +1,4 @@ -.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13 +.\" Automatically generated by Pod::Man v1.37, Pod::Parser v1.14 .\" .\" Standard preamble: .\" ======================================================================== @@ -129,7 +129,7 @@ .\" ======================================================================== .\" .IX Title "JV-SCAN 1" -.TH JV-SCAN 1 "2005-04-21" "gcc-4.0.0" "GNU" +.TH JV-SCAN 1 "2005-07-07" "gcc-4.0.1" "GNU" .SH "NAME" jv\-scan \- print information about Java source file .SH "SYNOPSIS" diff --git a/contrib/gcc-4.0/gcc/doc/md.texi b/contrib/gcc-4.0/gcc/doc/md.texi index 11b08820e9..02fb6ff08c 100644 --- a/contrib/gcc-4.0/gcc/doc/md.texi +++ b/contrib/gcc-4.0/gcc/doc/md.texi @@ -2069,6 +2069,102 @@ range of 1 to 2047. @end table +@item Blackfin family---@file{bfin.h} +@table @code +@item a +P register + +@item d +D register + +@item z +A call clobbered P register. + +@item D +Even-numbered D register + +@item W +Odd-numbered D register + +@item e +Accumulator register. + +@item A +Even-numbered accumulator register. + +@item B +Odd-numbered accumulator register. + +@item b +I register + +@item B +B register + +@item f +M register + +@item c +Registers used for circular buffering, i.e. I, B, or L registers. + +@item C +The CC register. + +@item x +Any D, P, B, M, I or L register. + +@item y +Additional registers typically used only in prologues and epilogues: RETS, +RETN, RETI, RETX, RETE, ASTAT, SEQSTAT and USP. + +@item w +Any register except accumulators or CC. + +@item Ksh +Signed 16 bit integer (in the range -32768 to 32767) + +@item Kuh +Unsigned 16 bit integer (in the range 0 to 65535) + +@item Ks7 +Signed 7 bit integer (in the range -64 to 63) + +@item Ku7 +Unsigned 7 bit integer (in the range 0 to 127) + +@item Ku5 +Unsigned 5 bit integer (in the range 0 to 31) + +@item Ks4 +Signed 4 bit integer (in the range -8 to 7) + +@item Ks3 +Signed 3 bit integer (in the range -3 to 4) + +@item Ku3 +Unsigned 3 bit integer (in the range 0 to 7) + +@item P@var{n} +Constant @var{n}, where @var{n} is a single-digit constant in the range 0 to 4. + +@item M1 +Constant 255. + +@item M2 +Constant 65535. + +@item J +An integer constant with exactly a single bit set. + +@item L +An integer constant with all bits set except exactly one. + +@item H + +@item Q +Any SYMBOL_REF. +@end table + @item IP2K---@file{ip2k.h} @table @code @item a diff --git a/contrib/gcc-4.0/gcc/doc/passes.texi b/contrib/gcc-4.0/gcc/doc/passes.texi index af11f725a4..24342ecd6d 100644 --- a/contrib/gcc-4.0/gcc/doc/passes.texi +++ b/contrib/gcc-4.0/gcc/doc/passes.texi @@ -393,6 +393,19 @@ The optimizations also use various utility functions contained in @file{tree-ssa-loop-manip.c}, @file{cfgloop.c}, @file{cfgloopanal.c} and @file{cfgloopmanip.c}. +Vectorization. This pass transforms loops to operate on vector types +instead of scalar types. Data parallelism across loop iterations is exploited +to group data elements from consecutive iterations into a vector and operate +on them in parallel. Depending on available target support the loop is +conceptually unrolled by a factor @code{VF} (vectorization factor), which is +the number of elements operated upon in parallel in each iteration, and the +@code{VF} copies of each scalar operation are fused to form a vector operation. +Additional loop transformations such as peeling and versioning may take place +to align the number of iterations, and to align the memory accesses in the loop. +The pass is implemented in @file{tree-vectorizer.c} (the main driver and general +utilities), @file{tree-vect-analyze.c} and @file{tree-vect-tranform.c}. +Analysis of data references is in @file{tree-data-ref.c}. + @item Tree level if-conversion for vectorizer This pass applies if-conversion to simple loops to help vectorizer. diff --git a/contrib/gcc-4.0/gcc/dojump.c b/contrib/gcc-4.0/gcc/dojump.c index c10ea39c36..898c422415 100644 --- a/contrib/gcc-4.0/gcc/dojump.c +++ b/contrib/gcc-4.0/gcc/dojump.c @@ -207,14 +207,6 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label) do_jump (TREE_OPERAND (exp, 0), if_false_label, if_true_label); break; - case MINUS_EXPR: - /* Nonzero iff operands of minus differ. */ - do_compare_and_jump (build2 (NE_EXPR, TREE_TYPE (exp), - TREE_OPERAND (exp, 0), - TREE_OPERAND (exp, 1)), - NE, NE, if_false_label, if_true_label); - break; - case BIT_AND_EXPR: /* fold_single_bit_test() converts (X & (1 << C)) into (X >> C) & 1. See if the former is preferred for jump tests and restore it @@ -369,6 +361,12 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label) break; } + case MINUS_EXPR: + /* Nonzero iff operands of minus differ. */ + exp = build2 (NE_EXPR, TREE_TYPE (exp), + TREE_OPERAND (exp, 0), + TREE_OPERAND (exp, 1)); + /* FALLTHRU */ case NE_EXPR: { tree inner_type = TREE_TYPE (TREE_OPERAND (exp, 0)); diff --git a/contrib/gcc-4.0/gcc/dwarf2out.c b/contrib/gcc-4.0/gcc/dwarf2out.c index 66802cdfcd..9eb3818041 100644 --- a/contrib/gcc-4.0/gcc/dwarf2out.c +++ b/contrib/gcc-4.0/gcc/dwarf2out.c @@ -2069,6 +2069,7 @@ output_call_frame_info (int for_eh) int fde_encoding = DW_EH_PE_absptr; int per_encoding = DW_EH_PE_absptr; int lsda_encoding = DW_EH_PE_absptr; + int return_reg; /* Don't emit a CIE if there won't be any FDEs. */ if (fde_table_in_use == 0) @@ -2207,10 +2208,11 @@ output_call_frame_info (int for_eh) dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT, "CIE Data Alignment Factor"); + return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh); if (DW_CIE_VERSION == 1) - dw2_asm_output_data (1, DWARF_FRAME_RETURN_COLUMN, "CIE RA Column"); + dw2_asm_output_data (1, return_reg, "CIE RA Column"); else - dw2_asm_output_data_uleb128 (DWARF_FRAME_RETURN_COLUMN, "CIE RA Column"); + dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column"); if (augmentation[0]) { @@ -11528,8 +11530,13 @@ gen_variable_die (tree decl, dw_die_ref context_die) copy decls and set the DECL_ABSTRACT flag on them instead of sharing them. - ??? Duplicated blocks have been rewritten to use .debug_ranges. */ - else if (old_die && TREE_STATIC (decl) + ??? Duplicated blocks have been rewritten to use .debug_ranges. + + ??? The declare_in_namespace support causes us to get two DIEs for one + variable, both of which are declarations. We want to avoid considering + one to be a specification, so we must test that this DIE is not a + declaration. */ + else if (old_die && TREE_STATIC (decl) && ! declaration && get_AT_flag (old_die, DW_AT_declaration) == 1) { /* This is a definition of a C++ class level static. */ diff --git a/contrib/gcc-4.0/gcc/expr.c b/contrib/gcc-4.0/gcc/expr.c index 0d4715bbb5..3b0b7decb2 100644 --- a/contrib/gcc-4.0/gcc/expr.c +++ b/contrib/gcc-4.0/gcc/expr.c @@ -126,7 +126,7 @@ static void move_by_pieces_1 (rtx (*) (rtx, ...), enum machine_mode, struct move_by_pieces *); static bool block_move_libcall_safe_for_call_parm (void); static bool emit_block_move_via_movmem (rtx, rtx, rtx, unsigned); -static rtx emit_block_move_via_libcall (rtx, rtx, rtx); +static rtx emit_block_move_via_libcall (rtx, rtx, rtx, bool); static tree emit_block_move_libcall_fn (int); static void emit_block_move_via_loop (rtx, rtx, rtx, unsigned); static rtx clear_by_pieces_1 (void *, HOST_WIDE_INT, enum machine_mode); @@ -135,7 +135,7 @@ static void store_by_pieces_1 (struct store_by_pieces *, unsigned int); static void store_by_pieces_2 (rtx (*) (rtx, ...), enum machine_mode, struct store_by_pieces *); static bool clear_storage_via_clrmem (rtx, rtx, unsigned); -static rtx clear_storage_via_libcall (rtx, rtx); +static rtx clear_storage_via_libcall (rtx, rtx, bool); static tree clear_storage_libcall_fn (int); static rtx compress_float_constant (rtx, rtx); static rtx get_subtarget (rtx); @@ -1124,6 +1124,7 @@ emit_block_move (rtx x, rtx y, rtx size, enum block_op_methods method) switch (method) { case BLOCK_OP_NORMAL: + case BLOCK_OP_TAILCALL: may_use_call = true; break; @@ -1172,7 +1173,8 @@ emit_block_move (rtx x, rtx y, rtx size, enum block_op_methods method) else if (emit_block_move_via_movmem (x, y, size, align)) ; else if (may_use_call) - retval = emit_block_move_via_libcall (x, y, size); + retval = emit_block_move_via_libcall (x, y, size, + method == BLOCK_OP_TAILCALL); else emit_block_move_via_loop (x, y, size, align); @@ -1301,7 +1303,7 @@ emit_block_move_via_movmem (rtx x, rtx y, rtx size, unsigned int align) Return the return value from memcpy, 0 otherwise. */ static rtx -emit_block_move_via_libcall (rtx dst, rtx src, rtx size) +emit_block_move_via_libcall (rtx dst, rtx src, rtx size, bool tailcall) { rtx dst_addr, src_addr; tree call_expr, arg_list, fn, src_tree, dst_tree, size_tree; @@ -1343,6 +1345,7 @@ emit_block_move_via_libcall (rtx dst, rtx src, rtx size) call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn); call_expr = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)), call_expr, arg_list, NULL_TREE); + CALL_EXPR_TAILCALL (call_expr) = tailcall; retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0); @@ -2403,11 +2406,13 @@ store_by_pieces_2 (rtx (*genfun) (rtx, ...), enum machine_mode mode, its length in bytes. */ rtx -clear_storage (rtx object, rtx size) +clear_storage (rtx object, rtx size, enum block_op_methods method) { enum machine_mode mode = GET_MODE (object); unsigned int align; + gcc_assert (method == BLOCK_OP_NORMAL || method == BLOCK_OP_TAILCALL); + /* If OBJECT is not BLKmode and SIZE is the same size as its mode, just move a zero. Otherwise, do this a piece at a time. */ if (mode != BLKmode @@ -2444,7 +2449,8 @@ clear_storage (rtx object, rtx size) else if (clear_storage_via_clrmem (object, size, align)) ; else - return clear_storage_via_libcall (object, size); + return clear_storage_via_libcall (object, size, + method == BLOCK_OP_TAILCALL); return NULL; } @@ -2509,7 +2515,7 @@ clear_storage_via_clrmem (rtx object, rtx size, unsigned int align) Return the return value of memset, 0 otherwise. */ static rtx -clear_storage_via_libcall (rtx object, rtx size) +clear_storage_via_libcall (rtx object, rtx size, bool tailcall) { tree call_expr, arg_list, fn, object_tree, size_tree; enum machine_mode size_mode; @@ -2542,6 +2548,7 @@ clear_storage_via_libcall (rtx object, rtx size) call_expr = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn); call_expr = build3 (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)), call_expr, arg_list, NULL_TREE); + CALL_EXPR_TAILCALL (call_expr) = tailcall; retval = expand_expr (call_expr, NULL_RTX, VOIDmode, 0); @@ -4246,7 +4253,7 @@ store_expr (tree exp, rtx target, int call_param_p) } if (size != const0_rtx) - clear_storage (target, size); + clear_storage (target, size, BLOCK_OP_NORMAL); if (label) emit_label (label); @@ -4601,7 +4608,7 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size) && ! CONSTRUCTOR_ELTS (exp)) /* If the constructor is empty, clear the union. */ { - clear_storage (target, expr_size (exp)); + clear_storage (target, expr_size (exp), BLOCK_OP_NORMAL); cleared = 1; } @@ -4629,7 +4636,7 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size) || ((HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target)) == size))) { - clear_storage (target, GEN_INT (size)); + clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL); cleared = 1; } @@ -4829,7 +4836,7 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size) if (REG_P (target)) emit_move_insn (target, CONST0_RTX (GET_MODE (target))); else - clear_storage (target, GEN_INT (size)); + clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL); cleared = 1; } @@ -5074,7 +5081,7 @@ store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size) if (REG_P (target)) emit_move_insn (target, CONST0_RTX (GET_MODE (target))); else - clear_storage (target, GEN_INT (size)); + clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL); cleared = 1; } diff --git a/contrib/gcc-4.0/gcc/expr.h b/contrib/gcc-4.0/gcc/expr.h index b624413e08..82557e0da5 100644 --- a/contrib/gcc-4.0/gcc/expr.h +++ b/contrib/gcc-4.0/gcc/expr.h @@ -362,7 +362,9 @@ enum block_op_methods { BLOCK_OP_NORMAL, BLOCK_OP_NO_LIBCALL, - BLOCK_OP_CALL_PARM + BLOCK_OP_CALL_PARM, + /* Like BLOCK_OP_NORMAL, but the libcall can be tail call optimized. */ + BLOCK_OP_TAILCALL }; extern void init_block_move_fn (const char *); @@ -414,7 +416,7 @@ extern void use_group_regs (rtx *, rtx); /* Write zeros through the storage of OBJECT. If OBJECT has BLKmode, SIZE is its length in bytes. */ -extern rtx clear_storage (rtx, rtx); +extern rtx clear_storage (rtx, rtx, enum block_op_methods); /* Determine whether the LEN bytes can be moved by using several move instructions. Return nonzero if a call to move_by_pieces should diff --git a/contrib/gcc-4.0/gcc/final.c b/contrib/gcc-4.0/gcc/final.c index 213ab5f745..1b4b2a5bc3 100644 --- a/contrib/gcc-4.0/gcc/final.c +++ b/contrib/gcc-4.0/gcc/final.c @@ -2845,17 +2845,17 @@ alter_cond (rtx cond) In an `asm', it's the user's fault; otherwise, the compiler's fault. */ void -output_operand_lossage (const char *msgid, ...) +output_operand_lossage (const char *cmsgid, ...) { char *fmt_string; char *new_message; const char *pfx_str; va_list ap; - va_start (ap, msgid); + va_start (ap, cmsgid); pfx_str = this_is_asm_operands ? _("invalid 'asm': ") : "output_operand: "; - asprintf (&fmt_string, "%s%s", pfx_str, _(msgid)); + asprintf (&fmt_string, "%s%s", pfx_str, _(cmsgid)); vasprintf (&new_message, fmt_string, ap); if (this_is_asm_operands) diff --git a/contrib/gcc-4.0/gcc/fold-const.c b/contrib/gcc-4.0/gcc/fold-const.c index 2313043b43..1f23487341 100644 --- a/contrib/gcc-4.0/gcc/fold-const.c +++ b/contrib/gcc-4.0/gcc/fold-const.c @@ -8418,6 +8418,7 @@ fold (tree expr) if (code == TRUNC_MOD_EXPR && !TYPE_UNSIGNED (type) && TREE_CODE (arg1) == INTEGER_CST + && !TREE_CONSTANT_OVERFLOW (arg1) && TREE_INT_CST_HIGH (arg1) < 0 && !flag_trapv /* Avoid this transformation if C is INT_MIN, i.e. C == -C. */ @@ -9932,6 +9933,8 @@ fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht) enum tree_code code; char buf[sizeof (struct tree_decl)]; int i, len; + +recursive_label: gcc_assert ((sizeof (struct tree_exp) + 5 * sizeof (tree) <= sizeof (struct tree_decl)) @@ -9953,11 +9956,13 @@ fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht) } else if (TREE_CODE_CLASS (code) == tcc_type && (TYPE_POINTER_TO (expr) || TYPE_REFERENCE_TO (expr) - || TYPE_CACHED_VALUES_P (expr))) + || TYPE_CACHED_VALUES_P (expr) + || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr))) { /* Allow these fields to be modified. */ memcpy (buf, expr, tree_size (expr)); expr = (tree) buf; + TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr) = 0; TYPE_POINTER_TO (expr) = NULL; TYPE_REFERENCE_TO (expr) = NULL; if (TYPE_CACHED_VALUES_P (expr)) @@ -9969,7 +9974,8 @@ fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht) md5_process_bytes (expr, tree_size (expr), ctx); fold_checksum_tree (TREE_TYPE (expr), ctx, ht); if (TREE_CODE_CLASS (code) != tcc_type - && TREE_CODE_CLASS (code) != tcc_declaration) + && TREE_CODE_CLASS (code) != tcc_declaration + && code != TREE_LIST) fold_checksum_tree (TREE_CHAIN (expr), ctx, ht); switch (TREE_CODE_CLASS (code)) { @@ -9997,6 +10003,8 @@ fold_checksum_tree (tree expr, struct md5_ctx *ctx, htab_t ht) case TREE_LIST: fold_checksum_tree (TREE_PURPOSE (expr), ctx, ht); fold_checksum_tree (TREE_VALUE (expr), ctx, ht); + expr = TREE_CHAIN (expr); + goto recursive_label; break; case TREE_VEC: for (i = 0; i < TREE_VEC_LENGTH (expr); ++i) @@ -11668,9 +11676,7 @@ split_address_to_core_and_offset (tree exp, core = get_inner_reference (TREE_OPERAND (exp, 0), &bitsize, pbitpos, poffset, &mode, &unsignedp, &volatilep, false); - - if (TREE_CODE (core) == INDIRECT_REF) - core = TREE_OPERAND (core, 0); + core = build_fold_addr_expr (core); } else { diff --git a/contrib/gcc-4.0/gcc/gcc.c b/contrib/gcc-4.0/gcc/gcc.c index 6a3065a218..e696b28d8a 100644 --- a/contrib/gcc-4.0/gcc/gcc.c +++ b/contrib/gcc-4.0/gcc/gcc.c @@ -6012,6 +6012,9 @@ main (int argc, const char **argv) GCC_DRIVER_HOST_INITIALIZATION; #endif + /* Unlock the stdio streams. */ + unlock_std_streams (); + gcc_init_libintl (); if (signal (SIGINT, SIG_IGN) != SIG_IGN) @@ -6736,40 +6739,46 @@ fancy_abort (const char *file, int line, const char *func) /* Output an error message and exit. */ void -fatal (const char *msgid, ...) +fatal (const char *cmsgid, ...) { va_list ap; - va_start (ap, msgid); + va_start (ap, cmsgid); fprintf (stderr, "%s: ", programname); - vfprintf (stderr, _(msgid), ap); + vfprintf (stderr, _(cmsgid), ap); va_end (ap); fprintf (stderr, "\n"); delete_temp_files (); exit (1); } +/* The argument is actually c-format, not gcc-internal-format, + but because functions with identical names are used through + the rest of the compiler with gcc-internal-format, we just + need to hope all users of these functions use the common + subset between c-format and gcc-internal-format. */ + void -error (const char *msgid, ...) +error (const char *gmsgid, ...) { va_list ap; - va_start (ap, msgid); + va_start (ap, gmsgid); fprintf (stderr, "%s: ", programname); - vfprintf (stderr, _(msgid), ap); + vfprintf (stderr, _(gmsgid), ap); va_end (ap); fprintf (stderr, "\n"); } static void -notice (const char *msgid, ...) +notice (const char *cmsgid, ...) { va_list ap; - va_start (ap, msgid); - vfprintf (stderr, _(msgid), ap); + va_start (ap, cmsgid); + vfprintf (stderr, _(cmsgid), ap); va_end (ap); } diff --git a/contrib/gcc-4.0/gcc/gcov-dump.c b/contrib/gcc-4.0/gcc/gcov-dump.c index 859fdb7331..eb1e99f293 100644 --- a/contrib/gcc-4.0/gcc/gcov-dump.c +++ b/contrib/gcc-4.0/gcc/gcov-dump.c @@ -77,6 +77,9 @@ main (int argc ATTRIBUTE_UNUSED, char **argv) { int opt; + /* Unlock the stdio streams. */ + unlock_std_streams (); + while ((opt = getopt_long (argc, argv, "hlpv", options, NULL)) != -1) { switch (opt) diff --git a/contrib/gcc-4.0/gcc/gcov-io.h b/contrib/gcc-4.0/gcc/gcov-io.h index eaa23adcb4..ede45bffcf 100644 --- a/contrib/gcc-4.0/gcc/gcov-io.h +++ b/contrib/gcc-4.0/gcc/gcov-io.h @@ -229,11 +229,15 @@ typedef HOST_WIDEST_INT gcov_type; #endif /* !IN_LIBGCOV */ -/* In gcov we want function linkage to be static. In libgcov we need - these functions to be extern, so prefix them with __gcov. In the - compiler we want it extern, so that they can be accessed from - elsewhere. */ +/* In gcov we want function linkage to be static. In the compiler we want + it extern, so that they can be accessed from elsewhere. In libgcov we + need these functions to be extern, so prefix them with __gcov. In + libgcov they must also be hidden so that the instance in the executable + is not also used in a DSO. */ #if IN_LIBGCOV + +#include "auto-host.h" /* for HAVE_GAS_HIDDEN */ + #define gcov_var __gcov_var #define gcov_open __gcov_open #define gcov_close __gcov_close @@ -253,6 +257,16 @@ typedef HOST_WIDEST_INT gcov_type; #pragma GCC poison gcov_write_string gcov_write_tag gcov_write_length #pragma GCC poison gcov_read_string gcov_sync gcov_time gcov_magic +#ifdef HAVE_GAS_HIDDEN +#define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden"))) +#else +#define ATTRIBUTE_HIDDEN +#endif + +#else + +#define ATTRIBUTE_HIDDEN + #endif #ifndef GCOV_LINKAGE @@ -432,30 +446,31 @@ struct gcov_info }; /* Register a new object file module. */ -extern void __gcov_init (struct gcov_info *); +extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN; /* Called before fork, to avoid double counting. */ -extern void __gcov_flush (void); +extern void __gcov_flush (void) ATTRIBUTE_HIDDEN; /* The merge function that just sums the counters. */ -extern void __gcov_merge_add (gcov_type *, unsigned); +extern void __gcov_merge_add (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; /* The merge function to choose the most common value. */ -extern void __gcov_merge_single (gcov_type *, unsigned); +extern void __gcov_merge_single (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; /* The merge function to choose the most common difference between consecutive values. */ -extern void __gcov_merge_delta (gcov_type *, unsigned); +extern void __gcov_merge_delta (gcov_type *, unsigned) ATTRIBUTE_HIDDEN; #ifndef inhibit_libc /* The wrappers around some library functions.. */ extern pid_t __gcov_fork (void); -extern int __gcov_execl (const char *, const char *, ...); -extern int __gcov_execlp (const char *, const char *, ...); -extern int __gcov_execle (const char *, const char *, ...); -extern int __gcov_execv (const char *, char *const []); -extern int __gcov_execvp (const char *, char *const []); -extern int __gcov_execve (const char *, char *const [], char *const []); +extern int __gcov_execl (const char *, const char *, ...) ATTRIBUTE_HIDDEN; +extern int __gcov_execlp (const char *, const char *, ...) ATTRIBUTE_HIDDEN; +extern int __gcov_execle (const char *, const char *, ...) ATTRIBUTE_HIDDEN; +extern int __gcov_execv (const char *, char *const []) ATTRIBUTE_HIDDEN; +extern int __gcov_execvp (const char *, char *const []) ATTRIBUTE_HIDDEN; +extern int __gcov_execve (const char *, char *const [], char *const []) + ATTRIBUTE_HIDDEN; #endif #endif /* IN_LIBGCOV */ @@ -487,7 +502,7 @@ GCOV_LINKAGE struct gcov_var size_t alloc; gcov_unsigned_t *buffer; #endif -} gcov_var; +} gcov_var ATTRIBUTE_HIDDEN; /* Functions for reading and writing gcov files. In libgcov you can open the file for reading then writing. Elsewhere you can open the @@ -499,29 +514,31 @@ GCOV_LINKAGE struct gcov_var functions for writing. Your file may become corrupted if you break these invariants. */ #if IN_LIBGCOV -GCOV_LINKAGE int gcov_open (const char */*name*/); +GCOV_LINKAGE int gcov_open (const char */*name*/) ATTRIBUTE_HIDDEN; #else GCOV_LINKAGE int gcov_open (const char */*name*/, int /*direction*/); GCOV_LINKAGE int gcov_magic (gcov_unsigned_t, gcov_unsigned_t); #endif -GCOV_LINKAGE int gcov_close (void); +GCOV_LINKAGE int gcov_close (void) ATTRIBUTE_HIDDEN; /* Available everywhere. */ static gcov_position_t gcov_position (void); static int gcov_is_error (void); -GCOV_LINKAGE gcov_unsigned_t gcov_read_unsigned (void); -GCOV_LINKAGE gcov_type gcov_read_counter (void); -GCOV_LINKAGE void gcov_read_summary (struct gcov_summary *); +GCOV_LINKAGE gcov_unsigned_t gcov_read_unsigned (void) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE gcov_type gcov_read_counter (void) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE void gcov_read_summary (struct gcov_summary *) ATTRIBUTE_HIDDEN; #if IN_LIBGCOV /* Available only in libgcov */ -GCOV_LINKAGE void gcov_write_counter (gcov_type); -GCOV_LINKAGE void gcov_write_tag_length (gcov_unsigned_t, gcov_unsigned_t); +GCOV_LINKAGE void gcov_write_counter (gcov_type) ATTRIBUTE_HIDDEN; +GCOV_LINKAGE void gcov_write_tag_length (gcov_unsigned_t, gcov_unsigned_t) + ATTRIBUTE_HIDDEN; GCOV_LINKAGE void gcov_write_summary (gcov_unsigned_t /*tag*/, - const struct gcov_summary *); + const struct gcov_summary *) + ATTRIBUTE_HIDDEN; static void gcov_rewrite (void); -GCOV_LINKAGE void gcov_seek (gcov_position_t /*position*/); +GCOV_LINKAGE void gcov_seek (gcov_position_t /*position*/) ATTRIBUTE_HIDDEN; #else /* Available outside libgcov */ GCOV_LINKAGE const char *gcov_read_string (void); @@ -531,7 +548,7 @@ GCOV_LINKAGE void gcov_sync (gcov_position_t /*base*/, #if !IN_GCOV /* Available outside gcov */ -GCOV_LINKAGE void gcov_write_unsigned (gcov_unsigned_t); +GCOV_LINKAGE void gcov_write_unsigned (gcov_unsigned_t) ATTRIBUTE_HIDDEN; #endif #if !IN_GCOV && !IN_LIBGCOV diff --git a/contrib/gcc-4.0/gcc/gcov.c b/contrib/gcc-4.0/gcc/gcov.c index 6675a06b60..d92e81c49a 100644 --- a/contrib/gcc-4.0/gcc/gcov.c +++ b/contrib/gcc-4.0/gcc/gcov.c @@ -347,6 +347,9 @@ main (int argc, char **argv) { int argno; + /* Unlock the stdio streams. */ + unlock_std_streams (); + gcc_init_libintl (); argno = process_args (argc, argv); @@ -364,12 +367,12 @@ main (int argc, char **argv) } static void -fnotice (FILE *file, const char *msgid, ...) +fnotice (FILE *file, const char *cmsgid, ...) { va_list ap; - va_start (ap, msgid); - vfprintf (file, _(msgid), ap); + va_start (ap, cmsgid); + vfprintf (file, _(cmsgid), ap); va_end (ap); } diff --git a/contrib/gcc-4.0/gcc/gengtype-lex.c b/contrib/gcc-4.0/gcc/gengtype-lex.c index 7bbe3187a4..548d8a251a 100644 --- a/contrib/gcc-4.0/gcc/gengtype-lex.c +++ b/contrib/gcc-4.0/gcc/gengtype-lex.c @@ -1,33 +1,86 @@ #line 2 "gengtype-lex.c" -/* A lexical scanner generated by flex */ -/* Scanner skeleton version: - * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $ - */ +#line 4 "gengtype-lex.c" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 5 +#define YY_FLEX_SUBMINOR_VERSION 31 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ #include -#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H +/* C99 systems have . Non-C99 systems may or may not. */ -/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ -#ifdef c_plusplus -#ifndef __cplusplus -#define __cplusplus +#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; +#endif /* ! C99 */ + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) #endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) #endif +#endif /* ! FLEXINT_H */ #ifdef __cplusplus -#include - -/* Use prototypes in function declarations. */ -#define YY_USE_PROTOS - /* The "const" storage-class-modifier is valid. */ #define YY_USE_CONST @@ -35,34 +88,17 @@ #if __STDC__ -#define YY_USE_PROTOS #define YY_USE_CONST #endif /* __STDC__ */ #endif /* ! __cplusplus */ -#ifdef __TURBOC__ - #pragma warn -rch - #pragma warn -use -#include -#include -#define YY_USE_CONST -#define YY_USE_PROTOS -#endif - #ifdef YY_USE_CONST #define yyconst const #else #define yyconst #endif - -#ifdef YY_USE_PROTOS -#define YY_PROTO(proto) proto -#else -#define YY_PROTO(proto) () -#endif - /* Returned upon end-of-file. */ #define YY_NULL 0 @@ -77,71 +113,71 @@ * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN. */ -#define BEGIN yy_start = 1 + 2 * +#define BEGIN (yy_start) = 1 + 2 * /* Translate the current start state into a value that can be later handed * to BEGIN to return to the state. The YYSTATE alias is for lex * compatibility. */ -#define YY_START ((yy_start - 1) / 2) +#define YY_START (((yy_start) - 1) / 2) #define YYSTATE YY_START /* Action number for EOF rule of a given start state. */ #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) /* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE yyrestart( yyin ) +#define YY_NEW_FILE yyrestart(yyin ) #define YY_END_OF_BUFFER_CHAR 0 /* Size of default input buffer. */ +#ifndef YY_BUF_SIZE #define YY_BUF_SIZE 16384 +#endif +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif extern int yyleng; + extern FILE *yyin, *yyout; #define EOB_ACT_CONTINUE_SCAN 0 #define EOB_ACT_END_OF_FILE 1 #define EOB_ACT_LAST_MATCH 2 -/* The funky do-while in the following #define is used to turn the definition - * int a single C statement (which needs a semi-colon terminator). This - * avoids problems with code like: - * - * if ( condition_holds ) - * yyless( 5 ); - * else - * do_something_else(); - * - * Prior to using the do-while the compiler would get upset at the - * "else" because it interpreted the "if" statement as being all - * done when it reached the ';' after the yyless() call. - */ - -/* Return all but the first 'n' matched characters back to the input stream. */ - + #define YY_LESS_LINENO(n) + +/* Return all but the first "n" matched characters back to the input stream. */ #define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ - *yy_cp = yy_hold_char; \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = (yy_hold_char); \ YY_RESTORE_YY_MORE_OFFSET \ - yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 ) -#define unput(c) yyunput( c, yytext_ptr ) +#define unput(c) yyunput( c, (yytext_ptr) ) /* The following is because we cannot portably get our hands on size_t * (without autoconf's help, which isn't available because we want * flex-generated scanners to compile on their own). */ -typedef unsigned int yy_size_t; +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef unsigned int yy_size_t; +#endif +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE struct yy_buffer_state { FILE *yy_input_file; @@ -178,12 +214,16 @@ struct yy_buffer_state */ int yy_at_bol; + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + /* Whether to try to fill the input buffer when we reach the * end of it. */ int yy_fill_buffer; int yy_buffer_status; + #define YY_BUFFER_NEW 0 #define YY_BUFFER_NORMAL 1 /* When an EOF's been seen but there's still some text to process @@ -197,23 +237,33 @@ struct yy_buffer_state * just pointing yyin at a new input file. */ #define YY_BUFFER_EOF_PENDING 2 + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ -static YY_BUFFER_STATE yy_current_buffer = 0; +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */ /* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general * "scanner state". + * + * Returns the top of the stack, or NULL. */ -#define YY_CURRENT_BUFFER yy_current_buffer +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] /* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; - static int yy_n_chars; /* number of characters read into yy_ch_buf */ - - int yyleng; /* Points to current character in buffer. */ @@ -226,69 +276,95 @@ static int yy_start = 0; /* start state number */ */ static int yy_did_buffer_switch_on_eof; -void yyrestart YY_PROTO(( FILE *input_file )); +void yyrestart (FILE *input_file ); +void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer (FILE *file,int size ); +void yy_delete_buffer (YY_BUFFER_STATE b ); +void yy_flush_buffer (YY_BUFFER_STATE b ); +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state (void ); -void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); -void yy_load_buffer_state YY_PROTO(( void )); -YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); -void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); -void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); -void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); -#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) +static void yyensure_buffer_stack (void ); +static void yy_load_buffer_state (void ); +static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ); -YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); -YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); -YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); +#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ) -static void *yy_flex_alloc YY_PROTO(( yy_size_t )); -static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )); -static void yy_flex_free YY_PROTO(( void * )); +YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size ); +YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len ); + +void *yyalloc (yy_size_t ); +void *yyrealloc (void *,yy_size_t ); +void yyfree (void * ); #define yy_new_buffer yy_create_buffer #define yy_set_interactive(is_interactive) \ { \ - if ( ! yy_current_buffer ) \ - yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ - yy_current_buffer->yy_is_interactive = is_interactive; \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer(yyin,YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ } #define yy_set_bol(at_bol) \ { \ - if ( ! yy_current_buffer ) \ - yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ - yy_current_buffer->yy_at_bol = at_bol; \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer(yyin,YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ } -#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) +/* Begin user sect3 */ -#define yywrap() 1 +#define yywrap(n) 1 #define YY_SKIP_YYWRAP + typedef unsigned char YY_CHAR; + FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; + typedef int yy_state_type; + +extern int yylineno; + +int yylineno = 1; + extern char *yytext; #define yytext_ptr yytext -static yy_state_type yy_get_previous_state YY_PROTO(( void )); -static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); -static int yy_get_next_buffer YY_PROTO(( void )); -static void yy_fatal_error YY_PROTO(( yyconst char msg[] )); +static yy_state_type yy_get_previous_state (void ); +static yy_state_type yy_try_NUL_trans (yy_state_type current_state ); +static int yy_get_next_buffer (void ); +static void yy_fatal_error (yyconst char msg[] ); /* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ - yytext_ptr = yy_bp; \ - yyleng = (int) (yy_cp - yy_bp); \ - yy_hold_char = *yy_cp; \ + (yytext_ptr) = yy_bp; \ + yyleng = (size_t) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ - yy_c_buf_p = yy_cp; + (yy_c_buf_p) = yy_cp; #define YY_NUM_RULES 60 #define YY_END_OF_BUFFER 61 -static yyconst short int yy_accept[932] = +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static yyconst flex_int16_t yy_accept[932] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 61, 41, 41, 38, 56, 41, 56, 41, 39, 41, @@ -395,7 +471,7 @@ static yyconst short int yy_accept[932] = 0 } ; -static yyconst int yy_ec[256] = +static yyconst flex_int32_t yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, @@ -427,7 +503,7 @@ static yyconst int yy_ec[256] = 1, 1, 1, 1, 1 } ; -static yyconst int yy_meta[66] = +static yyconst flex_int32_t yy_meta[66] = { 0, 1, 2, 3, 1, 1, 4, 1, 5, 6, 7, 1, 1, 8, 9, 1, 1, 10, 10, 10, 10, @@ -438,7 +514,7 @@ static yyconst int yy_meta[66] = 10, 10, 10, 12, 1 } ; -static yyconst short int yy_base[1016] = +static yyconst flex_int16_t yy_base[1016] = { 0, 0, 65, 130, 11, 15, 16, 18, 19, 17, 27, 3555, 0, 40, 194, 49, 43, 35, 4014, 0, 64, @@ -554,7 +630,7 @@ static yyconst short int yy_base[1016] = 3959, 3970, 3979, 3989, 4001 } ; -static yyconst short int yy_def[1016] = +static yyconst flex_int16_t yy_def[1016] = { 0, 932, 932, 931, 3, 933, 933, 933, 933, 934, 934, 931, 931, 931, 931, 935, 936, 937, 931, 938, 931, @@ -670,7 +746,7 @@ static yyconst short int yy_def[1016] = 931, 931, 931, 931, 931 } ; -static yyconst short int yy_nxt[4080] = +static yyconst flex_int16_t yy_nxt[4080] = { 0, 12, 13, 14, 15, 12, 12, 16, 12, 12, 12, 12, 17, 18, 12, 12, 12, 49, 52, 52, 56, @@ -1122,7 +1198,7 @@ static yyconst short int yy_nxt[4080] = 931, 931, 931, 931, 931, 931, 931, 931, 931 } ; -static yyconst short int yy_chk[4080] = +static yyconst flex_int16_t yy_chk[4080] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 5, 6, 9, @@ -1577,6 +1653,9 @@ static yyconst short int yy_chk[4080] = static yy_state_type yy_last_accepting_state; static char *yy_last_accepting_cpos; +extern int yy_flex_debug; +int yy_flex_debug = 0; + /* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. */ @@ -1585,8 +1664,7 @@ static char *yy_last_accepting_cpos; #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET char *yytext; -#line 1 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" -#define INITIAL 0 +#line 1 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" /* -*- indented-text -*- */ /* Process source files and output type information. Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. @@ -1607,7 +1685,7 @@ You should have received a copy of the GNU General Public License along with GCC; see the file COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#line 23 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 23 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" #include "bconfig.h" #include "coretypes.h" #include "system.h" @@ -1636,14 +1714,24 @@ update_lineno (const char *l, size_t len) lexer_line.line++; } + +#line 1719 "gengtype-lex.c" + +#define INITIAL 0 #define in_struct 1 #define in_struct_comment 2 #define in_comment 3 #define in_yacc_escape 4 -#define YY_NO_UNPUT 1 -#define YY_NEVER_INTERACTIVE 1 -#line 1647 "gengtype-lex.c" +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif /* Macros after this point can all be overridden by user definitions in * section 1. @@ -1651,65 +1739,28 @@ update_lineno (const char *l, size_t len) #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus -extern "C" int yywrap YY_PROTO(( void )); +extern "C" int yywrap (void ); #else -extern int yywrap YY_PROTO(( void )); +extern int yywrap (void ); #endif #endif -#ifndef YY_NO_UNPUT -static void yyunput YY_PROTO(( int c, char *buf_ptr )); -#endif - #ifndef yytext_ptr -static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); +static void yy_flex_strncpy (char *,yyconst char *,int ); #endif #ifdef YY_NEED_STRLEN -static int yy_flex_strlen YY_PROTO(( yyconst char * )); +static int yy_flex_strlen (yyconst char * ); #endif #ifndef YY_NO_INPUT -#ifdef __cplusplus -static int yyinput YY_PROTO(( void )); -#else -static int input YY_PROTO(( void )); -#endif -#endif - -#if YY_STACK_USED -static int yy_start_stack_ptr = 0; -static int yy_start_stack_depth = 0; -static int *yy_start_stack = 0; -#ifndef YY_NO_PUSH_STATE -static void yy_push_state YY_PROTO(( int new_state )); -#endif -#ifndef YY_NO_POP_STATE -static void yy_pop_state YY_PROTO(( void )); -#endif -#ifndef YY_NO_TOP_STATE -static int yy_top_state YY_PROTO(( void )); -#endif +#ifdef __cplusplus +static int yyinput (void ); #else -#define YY_NO_PUSH_STATE 1 -#define YY_NO_POP_STATE 1 -#define YY_NO_TOP_STATE 1 +static int input (void ); #endif -#ifdef YY_MALLOC_DECL -YY_MALLOC_DECL -#else -#if __STDC__ -#ifndef __cplusplus -#include -#endif -#else -/* Just try to get by without declaring the routines. This will fail - * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) - * or sizeof(void*) != sizeof(int). - */ -#endif #endif /* Amount of stuff to slurp up with each read. */ @@ -1718,7 +1769,6 @@ YY_MALLOC_DECL #endif /* Copy whatever the last rule matched to the standard output. */ - #ifndef ECHO /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). @@ -1731,9 +1781,10 @@ YY_MALLOC_DECL */ #ifndef YY_INPUT #define YY_INPUT(buf,result,max_size) \ - if ( yy_current_buffer->yy_is_interactive ) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ - int c = '*', n; \ + int c = '*'; \ + size_t n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -1743,9 +1794,22 @@ YY_MALLOC_DECL YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ - else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ - && ferror( yyin ) ) \ - YY_FATAL_ERROR( "input in flex scanner failed" ); + else \ + { \ + errno=0; \ + while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + #endif /* No semi-colon after return; correct usage is to write "yyterminate();" - @@ -1766,12 +1830,18 @@ YY_MALLOC_DECL #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) #endif +/* end tables serialization structures and prototypes */ + /* Default declaration of generated scanner - a define so the user can * easily add parameters. */ #ifndef YY_DECL -#define YY_DECL int yylex YY_PROTO(( void )) -#endif +#define YY_DECL_IS_OURS 1 + +extern int yylex (void); + +#define YY_DECL int yylex (void) +#endif /* !YY_DECL */ /* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. @@ -1787,31 +1857,33 @@ YY_MALLOC_DECL #define YY_RULE_SETUP \ if ( yyleng > 0 ) \ - yy_current_buffer->yy_at_bol = \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \ (yytext[yyleng - 1] == '\n'); \ YY_USER_ACTION +/** The main scanner function which does all the work. + */ YY_DECL - { +{ register yy_state_type yy_current_state; - register char *yy_cp = NULL, *yy_bp = NULL; + register char *yy_cp, *yy_bp; register int yy_act; - -#line 61 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" + +#line 61 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" -#line 1804 "gengtype-lex.c" +#line 1876 "gengtype-lex.c" - if ( yy_init ) + if ( (yy_init) ) { - yy_init = 0; + (yy_init) = 0; #ifdef YY_USER_INIT YY_USER_INIT; #endif - if ( ! yy_start ) - yy_start = 1; /* first start state */ + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ if ( ! yyin ) yyin = stdin; @@ -1819,26 +1891,28 @@ YY_DECL if ( ! yyout ) yyout = stdout; - if ( ! yy_current_buffer ) - yy_current_buffer = - yy_create_buffer( yyin, YY_BUF_SIZE ); + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer(yyin,YY_BUF_SIZE ); + } - yy_load_buffer_state(); + yy_load_buffer_state( ); } while ( 1 ) /* loops until end-of-file is reached */ { - yy_cp = yy_c_buf_p; + yy_cp = (yy_c_buf_p); /* Support of yytext. */ - *yy_cp = yy_hold_char; + *yy_cp = (yy_hold_char); /* yy_bp points to the position in yy_ch_buf of the start of * the current run. */ yy_bp = yy_cp; - yy_current_state = yy_start; + yy_current_state = (yy_start); yy_current_state += YY_AT_BOL(); yy_match: do @@ -1846,8 +1920,8 @@ yy_match: register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; if ( yy_accept[yy_current_state] ) { - yy_last_accepting_state = yy_current_state; - yy_last_accepting_cpos = yy_cp; + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { @@ -1858,35 +1932,30 @@ yy_match: yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; ++yy_cp; } - while ( yy_base[yy_current_state] != 4014 ); + while ( yy_current_state != 931 ); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); yy_find_action: yy_act = yy_accept[yy_current_state]; - if ( yy_act == 0 ) - { /* have to back up */ - yy_cp = yy_last_accepting_cpos; - yy_current_state = yy_last_accepting_state; - yy_act = yy_accept[yy_current_state]; - } YY_DO_BEFORE_ACTION; - do_action: /* This label is used only to access EOF actions. */ - switch ( yy_act ) { /* beginning of action switch */ case 0: /* must back up */ /* undo the effects of YY_DO_BEFORE_ACTION */ - *yy_cp = yy_hold_char; - yy_cp = yy_last_accepting_cpos; - yy_current_state = yy_last_accepting_state; + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); goto yy_find_action; case 1: +/* rule 1 can match eol */ YY_RULE_SETUP -#line 63 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 63 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { char *tagstart; size_t taglen; @@ -1927,8 +1996,9 @@ YY_RULE_SETUP } YY_BREAK case 2: +/* rule 2 can match eol */ YY_RULE_SETUP -#line 102 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 102 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { char *namestart; @@ -1958,8 +2028,9 @@ YY_RULE_SETUP } YY_BREAK case 3: +/* rule 3 can match eol */ YY_RULE_SETUP -#line 130 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 130 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { char *namestart; size_t namelen; @@ -1978,8 +2049,9 @@ YY_RULE_SETUP } YY_BREAK case 4: +/* rule 4 can match eol */ YY_RULE_SETUP -#line 147 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 147 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { char *namestart; size_t namelen; @@ -1998,8 +2070,9 @@ YY_RULE_SETUP } YY_BREAK case 5: +/* rule 5 can match eol */ YY_RULE_SETUP -#line 164 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 164 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { char *namestart; size_t namelen; @@ -2018,8 +2091,9 @@ YY_RULE_SETUP } YY_BREAK case 6: +/* rule 6 can match eol */ YY_RULE_SETUP -#line 181 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 181 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { char *namestart; size_t namelen; @@ -2038,11 +2112,12 @@ YY_RULE_SETUP } YY_BREAK case 7: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp -= 3; +/* rule 7 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp -= 3; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 198 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 198 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { char *tagstart; size_t taglen; @@ -2074,11 +2149,12 @@ YY_RULE_SETUP } YY_BREAK case 8: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp -= 3; +/* rule 8 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp -= 3; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 228 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 228 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { BEGIN(in_struct); update_lineno (yytext, yyleng); @@ -2086,11 +2162,12 @@ YY_RULE_SETUP } YY_BREAK case 9: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp -= 3; +/* rule 9 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp -= 3; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 234 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 234 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { BEGIN(in_struct); update_lineno (yytext, yyleng); @@ -2098,8 +2175,9 @@ YY_RULE_SETUP } YY_BREAK case 10: +/* rule 10 can match eol */ YY_RULE_SETUP -#line 240 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 240 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { char *macro, *arg; unsigned macro_len, arg_len; @@ -2132,104 +2210,115 @@ YY_RULE_SETUP case 11: YY_RULE_SETUP -#line 271 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 271 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { BEGIN(in_struct_comment); } YY_BREAK case 12: YY_RULE_SETUP -#line 273 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 273 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { BEGIN(in_yacc_escape); } /* } */ YY_BREAK case 13: YY_RULE_SETUP -#line 275 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 275 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" /* Used for c-parse.in C/ObjC demarcation. */ YY_BREAK case 14: +/* rule 14 can match eol */ YY_RULE_SETUP -#line 277 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 277 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { update_lineno (yytext, yyleng); } YY_BREAK case 15: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp = yy_bp + 5; +/* rule 15 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp = yy_bp + 5; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 279 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 279 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" /* don't care */ YY_BREAK case 16: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp = yy_bp + 3; +/* rule 16 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp = yy_bp + 3; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 280 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 280 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { return GTY_TOKEN; } YY_BREAK case 17: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp = yy_bp + 5; +/* rule 17 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp = yy_bp + 5; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 281 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 281 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { return UNION; } YY_BREAK case 18: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp = yy_bp + 6; +/* rule 18 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp = yy_bp + 6; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 282 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 282 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { return STRUCT; } YY_BREAK case 19: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp = yy_bp + 4; +/* rule 19 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp = yy_bp + 4; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 283 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 283 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { return ENUM; } YY_BREAK case 20: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp = yy_bp + 9; +/* rule 20 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp = yy_bp + 9; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 284 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 284 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { return ALIAS; } YY_BREAK case 21: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp = yy_bp + 10; +/* rule 21 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp = yy_bp + 10; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 285 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 285 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { return NESTED_PTR; } YY_BREAK case 22: YY_RULE_SETUP -#line 286 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 286 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { return NUM; } YY_BREAK case 23: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp -= 1; +/* rule 23 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 287 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 287 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { yylval.s = (const char *) xmemdup (yytext, yyleng, yyleng+1); return PARAM_IS; } YY_BREAK case 24: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp -= 1; +/* rule 24 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ -#line 293 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 293 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" case 25: +/* rule 25 can match eol */ YY_RULE_SETUP -#line 293 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 293 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { size_t len; @@ -2242,8 +2331,9 @@ YY_RULE_SETUP } YY_BREAK case 26: +/* rule 26 can match eol */ YY_RULE_SETUP -#line 304 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 304 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { char *macro, *arg; unsigned macro_len, arg_len; @@ -2267,27 +2357,30 @@ YY_RULE_SETUP } YY_BREAK case 27: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp -= 1; +/* rule 27 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp -= 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 326 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 326 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { yylval.s = (const char *) xmemdup (yytext, yyleng, yyleng+1); return ID; } YY_BREAK case 28: +/* rule 28 can match eol */ YY_RULE_SETUP -#line 331 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 331 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { yylval.s = (const char *) xmemdup (yytext+1, yyleng-2, yyleng-1); return STRING; } YY_BREAK case 29: +/* rule 29 can match eol */ YY_RULE_SETUP -#line 335 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 335 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { yylval.s = (const char *) xmemdup (yytext+1, yyleng-2, yyleng-1); return ARRAY; @@ -2295,15 +2388,16 @@ YY_RULE_SETUP YY_BREAK case 30: YY_RULE_SETUP -#line 339 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 339 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { yylval.s = (const char *) xmemdup (yytext+1, yyleng-1, yyleng); return PERCENT_ID; } YY_BREAK case 31: +/* rule 31 can match eol */ YY_RULE_SETUP -#line 343 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 343 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { yylval.s = (const char *) xmemdup (yytext+1, yyleng-2, yyleng); return CHAR; @@ -2311,12 +2405,12 @@ YY_RULE_SETUP YY_BREAK case 32: YY_RULE_SETUP -#line 348 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 348 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { return yytext[0]; } YY_BREAK case 33: YY_RULE_SETUP -#line 350 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 350 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { if (lexer_toplevel_done) { @@ -2328,20 +2422,21 @@ YY_RULE_SETUP YY_BREAK case 34: YY_RULE_SETUP -#line 359 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 359 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { BEGIN(INITIAL); return PERCENTPERCENT; } YY_BREAK case 35: +/* rule 35 can match eol */ YY_RULE_SETUP -#line 364 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 364 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" {lexer_line.line++;} YY_BREAK case 36: YY_RULE_SETUP -#line 366 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 366 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { error_at_line (&lexer_line, "unexpected character `%s'", yytext); } @@ -2349,97 +2444,108 @@ YY_RULE_SETUP case 37: YY_RULE_SETUP -#line 371 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 371 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { BEGIN(in_comment); } YY_BREAK case 38: +/* rule 38 can match eol */ YY_RULE_SETUP -#line 372 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 372 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { lexer_line.line++; } YY_BREAK case 39: -#line 374 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 374 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" case 40: -#line 375 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +/* rule 40 can match eol */ +#line 375 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" case 41: +/* rule 41 can match eol */ YY_RULE_SETUP -#line 375 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 375 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" /* do nothing */ YY_BREAK case 42: +/* rule 42 can match eol */ YY_RULE_SETUP -#line 376 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 376 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { update_lineno (yytext, yyleng); } YY_BREAK case 43: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp = yy_bp + 1; +/* rule 43 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp = yy_bp + 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 377 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 377 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" /* do nothing */ YY_BREAK case 44: +/* rule 44 can match eol */ YY_RULE_SETUP -#line 380 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 380 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { lexer_line.line++; } YY_BREAK case 45: -#line 382 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 382 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" case 46: YY_RULE_SETUP -#line 382 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 382 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" /* do nothing */ YY_BREAK case 47: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp = yy_bp + 1; +/* rule 47 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp = yy_bp + 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 383 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 383 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" /* do nothing */ YY_BREAK case 48: YY_RULE_SETUP -#line 385 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 385 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { BEGIN(INITIAL); } YY_BREAK case 49: YY_RULE_SETUP -#line 386 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 386 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { BEGIN(in_struct); } YY_BREAK case 50: +/* rule 50 can match eol */ YY_RULE_SETUP -#line 389 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 389 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { lexer_line.line++; } YY_BREAK case 51: -#line 391 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +/* rule 51 can match eol */ +#line 391 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" case 52: +/* rule 52 can match eol */ YY_RULE_SETUP -#line 391 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 391 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" /* do nothing */ YY_BREAK case 53: -*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ -yy_c_buf_p = yy_cp = yy_bp + 1; +/* rule 53 can match eol */ +*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */ +(yy_c_buf_p) = yy_cp = yy_bp + 1; YY_DO_BEFORE_ACTION; /* set up yytext again */ YY_RULE_SETUP -#line 392 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 392 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" /* do nothing */ YY_BREAK case 54: YY_RULE_SETUP -#line 393 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 393 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { BEGIN(in_struct); } YY_BREAK case 55: YY_RULE_SETUP -#line 394 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 394 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { error_at_line (&lexer_line, "unterminated %%{; unexpected EOF"); @@ -2447,33 +2553,35 @@ YY_RULE_SETUP YY_BREAK case 56: -#line 402 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 402 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" case 57: YY_RULE_SETUP -#line 402 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 402 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { error_at_line (&lexer_line, "unterminated comment or string; unexpected EOF"); } YY_BREAK case 58: +/* rule 58 can match eol */ YY_RULE_SETUP -#line 407 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 407 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" /* do nothing */ YY_BREAK case 59: +/* rule 59 can match eol */ YY_RULE_SETUP -#line 408 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 408 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" { error_at_line (&lexer_line, "stray GTY marker"); } YY_BREAK case 60: YY_RULE_SETUP -#line 412 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 412 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" YY_FATAL_ERROR( "flex scanner jammed" ); YY_BREAK -#line 2477 "gengtype-lex.c" +#line 2585 "gengtype-lex.c" case YY_STATE_EOF(INITIAL): case YY_STATE_EOF(in_struct): case YY_STATE_EOF(in_struct_comment): @@ -2484,26 +2592,26 @@ case YY_STATE_EOF(in_yacc_escape): case YY_END_OF_BUFFER: { /* Amount of text matched not including the EOB char. */ - int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; /* Undo the effects of YY_DO_BEFORE_ACTION. */ - *yy_cp = yy_hold_char; + *yy_cp = (yy_hold_char); YY_RESTORE_YY_MORE_OFFSET - if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) { /* We're scanning a new file or input source. It's * possible that this happened because the user * just pointed yyin at a new source and called * yylex(). If so, then we have to assure - * consistency between yy_current_buffer and our + * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a * back-up) that will match for the new input source. */ - yy_n_chars = yy_current_buffer->yy_n_chars; - yy_current_buffer->yy_input_file = yyin; - yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; } /* Note that here we test for yy_c_buf_p "<=" to the position @@ -2513,13 +2621,13 @@ case YY_STATE_EOF(in_yacc_escape): * end-of-buffer state). Contrast this with the test * in input(). */ - if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) { /* This was really a NUL. */ yy_state_type yy_next_state; - yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; - yy_current_state = yy_get_previous_state(); + yy_current_state = yy_get_previous_state( ); /* Okay, we're now positioned to make the NUL * transition. We couldn't have @@ -2532,30 +2640,31 @@ case YY_STATE_EOF(in_yacc_escape): yy_next_state = yy_try_NUL_trans( yy_current_state ); - yy_bp = yytext_ptr + YY_MORE_ADJ; + yy_bp = (yytext_ptr) + YY_MORE_ADJ; if ( yy_next_state ) { /* Consume the NUL. */ - yy_cp = ++yy_c_buf_p; + yy_cp = ++(yy_c_buf_p); yy_current_state = yy_next_state; goto yy_match; } else { - yy_cp = yy_c_buf_p; + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); goto yy_find_action; } } - else switch ( yy_get_next_buffer() ) + else switch ( yy_get_next_buffer( ) ) { case EOB_ACT_END_OF_FILE: { - yy_did_buffer_switch_on_eof = 0; + (yy_did_buffer_switch_on_eof) = 0; - if ( yywrap() ) + if ( yywrap( ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up @@ -2566,7 +2675,7 @@ case YY_STATE_EOF(in_yacc_escape): * YY_NULL, it'll still work - another * YY_NULL will get returned. */ - yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; yy_act = YY_STATE_EOF(YY_START); goto do_action; @@ -2574,30 +2683,30 @@ case YY_STATE_EOF(in_yacc_escape): else { - if ( ! yy_did_buffer_switch_on_eof ) + if ( ! (yy_did_buffer_switch_on_eof) ) YY_NEW_FILE; } break; } case EOB_ACT_CONTINUE_SCAN: - yy_c_buf_p = - yytext_ptr + yy_amount_of_matched_text; + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; - yy_current_state = yy_get_previous_state(); + yy_current_state = yy_get_previous_state( ); - yy_cp = yy_c_buf_p; - yy_bp = yytext_ptr + YY_MORE_ADJ; + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; goto yy_match; case EOB_ACT_LAST_MATCH: - yy_c_buf_p = - &yy_current_buffer->yy_ch_buf[yy_n_chars]; + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; - yy_current_state = yy_get_previous_state(); + yy_current_state = yy_get_previous_state( ); - yy_cp = yy_c_buf_p; - yy_bp = yytext_ptr + YY_MORE_ADJ; + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; goto yy_find_action; } break; @@ -2608,8 +2717,7 @@ case YY_STATE_EOF(in_yacc_escape): "fatal flex scanner internal error--no action found" ); } /* end of action switch */ } /* end of scanning one token */ - } /* end of yylex */ - +} /* end of yylex */ /* yy_get_next_buffer - try to read in a new buffer * @@ -2618,21 +2726,20 @@ case YY_STATE_EOF(in_yacc_escape): * EOB_ACT_CONTINUE_SCAN - continue scanning from current position * EOB_ACT_END_OF_FILE - end of file */ - -static int yy_get_next_buffer() - { - register char *dest = yy_current_buffer->yy_ch_buf; - register char *source = yytext_ptr; +static int yy_get_next_buffer (void) +{ + register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + register char *source = (yytext_ptr); register int number_to_move, i; int ret_val; - if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) YY_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed" ); - if ( yy_current_buffer->yy_fill_buffer == 0 ) + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) { /* Don't try to fill the buffer, so this is an EOF. */ - if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) { /* We matched a single character, the EOB, so * treat this as a final EOF. @@ -2652,34 +2759,30 @@ static int yy_get_next_buffer() /* Try to read more data. */ /* First move last chars to start of buffer. */ - number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1; for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++); - if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) /* don't do the read, it's not guaranteed to return an EOF, * just force an EOF */ - yy_current_buffer->yy_n_chars = yy_n_chars = 0; + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; else { - int num_to_read = - yy_current_buffer->yy_buf_size - number_to_move - 1; + size_t num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */ -#ifdef YY_USES_REJECT - YY_FATAL_ERROR( -"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); -#else /* just a shorter name for the current buffer */ - YY_BUFFER_STATE b = yy_current_buffer; + YY_BUFFER_STATE b = YY_CURRENT_BUFFER; int yy_c_buf_p_offset = - (int) (yy_c_buf_p - b->yy_ch_buf); + (int) ((yy_c_buf_p) - b->yy_ch_buf); if ( b->yy_is_our_buffer ) { @@ -2692,8 +2795,7 @@ static int yy_get_next_buffer() b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ - yy_flex_realloc( (void *) b->yy_ch_buf, - b->yy_buf_size + 2 ); + yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ); } else /* Can't grow it, we don't own it. */ @@ -2703,35 +2805,35 @@ static int yy_get_next_buffer() YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" ); - yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; - num_to_read = yy_current_buffer->yy_buf_size - + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; -#endif + } if ( num_to_read > YY_READ_BUF_SIZE ) num_to_read = YY_READ_BUF_SIZE; /* Read in more data. */ - YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), - yy_n_chars, num_to_read ); + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), num_to_read ); - yy_current_buffer->yy_n_chars = yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); } - if ( yy_n_chars == 0 ) + if ( (yy_n_chars) == 0 ) { if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; - yyrestart( yyin ); + yyrestart(yyin ); } else { ret_val = EOB_ACT_LAST_MATCH; - yy_current_buffer->yy_buffer_status = + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_EOF_PENDING; } } @@ -2739,33 +2841,32 @@ static int yy_get_next_buffer() else ret_val = EOB_ACT_CONTINUE_SCAN; - yy_n_chars += number_to_move; - yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; - yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; - yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; return ret_val; - } - +} /* yy_get_previous_state - get the state just before the EOB char was reached */ -static yy_state_type yy_get_previous_state() - { + static yy_state_type yy_get_previous_state (void) +{ register yy_state_type yy_current_state; register char *yy_cp; - - yy_current_state = yy_start; + + yy_current_state = (yy_start); yy_current_state += YY_AT_BOL(); - for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) { register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { - yy_last_accepting_state = yy_current_state; - yy_last_accepting_cpos = yy_cp; + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { @@ -2777,30 +2878,23 @@ static yy_state_type yy_get_previous_state() } return yy_current_state; - } - +} /* yy_try_NUL_trans - try to make a transition on the NUL character * * synopsis * next_state = yy_try_NUL_trans( current_state ); */ - -#ifdef YY_USE_PROTOS -static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) -#else -static yy_state_type yy_try_NUL_trans( yy_current_state ) -yy_state_type yy_current_state; -#endif - { + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +{ register int yy_is_jam; - register char *yy_cp = yy_c_buf_p; + register char *yy_cp = (yy_c_buf_p); register YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) { - yy_last_accepting_state = yy_current_state; - yy_last_accepting_cpos = yy_cp; + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { @@ -2812,80 +2906,36 @@ yy_state_type yy_current_state; yy_is_jam = (yy_current_state == 931); return yy_is_jam ? 0 : yy_current_state; - } - - -#ifndef YY_NO_UNPUT -#ifdef YY_USE_PROTOS -static void yyunput( int c, register char *yy_bp ) -#else -static void yyunput( c, yy_bp ) -int c; -register char *yy_bp; -#endif - { - register char *yy_cp = yy_c_buf_p; - - /* undo effects of setting up yytext */ - *yy_cp = yy_hold_char; - - if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) - { /* need to shift things up to make room */ - /* +2 for EOB chars. */ - register int number_to_move = yy_n_chars + 2; - register char *dest = &yy_current_buffer->yy_ch_buf[ - yy_current_buffer->yy_buf_size + 2]; - register char *source = - &yy_current_buffer->yy_ch_buf[number_to_move]; - - while ( source > yy_current_buffer->yy_ch_buf ) - *--dest = *--source; - - yy_cp += (int) (dest - source); - yy_bp += (int) (dest - source); - yy_current_buffer->yy_n_chars = - yy_n_chars = yy_current_buffer->yy_buf_size; - - if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) - YY_FATAL_ERROR( "flex scanner push-back overflow" ); - } - - *--yy_cp = (char) c; - - - yytext_ptr = yy_bp; - yy_hold_char = *yy_cp; - yy_c_buf_p = yy_cp; - } -#endif /* ifndef YY_NO_UNPUT */ - +} +#ifndef YY_NO_INPUT #ifdef __cplusplus -static int yyinput() + static int yyinput (void) #else -static int input() + static int input (void) #endif - { - int c; - *yy_c_buf_p = yy_hold_char; +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); - if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) { /* yy_c_buf_p now points to the character we want to return. * If this occurs *before* the EOB characters, then it's a * valid NUL; if not, then we've hit the end of the buffer. */ - if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) /* This was really a NUL. */ - *yy_c_buf_p = '\0'; + *(yy_c_buf_p) = '\0'; else { /* need more input */ - int offset = yy_c_buf_p - yytext_ptr; - ++yy_c_buf_p; + int offset = (yy_c_buf_p) - (yytext_ptr); + ++(yy_c_buf_p); - switch ( yy_get_next_buffer() ) + switch ( yy_get_next_buffer( ) ) { case EOB_ACT_LAST_MATCH: /* This happens because yy_g_n_b() @@ -2899,16 +2949,16 @@ static int input() */ /* Reset buffer status. */ - yyrestart( yyin ); + yyrestart(yyin ); - /* fall through */ + /*FALLTHROUGH*/ case EOB_ACT_END_OF_FILE: { - if ( yywrap() ) + if ( yywrap( ) ) return EOF; - if ( ! yy_did_buffer_switch_on_eof ) + if ( ! (yy_did_buffer_switch_on_eof) ) YY_NEW_FILE; #ifdef __cplusplus return yyinput(); @@ -2918,91 +2968,94 @@ static int input() } case EOB_ACT_CONTINUE_SCAN: - yy_c_buf_p = yytext_ptr + offset; + (yy_c_buf_p) = (yytext_ptr) + offset; break; } } } - c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ - *yy_c_buf_p = '\0'; /* preserve yytext */ - yy_hold_char = *++yy_c_buf_p; + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); - yy_current_buffer->yy_at_bol = (c == '\n'); + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n'); return c; - } - - -#ifdef YY_USE_PROTOS -void yyrestart( FILE *input_file ) -#else -void yyrestart( input_file ) -FILE *input_file; -#endif - { - if ( ! yy_current_buffer ) - yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); +} +#endif /* ifndef YY_NO_INPUT */ - yy_init_buffer( yy_current_buffer, input_file ); - yy_load_buffer_state(); +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer(yyin,YY_BUF_SIZE ); } + yy_init_buffer(YY_CURRENT_BUFFER,input_file ); + yy_load_buffer_state( ); +} -#ifdef YY_USE_PROTOS -void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) -#else -void yy_switch_to_buffer( new_buffer ) -YY_BUFFER_STATE new_buffer; -#endif - { - if ( yy_current_buffer == new_buffer ) +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) return; - if ( yy_current_buffer ) + if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ - *yy_c_buf_p = yy_hold_char; - yy_current_buffer->yy_buf_pos = yy_c_buf_p; - yy_current_buffer->yy_n_chars = yy_n_chars; + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); } - yy_current_buffer = new_buffer; - yy_load_buffer_state(); + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); /* We don't actually know whether we did this switch during * EOF (yywrap()) processing, but the only time this flag * is looked at is after yywrap() is called, so it's safe * to go ahead and always set it. */ - yy_did_buffer_switch_on_eof = 1; - } - - -#ifdef YY_USE_PROTOS -void yy_load_buffer_state( void ) -#else -void yy_load_buffer_state() -#endif - { - yy_n_chars = yy_current_buffer->yy_n_chars; - yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; - yyin = yy_current_buffer->yy_input_file; - yy_hold_char = *yy_c_buf_p; - } + (yy_did_buffer_switch_on_eof) = 1; +} +static void yy_load_buffer_state (void) +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(yy_c_buf_p); +} -#ifdef YY_USE_PROTOS -YY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) -#else -YY_BUFFER_STATE yy_create_buffer( file, size ) -FILE *file; -int size; -#endif - { +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +{ YY_BUFFER_STATE b; - - b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + + b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); @@ -3011,75 +3064,71 @@ int size; /* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. */ - b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); + b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2 ); if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); b->yy_is_our_buffer = 1; - yy_init_buffer( b, file ); + yy_init_buffer(b,file ); return b; - } - +} -#ifdef YY_USE_PROTOS -void yy_delete_buffer( YY_BUFFER_STATE b ) -#else -void yy_delete_buffer( b ) -YY_BUFFER_STATE b; -#endif - { +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) return; - if ( b == yy_current_buffer ) - yy_current_buffer = (YY_BUFFER_STATE) 0; + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; if ( b->yy_is_our_buffer ) - yy_flex_free( (void *) b->yy_ch_buf ); - - yy_flex_free( (void *) b ); - } - - + yyfree((void *) b->yy_ch_buf ); -#ifdef YY_USE_PROTOS -void yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) -#else -void yy_init_buffer( b, file ) -YY_BUFFER_STATE b; -FILE *file; -#endif + yyfree((void *) b ); +} +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) - { - yy_flush_buffer( b ); +{ + int oerrno = errno; + + yy_flush_buffer(b ); b->yy_input_file = file; b->yy_fill_buffer = 1; -#if YY_ALWAYS_INTERACTIVE - b->yy_is_interactive = 1; -#else -#if YY_NEVER_INTERACTIVE - b->yy_is_interactive = 0; -#else - b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; -#endif -#endif - } - + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } -#ifdef YY_USE_PROTOS -void yy_flush_buffer( YY_BUFFER_STATE b ) -#else -void yy_flush_buffer( b ) -YY_BUFFER_STATE b; -#endif + b->yy_is_interactive = 0; + + errno = oerrno; +} - { - if ( ! b ) +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) return; b->yy_n_chars = 0; @@ -3096,29 +3145,121 @@ YY_BUFFER_STATE b; b->yy_at_bol = 1; b->yy_buffer_status = YY_BUFFER_NEW; - if ( b == yy_current_buffer ) - yy_load_buffer_state(); + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void yypop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; } +} +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (void) +{ + int num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } -#ifndef YY_NO_SCAN_BUFFER -#ifdef YY_USE_PROTOS -YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) -#else -YY_BUFFER_STATE yy_scan_buffer( base, size ) -char *base; -yy_size_t size; -#endif - { - YY_BUFFER_STATE b; + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + int grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + if ( size < 2 || base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ return 0; - b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); + b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); @@ -3132,47 +3273,42 @@ yy_size_t size; b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW; - yy_switch_to_buffer( b ); + yy_switch_to_buffer(b ); return b; - } -#endif - - -#ifndef YY_NO_SCAN_STRING -#ifdef YY_USE_PROTOS -YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) -#else -YY_BUFFER_STATE yy_scan_string( yy_str ) -yyconst char *yy_str; -#endif - { - int len; - for ( len = 0; yy_str[len]; ++len ) - ; - - return yy_scan_bytes( yy_str, len ); - } -#endif +} +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param str a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (yyconst char * str ) +{ + + return yy_scan_bytes(str,strlen(str) ); +} -#ifndef YY_NO_SCAN_BYTES -#ifdef YY_USE_PROTOS -YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) -#else -YY_BUFFER_STATE yy_scan_bytes( bytes, len ) -yyconst char *bytes; -int len; -#endif - { +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param bytes the byte buffer to scan + * @param len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (yyconst char * bytes, int len ) +{ YY_BUFFER_STATE b; char *buf; yy_size_t n; int i; - + /* Get memory for full buffer, including space for trailing EOB's. */ n = len + 2; - buf = (char *) yy_flex_alloc( n ); + buf = (char *) yyalloc(n ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); @@ -3181,7 +3317,7 @@ int len; buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; - b = yy_scan_buffer( buf, n ); + b = yy_scan_buffer(buf,n ); if ( ! b ) YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); @@ -3191,148 +3327,164 @@ int len; b->yy_is_our_buffer = 1; return b; - } -#endif - +} -#ifndef YY_NO_PUSH_STATE -#ifdef YY_USE_PROTOS -static void yy_push_state( int new_state ) -#else -static void yy_push_state( new_state ) -int new_state; +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 #endif - { - if ( yy_start_stack_ptr >= yy_start_stack_depth ) - { - yy_size_t new_size; - yy_start_stack_depth += YY_START_STACK_INCR; - new_size = yy_start_stack_depth * sizeof( int ); +static void yy_fatal_error (yyconst char* msg ) +{ + (void) fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} - if ( ! yy_start_stack ) - yy_start_stack = (int *) yy_flex_alloc( new_size ); +/* Redefine yyless() so it works in section 3 code. */ - else - yy_start_stack = (int *) yy_flex_realloc( - (void *) yy_start_stack, new_size ); +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) - if ( ! yy_start_stack ) - YY_FATAL_ERROR( - "out of memory expanding start-condition stack" ); - } +/* Accessor methods (get/set functions) to struct members. */ - yy_start_stack[yy_start_stack_ptr++] = YY_START; +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} - BEGIN(new_state); - } -#endif +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} -#ifndef YY_NO_POP_STATE -static void yy_pop_state() - { - if ( --yy_start_stack_ptr < 0 ) - YY_FATAL_ERROR( "start-condition stack underflow" ); +/** Get the length of the current token. + * + */ +int yyget_leng (void) +{ + return yyleng; +} - BEGIN(yy_start_stack[yy_start_stack_ptr]); - } -#endif +/** Get the current token. + * + */ +char *yyget_text (void) +{ + return yytext; +} -#ifndef YY_NO_TOP_STATE -static int yy_top_state() - { - return yy_start_stack[yy_start_stack_ptr - 1]; - } -#endif +/** Set the current line number. + * @param line_number + * + */ +void yyset_lineno (int line_number ) +{ + + yylineno = line_number; +} -#ifndef YY_EXIT_FAILURE -#define YY_EXIT_FAILURE 2 -#endif +/** Set the input stream. This does not discard the current + * input buffer. + * @param in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * in_str ) +{ + yyin = in_str ; +} -#ifdef YY_USE_PROTOS -static void yy_fatal_error( yyconst char msg[] ) -#else -static void yy_fatal_error( msg ) -char msg[]; -#endif - { - (void) fprintf( stderr, "%s\n", msg ); - exit( YY_EXIT_FAILURE ); - } +void yyset_out (FILE * out_str ) +{ + yyout = out_str ; +} +int yyget_debug (void) +{ + return yy_flex_debug; +} +void yyset_debug (int bdebug ) +{ + yy_flex_debug = bdebug ; +} -/* Redefine yyless() so it works in section 3 code. */ +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } -#undef yyless -#define yyless(n) \ - do \ - { \ - /* Undo effects of setting up yytext. */ \ - yytext[yyleng] = yy_hold_char; \ - yy_c_buf_p = yytext + n; \ - yy_hold_char = *yy_c_buf_p; \ - *yy_c_buf_p = '\0'; \ - yyleng = n; \ - } \ - while ( 0 ) + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + return 0; +} -/* Internal utility routines. */ +/* + * Internal utility routines. + */ #ifndef yytext_ptr -#ifdef YY_USE_PROTOS -static void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) -#else -static void yy_flex_strncpy( s1, s2, n ) -char *s1; -yyconst char *s2; -int n; -#endif - { +static void yy_flex_strncpy (char* s1, yyconst char * s2, int n ) +{ register int i; - for ( i = 0; i < n; ++i ) + for ( i = 0; i < n; ++i ) s1[i] = s2[i]; - } +} #endif #ifdef YY_NEED_STRLEN -#ifdef YY_USE_PROTOS -static int yy_flex_strlen( yyconst char *s ) -#else -static int yy_flex_strlen( s ) -yyconst char *s; -#endif - { +static int yy_flex_strlen (yyconst char * s ) +{ register int n; - for ( n = 0; s[n]; ++n ) + for ( n = 0; s[n]; ++n ) ; return n; - } +} #endif - -#ifdef YY_USE_PROTOS -static void *yy_flex_alloc( yy_size_t size ) -#else -static void *yy_flex_alloc( size ) -yy_size_t size; -#endif - { +void *yyalloc (yy_size_t size ) +{ return (void *) malloc( size ); - } +} -#ifdef YY_USE_PROTOS -static void *yy_flex_realloc( void *ptr, yy_size_t size ) -#else -static void *yy_flex_realloc( ptr, size ) -void *ptr; -yy_size_t size; -#endif - { +void *yyrealloc (void * ptr, yy_size_t size ) +{ /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter @@ -3341,26 +3493,29 @@ yy_size_t size; * as though doing an assignment. */ return (void *) realloc( (char *) ptr, size ); - } +} -#ifdef YY_USE_PROTOS -static void yy_flex_free( void *ptr ) -#else -static void yy_flex_free( ptr ) -void *ptr; -#endif - { - free( ptr ); - } +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} -#if YY_MAIN -int main() - { - yylex(); - return 0; - } +#define YYTABLES_NAME "yytables" + +#undef YY_NEW_FILE +#undef YY_FLUSH_BUFFER +#undef yy_set_bol +#undef yy_new_buffer +#undef yy_set_interactive +#undef yytext_ptr +#undef YY_DO_BEFORE_ACTION + +#ifdef YY_DECL_IS_OURS +#undef YY_DECL_IS_OURS +#undef YY_DECL #endif -#line 412 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-lex.l" +#line 412 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-lex.l" + /* Deal with the expansion caused by the DEF_VEC_x macros. */ @@ -3471,3 +3626,4 @@ parse_file (const char *fname) exit (1); fclose (yyin); } + diff --git a/contrib/gcc-4.0/gcc/gengtype-yacc.c b/contrib/gcc-4.0/gcc/gengtype-yacc.c dissimilarity index 60% index 86caf71caa..7d40e5181d 100644 --- a/contrib/gcc-4.0/gcc/gengtype-yacc.c +++ b/contrib/gcc-4.0/gcc/gengtype-yacc.c @@ -1,1521 +1,1743 @@ -/* A Bison parser, made from /scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y - by GNU bison 1.35. */ - -#define YYBISON 1 /* Identify Bison output. */ - -# define ENT_TYPEDEF_STRUCT 257 -# define ENT_STRUCT 258 -# define ENT_EXTERNSTATIC 259 -# define ENT_YACCUNION 260 -# define GTY_TOKEN 261 -# define UNION 262 -# define STRUCT 263 -# define ENUM 264 -# define ALIAS 265 -# define NESTED_PTR 266 -# define PARAM_IS 267 -# define NUM 268 -# define PERCENTPERCENT 269 -# define SCALAR 270 -# define ID 271 -# define STRING 272 -# define ARRAY 273 -# define PERCENT_ID 274 -# define CHAR 275 - -#line 22 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" - -#include "bconfig.h" -#include "system.h" -#include "coretypes.h" -#include "tm.h" -#include "gengtype.h" -#define YYERROR_VERBOSE - -#line 31 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -#ifndef YYSTYPE -typedef union { - type_p t; - pair_p p; - options_p o; - const char *s; -} yystype; -# define YYSTYPE yystype -# define YYSTYPE_IS_TRIVIAL 1 -#endif -#ifndef YYDEBUG -# define YYDEBUG 0 -#endif - - - -#define YYFINAL 127 -#define YYFLAG -32768 -#define YYNTBASE 33 - -/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */ -#define YYTRANSLATE(x) ((unsigned)(x) <= 275 ? yytranslate[x] : 55) - -/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */ -static const char yytranslate[] = -{ - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 31, 32, 29, 2, 30, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 28, 24, - 26, 25, 27, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 22, 2, 23, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 3, 4, 5, - 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, - 16, 17, 18, 19, 20, 21 -}; - -#if YYDEBUG -static const short yyprhs[] = -{ - 0, 0, 1, 4, 7, 10, 11, 20, 21, 29, - 35, 42, 50, 52, 54, 56, 63, 64, 68, 75, - 76, 79, 82, 83, 90, 97, 105, 111, 112, 115, - 117, 119, 121, 123, 126, 132, 135, 141, 144, 147, - 153, 154, 160, 164, 167, 168, 170, 177, 179, 181, - 183, 188, 193, 202, 204, 208, 209, 211, 213 -}; -static const short yyrhs[] = -{ - -1, 34, 33, 0, 37, 33, 0, 40, 33, 0, - 0, 3, 49, 22, 43, 23, 17, 35, 24, 0, - 0, 4, 49, 22, 43, 23, 36, 24, 0, 5, - 49, 38, 17, 39, 0, 5, 49, 38, 17, 19, - 39, 0, 5, 49, 38, 17, 19, 19, 39, 0, - 46, 0, 24, 0, 25, 0, 6, 49, 43, 23, - 41, 15, 0, 0, 41, 20, 42, 0, 41, 20, - 26, 17, 27, 42, 0, 0, 42, 17, 0, 42, - 21, 0, 0, 46, 48, 17, 44, 24, 43, 0, - 46, 48, 17, 19, 24, 43, 0, 46, 48, 17, - 19, 19, 24, 43, 0, 46, 28, 45, 24, 43, - 0, 0, 28, 45, 0, 14, 0, 17, 0, 16, - 0, 17, 0, 46, 29, 0, 9, 17, 22, 43, - 23, 0, 9, 17, 0, 8, 17, 22, 43, 23, - 0, 8, 17, 0, 10, 17, 0, 10, 17, 22, - 47, 23, 0, 0, 17, 25, 14, 30, 47, 0, - 17, 30, 47, 0, 17, 47, 0, 0, 49, 0, - 7, 31, 31, 53, 32, 32, 0, 11, 0, 13, - 0, 17, 0, 17, 31, 54, 32, 0, 50, 31, - 46, 32, 0, 12, 31, 46, 30, 54, 30, 54, - 32, 0, 51, 0, 52, 30, 51, 0, 0, 52, - 0, 18, 0, 54, 18, 0 -}; - -#endif - -#if YYDEBUG -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const short yyrline[] = -{ - 0, 65, 66, 67, 68, 71, 71, 80, 80, 90, - 95, 100, 108, 115, 116, 119, 126, 128, 141, 159, - 161, 172, 185, 186, 196, 206, 216, 220, 221, 224, - 224, 228, 230, 232, 234, 239, 241, 246, 248, 250, - 254, 255, 257, 259, 263, 264, 267, 271, 273, 277, - 279, 281, 283, 295, 300, 307, 308, 311, 313 -}; -#endif - - -#if (YYDEBUG) || defined YYERROR_VERBOSE - -/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */ -static const char *const yytname[] = -{ - "$", "error", "$undefined.", "ENT_TYPEDEF_STRUCT", "ENT_STRUCT", - "ENT_EXTERNSTATIC", "ENT_YACCUNION", "GTY_TOKEN", "UNION", "STRUCT", - "ENUM", "ALIAS", "NESTED_PTR", "PARAM_IS", "NUM", "\"%%\"", "SCALAR", - "ID", "STRING", "ARRAY", "PERCENT_ID", "CHAR", "'{'", "'}'", "';'", - "'='", "'<'", "'>'", "':'", "'*'", "','", "'('", "')'", "start", - "typedef_struct", "@1", "@2", "externstatic", "lasttype", "semiequal", - "yacc_union", "yacc_typematch", "yacc_ids", "struct_fields", - "bitfieldopt", "bitfieldlen", "type", "enum_items", "optionsopt", - "options", "type_option", "option", "optionseq", "optionseqopt", - "stringseq", 0 -}; -#endif - -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const short yyr1[] = -{ - 0, 33, 33, 33, 33, 35, 34, 36, 34, 37, - 37, 37, 38, 39, 39, 40, 41, 41, 41, 42, - 42, 42, 43, 43, 43, 43, 43, 44, 44, 45, - 45, 46, 46, 46, 46, 46, 46, 46, 46, 46, - 47, 47, 47, 47, 48, 48, 49, 50, 50, 51, - 51, 51, 51, 52, 52, 53, 53, 54, 54 -}; - -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const short yyr2[] = -{ - 0, 0, 2, 2, 2, 0, 8, 0, 7, 5, - 6, 7, 1, 1, 1, 6, 0, 3, 6, 0, - 2, 2, 0, 6, 6, 7, 5, 0, 2, 1, - 1, 1, 1, 2, 5, 2, 5, 2, 2, 5, - 0, 5, 3, 2, 0, 1, 6, 1, 1, 1, - 4, 4, 8, 1, 3, 0, 1, 1, 2 -}; - -/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE - doesn't specify something else to do. Zero means the default is an - error. */ -static const short yydefact[] = -{ - 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, - 0, 0, 22, 2, 3, 4, 0, 22, 22, 0, - 0, 0, 31, 32, 0, 12, 0, 44, 55, 0, - 0, 37, 35, 38, 0, 33, 16, 0, 0, 45, - 47, 0, 48, 49, 0, 53, 56, 0, 0, 7, - 22, 22, 40, 0, 13, 14, 9, 0, 29, 30, - 0, 27, 0, 0, 0, 0, 0, 5, 0, 0, - 0, 40, 0, 0, 10, 15, 19, 22, 0, 0, - 0, 0, 57, 0, 0, 54, 46, 0, 8, 36, - 34, 0, 40, 43, 39, 11, 0, 17, 26, 0, - 22, 28, 22, 0, 58, 50, 51, 6, 0, 42, - 0, 20, 21, 22, 24, 23, 0, 40, 19, 25, - 0, 41, 18, 0, 52, 0, 0, 0 -}; - -static const short yydefgoto[] = -{ - 13, 5, 87, 68, 6, 24, 56, 7, 57, 97, - 26, 80, 60, 27, 72, 38, 9, 44, 45, 46, - 47, 83 -}; - -static const short yypact[] = -{ - 63, 31, 31, 31, 31, 63, 63, 63, 25, 40, - 49, 27, 27,-32768,-32768,-32768, 41, 27, 27, 57, - 58, 59,-32768,-32768, 60, 50, 55, 3, 29, 61, - 64, 66, 67, 68, 26,-32768,-32768, 56, 65,-32768, - -32768, 62,-32768, 69, 70,-32768, 51, 48, 74,-32768, - 27, 27, 75, 33,-32768,-32768,-32768, 1,-32768,-32768, - 71, 11, 27, 76, 27, 29, 54,-32768, 73, 79, - 80, -8, 81, 23,-32768,-32768, 72, 27, 35, 56, - 82, 34,-32768, -6, -14,-32768,-32768, 83,-32768,-32768, - -32768, 85, 75,-32768,-32768,-32768, 88, 44,-32768, 84, - 27,-32768, 27, 76,-32768,-32768,-32768,-32768, 86,-32768, - 87,-32768,-32768, 27,-32768,-32768, -7, 75,-32768,-32768, - 76,-32768, 44, -4,-32768, 109, 110,-32768 -}; - -static const short yypgoto[] = -{ - 13,-32768,-32768,-32768,-32768,-32768, -46,-32768,-32768, -5, - -17,-32768, 32, -9, -68,-32768, 2,-32768, 47,-32768, - -32768, -95 -}; - - -#define YYLAST 116 - - -static const short yytable[] = -{ - 29, 30, 25, 93, 10, 11, 12, 74, 116, 71, - 8, 104, 104, 125, 104, 35, 75, 91, 106, 14, - 15, 76, 92, 120, 109, 123, 105, 95, 124, 39, - 78, 37, 35, 69, 70, 19, 20, 21, 8, 79, - 40, 41, 42, 22, 23, 53, 43, 54, 55, 121, - 54, 55, 73, 81, 99, 84, 16, 54, 55, 100, - 98, 111, 17, 35, 103, 112, 1, 2, 3, 4, - 58, 18, 28, 59, 31, 32, 33, 34, 36, 35, - 66, 65, 61, 114, 48, 115, 86, 49, 50, 51, - 52, 67, 71, 62, 82, 77, 119, 88, 96, 108, - 63, 64, 89, 90, 94, 110, 102, 107, 113, 126, - 127, 101, 85, 122, 118, 0, 117 -}; - -static const short yycheck[] = -{ - 17, 18, 11, 71, 2, 3, 4, 53, 103, 17, - 7, 18, 18, 0, 18, 29, 15, 25, 32, 6, - 7, 20, 30, 30, 92, 120, 32, 73, 32, 27, - 19, 28, 29, 50, 51, 8, 9, 10, 7, 28, - 11, 12, 13, 16, 17, 19, 17, 24, 25, 117, - 24, 25, 19, 62, 19, 64, 31, 24, 25, 24, - 77, 17, 22, 29, 30, 21, 3, 4, 5, 6, - 14, 22, 31, 17, 17, 17, 17, 17, 23, 29, - 32, 30, 17, 100, 23, 102, 32, 23, 22, 22, - 22, 17, 17, 31, 18, 24, 113, 24, 26, 14, - 31, 31, 23, 23, 23, 17, 24, 24, 24, 0, - 0, 79, 65, 118, 27, -1, 30 -}; -/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ -#line 3 "/usr/share/bison/bison.simple" - -/* Skeleton output parser for bison, - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software - Foundation, Inc. - - 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, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -/* As a special exception, when this file is copied by Bison into a - Bison output file, you may use that output file without restriction. - This special exception was added by the Free Software Foundation - in version 1.24 of Bison. */ - -/* This is the parser code that is written into each bison parser when - the %semantic_parser declaration is not specified in the grammar. - It was written by Richard Stallman by simplifying the hairy parser - used when %semantic_parser is specified. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE) - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# if YYSTACK_USE_ALLOCA -# define YYSTACK_ALLOC alloca -# else -# ifndef YYSTACK_USE_ALLOCA -# if defined (alloca) || defined (_ALLOCA_H) -# define YYSTACK_ALLOC alloca -# else -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# endif -# endif -# endif -# endif - -# ifdef YYSTACK_ALLOC - /* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) -# else -# if defined (__STDC__) || defined (__cplusplus) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# endif -# define YYSTACK_ALLOC malloc -# define YYSTACK_FREE free -# endif -#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */ - - -#if (! defined (yyoverflow) \ - && (! defined (__cplusplus) \ - || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union yyalloc -{ - short yyss; - YYSTYPE yyvs; -# if YYLSP_NEEDED - YYLTYPE yyls; -# endif -}; - -/* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -# if YYLSP_NEEDED -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ - + 2 * YYSTACK_GAP_MAX) -# else -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAX) -# endif - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - register YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } \ - while (0) -# endif -# endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -# define YYSTACK_RELOCATE(Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY (&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ - yyptr += yynewbytes / sizeof (*yyptr); \ - } \ - while (0) - -#endif - - -#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) -# define YYSIZE_T __SIZE_TYPE__ -#endif -#if ! defined (YYSIZE_T) && defined (size_t) -# define YYSIZE_T size_t -#endif -#if ! defined (YYSIZE_T) -# if defined (__STDC__) || defined (__cplusplus) -# include /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# endif -#endif -#if ! defined (YYSIZE_T) -# define YYSIZE_T unsigned int -#endif - -#define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) -#define YYEMPTY -2 -#define YYEOF 0 -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrlab1 -/* Like YYERROR except do call yyerror. This remains here temporarily - to ease the transition to the new meaning of YYERROR, for GCC. - Once GCC version 2 has supplanted version 1, this can go. */ -#define YYFAIL goto yyerrlab -#define YYRECOVERING() (!!yyerrstatus) -#define YYBACKUP(Token, Value) \ -do \ - if (yychar == YYEMPTY && yylen == 1) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - yychar1 = YYTRANSLATE (yychar); \ - YYPOPSTACK; \ - goto yybackup; \ - } \ - else \ - { \ - yyerror ("syntax error: cannot back up"); \ - YYERROR; \ - } \ -while (0) - -#define YYTERROR 1 -#define YYERRCODE 256 - - -/* YYLLOC_DEFAULT -- Compute the default location (before the actions - are run). - - When YYLLOC_DEFAULT is run, CURRENT is set the location of the - first token. By default, to implement support for ranges, extend - its range to the last symbol. */ - -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - Current.last_line = Rhs[N].last_line; \ - Current.last_column = Rhs[N].last_column; -#endif - - -/* YYLEX -- calling `yylex' with the right arguments. */ - -#if YYPURE -# if YYLSP_NEEDED -# ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM) -# else -# define YYLEX yylex (&yylval, &yylloc) -# endif -# else /* !YYLSP_NEEDED */ -# ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval, YYLEX_PARAM) -# else -# define YYLEX yylex (&yylval) -# endif -# endif /* !YYLSP_NEEDED */ -#else /* !YYPURE */ -# define YYLEX yylex () -#endif /* !YYPURE */ - - -/* Enable debugging if requested. */ -#if YYDEBUG - -# ifndef YYFPRINTF -# include /* INFRINGES ON USER NAME SPACE */ -# define YYFPRINTF fprintf -# endif - -# define YYDPRINTF(Args) \ -do { \ - if (yydebug) \ - YYFPRINTF Args; \ -} while (0) -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int yydebug; -#else /* !YYDEBUG */ -# define YYDPRINTF(Args) -#endif /* !YYDEBUG */ - -/* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH -# define YYINITDEPTH 200 -#endif - -/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only - if the built-in stack extension method is used). - - Do not make this value too large; the results are undefined if - SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) - evaluated with infinite-precision integer arithmetic. */ - -#if YYMAXDEPTH == 0 -# undef YYMAXDEPTH -#endif - -#ifndef YYMAXDEPTH -# define YYMAXDEPTH 10000 -#endif - -#ifdef YYERROR_VERBOSE - -# ifndef yystrlen -# if defined (__GLIBC__) && defined (_STRING_H) -# define yystrlen strlen -# else -/* Return the length of YYSTR. */ -static YYSIZE_T -# if defined (__STDC__) || defined (__cplusplus) -yystrlen (const char *yystr) -# else -yystrlen (yystr) - const char *yystr; -# endif -{ - register const char *yys = yystr; - - while (*yys++ != '\0') - continue; - - return yys - yystr - 1; -} -# endif -# endif - -# ifndef yystpcpy -# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) -# define yystpcpy stpcpy -# else -/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in - YYDEST. */ -static char * -# if defined (__STDC__) || defined (__cplusplus) -yystpcpy (char *yydest, const char *yysrc) -# else -yystpcpy (yydest, yysrc) - char *yydest; - const char *yysrc; -# endif -{ - register char *yyd = yydest; - register const char *yys = yysrc; - - while ((*yyd++ = *yys++) != '\0') - continue; - - return yyd - 1; -} -# endif -# endif -#endif - -#line 315 "/usr/share/bison/bison.simple" - - -/* The user can define YYPARSE_PARAM as the name of an argument to be passed - into yyparse. The argument should have type void *. - It should actually point to an object. - Grammar actions can access the variable by casting it - to the proper pointer type. */ - -#ifdef YYPARSE_PARAM -# if defined (__STDC__) || defined (__cplusplus) -# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM -# define YYPARSE_PARAM_DECL -# else -# define YYPARSE_PARAM_ARG YYPARSE_PARAM -# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; -# endif -#else /* !YYPARSE_PARAM */ -# define YYPARSE_PARAM_ARG -# define YYPARSE_PARAM_DECL -#endif /* !YYPARSE_PARAM */ - -/* Prevent warning if -Wstrict-prototypes. */ -#ifdef __GNUC__ -# ifdef YYPARSE_PARAM -int yyparse (void *); -# else -int yyparse (void); -# endif -#endif - -/* YY_DECL_VARIABLES -- depending whether we use a pure parser, - variables are global, or local to YYPARSE. */ - -#define YY_DECL_NON_LSP_VARIABLES \ -/* The lookahead symbol. */ \ -int yychar; \ - \ -/* The semantic value of the lookahead symbol. */ \ -YYSTYPE yylval; \ - \ -/* Number of parse errors so far. */ \ -int yynerrs; - -#if YYLSP_NEEDED -# define YY_DECL_VARIABLES \ -YY_DECL_NON_LSP_VARIABLES \ - \ -/* Location data for the lookahead symbol. */ \ -YYLTYPE yylloc; -#else -# define YY_DECL_VARIABLES \ -YY_DECL_NON_LSP_VARIABLES -#endif - - -/* If nonreentrant, generate the variables here. */ - -#if !YYPURE -YY_DECL_VARIABLES -#endif /* !YYPURE */ - -int -yyparse (YYPARSE_PARAM_ARG) - YYPARSE_PARAM_DECL -{ - /* If reentrant, generate the variables here. */ -#if YYPURE - YY_DECL_VARIABLES -#endif /* !YYPURE */ - - register int yystate; - register int yyn; - int yyresult; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus; - /* Lookahead token as an internal (translated) token number. */ - int yychar1 = 0; - - /* Three stacks and their tools: - `yyss': related to states, - `yyvs': related to semantic values, - `yyls': related to locations. - - Refer to the stacks thru separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* The state stack. */ - short yyssa[YYINITDEPTH]; - short *yyss = yyssa; - register short *yyssp; - - /* The semantic value stack. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs = yyvsa; - register YYSTYPE *yyvsp; - -#if YYLSP_NEEDED - /* The location stack. */ - YYLTYPE yylsa[YYINITDEPTH]; - YYLTYPE *yyls = yylsa; - YYLTYPE *yylsp; -#endif - -#if YYLSP_NEEDED -# define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) -#else -# define YYPOPSTACK (yyvsp--, yyssp--) -#endif - - YYSIZE_T yystacksize = YYINITDEPTH; - - - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; -#if YYLSP_NEEDED - YYLTYPE yyloc; -#endif - - /* When reducing, the number of symbols on the RHS of the reduced - rule. */ - int yylen; - - YYDPRINTF ((stderr, "Starting parse\n")); - - yystate = 0; - yyerrstatus = 0; - yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */ - - /* Initialize stack pointers. - Waste one element of value and location stack - so that they stay on the same level as the state stack. - The wasted elements are never initialized. */ - - yyssp = yyss; - yyvsp = yyvs; -#if YYLSP_NEEDED - yylsp = yyls; -#endif - goto yysetstate; - -/*------------------------------------------------------------. -| yynewstate -- Push a new state, which is found in yystate. | -`------------------------------------------------------------*/ - yynewstate: - /* In all cases, when you get here, the value and location stacks - have just been pushed. so pushing a state here evens the stacks. - */ - yyssp++; - - yysetstate: - *yyssp = yystate; - - if (yyssp >= yyss + yystacksize - 1) - { - /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; - -#ifdef yyoverflow - { - /* Give user a chance to reallocate the stack. Use copies of - these so that the &'s don't force the real ones into - memory. */ - YYSTYPE *yyvs1 = yyvs; - short *yyss1 = yyss; - - /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. */ -# if YYLSP_NEEDED - YYLTYPE *yyls1 = yyls; - /* This used to be a conditional around just the two extra args, - but that might be undefined if yyoverflow is a macro. */ - yyoverflow ("parser stack overflow", - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - &yyls1, yysize * sizeof (*yylsp), - &yystacksize); - yyls = yyls1; -# else - yyoverflow ("parser stack overflow", - &yyss1, yysize * sizeof (*yyssp), - &yyvs1, yysize * sizeof (*yyvsp), - &yystacksize); -# endif - yyss = yyss1; - yyvs = yyvs1; - } -#else /* no yyoverflow */ -# ifndef YYSTACK_RELOCATE - goto yyoverflowlab; -# else - /* Extend the stack our own way. */ - if (yystacksize >= YYMAXDEPTH) - goto yyoverflowlab; - yystacksize *= 2; - if (yystacksize > YYMAXDEPTH) - yystacksize = YYMAXDEPTH; - - { - short *yyss1 = yyss; - union yyalloc *yyptr = - (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); - if (! yyptr) - goto yyoverflowlab; - YYSTACK_RELOCATE (yyss); - YYSTACK_RELOCATE (yyvs); -# if YYLSP_NEEDED - YYSTACK_RELOCATE (yyls); -# endif -# undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE (yyss1); - } -# endif -#endif /* no yyoverflow */ - - yyssp = yyss + yysize - 1; - yyvsp = yyvs + yysize - 1; -#if YYLSP_NEEDED - yylsp = yyls + yysize - 1; -#endif - - YYDPRINTF ((stderr, "Stack size increased to %lu\n", - (unsigned long int) yystacksize)); - - if (yyssp >= yyss + yystacksize - 1) - YYABORT; - } - - YYDPRINTF ((stderr, "Entering state %d\n", yystate)); - - goto yybackup; - - -/*-----------. -| yybackup. | -`-----------*/ -yybackup: - -/* Do appropriate processing given the current state. */ -/* Read a lookahead token if we need one and don't already have one. */ -/* yyresume: */ - - /* First try to decide what to do without reference to lookahead token. */ - - yyn = yypact[yystate]; - if (yyn == YYFLAG) - goto yydefault; - - /* Not known => get a lookahead token if don't already have one. */ - - /* yychar is either YYEMPTY or YYEOF - or a valid token in external form. */ - - if (yychar == YYEMPTY) - { - YYDPRINTF ((stderr, "Reading a token: ")); - yychar = YYLEX; - } - - /* Convert token to internal form (in yychar1) for indexing tables with */ - - if (yychar <= 0) /* This means end of input. */ - { - yychar1 = 0; - yychar = YYEOF; /* Don't call YYLEX any more */ - - YYDPRINTF ((stderr, "Now at end of input.\n")); - } - else - { - yychar1 = YYTRANSLATE (yychar); - -#if YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables - which are defined only if `YYDEBUG' is set. */ - if (yydebug) - { - YYFPRINTF (stderr, "Next token is %d (%s", - yychar, yytname[yychar1]); - /* Give the individual parser a way to print the precise - meaning of a token, for further debugging info. */ -# ifdef YYPRINT - YYPRINT (stderr, yychar, yylval); -# endif - YYFPRINTF (stderr, ")\n"); - } -#endif - } - - yyn += yychar1; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) - goto yydefault; - - yyn = yytable[yyn]; - - /* yyn is what to do for this token type in this state. - Negative => reduce, -yyn is rule number. - Positive => shift, yyn is new state. - New state is final state => don't bother to shift, - just return success. - 0, or most negative number => error. */ - - if (yyn < 0) - { - if (yyn == YYFLAG) - goto yyerrlab; - yyn = -yyn; - goto yyreduce; - } - else if (yyn == 0) - goto yyerrlab; - - if (yyn == YYFINAL) - YYACCEPT; - - /* Shift the lookahead token. */ - YYDPRINTF ((stderr, "Shifting token %d (%s), ", - yychar, yytname[yychar1])); - - /* Discard the token being shifted unless it is eof. */ - if (yychar != YYEOF) - yychar = YYEMPTY; - - *++yyvsp = yylval; -#if YYLSP_NEEDED - *++yylsp = yylloc; -#endif - - /* Count tokens shifted since error; after three, turn off error - status. */ - if (yyerrstatus) - yyerrstatus--; - - yystate = yyn; - goto yynewstate; - - -/*-----------------------------------------------------------. -| yydefault -- do the default action for the current state. | -`-----------------------------------------------------------*/ -yydefault: - yyn = yydefact[yystate]; - if (yyn == 0) - goto yyerrlab; - goto yyreduce; - - -/*-----------------------------. -| yyreduce -- Do a reduction. | -`-----------------------------*/ -yyreduce: - /* yyn is the number of a rule to reduce with. */ - yylen = yyr2[yyn]; - - /* If YYLEN is nonzero, implement the default value of the action: - `$$ = $1'. - - Otherwise, the following line sets YYVAL to the semantic value of - the lookahead token. This behavior is undocumented and Bison - users should not rely upon it. Assigning to YYVAL - unconditionally makes the parser a bit smaller, and it avoids a - GCC warning that YYVAL may be used uninitialized. */ - yyval = yyvsp[1-yylen]; - -#if YYLSP_NEEDED - /* Similarly for the default location. Let the user run additional - commands if for instance locations are ranges. */ - yyloc = yylsp[1-yylen]; - YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); -#endif - -#if YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables which - are defined only if `YYDEBUG' is set. */ - if (yydebug) - { - int yyi; - - YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", - yyn, yyrline[yyn]); - - /* Print the symbols being reduced, and their result. */ - for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++) - YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); - YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); - } -#endif - - switch (yyn) { - -case 5: -#line 72 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - new_structure (yyvsp[-5].t->u.s.tag, UNION_P (yyvsp[-5].t), &lexer_line, - yyvsp[-2].p, yyvsp[-4].o); - do_typedef (yyvsp[0].s, yyvsp[-5].t, &lexer_line); - lexer_toplevel_done = 1; - ; - break;} -case 6: -#line 79 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{; - break;} -case 7: -#line 81 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - new_structure (yyvsp[-4].t->u.s.tag, UNION_P (yyvsp[-4].t), &lexer_line, - yyvsp[-1].p, yyvsp[-3].o); - lexer_toplevel_done = 1; - ; - break;} -case 8: -#line 87 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{; - break;} -case 9: -#line 91 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - note_variable (yyvsp[-1].s, adjust_field_type (yyvsp[-2].t, yyvsp[-3].o), yyvsp[-3].o, - &lexer_line); - ; - break;} -case 10: -#line 96 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - note_variable (yyvsp[-2].s, create_array (yyvsp[-3].t, yyvsp[-1].s), - yyvsp[-4].o, &lexer_line); - ; - break;} -case 11: -#line 101 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - note_variable (yyvsp[-3].s, create_array (create_array (yyvsp[-4].t, yyvsp[-1].s), - yyvsp[-2].s), - yyvsp[-5].o, &lexer_line); - ; - break;} -case 12: -#line 109 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - lexer_toplevel_done = 1; - yyval.t = yyvsp[0].t; - ; - break;} -case 15: -#line 121 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - note_yacc_type (yyvsp[-4].o, yyvsp[-3].p, yyvsp[-1].p, &lexer_line); - ; - break;} -case 16: -#line 127 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.p = NULL; ; - break;} -case 17: -#line 129 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - pair_p p; - for (p = yyvsp[0].p; p->next != NULL; p = p->next) - { - p->name = NULL; - p->type = NULL; - } - p->name = NULL; - p->type = NULL; - p->next = yyvsp[-2].p; - yyval.p = yyvsp[0].p; - ; - break;} -case 18: -#line 142 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - pair_p p; - type_p newtype = NULL; - if (strcmp (yyvsp[-4].s, "type") == 0) - newtype = (type_p) 1; - for (p = yyvsp[0].p; p->next != NULL; p = p->next) - { - p->name = yyvsp[-2].s; - p->type = newtype; - } - p->name = yyvsp[-2].s; - p->next = yyvsp[-5].p; - p->type = newtype; - yyval.p = yyvsp[0].p; - ; - break;} -case 19: -#line 160 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.p = NULL; ; - break;} -case 20: -#line 162 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - pair_p p = XCNEW (struct pair); - p->next = yyvsp[-1].p; - p->line = lexer_line; - p->opt = XNEW (struct options); - p->opt->name = "tag"; - p->opt->next = NULL; - p->opt->info = (char *)yyvsp[0].s; - yyval.p = p; - ; - break;} -case 21: -#line 173 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - pair_p p = XCNEW (struct pair); - p->next = yyvsp[-1].p; - p->line = lexer_line; - p->opt = XNEW (struct options); - p->opt->name = "tag"; - p->opt->next = NULL; - p->opt->info = xasprintf ("'%s'", yyvsp[0].s); - yyval.p = p; - ; - break;} -case 22: -#line 185 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.p = NULL; ; - break;} -case 23: -#line 187 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - pair_p p = XNEW (struct pair); - p->type = adjust_field_type (yyvsp[-5].t, yyvsp[-4].o); - p->opt = yyvsp[-4].o; - p->name = yyvsp[-3].s; - p->next = yyvsp[0].p; - p->line = lexer_line; - yyval.p = p; - ; - break;} -case 24: -#line 197 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - pair_p p = XNEW (struct pair); - p->type = adjust_field_type (create_array (yyvsp[-5].t, yyvsp[-2].s), yyvsp[-4].o); - p->opt = yyvsp[-4].o; - p->name = yyvsp[-3].s; - p->next = yyvsp[0].p; - p->line = lexer_line; - yyval.p = p; - ; - break;} -case 25: -#line 207 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - pair_p p = XNEW (struct pair); - p->type = create_array (create_array (yyvsp[-6].t, yyvsp[-2].s), yyvsp[-3].s); - p->opt = yyvsp[-5].o; - p->name = yyvsp[-4].s; - p->next = yyvsp[0].p; - p->line = lexer_line; - yyval.p = p; - ; - break;} -case 26: -#line 217 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.p = yyvsp[0].p; ; - break;} -case 30: -#line 225 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ ; - break;} -case 31: -#line 229 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.t = yyvsp[0].t; ; - break;} -case 32: -#line 231 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.t = resolve_typedef (yyvsp[0].s, &lexer_line); ; - break;} -case 33: -#line 233 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.t = create_pointer (yyvsp[-1].t); ; - break;} -case 34: -#line 235 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - new_structure (yyvsp[-3].s, 0, &lexer_line, yyvsp[-1].p, NULL); - yyval.t = find_structure (yyvsp[-3].s, 0); - ; - break;} -case 35: -#line 240 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.t = find_structure (yyvsp[0].s, 0); ; - break;} -case 36: -#line 242 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - new_structure (yyvsp[-3].s, 1, &lexer_line, yyvsp[-1].p, NULL); - yyval.t = find_structure (yyvsp[-3].s, 1); - ; - break;} -case 37: -#line 247 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.t = find_structure (yyvsp[0].s, 1); ; - break;} -case 38: -#line 249 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.t = create_scalar_type (yyvsp[0].s, strlen (yyvsp[0].s)); ; - break;} -case 39: -#line 251 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.t = create_scalar_type (yyvsp[-3].s, strlen (yyvsp[-3].s)); ; - break;} -case 41: -#line 256 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ ; - break;} -case 42: -#line 258 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ ; - break;} -case 43: -#line 260 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ ; - break;} -case 44: -#line 263 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.o = NULL; ; - break;} -case 45: -#line 264 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.o = yyvsp[0].o; ; - break;} -case 46: -#line 268 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.o = yyvsp[-2].o; ; - break;} -case 47: -#line 272 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.s = "ptr_alias"; ; - break;} -case 48: -#line 274 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.s = yyvsp[0].s; ; - break;} -case 49: -#line 278 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.o = create_option (yyvsp[0].s, (void *)""); ; - break;} -case 50: -#line 280 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.o = create_option (yyvsp[-3].s, (void *)yyvsp[-1].s); ; - break;} -case 51: -#line 282 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.o = create_option (yyvsp[-3].s, adjust_field_type (yyvsp[-1].t, NULL)); ; - break;} -case 52: -#line 284 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - struct nested_ptr_data d; - - d.type = adjust_field_type (yyvsp[-5].t, NULL); - d.convert_to = yyvsp[-3].s; - d.convert_from = yyvsp[-1].s; - yyval.o = create_option ("nested_ptr", - xmemdup (&d, sizeof (d), sizeof (d))); - ; - break;} -case 53: -#line 296 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - yyvsp[0].o->next = NULL; - yyval.o = yyvsp[0].o; - ; - break;} -case 54: -#line 301 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - yyvsp[0].o->next = yyvsp[-2].o; - yyval.o = yyvsp[0].o; - ; - break;} -case 55: -#line 307 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.o = NULL; ; - break;} -case 56: -#line 308 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.o = yyvsp[0].o; ; - break;} -case 57: -#line 312 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ yyval.s = yyvsp[0].s; ; - break;} -case 58: -#line 314 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" -{ - size_t l1 = strlen (yyvsp[-1].s); - size_t l2 = strlen (yyvsp[0].s); - char *s = XRESIZEVEC (char, yyvsp[-1].s, l1 + l2 + 1); - memcpy (s + l1, yyvsp[0].s, l2 + 1); - XDELETE (yyvsp[0].s); - yyval.s = s; - ; - break;} -} - -#line 705 "/usr/share/bison/bison.simple" - - - yyvsp -= yylen; - yyssp -= yylen; -#if YYLSP_NEEDED - yylsp -= yylen; -#endif - -#if YYDEBUG - if (yydebug) - { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif - - *++yyvsp = yyval; -#if YYLSP_NEEDED - *++yylsp = yyloc; -#endif - - /* Now `shift' the result of the reduction. Determine what state - that goes to, based on the state we popped back to and the rule - number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTBASE] + *yyssp; - if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTBASE]; - - goto yynewstate; - - -/*------------------------------------. -| yyerrlab -- here on detecting error | -`------------------------------------*/ -yyerrlab: - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus) - { - ++yynerrs; - -#ifdef YYERROR_VERBOSE - yyn = yypact[yystate]; - - if (yyn > YYFLAG && yyn < YYLAST) - { - YYSIZE_T yysize = 0; - char *yymsg; - int yyx, yycount; - - yycount = 0; - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) - if (yycheck[yyx + yyn] == yyx) - yysize += yystrlen (yytname[yyx]) + 15, yycount++; - yysize += yystrlen ("parse error, unexpected ") + 1; - yysize += yystrlen (yytname[YYTRANSLATE (yychar)]); - yymsg = (char *) YYSTACK_ALLOC (yysize); - if (yymsg != 0) - { - char *yyp = yystpcpy (yymsg, "parse error, unexpected "); - yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]); - - if (yycount < 5) - { - yycount = 0; - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); - yyx++) - if (yycheck[yyx + yyn] == yyx) - { - const char *yyq = ! yycount ? ", expecting " : " or "; - yyp = yystpcpy (yyp, yyq); - yyp = yystpcpy (yyp, yytname[yyx]); - yycount++; - } - } - yyerror (yymsg); - YYSTACK_FREE (yymsg); - } - else - yyerror ("parse error; also virtual memory exhausted"); - } - else -#endif /* defined (YYERROR_VERBOSE) */ - yyerror ("parse error"); - } - goto yyerrlab1; - - -/*--------------------------------------------------. -| yyerrlab1 -- error raised explicitly by an action | -`--------------------------------------------------*/ -yyerrlab1: - if (yyerrstatus == 3) - { - /* If just tried and failed to reuse lookahead token after an - error, discard it. */ - - /* return failure if at end of input */ - if (yychar == YYEOF) - YYABORT; - YYDPRINTF ((stderr, "Discarding token %d (%s).\n", - yychar, yytname[yychar1])); - yychar = YYEMPTY; - } - - /* Else will try to reuse lookahead token after shifting the error - token. */ - - yyerrstatus = 3; /* Each real token shifted decrements this */ - - goto yyerrhandle; - - -/*-------------------------------------------------------------------. -| yyerrdefault -- current state does not do anything special for the | -| error token. | -`-------------------------------------------------------------------*/ -yyerrdefault: -#if 0 - /* This is wrong; only states that explicitly want error tokens - should shift them. */ - - /* If its default is to accept any token, ok. Otherwise pop it. */ - yyn = yydefact[yystate]; - if (yyn) - goto yydefault; -#endif - - -/*---------------------------------------------------------------. -| yyerrpop -- pop the current state because it cannot handle the | -| error token | -`---------------------------------------------------------------*/ -yyerrpop: - if (yyssp == yyss) - YYABORT; - yyvsp--; - yystate = *--yyssp; -#if YYLSP_NEEDED - yylsp--; -#endif - -#if YYDEBUG - if (yydebug) - { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "Error: state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif - -/*--------------. -| yyerrhandle. | -`--------------*/ -yyerrhandle: - yyn = yypact[yystate]; - if (yyn == YYFLAG) - goto yyerrdefault; - - yyn += YYTERROR; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) - goto yyerrdefault; - - yyn = yytable[yyn]; - if (yyn < 0) - { - if (yyn == YYFLAG) - goto yyerrpop; - yyn = -yyn; - goto yyreduce; - } - else if (yyn == 0) - goto yyerrpop; - - if (yyn == YYFINAL) - YYACCEPT; - - YYDPRINTF ((stderr, "Shifting error token, ")); - - *++yyvsp = yylval; -#if YYLSP_NEEDED - *++yylsp = yylloc; -#endif - - yystate = yyn; - goto yynewstate; - - -/*-------------------------------------. -| yyacceptlab -- YYACCEPT comes here. | -`-------------------------------------*/ -yyacceptlab: - yyresult = 0; - goto yyreturn; - -/*-----------------------------------. -| yyabortlab -- YYABORT comes here. | -`-----------------------------------*/ -yyabortlab: - yyresult = 1; - goto yyreturn; - -/*---------------------------------------------. -| yyoverflowab -- parser overflow comes here. | -`---------------------------------------------*/ -yyoverflowlab: - yyerror ("parser stack overflow"); - yyresult = 2; - /* Fall through. */ - -yyreturn: -#ifndef yyoverflow - if (yyss != yyssa) - YYSTACK_FREE (yyss); -#endif - return yyresult; -} -#line 323 "/scratch/mitchell/gcc-releases/gcc-4.0.0/gcc-4.0.0/gcc/gengtype-yacc.y" - +/* A Bison parser, made by GNU Bison 2.0. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + + 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, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Written by Richard Stallman by simplifying the original so called + ``semantic'' parser. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output. */ +#define YYBISON 1 + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 0 + +/* Using locations. */ +#define YYLSP_NEEDED 0 + + + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + ENT_TYPEDEF_STRUCT = 258, + ENT_STRUCT = 259, + ENT_EXTERNSTATIC = 260, + ENT_YACCUNION = 261, + GTY_TOKEN = 262, + UNION = 263, + STRUCT = 264, + ENUM = 265, + ALIAS = 266, + NESTED_PTR = 267, + PARAM_IS = 268, + NUM = 269, + PERCENTPERCENT = 270, + SCALAR = 271, + ID = 272, + STRING = 273, + ARRAY = 274, + PERCENT_ID = 275, + CHAR = 276 + }; +#endif +#define ENT_TYPEDEF_STRUCT 258 +#define ENT_STRUCT 259 +#define ENT_EXTERNSTATIC 260 +#define ENT_YACCUNION 261 +#define GTY_TOKEN 262 +#define UNION 263 +#define STRUCT 264 +#define ENUM 265 +#define ALIAS 266 +#define NESTED_PTR 267 +#define PARAM_IS 268 +#define NUM 269 +#define PERCENTPERCENT 270 +#define SCALAR 271 +#define ID 272 +#define STRING 273 +#define ARRAY 274 +#define PERCENT_ID 275 +#define CHAR 276 + + + + +/* Copy the first part of user declarations. */ +#line 22 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + +#include "bconfig.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "gengtype.h" +#define YYERROR_VERBOSE + + +/* Enabling traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif + +/* Enabling verbose error messages. */ +#ifdef YYERROR_VERBOSE +# undef YYERROR_VERBOSE +# define YYERROR_VERBOSE 1 +#else +# define YYERROR_VERBOSE 0 +#endif + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +#line 31 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" +typedef union YYSTYPE { + type_p t; + pair_p p; + options_p o; + const char *s; +} YYSTYPE; +/* Line 190 of yacc.c. */ +#line 134 "gengtype-yacc.c" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + + + +/* Copy the second part of user declarations. */ + + +/* Line 213 of yacc.c. */ +#line 146 "gengtype-yacc.c" + +#if ! defined (yyoverflow) || YYERROR_VERBOSE + +# ifndef YYFREE +# define YYFREE free +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# endif + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# else +# define YYSTACK_ALLOC alloca +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's `empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# else +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# endif +#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ + + +#if (! defined (yyoverflow) \ + && (! defined (__cplusplus) \ + || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + short int yyss; + YYSTYPE yyvs; + }; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +/* Copy COUNT objects from FROM to TO. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined (__GNUC__) && 1 < __GNUC__ +# define YYCOPY(To, From, Count) \ + __builtin_memcpy (To, From, (Count) * sizeof (*(From))) +# else +# define YYCOPY(To, From, Count) \ + do \ + { \ + register YYSIZE_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (To)[yyi] = (From)[yyi]; \ + } \ + while (0) +# endif +# endif + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack) \ + do \ + { \ + YYSIZE_T yynewbytes; \ + YYCOPY (&yyptr->Stack, Stack, yysize); \ + Stack = &yyptr->Stack; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / sizeof (*yyptr); \ + } \ + while (0) + +#endif + +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short int yysigned_char; +#endif + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 14 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 118 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 33 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 23 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 59 +/* YYNRULES -- Number of states. */ +#define YYNSTATES 127 + +/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ +#define YYUNDEFTOK 2 +#define YYMAXUTOK 276 + +#define YYTRANSLATE(YYX) \ + ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) + +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const unsigned char yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 31, 32, 29, 2, 30, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 28, 24, + 26, 25, 27, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 22, 2, 23, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21 +}; + +#if YYDEBUG +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in + YYRHS. */ +static const unsigned char yyprhs[] = +{ + 0, 0, 3, 4, 7, 10, 13, 14, 23, 24, + 32, 38, 45, 53, 55, 57, 59, 66, 67, 71, + 78, 79, 82, 85, 86, 93, 100, 108, 114, 115, + 118, 120, 122, 124, 126, 129, 135, 138, 144, 147, + 150, 156, 157, 163, 167, 170, 171, 173, 180, 182, + 184, 186, 191, 196, 205, 207, 211, 212, 214, 216 +}; + +/* YYRHS -- A `-1'-separated list of the rules' RHS. */ +static const yysigned_char yyrhs[] = +{ + 34, 0, -1, -1, 35, 34, -1, 38, 34, -1, + 41, 34, -1, -1, 3, 50, 22, 44, 23, 17, + 36, 24, -1, -1, 4, 50, 22, 44, 23, 37, + 24, -1, 5, 50, 39, 17, 40, -1, 5, 50, + 39, 17, 19, 40, -1, 5, 50, 39, 17, 19, + 19, 40, -1, 47, -1, 24, -1, 25, -1, 6, + 50, 44, 23, 42, 15, -1, -1, 42, 20, 43, + -1, 42, 20, 26, 17, 27, 43, -1, -1, 43, + 17, -1, 43, 21, -1, -1, 47, 49, 17, 45, + 24, 44, -1, 47, 49, 17, 19, 24, 44, -1, + 47, 49, 17, 19, 19, 24, 44, -1, 47, 28, + 46, 24, 44, -1, -1, 28, 46, -1, 14, -1, + 17, -1, 16, -1, 17, -1, 47, 29, -1, 9, + 17, 22, 44, 23, -1, 9, 17, -1, 8, 17, + 22, 44, 23, -1, 8, 17, -1, 10, 17, -1, + 10, 17, 22, 48, 23, -1, -1, 17, 25, 14, + 30, 48, -1, 17, 30, 48, -1, 17, 48, -1, + -1, 50, -1, 7, 31, 31, 54, 32, 32, -1, + 11, -1, 13, -1, 17, -1, 17, 31, 55, 32, + -1, 51, 31, 47, 32, -1, 12, 31, 47, 30, + 55, 30, 55, 32, -1, 52, -1, 53, 30, 52, + -1, -1, 53, -1, 18, -1, 55, 18, -1 +}; + +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const unsigned short int yyrline[] = +{ + 0, 65, 65, 66, 67, 68, 72, 71, 81, 80, + 90, 95, 100, 108, 115, 116, 119, 127, 128, 141, + 160, 161, 172, 185, 186, 196, 206, 216, 220, 221, + 224, 224, 228, 230, 232, 234, 239, 241, 246, 248, + 250, 254, 255, 257, 259, 263, 264, 267, 271, 273, + 277, 279, 281, 283, 295, 300, 307, 308, 311, 313 +}; +#endif + +#if YYDEBUG || YYERROR_VERBOSE +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "$end", "error", "$undefined", "ENT_TYPEDEF_STRUCT", "ENT_STRUCT", + "ENT_EXTERNSTATIC", "ENT_YACCUNION", "GTY_TOKEN", "UNION", "STRUCT", + "ENUM", "ALIAS", "NESTED_PTR", "PARAM_IS", "NUM", "\"%%\"", "SCALAR", + "ID", "STRING", "ARRAY", "PERCENT_ID", "CHAR", "'{'", "'}'", "';'", + "'='", "'<'", "'>'", "':'", "'*'", "','", "'('", "')'", "$accept", + "start", "typedef_struct", "@1", "@2", "externstatic", "lasttype", + "semiequal", "yacc_union", "yacc_typematch", "yacc_ids", "struct_fields", + "bitfieldopt", "bitfieldlen", "type", "enum_items", "optionsopt", + "options", "type_option", "option", "optionseq", "optionseqopt", + "stringseq", 0 +}; +#endif + +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to + token YYLEX-NUM. */ +static const unsigned short int yytoknum[] = +{ + 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 123, 125, 59, 61, 60, 62, 58, 42, + 44, 40, 41 +}; +# endif + +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const unsigned char yyr1[] = +{ + 0, 33, 34, 34, 34, 34, 36, 35, 37, 35, + 38, 38, 38, 39, 40, 40, 41, 42, 42, 42, + 43, 43, 43, 44, 44, 44, 44, 44, 45, 45, + 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, + 47, 48, 48, 48, 48, 49, 49, 50, 51, 51, + 52, 52, 52, 52, 53, 53, 54, 54, 55, 55 +}; + +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const unsigned char yyr2[] = +{ + 0, 2, 0, 2, 2, 2, 0, 8, 0, 7, + 5, 6, 7, 1, 1, 1, 6, 0, 3, 6, + 0, 2, 2, 0, 6, 6, 7, 5, 0, 2, + 1, 1, 1, 1, 2, 5, 2, 5, 2, 2, + 5, 0, 5, 3, 2, 0, 1, 6, 1, 1, + 1, 4, 4, 8, 1, 3, 0, 1, 1, 2 +}; + +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state + STATE-NUM when YYTABLE doesn't specify something else to do. Zero + means the default is an error. */ +static const unsigned char yydefact[] = +{ + 2, 0, 0, 0, 0, 0, 2, 2, 2, 0, + 0, 0, 0, 23, 1, 3, 4, 5, 0, 23, + 23, 0, 0, 0, 32, 33, 0, 13, 0, 45, + 56, 0, 0, 38, 36, 39, 0, 34, 17, 0, + 0, 46, 48, 0, 49, 50, 0, 54, 57, 0, + 0, 8, 23, 23, 41, 0, 14, 15, 10, 0, + 30, 31, 0, 28, 0, 0, 0, 0, 0, 6, + 0, 0, 0, 41, 0, 0, 11, 16, 20, 23, + 0, 0, 0, 0, 58, 0, 0, 55, 47, 0, + 9, 37, 35, 0, 41, 44, 40, 12, 0, 18, + 27, 0, 23, 29, 23, 0, 59, 51, 52, 7, + 0, 43, 0, 21, 22, 23, 25, 24, 0, 41, + 20, 26, 0, 42, 19, 0, 53 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yysigned_char yydefgoto[] = +{ + -1, 5, 6, 89, 70, 7, 26, 58, 8, 59, + 99, 28, 82, 62, 29, 74, 40, 10, 46, 47, + 48, 49, 85 +}; + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +#define YYPACT_NINF -98 +static const yysigned_char yypact[] = +{ + 58, 12, 12, 12, 12, 43, 58, 58, 58, 5, + 45, 53, 29, 29, -98, -98, -98, -98, 28, 29, + 29, 41, 59, 60, -98, -98, 61, 50, 57, 0, + 4, 63, 65, 62, 67, 68, 16, -98, -98, 51, + 70, -98, -98, 66, -98, 69, 71, -98, 52, 49, + 74, -98, 29, 29, 75, 23, -98, -98, -98, -2, + -98, -98, 77, -8, 29, 76, 29, 4, 72, -98, + 79, 82, 83, -3, 84, 27, -98, -98, 73, 29, + 31, 51, 85, 44, -98, -9, 37, -98, -98, 86, + -98, -98, -98, 81, 75, -98, -98, -98, 91, 36, + -98, 87, 29, -98, 29, 76, -98, -98, -98, -98, + 88, -98, 89, -98, -98, 29, -98, -98, 14, 75, + -98, -98, 76, -98, 36, -6, -98 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yysigned_char yypgoto[] = +{ + -98, 64, -98, -98, -98, -98, -98, -45, -98, -98, + -27, -19, -98, 17, -10, -70, -98, 2, -98, 46, + -98, -98, -97 +}; + +/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule which + number is the opposite. If zero, do what YYDEFACT says. + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF -1 +static const unsigned char yytable[] = +{ + 31, 32, 27, 95, 11, 12, 13, 9, 118, 106, + 76, 80, 106, 77, 73, 42, 43, 44, 78, 9, + 81, 45, 93, 107, 111, 125, 126, 94, 39, 37, + 97, 41, 106, 71, 72, 55, 18, 21, 22, 23, + 56, 57, 75, 14, 122, 24, 25, 56, 57, 123, + 101, 56, 57, 113, 83, 102, 86, 114, 33, 30, + 100, 1, 2, 3, 4, 60, 37, 19, 61, 108, + 15, 16, 17, 37, 105, 20, 34, 35, 36, 37, + 38, 68, 67, 116, 52, 117, 50, 63, 51, 53, + 54, 69, 73, 124, 84, 110, 121, 64, 103, 98, + 65, 79, 66, 90, 88, 91, 92, 96, 112, 104, + 109, 115, 0, 87, 0, 0, 120, 0, 119 +}; + +static const yysigned_char yycheck[] = +{ + 19, 20, 12, 73, 2, 3, 4, 7, 105, 18, + 55, 19, 18, 15, 17, 11, 12, 13, 20, 7, + 28, 17, 25, 32, 94, 122, 32, 30, 28, 29, + 75, 29, 18, 52, 53, 19, 31, 8, 9, 10, + 24, 25, 19, 0, 30, 16, 17, 24, 25, 119, + 19, 24, 25, 17, 64, 24, 66, 21, 17, 31, + 79, 3, 4, 5, 6, 14, 29, 22, 17, 32, + 6, 7, 8, 29, 30, 22, 17, 17, 17, 29, + 23, 32, 30, 102, 22, 104, 23, 17, 23, 22, + 22, 17, 17, 120, 18, 14, 115, 31, 81, 26, + 31, 24, 31, 24, 32, 23, 23, 23, 17, 24, + 24, 24, -1, 67, -1, -1, 27, -1, 30 +}; + +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const unsigned char yystos[] = +{ + 0, 3, 4, 5, 6, 34, 35, 38, 41, 7, + 50, 50, 50, 50, 0, 34, 34, 34, 31, 22, + 22, 8, 9, 10, 16, 17, 39, 47, 44, 47, + 31, 44, 44, 17, 17, 17, 17, 29, 23, 28, + 49, 50, 11, 12, 13, 17, 51, 52, 53, 54, + 23, 23, 22, 22, 22, 19, 24, 25, 40, 42, + 14, 17, 46, 17, 31, 31, 31, 30, 32, 17, + 37, 44, 44, 17, 48, 19, 40, 15, 20, 24, + 19, 28, 45, 47, 18, 55, 47, 52, 32, 36, + 24, 23, 23, 25, 30, 48, 23, 40, 26, 43, + 44, 19, 24, 46, 24, 30, 18, 32, 32, 24, + 14, 48, 17, 17, 21, 24, 44, 44, 55, 30, + 27, 44, 30, 48, 43, 55, 32 +}; + +#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) +# define YYSIZE_T __SIZE_TYPE__ +#endif +#if ! defined (YYSIZE_T) && defined (size_t) +# define YYSIZE_T size_t +#endif +#if ! defined (YYSIZE_T) +# if defined (__STDC__) || defined (__cplusplus) +# include /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# endif +#endif +#if ! defined (YYSIZE_T) +# define YYSIZE_T unsigned int +#endif + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY (-2) +#define YYEOF 0 + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab + + +/* Like YYERROR except do call yyerror. This remains here temporarily + to ease the transition to the new meaning of YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ + +#define YYFAIL goto yyerrlab + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ +do \ + if (yychar == YYEMPTY && yylen == 1) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + yytoken = YYTRANSLATE (yychar); \ + YYPOPSTACK; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror ("syntax error: cannot back up");\ + YYERROR; \ + } \ +while (0) + + +#define YYTERROR 1 +#define YYERRCODE 256 + + +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +#define YYRHSLOC(Rhs, K) ((Rhs)[K]) +#ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ + (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ + (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ + (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ + } \ + else \ + { \ + (Current).first_line = (Current).last_line = \ + YYRHSLOC (Rhs, 0).last_line; \ + (Current).first_column = (Current).last_column = \ + YYRHSLOC (Rhs, 0).last_column; \ + } \ + while (0) +#endif + + +/* YY_LOCATION_PRINT -- Print the location on the stream. + This macro was not mandated originally: define only if we know + we won't break user code: when these are the locations we know. */ + +#ifndef YY_LOCATION_PRINT +# if YYLTYPE_IS_TRIVIAL +# define YY_LOCATION_PRINT(File, Loc) \ + fprintf (File, "%d.%d-%d.%d", \ + (Loc).first_line, (Loc).first_column, \ + (Loc).last_line, (Loc).last_column) +# else +# define YY_LOCATION_PRINT(File, Loc) ((void) 0) +# endif +#endif + + +/* YYLEX -- calling `yylex' with the right arguments. */ + +#ifdef YYLEX_PARAM +# define YYLEX yylex (YYLEX_PARAM) +#else +# define YYLEX yylex () +#endif + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yysymprint (stderr, \ + Type, Value); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_stack_print (short int *bottom, short int *top) +#else +static void +yy_stack_print (bottom, top) + short int *bottom; + short int *top; +#endif +{ + YYFPRINTF (stderr, "Stack now"); + for (/* Nothing. */; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yy_reduce_print (int yyrule) +#else +static void +yy_reduce_print (yyrule) + int yyrule; +#endif +{ + int yyi; + unsigned int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", + yyrule - 1, yylno); + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) + YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); + YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (Rule); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) +# define YY_SYMBOL_PRINT(Title, Type, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + + +#if YYERROR_VERBOSE + +# ifndef yystrlen +# if defined (__GLIBC__) && defined (_STRING_H) +# define yystrlen strlen +# else +/* Return the length of YYSTR. */ +static YYSIZE_T +# if defined (__STDC__) || defined (__cplusplus) +yystrlen (const char *yystr) +# else +yystrlen (yystr) + const char *yystr; +# endif +{ + register const char *yys = yystr; + + while (*yys++ != '\0') + continue; + + return yys - yystr - 1; +} +# endif +# endif + +# ifndef yystpcpy +# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +# if defined (__STDC__) || defined (__cplusplus) +yystpcpy (char *yydest, const char *yysrc) +# else +yystpcpy (yydest, yysrc) + char *yydest; + const char *yysrc; +# endif +{ + register char *yyd = yydest; + register const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +# endif + +#endif /* !YYERROR_VERBOSE */ + + + +#if YYDEBUG +/*--------------------------------. +| Print this symbol on YYOUTPUT. | +`--------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) +#else +static void +yysymprint (yyoutput, yytype, yyvaluep) + FILE *yyoutput; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (yytype < YYNTOKENS) + YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); + else + YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); + + +# ifdef YYPRINT + if (yytype < YYNTOKENS) + YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); +# endif + switch (yytype) + { + default: + break; + } + YYFPRINTF (yyoutput, ")"); +} + +#endif /* ! YYDEBUG */ +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +#if defined (__STDC__) || defined (__cplusplus) +static void +yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) +#else +static void +yydestruct (yymsg, yytype, yyvaluep) + const char *yymsg; + int yytype; + YYSTYPE *yyvaluep; +#endif +{ + /* Pacify ``unused variable'' warnings. */ + (void) yyvaluep; + + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); + + switch (yytype) + { + + default: + break; + } +} + + +/* Prevent warnings from -Wmissing-prototypes. */ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM); +# else +int yyparse (); +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int yyparse (void); +#else +int yyparse (); +#endif +#endif /* ! YYPARSE_PARAM */ + + + +/* The look-ahead symbol. */ +int yychar; + +/* The semantic value of the look-ahead symbol. */ +YYSTYPE yylval; + +/* Number of syntax errors so far. */ +int yynerrs; + + + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM) +# else +int yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +# endif +#else /* ! YYPARSE_PARAM */ +#if defined (__STDC__) || defined (__cplusplus) +int +yyparse (void) +#else +int +yyparse () + +#endif +#endif +{ + + register int yystate; + register int yyn; + int yyresult; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus; + /* Look-ahead token as an internal (translated) token number. */ + int yytoken = 0; + + /* Three stacks and their tools: + `yyss': related to states, + `yyvs': related to semantic values, + `yyls': related to locations. + + Refer to the stacks thru separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* The state stack. */ + short int yyssa[YYINITDEPTH]; + short int *yyss = yyssa; + register short int *yyssp; + + /* The semantic value stack. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + register YYSTYPE *yyvsp; + + + +#define YYPOPSTACK (yyvsp--, yyssp--) + + YYSIZE_T yystacksize = YYINITDEPTH; + + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + + /* When reducing, the number of symbols on the RHS of the reduced + rule. */ + int yylen; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + yyssp = yyss; + yyvsp = yyvs; + + + yyvsp[0] = yylval; + + goto yysetstate; + +/*------------------------------------------------------------. +| yynewstate -- Push a new state, which is found in yystate. | +`------------------------------------------------------------*/ + yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. + */ + yyssp++; + + yysetstate: + *yyssp = yystate; + + if (yyss + yystacksize - 1 <= yyssp) + { + /* Get the current used size of the three stacks, in elements. */ + YYSIZE_T yysize = yyssp - yyss + 1; + +#ifdef yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + YYSTYPE *yyvs1 = yyvs; + short int *yyss1 = yyss; + + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow ("parser stack overflow", + &yyss1, yysize * sizeof (*yyssp), + &yyvs1, yysize * sizeof (*yyvsp), + + &yystacksize); + + yyss = yyss1; + yyvs = yyvs1; + } +#else /* no yyoverflow */ +# ifndef YYSTACK_RELOCATE + goto yyoverflowlab; +# else + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + goto yyoverflowlab; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + short int *yyss1 = yyss; + union yyalloc *yyptr = + (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); + if (! yyptr) + goto yyoverflowlab; + YYSTACK_RELOCATE (yyss); + YYSTACK_RELOCATE (yyvs); + +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif +#endif /* no yyoverflow */ + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + + YYDPRINTF ((stderr, "Stack size increased to %lu\n", + (unsigned long int) yystacksize)); + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } + + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + + goto yybackup; + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a look-ahead token if we need one and don't already have one. */ +/* yyresume: */ + + /* First try to decide what to do without reference to look-ahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYPACT_NINF) + goto yydefault; + + /* Not known => get a look-ahead token if don't already have one. */ + + /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token: ")); + yychar = YYLEX; + } + + if (yychar <= YYEOF) + { + yychar = yytoken = YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yyn == 0 || yyn == YYTABLE_NINF) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the look-ahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; + + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + yystate = yyn; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- Do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + `$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 6: +#line 72 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + new_structure ((yyvsp[-5].t)->u.s.tag, UNION_P ((yyvsp[-5].t)), &lexer_line, + (yyvsp[-2].p), (yyvsp[-4].o)); + do_typedef ((yyvsp[0].s), (yyvsp[-5].t), &lexer_line); + lexer_toplevel_done = 1; + ;} + break; + + case 7: +#line 79 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + {;} + break; + + case 8: +#line 81 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + new_structure ((yyvsp[-4].t)->u.s.tag, UNION_P ((yyvsp[-4].t)), &lexer_line, + (yyvsp[-1].p), (yyvsp[-3].o)); + lexer_toplevel_done = 1; + ;} + break; + + case 9: +#line 87 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + {;} + break; + + case 10: +#line 91 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + note_variable ((yyvsp[-1].s), adjust_field_type ((yyvsp[-2].t), (yyvsp[-3].o)), (yyvsp[-3].o), + &lexer_line); + ;} + break; + + case 11: +#line 96 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + note_variable ((yyvsp[-2].s), create_array ((yyvsp[-3].t), (yyvsp[-1].s)), + (yyvsp[-4].o), &lexer_line); + ;} + break; + + case 12: +#line 101 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + note_variable ((yyvsp[-3].s), create_array (create_array ((yyvsp[-4].t), (yyvsp[-1].s)), + (yyvsp[-2].s)), + (yyvsp[-5].o), &lexer_line); + ;} + break; + + case 13: +#line 109 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + lexer_toplevel_done = 1; + (yyval.t) = (yyvsp[0].t); + ;} + break; + + case 16: +#line 121 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + note_yacc_type ((yyvsp[-4].o), (yyvsp[-3].p), (yyvsp[-1].p), &lexer_line); + ;} + break; + + case 17: +#line 127 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.p) = NULL; ;} + break; + + case 18: +#line 129 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + pair_p p; + for (p = (yyvsp[0].p); p->next != NULL; p = p->next) + { + p->name = NULL; + p->type = NULL; + } + p->name = NULL; + p->type = NULL; + p->next = (yyvsp[-2].p); + (yyval.p) = (yyvsp[0].p); + ;} + break; + + case 19: +#line 142 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + pair_p p; + type_p newtype = NULL; + if (strcmp ((yyvsp[-4].s), "type") == 0) + newtype = (type_p) 1; + for (p = (yyvsp[0].p); p->next != NULL; p = p->next) + { + p->name = (yyvsp[-2].s); + p->type = newtype; + } + p->name = (yyvsp[-2].s); + p->next = (yyvsp[-5].p); + p->type = newtype; + (yyval.p) = (yyvsp[0].p); + ;} + break; + + case 20: +#line 160 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.p) = NULL; ;} + break; + + case 21: +#line 162 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + pair_p p = XCNEW (struct pair); + p->next = (yyvsp[-1].p); + p->line = lexer_line; + p->opt = XNEW (struct options); + p->opt->name = "tag"; + p->opt->next = NULL; + p->opt->info = (char *)(yyvsp[0].s); + (yyval.p) = p; + ;} + break; + + case 22: +#line 173 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + pair_p p = XCNEW (struct pair); + p->next = (yyvsp[-1].p); + p->line = lexer_line; + p->opt = XNEW (struct options); + p->opt->name = "tag"; + p->opt->next = NULL; + p->opt->info = xasprintf ("'%s'", (yyvsp[0].s)); + (yyval.p) = p; + ;} + break; + + case 23: +#line 185 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.p) = NULL; ;} + break; + + case 24: +#line 187 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + pair_p p = XNEW (struct pair); + p->type = adjust_field_type ((yyvsp[-5].t), (yyvsp[-4].o)); + p->opt = (yyvsp[-4].o); + p->name = (yyvsp[-3].s); + p->next = (yyvsp[0].p); + p->line = lexer_line; + (yyval.p) = p; + ;} + break; + + case 25: +#line 197 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + pair_p p = XNEW (struct pair); + p->type = adjust_field_type (create_array ((yyvsp[-5].t), (yyvsp[-2].s)), (yyvsp[-4].o)); + p->opt = (yyvsp[-4].o); + p->name = (yyvsp[-3].s); + p->next = (yyvsp[0].p); + p->line = lexer_line; + (yyval.p) = p; + ;} + break; + + case 26: +#line 207 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + pair_p p = XNEW (struct pair); + p->type = create_array (create_array ((yyvsp[-6].t), (yyvsp[-2].s)), (yyvsp[-3].s)); + p->opt = (yyvsp[-5].o); + p->name = (yyvsp[-4].s); + p->next = (yyvsp[0].p); + p->line = lexer_line; + (yyval.p) = p; + ;} + break; + + case 27: +#line 217 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.p) = (yyvsp[0].p); ;} + break; + + case 31: +#line 225 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { ;} + break; + + case 32: +#line 229 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.t) = (yyvsp[0].t); ;} + break; + + case 33: +#line 231 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.t) = resolve_typedef ((yyvsp[0].s), &lexer_line); ;} + break; + + case 34: +#line 233 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.t) = create_pointer ((yyvsp[-1].t)); ;} + break; + + case 35: +#line 235 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + new_structure ((yyvsp[-3].s), 0, &lexer_line, (yyvsp[-1].p), NULL); + (yyval.t) = find_structure ((yyvsp[-3].s), 0); + ;} + break; + + case 36: +#line 240 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.t) = find_structure ((yyvsp[0].s), 0); ;} + break; + + case 37: +#line 242 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + new_structure ((yyvsp[-3].s), 1, &lexer_line, (yyvsp[-1].p), NULL); + (yyval.t) = find_structure ((yyvsp[-3].s), 1); + ;} + break; + + case 38: +#line 247 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.t) = find_structure ((yyvsp[0].s), 1); ;} + break; + + case 39: +#line 249 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.t) = create_scalar_type ((yyvsp[0].s), strlen ((yyvsp[0].s))); ;} + break; + + case 40: +#line 251 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.t) = create_scalar_type ((yyvsp[-3].s), strlen ((yyvsp[-3].s))); ;} + break; + + case 42: +#line 256 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { ;} + break; + + case 43: +#line 258 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { ;} + break; + + case 44: +#line 260 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { ;} + break; + + case 45: +#line 263 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.o) = NULL; ;} + break; + + case 46: +#line 264 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.o) = (yyvsp[0].o); ;} + break; + + case 47: +#line 268 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.o) = (yyvsp[-2].o); ;} + break; + + case 48: +#line 272 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.s) = "ptr_alias"; ;} + break; + + case 49: +#line 274 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.s) = (yyvsp[0].s); ;} + break; + + case 50: +#line 278 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.o) = create_option ((yyvsp[0].s), (void *)""); ;} + break; + + case 51: +#line 280 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.o) = create_option ((yyvsp[-3].s), (void *)(yyvsp[-1].s)); ;} + break; + + case 52: +#line 282 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.o) = create_option ((yyvsp[-3].s), adjust_field_type ((yyvsp[-1].t), NULL)); ;} + break; + + case 53: +#line 284 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + struct nested_ptr_data d; + + d.type = adjust_field_type ((yyvsp[-5].t), NULL); + d.convert_to = (yyvsp[-3].s); + d.convert_from = (yyvsp[-1].s); + (yyval.o) = create_option ("nested_ptr", + xmemdup (&d, sizeof (d), sizeof (d))); + ;} + break; + + case 54: +#line 296 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + (yyvsp[0].o)->next = NULL; + (yyval.o) = (yyvsp[0].o); + ;} + break; + + case 55: +#line 301 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + (yyvsp[0].o)->next = (yyvsp[-2].o); + (yyval.o) = (yyvsp[0].o); + ;} + break; + + case 56: +#line 307 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.o) = NULL; ;} + break; + + case 57: +#line 308 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.o) = (yyvsp[0].o); ;} + break; + + case 58: +#line 312 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { (yyval.s) = (yyvsp[0].s); ;} + break; + + case 59: +#line 314 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + { + size_t l1 = strlen ((yyvsp[-1].s)); + size_t l2 = strlen ((yyvsp[0].s)); + char *s = XRESIZEVEC (char, (yyvsp[-1].s), l1 + l2 + 1); + memcpy (s + l1, (yyvsp[0].s), l2 + 1); + XDELETE ((yyvsp[0].s)); + (yyval.s) = s; + ;} + break; + + + } + +/* Line 1037 of yacc.c. */ +#line 1514 "gengtype-yacc.c" + + yyvsp -= yylen; + yyssp -= yylen; + + + YY_STACK_PRINT (yyss, yyssp); + + *++yyvsp = yyval; + + + /* Now `shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; + if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTOKENS]; + + goto yynewstate; + + +/*------------------------------------. +| yyerrlab -- here on detecting error | +`------------------------------------*/ +yyerrlab: + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; +#if YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (YYPACT_NINF < yyn && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + const char* yyprefix; + char *yymsg; + int yyx; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 0; + + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); + yycount += 1; + if (yycount == 5) + { + yysize = 0; + break; + } + } + yysize += (sizeof ("syntax error, unexpected ") + + yystrlen (yytname[yytype])); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); + + if (yycount < 5) + { + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yyp = yystpcpy (yyp, yyprefix); + yyp = yystpcpy (yyp, yytname[yyx]); + yyprefix = " or "; + } + } + yyerror (yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror ("syntax error; also virtual memory exhausted"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror ("syntax error"); + } + + + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse look-ahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* If at end of input, pop the error token, + then the rest of the stack, then return failure. */ + if (yychar == YYEOF) + for (;;) + { + + YYPOPSTACK; + if (yyssp == yyss) + YYABORT; + yydestruct ("Error: popping", + yystos[*yyssp], yyvsp); + } + } + else + { + yydestruct ("Error: discarding", yytoken, &yylval); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse look-ahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + +#ifdef __GNUC__ + /* Pacify GCC when the user code never invokes YYERROR and the label + yyerrorlab therefore never appears in user code. */ + if (0) + goto yyerrorlab; +#endif + +yyvsp -= yylen; + yyssp -= yylen; + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYPACT_NINF) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", yystos[yystate], yyvsp); + YYPOPSTACK; + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + if (yyn == YYFINAL) + YYACCEPT; + + *++yyvsp = yylval; + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturn; + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yydestruct ("Error: discarding lookahead", + yytoken, &yylval); + yychar = YYEMPTY; + yyresult = 1; + goto yyreturn; + +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ +yyoverflowlab: + yyerror ("parser stack overflow"); + yyresult = 2; + /* Fall through. */ +#endif + +yyreturn: +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + return yyresult; +} + + +#line 323 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" + + diff --git a/contrib/gcc-4.0/gcc/gengtype-yacc.h b/contrib/gcc-4.0/gcc/gengtype-yacc.h dissimilarity index 83% index 5ef464a5aa..2e83415435 100644 --- a/contrib/gcc-4.0/gcc/gengtype-yacc.h +++ b/contrib/gcc-4.0/gcc/gengtype-yacc.h @@ -1,37 +1,94 @@ -#ifndef BISON_GENGTYPE_YACC_H -# define BISON_GENGTYPE_YACC_H - -#ifndef YYSTYPE -typedef union { - type_p t; - pair_p p; - options_p o; - const char *s; -} yystype; -# define YYSTYPE yystype -# define YYSTYPE_IS_TRIVIAL 1 -#endif -# define ENT_TYPEDEF_STRUCT 257 -# define ENT_STRUCT 258 -# define ENT_EXTERNSTATIC 259 -# define ENT_YACCUNION 260 -# define GTY_TOKEN 261 -# define UNION 262 -# define STRUCT 263 -# define ENUM 264 -# define ALIAS 265 -# define NESTED_PTR 266 -# define PARAM_IS 267 -# define NUM 268 -# define PERCENTPERCENT 269 -# define SCALAR 270 -# define ID 271 -# define STRING 272 -# define ARRAY 273 -# define PERCENT_ID 274 -# define CHAR 275 - - -extern YYSTYPE yylval; - -#endif /* not BISON_GENGTYPE_YACC_H */ +/* A Bison parser, made by GNU Bison 2.0. */ + +/* Skeleton parser for Yacc-like parsing with Bison, + Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. + + 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, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* Tokens. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { + ENT_TYPEDEF_STRUCT = 258, + ENT_STRUCT = 259, + ENT_EXTERNSTATIC = 260, + ENT_YACCUNION = 261, + GTY_TOKEN = 262, + UNION = 263, + STRUCT = 264, + ENUM = 265, + ALIAS = 266, + NESTED_PTR = 267, + PARAM_IS = 268, + NUM = 269, + PERCENTPERCENT = 270, + SCALAR = 271, + ID = 272, + STRING = 273, + ARRAY = 274, + PERCENT_ID = 275, + CHAR = 276 + }; +#endif +#define ENT_TYPEDEF_STRUCT 258 +#define ENT_STRUCT 259 +#define ENT_EXTERNSTATIC 260 +#define ENT_YACCUNION 261 +#define GTY_TOKEN 262 +#define UNION 263 +#define STRUCT 264 +#define ENUM 265 +#define ALIAS 266 +#define NESTED_PTR 267 +#define PARAM_IS 268 +#define NUM 269 +#define PERCENTPERCENT 270 +#define SCALAR 271 +#define ID 272 +#define STRING 273 +#define ARRAY 274 +#define PERCENT_ID 275 +#define CHAR 276 + + + + +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +#line 31 "/scratch/mitchell/gcc-releases/gcc-4.0.1/gcc-4.0.1/gcc/gengtype-yacc.y" +typedef union YYSTYPE { + type_p t; + pair_p p; + options_p o; + const char *s; +} YYSTYPE; +/* Line 1318 of yacc.c. */ +#line 86 "gengtype-yacc.h" +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 +#endif + +extern YYSTYPE yylval; + + + diff --git a/contrib/gcc-4.0/gcc/gensupport.c b/contrib/gcc-4.0/gcc/gensupport.c index a0b3faa606..d85ef3e9d2 100644 --- a/contrib/gcc-4.0/gcc/gensupport.c +++ b/contrib/gcc-4.0/gcc/gensupport.c @@ -911,6 +911,9 @@ init_md_reader_args_cb (int argc, char **argv, bool (*parse_opt)(const char *)) char *lastsl; rtx desc; + /* Unlock the stdio streams. */ + unlock_std_streams (); + for (i = 1; i < argc; i++) { if (argv[i][0] != '-') diff --git a/contrib/gcc-4.0/gcc/gimplify.c b/contrib/gcc-4.0/gcc/gimplify.c index 992f546bb7..d950a90661 100644 --- a/contrib/gcc-4.0/gcc/gimplify.c +++ b/contrib/gcc-4.0/gcc/gimplify.c @@ -983,10 +983,12 @@ gimplify_decl_expr (tree *stmt_p) if (TREE_TYPE (decl) == error_mark_node) return GS_ERROR; - else if (TREE_CODE (decl) == TYPE_DECL) + if ((TREE_CODE (decl) == TYPE_DECL + || TREE_CODE (decl) == VAR_DECL) + && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl))) gimplify_type_sizes (TREE_TYPE (decl), stmt_p); - else if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)) + if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)) { tree init = DECL_INITIAL (decl); @@ -997,12 +999,6 @@ gimplify_decl_expr (tree *stmt_p) of the emitted code: see mx_register_decls(). */ tree t, args, addr, ptr_type; - /* ??? We really shouldn't need to gimplify the type of the variable - since it already should have been done. But leave this here - for now to avoid disrupting too many things at once. */ - if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl))) - gimplify_type_sizes (TREE_TYPE (decl), stmt_p); - gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p); gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p); @@ -2715,13 +2711,18 @@ gimplify_init_constructor (tree *expr_p, tree *pre_p, parts in, then generate code for the non-constant parts. */ /* TODO. There's code in cp/typeck.c to do this. */ - num_type_elements = count_type_elements (TREE_TYPE (ctor)); + num_type_elements = count_type_elements (type); + /* If count_type_elements could not determine number of type elements + for a constant-sized object, assume clearing is needed. + Don't do this for variable-sized objects, as store_constructor + will ignore the clearing of variable-sized objects. */ + if (num_type_elements < 0 && int_size_in_bytes (type) >= 0) + cleared = true; /* If there are "lots" of zeros, then block clear the object first. */ - if (num_type_elements - num_nonzero_elements > CLEAR_RATIO - && num_nonzero_elements < num_type_elements/4) + else if (num_type_elements - num_nonzero_elements > CLEAR_RATIO + && num_nonzero_elements < num_type_elements/4) cleared = true; - /* ??? This bit ought not be needed. For any element not present in the initializer, we should simply set them to zero. Except we'd need to *find* the elements that are not present, and that @@ -4360,21 +4361,21 @@ gimplify_type_sizes (tree type, tree *list_p) { tree field, t; - /* Note that we do not check for TYPE_SIZES_GIMPLIFIED already set because - that's not supposed to happen on types where gimplification does anything. - We should assert that it isn't set, but we can indeed be called multiple - times on pointers. Unfortunately, this includes fat pointers which we - can't easily test for. We could pass TYPE down to gimplify_one_sizepos - and test there, but it doesn't seem worth it. */ + if (type == NULL) + return; /* We first do the main variant, then copy into any other variants. */ type = TYPE_MAIN_VARIANT (type); + /* Avoid infinite recursion. */ + if (TYPE_SIZES_GIMPLIFIED (type) + || type == error_mark_node) + return; + + TYPE_SIZES_GIMPLIFIED (type) = 1; + switch (TREE_CODE (type)) { - case ERROR_MARK: - return; - case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: @@ -4387,17 +4388,13 @@ gimplify_type_sizes (tree type, tree *list_p) { TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type); TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type); - TYPE_SIZES_GIMPLIFIED (t) = 1; } break; case ARRAY_TYPE: /* These types may not have declarations, so handle them here. */ - if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (type))) - gimplify_type_sizes (TREE_TYPE (type), list_p); - - if (!TYPE_SIZES_GIMPLIFIED (TYPE_DOMAIN (type))) - gimplify_type_sizes (TYPE_DOMAIN (type), list_p); + gimplify_type_sizes (TREE_TYPE (type), list_p); + gimplify_type_sizes (TYPE_DOMAIN (type), list_p); break; case RECORD_TYPE: @@ -4405,7 +4402,15 @@ gimplify_type_sizes (tree type, tree *list_p) case QUAL_UNION_TYPE: for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) if (TREE_CODE (field) == FIELD_DECL) - gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p); + { + gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p); + gimplify_type_sizes (TREE_TYPE (field), list_p); + } + break; + + case POINTER_TYPE: + case REFERENCE_TYPE: + gimplify_type_sizes (TREE_TYPE (type), list_p); break; default: @@ -4421,8 +4426,6 @@ gimplify_type_sizes (tree type, tree *list_p) TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type); TYPE_SIZES_GIMPLIFIED (t) = 1; } - - TYPE_SIZES_GIMPLIFIED (type) = 1; } /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P, diff --git a/contrib/gcc-4.0/gcc/gthr-posix.h b/contrib/gcc-4.0/gcc/gthr-posix.h index 9b56b5aec5..938b4f15dd 100644 --- a/contrib/gcc-4.0/gcc/gthr-posix.h +++ b/contrib/gcc-4.0/gcc/gthr-posix.h @@ -548,6 +548,7 @@ __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex) r = pthread_mutexattr_destroy (&attr); return r; } + return 0; } #endif diff --git a/contrib/gcc-4.0/gcc/intl.h b/contrib/gcc-4.0/gcc/intl.h index 1166794ed7..cca596d984 100644 --- a/contrib/gcc-4.0/gcc/intl.h +++ b/contrib/gcc-4.0/gcc/intl.h @@ -51,6 +51,10 @@ extern size_t gcc_gettext_width (const char *); # define N_(msgid) msgid #endif +#ifndef G_ +# define G_(gmsgid) gmsgid +#endif + extern const char *open_quote; extern const char *close_quote; diff --git a/contrib/gcc-4.0/gcc/loop-unswitch.c b/contrib/gcc-4.0/gcc/loop-unswitch.c index f307dc1a29..4a8865433e 100644 --- a/contrib/gcc-4.0/gcc/loop-unswitch.c +++ b/contrib/gcc-4.0/gcc/loop-unswitch.c @@ -226,11 +226,11 @@ may_unswitch_on (basic_block bb, struct loop *loop, rtx *cinsn) if (at != BB_END (bb)) return NULL_RTX; - *cinsn = BB_END (bb); if (!rtx_equal_p (op[0], XEXP (test, 0)) || !rtx_equal_p (op[1], XEXP (test, 1))) return NULL_RTX; + *cinsn = BB_END (bb); return test; } @@ -269,7 +269,7 @@ unswitch_single_loop (struct loops *loops, struct loop *loop, basic_block *bbs; struct loop *nloop; unsigned i; - rtx cond, rcond = NULL_RTX, conds, rconds, acond, cinsn = NULL_RTX; + rtx cond, rcond = NULL_RTX, conds, rconds, acond, cinsn; int repeat; edge e; @@ -324,6 +324,7 @@ unswitch_single_loop (struct loops *loops, struct loop *loop, do { repeat = 0; + cinsn = NULL_RTX; /* Find a bb to unswitch on. */ bbs = get_loop_body (loop); diff --git a/contrib/gcc-4.0/gcc/params.def b/contrib/gcc-4.0/gcc/params.def index 64cb88040e..e3d2a7b627 100644 --- a/contrib/gcc-4.0/gcc/params.def +++ b/contrib/gcc-4.0/gcc/params.def @@ -364,6 +364,11 @@ DEFPARAM(PARAM_IV_ALWAYS_PRUNE_CAND_SET_BOUND, "If number of candidates in the set is smaller, we always try to remove unused ivs during its optimization", 10, 0, 0) +DEFPARAM(PARAM_SCEV_MAX_EXPR_SIZE, + "scev-max-expr-size", + "Bound on size of expressions used in the scalar evolutions analyzer", + 20, 0, 0) + /* The product of the next two is used to decide whether or not to use .GLOBAL_VAR. See tree-dfa.c. */ DEFPARAM(PARAM_GLOBAL_VAR_THRESHOLD, diff --git a/contrib/gcc-4.0/gcc/postreload.c b/contrib/gcc-4.0/gcc/postreload.c index df10eb4942..6e53389b70 100644 --- a/contrib/gcc-4.0/gcc/postreload.c +++ b/contrib/gcc-4.0/gcc/postreload.c @@ -1273,7 +1273,8 @@ reload_cse_move2add (rtx first) { enum machine_mode narrow_mode; for (narrow_mode = GET_CLASS_NARROWEST_MODE (MODE_INT); - narrow_mode != GET_MODE (reg); + narrow_mode != VOIDmode + && narrow_mode != GET_MODE (reg); narrow_mode = GET_MODE_WIDER_MODE (narrow_mode)) { if (have_insn_for (STRICT_LOW_PART, narrow_mode) diff --git a/contrib/gcc-4.0/gcc/reg-stack.c b/contrib/gcc-4.0/gcc/reg-stack.c index d561416fa2..7989fa7c0d 100644 --- a/contrib/gcc-4.0/gcc/reg-stack.c +++ b/contrib/gcc-4.0/gcc/reg-stack.c @@ -1233,9 +1233,9 @@ swap_rtx_condition (rtx insn) pat = PATTERN (insn); } - /* See if this is, or ends in, a fnstsw, aka unspec 9. If so, we're - not doing anything with the cc value right now. We may be able to - search for one though. */ + /* See if this is, or ends in, a fnstsw. If so, we're not doing anything + with the cc value right now. We may be able to search for one + though. */ if (GET_CODE (pat) == SET && GET_CODE (SET_SRC (pat)) == UNSPEC @@ -1254,9 +1254,13 @@ swap_rtx_condition (rtx insn) return 0; } + /* We haven't found it. */ + if (insn == BB_END (current_block)) + return 0; + /* So we've found the insn using this value. If it is anything - other than sahf, aka unspec 10, or the value does not die - (meaning we'd have to search further), then we must give up. */ + other than sahf or the value does not die (meaning we'd have + to search further), then we must give up. */ pat = PATTERN (insn); if (GET_CODE (pat) != SET || GET_CODE (SET_SRC (pat)) != UNSPEC diff --git a/contrib/gcc-4.0/gcc/reload.c b/contrib/gcc-4.0/gcc/reload.c index 7d42492a98..29154753b8 100644 --- a/contrib/gcc-4.0/gcc/reload.c +++ b/contrib/gcc-4.0/gcc/reload.c @@ -1520,7 +1520,7 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc, But if there is no spilling in this block, that is OK. An explicitly used hard reg cannot be a spill reg. */ - if (rld[i].reg_rtx == 0 && in != 0) + if (rld[i].reg_rtx == 0 && in != 0 && hard_regs_live_known) { rtx note; int regno; @@ -1534,6 +1534,11 @@ push_reload (rtx in, rtx out, rtx *inloc, rtx *outloc, && REG_P (XEXP (note, 0)) && (regno = REGNO (XEXP (note, 0))) < FIRST_PSEUDO_REGISTER && reg_mentioned_p (XEXP (note, 0), in) + /* Check that we don't use a hardreg for an uninitialized + pseudo. See also find_dummy_reload(). */ + && (ORIGINAL_REGNO (XEXP (note, 0)) < FIRST_PSEUDO_REGISTER + || ! bitmap_bit_p (ENTRY_BLOCK_PTR->global_live_at_end, + ORIGINAL_REGNO (XEXP (note, 0)))) && ! refers_to_regno_for_reload_p (regno, (regno + hard_regno_nregs[regno] @@ -1997,7 +2002,17 @@ find_dummy_reload (rtx real_in, rtx real_out, rtx *inloc, rtx *outloc, is a subreg, and in that case, out has a real mode. */ (GET_MODE (out) != VOIDmode - ? GET_MODE (out) : outmode))) + ? GET_MODE (out) : outmode)) + /* But only do all this if we can be sure, that this input + operand doesn't correspond with an uninitialized pseudoreg. + global can assign some hardreg to it, which is the same as + a different pseudo also currently live (as it can ignore the + conflict). So we never must introduce writes to such hardregs, + as they would clobber the other live pseudo using the same. + See also PR20973. */ + && (ORIGINAL_REGNO (in) < FIRST_PSEUDO_REGISTER + || ! bitmap_bit_p (ENTRY_BLOCK_PTR->global_live_at_end, + ORIGINAL_REGNO (in)))) { unsigned int regno = REGNO (in) + in_offset; unsigned int nwords = hard_regno_nregs[regno][inmode]; diff --git a/contrib/gcc-4.0/gcc/reload1.c b/contrib/gcc-4.0/gcc/reload1.c index ea9a1775b1..2c266f9055 100644 --- a/contrib/gcc-4.0/gcc/reload1.c +++ b/contrib/gcc-4.0/gcc/reload1.c @@ -383,7 +383,7 @@ static int eliminate_regs_in_insn (rtx, int); static void update_eliminable_offsets (void); static void mark_not_eliminable (rtx, rtx, void *); static void set_initial_elim_offsets (void); -static void verify_initial_elim_offsets (void); +static bool verify_initial_elim_offsets (void); static void set_initial_label_offsets (void); static void set_offsets_for_label (rtx); static void init_elim_table (void); @@ -972,6 +972,13 @@ reload (rtx first, int global) if (starting_frame_size != get_frame_size ()) something_changed = 1; + /* Even if the frame size remained the same, we might still have + changed elimination offsets, e.g. if find_reloads called + force_const_mem requiring the back end to allocate a constant + pool base register that needs to be saved on the stack. */ + else if (!verify_initial_elim_offsets ()) + something_changed = 1; + { HARD_REG_SET to_spill; CLEAR_HARD_REG_SET (to_spill); @@ -1063,8 +1070,7 @@ reload (rtx first, int global) gcc_assert (old_frame_size == get_frame_size ()); - if (num_eliminable) - verify_initial_elim_offsets (); + gcc_assert (verify_initial_elim_offsets ()); } /* If we were able to eliminate the frame pointer, show that it is no @@ -3275,23 +3281,32 @@ mark_not_eliminable (rtx dest, rtx x, void *data ATTRIBUTE_UNUSED) where something illegal happened during reload_as_needed that could cause incorrect code to be generated if we did not check for it. */ -static void +static bool verify_initial_elim_offsets (void) { HOST_WIDE_INT t; -#ifdef ELIMINABLE_REGS - struct elim_table *ep; + if (!num_eliminable) + return true; - for (ep = reg_eliminate; ep < ®_eliminate[NUM_ELIMINABLE_REGS]; ep++) - { - INITIAL_ELIMINATION_OFFSET (ep->from, ep->to, t); - gcc_assert (t == ep->initial_offset); - } +#ifdef ELIMINABLE_REGS + { + struct elim_table *ep; + + for (ep = reg_eliminate; ep < ®_eliminate[NUM_ELIMINABLE_REGS]; ep++) + { + INITIAL_ELIMINATION_OFFSET (ep->from, ep->to, t); + if (t != ep->initial_offset) + return false; + } + } #else INITIAL_FRAME_POINTER_OFFSET (t); - gcc_assert (t == reg_eliminate[0].initial_offset); + if (t != reg_eliminate[0].initial_offset) + return false; #endif + + return true; } /* Reset all offsets on eliminable registers to their initial values. */ diff --git a/contrib/gcc-4.0/gcc/rtl-error.c b/contrib/gcc-4.0/gcc/rtl-error.c index db795929e6..3521c1d361 100644 --- a/contrib/gcc-4.0/gcc/rtl-error.c +++ b/contrib/gcc-4.0/gcc/rtl-error.c @@ -87,22 +87,22 @@ diagnostic_for_asm (rtx insn, const char *msg, va_list *args_ptr, } void -error_for_asm (rtx insn, const char *msgid, ...) +error_for_asm (rtx insn, const char *gmsgid, ...) { va_list ap; - va_start (ap, msgid); - diagnostic_for_asm (insn, msgid, &ap, DK_ERROR); + va_start (ap, gmsgid); + diagnostic_for_asm (insn, gmsgid, &ap, DK_ERROR); va_end (ap); } void -warning_for_asm (rtx insn, const char *msgid, ...) +warning_for_asm (rtx insn, const char *gmsgid, ...) { va_list ap; - va_start (ap, msgid); - diagnostic_for_asm (insn, msgid, &ap, DK_WARNING); + va_start (ap, gmsgid); + diagnostic_for_asm (insn, gmsgid, &ap, DK_WARNING); va_end (ap); } diff --git a/contrib/gcc-4.0/gcc/rtlanal.c b/contrib/gcc-4.0/gcc/rtlanal.c index 94e8d4c803..5fdb4704fd 100644 --- a/contrib/gcc-4.0/gcc/rtlanal.c +++ b/contrib/gcc-4.0/gcc/rtlanal.c @@ -1309,8 +1309,18 @@ reg_overlap_mentioned_p (rtx x, rtx in) fmt = GET_RTX_FORMAT (GET_CODE (in)); for (i = GET_RTX_LENGTH (GET_CODE (in)) - 1; i >= 0; i--) - if (fmt[i] == 'e' && reg_overlap_mentioned_p (x, XEXP (in, i))) - return 1; + if (fmt[i] == 'e') + { + if (reg_overlap_mentioned_p (x, XEXP (in, i))) + return 1; + } + else if (fmt[i] == 'E') + { + int j; + for (j = XVECLEN (in, i) - 1; j >= 0; --j) + if (reg_overlap_mentioned_p (x, XVECEXP (in, i, j))) + return 1; + } return 0; } diff --git a/contrib/gcc-4.0/gcc/simplify-rtx.c b/contrib/gcc-4.0/gcc/simplify-rtx.c index 3878008951..2c499d0b5f 100644 --- a/contrib/gcc-4.0/gcc/simplify-rtx.c +++ b/contrib/gcc-4.0/gcc/simplify-rtx.c @@ -1549,7 +1549,7 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, have X (if C is 2 in the example above). But don't make something more expensive than we had before. */ - if (! FLOAT_MODE_P (mode)) + if (SCALAR_INT_MODE_P (mode)) { HOST_WIDE_INT coeff0h = 0, coeff1h = 0; unsigned HOST_WIDE_INT coeff0l = 1, coeff1l = 1; @@ -1720,7 +1720,7 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, have X (if C is 2 in the example above). But don't make something more expensive than we had before. */ - if (! FLOAT_MODE_P (mode)) + if (SCALAR_INT_MODE_P (mode)) { HOST_WIDE_INT coeff0h = 0, negcoeff1h = -1; unsigned HOST_WIDE_INT coeff0l = 1, negcoeff1l = -1; @@ -1921,7 +1921,7 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, if (((GET_CODE (op0) == NOT && rtx_equal_p (XEXP (op0, 0), op1)) || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0))) && ! side_effects_p (op0) - && GET_MODE_CLASS (mode) != MODE_CC) + && SCALAR_INT_MODE_P (mode)) return constm1_rtx; tem = simplify_associative_operation (code, mode, op0, op1); if (tem) @@ -1938,7 +1938,7 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, if (trueop0 == trueop1 && ! side_effects_p (op0) && GET_MODE_CLASS (mode) != MODE_CC) - return const0_rtx; + return CONST0_RTX (mode); /* Canonicalize XOR of the most significant bit to PLUS. */ if ((GET_CODE (op1) == CONST_INT @@ -1962,8 +1962,8 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, break; case AND: - if (trueop1 == const0_rtx && ! side_effects_p (op0)) - return const0_rtx; + if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0)) + return trueop1; /* If we are turning off bits already known off in OP0, we need not do an AND. */ if (GET_CODE (trueop1) == CONST_INT @@ -1978,7 +1978,7 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, || (GET_CODE (op1) == NOT && rtx_equal_p (XEXP (op1, 0), op0))) && ! side_effects_p (op0) && GET_MODE_CLASS (mode) != MODE_CC) - return const0_rtx; + return CONST0_RTX (mode); /* Transform (and (extend X) C) into (zero_extend (and X C)) if there are no nonzero bits of C outside of X's mode. */ @@ -2049,12 +2049,14 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, case UDIV: /* 0/x is 0 (or x&0 if x has side-effects). */ - if (trueop0 == const0_rtx) - return side_effects_p (op1) - ? simplify_gen_binary (AND, mode, op1, const0_rtx) - : const0_rtx; + if (trueop0 == CONST0_RTX (mode)) + { + if (side_effects_p (op1)) + return simplify_gen_binary (AND, mode, op1, trueop0); + return trueop0; + } /* x/1 is x. */ - if (trueop1 == const1_rtx) + if (trueop1 == CONST1_RTX (mode)) { /* Handle narrowing UDIV. */ rtx x = gen_lowpart_common (mode, op0); @@ -2113,12 +2115,14 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, else { /* 0/x is 0 (or x&0 if x has side-effects). */ - if (trueop0 == const0_rtx) - return side_effects_p (op1) - ? simplify_gen_binary (AND, mode, op1, const0_rtx) - : const0_rtx; + if (trueop0 == CONST0_RTX (mode)) + { + if (side_effects_p (op1)) + return simplify_gen_binary (AND, mode, op1, trueop0); + return trueop0; + } /* x/1 is x. */ - if (trueop1 == const1_rtx) + if (trueop1 == CONST1_RTX (mode)) { /* Handle narrowing DIV. */ rtx x = gen_lowpart_common (mode, op0); @@ -2142,15 +2146,19 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, case UMOD: /* 0%x is 0 (or x&0 if x has side-effects). */ - if (trueop0 == const0_rtx) - return side_effects_p (op1) - ? simplify_gen_binary (AND, mode, op1, const0_rtx) - : const0_rtx; + if (trueop0 == CONST0_RTX (mode)) + { + if (side_effects_p (op1)) + return simplify_gen_binary (AND, mode, op1, trueop0); + return trueop0; + } /* x%1 is 0 (of x&0 if x has side-effects). */ - if (trueop1 == const1_rtx) - return side_effects_p (op0) - ? simplify_gen_binary (AND, mode, op0, const0_rtx) - : const0_rtx; + if (trueop1 == CONST1_RTX (mode)) + { + if (side_effects_p (op0)) + return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode)); + return CONST0_RTX (mode); + } /* Implement modulus by power of two as AND. */ if (GET_CODE (trueop1) == CONST_INT && exact_log2 (INTVAL (trueop1)) > 0) @@ -2160,15 +2168,19 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, case MOD: /* 0%x is 0 (or x&0 if x has side-effects). */ - if (trueop0 == const0_rtx) - return side_effects_p (op1) - ? simplify_gen_binary (AND, mode, op1, const0_rtx) - : const0_rtx; + if (trueop0 == CONST0_RTX (mode)) + { + if (side_effects_p (op1)) + return simplify_gen_binary (AND, mode, op1, trueop0); + return trueop0; + } /* x%1 and x%-1 is 0 (or x&0 if x has side-effects). */ - if (trueop1 == const1_rtx || trueop1 == constm1_rtx) - return side_effects_p (op0) - ? simplify_gen_binary (AND, mode, op0, const0_rtx) - : const0_rtx; + if (trueop1 == CONST1_RTX (mode) || trueop1 == constm1_rtx) + { + if (side_effects_p (op0)) + return simplify_gen_binary (AND, mode, op0, CONST0_RTX (mode)); + return CONST0_RTX (mode); + } break; case ROTATERT: @@ -2184,9 +2196,9 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, case ASHIFT: case LSHIFTRT: - if (trueop1 == const0_rtx) + if (trueop1 == CONST0_RTX (mode)) return op0; - if (trueop0 == const0_rtx && ! side_effects_p (op1)) + if (trueop0 == CONST0_RTX (mode) && ! side_effects_p (op1)) return op0; break; @@ -2218,7 +2230,7 @@ simplify_binary_operation (enum rtx_code code, enum machine_mode mode, break; case UMIN: - if (trueop1 == const0_rtx && ! side_effects_p (op0)) + if (trueop1 == CONST0_RTX (mode) && ! side_effects_p (op0)) return op1; if (rtx_equal_p (trueop0, trueop1) && ! side_effects_p (op0)) return op0; diff --git a/contrib/gcc-4.0/gcc/system.h b/contrib/gcc-4.0/gcc/system.h index d45e56afb3..e84165f81d 100644 --- a/contrib/gcc-4.0/gcc/system.h +++ b/contrib/gcc-4.0/gcc/system.h @@ -46,6 +46,11 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define NULL 0 #endif +/* Use the unlocked open routines from libiberty. */ +#define fopen(PATH,MODE) fopen_unlocked(PATH,MODE) +#define fdopen(FILDES,MODE) fdopen_unlocked(FILDES,MODE) +#define freopen(PATH,MODE,STREAM) freopen_unlocked(PATH,MODE,STREAM) + /* The compiler is not a multi-threaded application and therefore we do not have to use the locking functions. In fact, using the locking functions can cause the compiler to be significantly slower under @@ -65,11 +70,65 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA # undef putc # define putc(C, Stream) putc_unlocked (C, Stream) # endif +# ifdef HAVE_PUTCHAR_UNLOCKED +# undef putchar +# define putchar(C) putchar_unlocked (C) +# endif +# ifdef HAVE_GETC_UNLOCKED +# undef getc +# define getc(Stream) getc_unlocked (Stream) +# endif +# ifdef HAVE_GETCHAR_UNLOCKED +# undef getchar +# define getchar() getchar_unlocked () +# endif # ifdef HAVE_FPUTC_UNLOCKED # undef fputc # define fputc(C, Stream) fputc_unlocked (C, Stream) # endif +# ifdef HAVE_CLEARERR_UNLOCKED +# undef clearerr +# define clearerr(Stream) clearerr_unlocked (Stream) +# if defined (HAVE_DECL_CLEARERR_UNLOCKED) && !HAVE_DECL_CLEARERR_UNLOCKED +extern void clearerr_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FEOF_UNLOCKED +# undef feof +# define feof(Stream) feof_unlocked (Stream) +# if defined (HAVE_DECL_FEOF_UNLOCKED) && !HAVE_DECL_FEOF_UNLOCKED +extern int feof_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FILENO_UNLOCKED +# undef fileno +# define fileno(Stream) fileno_unlocked (Stream) +# if defined (HAVE_DECL_FILENO_UNLOCKED) && !HAVE_DECL_FILENO_UNLOCKED +extern int fileno_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FFLUSH_UNLOCKED +# undef fflush +# define fflush(Stream) fflush_unlocked (Stream) +# if defined (HAVE_DECL_FFLUSH_UNLOCKED) && !HAVE_DECL_FFLUSH_UNLOCKED +extern int fflush_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FGETC_UNLOCKED +# undef fgetc +# define fgetc(Stream) fgetc_unlocked (Stream) +# if defined (HAVE_DECL_FGETC_UNLOCKED) && !HAVE_DECL_FGETC_UNLOCKED +extern int fgetc_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FGETS_UNLOCKED +# undef fgets +# define fgets(S, n, Stream) fgets_unlocked (S, n, Stream) +# if defined (HAVE_DECL_FGETS_UNLOCKED) && !HAVE_DECL_FGETS_UNLOCKED +extern char *fgets_unlocked (char *, int, FILE *); +# endif +# endif # ifdef HAVE_FPUTS_UNLOCKED # undef fputs # define fputs(String, Stream) fputs_unlocked (String, Stream) @@ -77,11 +136,25 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA extern int fputs_unlocked (const char *, FILE *); # endif # endif +# ifdef HAVE_FERROR_UNLOCKED +# undef ferror +# define ferror(Stream) ferror_unlocked (Stream) +# if defined (HAVE_DECL_FERROR_UNLOCKED) && !HAVE_DECL_FERROR_UNLOCKED +extern int ferror_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FREAD_UNLOCKED +# undef fread +# define fread(Ptr, Size, N, Stream) fread_unlocked (Ptr, Size, N, Stream) +# if defined (HAVE_DECL_FREAD_UNLOCKED) && !HAVE_DECL_FREAD_UNLOCKED +extern size_t fread_unlocked (void *, size_t, size_t, FILE *); +# endif +# endif # ifdef HAVE_FWRITE_UNLOCKED # undef fwrite # define fwrite(Ptr, Size, N, Stream) fwrite_unlocked (Ptr, Size, N, Stream) # if defined (HAVE_DECL_FWRITE_UNLOCKED) && !HAVE_DECL_FWRITE_UNLOCKED -extern int fwrite_unlocked (const void *, size_t, size_t, FILE *); +extern size_t fwrite_unlocked (const void *, size_t, size_t, FILE *); # endif # endif # ifdef HAVE_FPRINTF_UNLOCKED diff --git a/contrib/gcc-4.0/gcc/toplev.c b/contrib/gcc-4.0/gcc/toplev.c index dc140e14f5..8891f73115 100644 --- a/contrib/gcc-4.0/gcc/toplev.c +++ b/contrib/gcc-4.0/gcc/toplev.c @@ -1602,6 +1602,9 @@ general_init (const char *argv0) hex_init (); + /* Unlock the stdio streams. */ + unlock_std_streams (); + gcc_init_libintl (); /* Initialize the diagnostics reporting machinery, so option parsing diff --git a/contrib/gcc-4.0/gcc/tree-cfg.c b/contrib/gcc-4.0/gcc/tree-cfg.c index 9e87dbfccb..7f997492da 100644 --- a/contrib/gcc-4.0/gcc/tree-cfg.c +++ b/contrib/gcc-4.0/gcc/tree-cfg.c @@ -2247,20 +2247,11 @@ find_taken_edge_cond_expr (basic_block bb, tree val) edge true_edge, false_edge; extract_true_false_edges_from_block (bb, &true_edge, &false_edge); - - /* Otherwise, try to determine which branch of the if() will be taken. - If VAL is a constant but it can't be reduced to a 0 or a 1, then - we don't really know which edge will be taken at runtime. This - may happen when comparing addresses (e.g., if (&var1 == 4)). */ - if (integer_nonzerop (val)) - return true_edge; - else if (integer_zerop (val)) - return false_edge; - - gcc_unreachable (); + + gcc_assert (TREE_CODE (val) == INTEGER_CST); + return (zero_p (val) ? false_edge : true_edge); } - /* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR statement, determine which edge will be taken out of the block. Return NULL if any edge may be taken. */ diff --git a/contrib/gcc-4.0/gcc/tree-chrec.c b/contrib/gcc-4.0/gcc/tree-chrec.c index b6276e929f..cb0f698c04 100644 --- a/contrib/gcc-4.0/gcc/tree-chrec.c +++ b/contrib/gcc-4.0/gcc/tree-chrec.c @@ -35,6 +35,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "varray.h" #include "tree-chrec.h" #include "tree-pass.h" +#include "params.h" @@ -286,11 +287,17 @@ chrec_fold_plus_1 (enum tree_code code, build_int_cst_type (type, -1))); default: - if (tree_contains_chrecs (op0) - || tree_contains_chrecs (op1)) - return build (code, type, op0, op1); - else - return fold (build (code, type, op0, op1)); + { + int size = 0; + if ((tree_contains_chrecs (op0, &size) + || tree_contains_chrecs (op1, &size)) + && size < PARAM_VALUE (PARAM_SCEV_MAX_EXPR_SIZE)) + return build2 (code, type, op0, op1); + else if (size < PARAM_VALUE (PARAM_SCEV_MAX_EXPR_SIZE)) + return fold (build2 (code, type, op0, op1)); + else + return chrec_dont_know; + } } } } @@ -374,7 +381,7 @@ chrec_fold_multiply (tree type, return op0; if (integer_zerop (op1)) return build_int_cst_type (type, 0); - return fold (build (MULT_EXPR, type, op0, op1)); + return fold (build2 (MULT_EXPR, type, op0, op1)); } } } @@ -717,7 +724,7 @@ reset_evolution_in_loop (unsigned loop_num, { if (TREE_CODE (chrec) == POLYNOMIAL_CHREC && CHREC_VARIABLE (chrec) > loop_num) - return build + return build2 (TREE_CODE (chrec), build_int_cst (NULL_TREE, CHREC_VARIABLE (chrec)), reset_evolution_in_loop (loop_num, CHREC_LEFT (chrec), new_evol), @@ -862,29 +869,34 @@ chrec_contains_undetermined (tree chrec) } } -/* Determines whether the tree EXPR contains chrecs. */ +/* Determines whether the tree EXPR contains chrecs, and increment + SIZE if it is not a NULL pointer by an estimation of the depth of + the tree. */ bool -tree_contains_chrecs (tree expr) +tree_contains_chrecs (tree expr, int *size) { if (expr == NULL_TREE) return false; + + if (size) + (*size)++; if (tree_is_chrec (expr)) return true; - + switch (TREE_CODE_LENGTH (TREE_CODE (expr))) { case 3: - if (tree_contains_chrecs (TREE_OPERAND (expr, 2))) + if (tree_contains_chrecs (TREE_OPERAND (expr, 2), size)) return true; case 2: - if (tree_contains_chrecs (TREE_OPERAND (expr, 1))) + if (tree_contains_chrecs (TREE_OPERAND (expr, 1), size)) return true; case 1: - if (tree_contains_chrecs (TREE_OPERAND (expr, 0))) + if (tree_contains_chrecs (TREE_OPERAND (expr, 0), size)) return true; default: diff --git a/contrib/gcc-4.0/gcc/tree-chrec.h b/contrib/gcc-4.0/gcc/tree-chrec.h index a3e219086d..8f8c065470 100644 --- a/contrib/gcc-4.0/gcc/tree-chrec.h +++ b/contrib/gcc-4.0/gcc/tree-chrec.h @@ -87,7 +87,7 @@ extern bool chrec_is_positive (tree, bool *); extern bool chrec_contains_symbols (tree); extern bool chrec_contains_symbols_defined_in_loop (tree, unsigned); extern bool chrec_contains_undetermined (tree); -extern bool tree_contains_chrecs (tree); +extern bool tree_contains_chrecs (tree, int *); extern bool evolution_function_is_affine_multivariate_p (tree); extern bool evolution_function_is_univariate_p (tree); extern unsigned nb_vars_in_chrec (tree); @@ -183,7 +183,7 @@ evolution_function_is_affine_or_constant_p (tree chrec) static inline bool tree_does_not_contain_chrecs (tree expr) { - return !tree_contains_chrecs (expr); + return !tree_contains_chrecs (expr, NULL); } /* Determines whether CHREC is a loop invariant with respect to LOOP_NUM. diff --git a/contrib/gcc-4.0/gcc/tree-gimple.c b/contrib/gcc-4.0/gcc/tree-gimple.c index 61d2ec74ac..f69d95ef8a 100644 --- a/contrib/gcc-4.0/gcc/tree-gimple.c +++ b/contrib/gcc-4.0/gcc/tree-gimple.c @@ -180,7 +180,7 @@ is_gimple_min_invariant (tree t) case STRING_CST: case COMPLEX_CST: case VECTOR_CST: - return !TREE_OVERFLOW (t); + return true; default: return false; diff --git a/contrib/gcc-4.0/gcc/tree-inline.c b/contrib/gcc-4.0/gcc/tree-inline.c index efbba304f9..ae69853a15 100644 --- a/contrib/gcc-4.0/gcc/tree-inline.c +++ b/contrib/gcc-4.0/gcc/tree-inline.c @@ -971,7 +971,7 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn))) { inline_forbidden_reason - = N_("%Jfunction %qF can never be inlined because it uses " + = G_("%Jfunction %qF can never be inlined because it uses " "alloca (override using the always_inline attribute)"); return node; } @@ -983,7 +983,7 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, if (setjmp_call_p (t)) { inline_forbidden_reason - = N_("%Jfunction %qF can never be inlined because it uses setjmp"); + = G_("%Jfunction %qF can never be inlined because it uses setjmp"); return node; } @@ -997,7 +997,7 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, case BUILT_IN_NEXT_ARG: case BUILT_IN_VA_END: inline_forbidden_reason - = N_("%Jfunction %qF can never be inlined because it " + = G_("%Jfunction %qF can never be inlined because it " "uses variable argument lists"); return node; @@ -1008,14 +1008,14 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, function calling __builtin_longjmp to be inlined into the function calling __builtin_setjmp, Things will Go Awry. */ inline_forbidden_reason - = N_("%Jfunction %qF can never be inlined because " + = G_("%Jfunction %qF can never be inlined because " "it uses setjmp-longjmp exception handling"); return node; case BUILT_IN_NONLOCAL_GOTO: /* Similarly. */ inline_forbidden_reason - = N_("%Jfunction %qF can never be inlined because " + = G_("%Jfunction %qF can never be inlined because " "it uses non-local goto"); return node; @@ -1026,7 +1026,7 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, been inlined into. Similarly __builtin_return would return from the function the inline has been inlined into. */ inline_forbidden_reason - = N_("%Jfunction %qF can never be inlined because " + = G_("%Jfunction %qF can never be inlined because " "it uses __builtin_return or __builtin_apply_args"); return node; @@ -1045,7 +1045,7 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, if (TREE_CODE (t) != LABEL_DECL) { inline_forbidden_reason - = N_("%Jfunction %qF can never be inlined " + = G_("%Jfunction %qF can never be inlined " "because it contains a computed goto"); return node; } @@ -1059,7 +1059,7 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, because we cannot remap the destination label used in the function that is performing the non-local goto. */ inline_forbidden_reason - = N_("%Jfunction %qF can never be inlined " + = G_("%Jfunction %qF can never be inlined " "because it receives a non-local goto"); return node; } @@ -1084,7 +1084,7 @@ inline_forbidden_p_1 (tree *nodep, int *walk_subtrees ATTRIBUTE_UNUSED, if (variably_modified_type_p (TREE_TYPE (t), NULL)) { inline_forbidden_reason - = N_("%Jfunction %qF can never be inlined " + = G_("%Jfunction %qF can never be inlined " "because it uses variable sized variables"); return node; } diff --git a/contrib/gcc-4.0/gcc/tree-scalar-evolution.c b/contrib/gcc-4.0/gcc/tree-scalar-evolution.c index 576fce0ae1..da72177ade 100644 --- a/contrib/gcc-4.0/gcc/tree-scalar-evolution.c +++ b/contrib/gcc-4.0/gcc/tree-scalar-evolution.c @@ -2563,7 +2563,7 @@ simple_iv (struct loop *loop, tree stmt, tree op, tree *base, tree *step) if (TREE_CODE (*step) != INTEGER_CST) return false; *base = CHREC_LEFT (ev); - if (tree_contains_chrecs (*base) + if (tree_contains_chrecs (*base, NULL) || chrec_contains_symbols_defined_in_loop (*base, loop->num)) return false; diff --git a/contrib/gcc-4.0/gcc/tree-ssa-ccp.c b/contrib/gcc-4.0/gcc/tree-ssa-ccp.c index 2e3d11288e..b255020917 100644 --- a/contrib/gcc-4.0/gcc/tree-ssa-ccp.c +++ b/contrib/gcc-4.0/gcc/tree-ssa-ccp.c @@ -2090,18 +2090,6 @@ fold_stmt (tree *stmt_p) t = TREE_TYPE (TREE_TYPE (OBJ_TYPE_REF_OBJECT (callee))); t = lang_hooks.fold_obj_type_ref (callee, t); - if (t && TREE_CODE (t) == ADDR_EXPR - && TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL - && cgraph_global_info_ready) - { - /* If the method has been already finalized as unreachable, - avoid any new references to it. */ - struct cgraph_node *node; - - node = cgraph_node (TREE_OPERAND (t, 0)); - if (!node->reachable && node->local.finalized) - t = NULL_TREE; - } if (t) { TREE_OPERAND (rhs, 0) = t; diff --git a/contrib/gcc-4.0/gcc/tree-ssa-dce.c b/contrib/gcc-4.0/gcc/tree-ssa-dce.c index 30b0ddb23a..a236206ff3 100644 --- a/contrib/gcc-4.0/gcc/tree-ssa-dce.c +++ b/contrib/gcc-4.0/gcc/tree-ssa-dce.c @@ -283,6 +283,15 @@ mark_stmt_if_obviously_necessary (tree stmt, bool aggressive) tree op, def; ssa_op_iter iter; + /* With non-call exceptions, we have to assume that all statements could + throw. If a statement may throw, it is inherently necessary. */ + if (flag_non_call_exceptions + && tree_could_throw_p (stmt)) + { + mark_stmt_necessary (stmt, true); + return; + } + /* Statements that are implicitly live. Most function calls, asm and return statements are required. Labels and BIND_EXPR nodes are kept because they are control flow, and we have no way of knowing whether they can be diff --git a/contrib/gcc-4.0/gcc/tree-ssa-dom.c b/contrib/gcc-4.0/gcc/tree-ssa-dom.c index 59d51c0e8a..8518cf1581 100644 --- a/contrib/gcc-4.0/gcc/tree-ssa-dom.c +++ b/contrib/gcc-4.0/gcc/tree-ssa-dom.c @@ -1929,6 +1929,18 @@ find_equivalent_equality_comparison (tree cond) { tree def_rhs = TREE_OPERAND (def_stmt, 1); + + /* If either operand to the comparison is a pointer to + a function, then we can not apply this optimization + as some targets require function pointers to be + canonicalized and in this case this optimization would + eliminate a necessary canonicalization. */ + if ((POINTER_TYPE_P (TREE_TYPE (op0)) + && TREE_CODE (TREE_TYPE (TREE_TYPE (op0))) == FUNCTION_TYPE) + || (POINTER_TYPE_P (TREE_TYPE (op1)) + && TREE_CODE (TREE_TYPE (TREE_TYPE (op1))) == FUNCTION_TYPE)) + return NULL; + /* Now make sure the RHS of the MODIFY_EXPR is a typecast. */ if ((TREE_CODE (def_rhs) == NOP_EXPR || TREE_CODE (def_rhs) == CONVERT_EXPR) @@ -1942,6 +1954,16 @@ find_equivalent_equality_comparison (tree cond) > TYPE_PRECISION (TREE_TYPE (def_rhs))) return NULL; + /* If the inner type of the conversion is a pointer to + a function, then we can not apply this optimization + as some targets require function pointers to be + canonicalized. This optimization would result in + canonicalization of the pointer when it was not originally + needed/intended. */ + if (POINTER_TYPE_P (def_rhs_inner_type) + && TREE_CODE (TREE_TYPE (def_rhs_inner_type)) == FUNCTION_TYPE) + return NULL; + /* What we want to prove is that if we convert OP1 to the type of the object inside the NOP_EXPR that the result is still equivalent to SRC. diff --git a/contrib/gcc-4.0/gcc/tree-ssa-loop-im.c b/contrib/gcc-4.0/gcc/tree-ssa-loop-im.c index 770b71b120..dd73c0f5cb 100644 --- a/contrib/gcc-4.0/gcc/tree-ssa-loop-im.c +++ b/contrib/gcc-4.0/gcc/tree-ssa-loop-im.c @@ -194,6 +194,7 @@ for_each_index (tree *addr_p, bool (*cbck) (tree, tree *, void *), void *data) case PARM_DECL: case STRING_CST: case RESULT_DECL: + case VECTOR_CST: return true; default: diff --git a/contrib/gcc-4.0/gcc/tree-ssa-loop-ivopts.c b/contrib/gcc-4.0/gcc/tree-ssa-loop-ivopts.c index 796946369d..f10b98cd98 100644 --- a/contrib/gcc-4.0/gcc/tree-ssa-loop-ivopts.c +++ b/contrib/gcc-4.0/gcc/tree-ssa-loop-ivopts.c @@ -1507,6 +1507,11 @@ find_interesting_uses_address (struct ivopts_data *data, tree stmt, tree *op_p) struct iv *civ; struct ifs_ivopts_data ifs_ivopts_data; + /* Do not play with volatile memory references. A bit too conservative, + perhaps, but safe. */ + if (stmt_ann (stmt)->has_volatile_ops) + goto fail; + /* Ignore bitfields for now. Not really something terribly complicated to handle. TODO. */ if (TREE_CODE (base) == COMPONENT_REF diff --git a/contrib/gcc-4.0/gcc/tree-ssa-operands.c b/contrib/gcc-4.0/gcc/tree-ssa-operands.c index 3b5de9bfaa..7e1ff813cc 100644 --- a/contrib/gcc-4.0/gcc/tree-ssa-operands.c +++ b/contrib/gcc-4.0/gcc/tree-ssa-operands.c @@ -1133,8 +1133,12 @@ get_expr_operands (tree stmt, tree *expr_p, int flags) else get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags); - if (code == COMPONENT_REF) - get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none); + if (code == COMPONENT_REF) + { + if (s_ann && TREE_THIS_VOLATILE (TREE_OPERAND (expr, 1))) + s_ann->has_volatile_ops = true; + get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none); + } return; case WITH_SIZE_EXPR: diff --git a/contrib/gcc-4.0/gcc/tree-ssa-pre.c b/contrib/gcc-4.0/gcc/tree-ssa-pre.c index b50c138fd4..acee93776d 100644 --- a/contrib/gcc-4.0/gcc/tree-ssa-pre.c +++ b/contrib/gcc-4.0/gcc/tree-ssa-pre.c @@ -1330,7 +1330,8 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts) folded = fold (build (TREE_CODE (expr), TREE_TYPE (expr), genop1, genop2)); - newexpr = force_gimple_operand (folded, &forced_stmts, false, NULL); + newexpr = force_gimple_operand (unshare_expr (folded), + &forced_stmts, false, NULL); if (forced_stmts) { tsi = tsi_start (forced_stmts); @@ -1340,6 +1341,8 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts) tree forcedname = TREE_OPERAND (stmt, 0); tree forcedexpr = TREE_OPERAND (stmt, 1); tree val = vn_lookup_or_add (forcedexpr, NULL); + + VEC_safe_push (tree_on_heap, inserted_exprs, stmt); vn_add (forcedname, val, NULL); bitmap_value_replace_in_set (NEW_SETS (block), forcedname); bitmap_value_replace_in_set (AVAIL_OUT (block), forcedname); @@ -1372,14 +1375,8 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts) add_referenced_tmp_var (temp); folded = fold (build (TREE_CODE (expr), TREE_TYPE (expr), genop1)); - /* If the generated operand is already GIMPLE min_invariant - just use it instead of calling force_gimple_operand on it, - since that may make it not invariant by copying it into an - assignment. */ - if (!is_gimple_min_invariant (genop1)) - newexpr = force_gimple_operand (folded, &forced_stmts, false, NULL); - else - newexpr = genop1; + newexpr = force_gimple_operand (unshare_expr (folded), + &forced_stmts, false, NULL); if (forced_stmts) { tsi = tsi_start (forced_stmts); @@ -1389,6 +1386,8 @@ create_expression_by_pieces (basic_block block, tree expr, tree stmts) tree forcedname = TREE_OPERAND (stmt, 0); tree forcedexpr = TREE_OPERAND (stmt, 1); tree val = vn_lookup_or_add (forcedexpr, NULL); + + VEC_safe_push (tree_on_heap, inserted_exprs, stmt); vn_add (forcedname, val, NULL); bitmap_value_replace_in_set (NEW_SETS (block), forcedname); bitmap_value_replace_in_set (AVAIL_OUT (block), forcedname); diff --git a/contrib/gcc-4.0/gcc/tree-ssa-threadupdate.c b/contrib/gcc-4.0/gcc/tree-ssa-threadupdate.c index 9c93699f92..0dc0faa7c1 100644 --- a/contrib/gcc-4.0/gcc/tree-ssa-threadupdate.c +++ b/contrib/gcc-4.0/gcc/tree-ssa-threadupdate.c @@ -560,7 +560,8 @@ thread_through_all_blocks (void) FOR_EACH_BB (bb) { - if (bb_ann (bb)->incoming_edge_threaded) + if (bb_ann (bb)->incoming_edge_threaded + && EDGE_COUNT (bb->preds) > 0) { thread_block (bb); retval = true; diff --git a/contrib/gcc-4.0/gcc/tree-ssa.c b/contrib/gcc-4.0/gcc/tree-ssa.c index 9346d6cf70..fd8003e393 100644 --- a/contrib/gcc-4.0/gcc/tree-ssa.c +++ b/contrib/gcc-4.0/gcc/tree-ssa.c @@ -1335,7 +1335,7 @@ struct tree_opt_pass pass_redundant_phi = warning text is in MSGID and LOCUS may contain a location or be null. */ static void -warn_uninit (tree t, const char *msgid, location_t *locus) +warn_uninit (tree t, const char *gmsgid, location_t *locus) { tree var = SSA_NAME_VAR (t); tree def = SSA_NAME_DEF_STMT (t); @@ -1360,7 +1360,7 @@ warn_uninit (tree t, const char *msgid, location_t *locus) if (!locus) locus = &DECL_SOURCE_LOCATION (var); - warning (msgid, locus, var); + warning (gmsgid, locus, var); TREE_NO_WARNING (var) = 1; } diff --git a/contrib/gcc-4.0/gcc/tree.c b/contrib/gcc-4.0/gcc/tree.c index b76f78fcce..b43277f0e2 100644 --- a/contrib/gcc-4.0/gcc/tree.c +++ b/contrib/gcc-4.0/gcc/tree.c @@ -4733,9 +4733,16 @@ get_unwidened (tree op, tree for_type) while (TREE_CODE (op) == NOP_EXPR || TREE_CODE (op) == CONVERT_EXPR) { - int bitschange - = TYPE_PRECISION (TREE_TYPE (op)) - - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))); + int bitschange; + + /* TYPE_PRECISION on vector types has different meaning + (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions, + so avoid them here. */ + if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE) + break; + + bitschange = TYPE_PRECISION (TREE_TYPE (op)) + - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))); /* Truncations are many-one so cannot be removed. Unless we are later going to truncate down even farther. */ @@ -5849,7 +5856,7 @@ build_common_builtin_nodes (void) tmp = tree_cons (NULL_TREE, size_type_node, void_list_node); tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp); tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp); - ftype = build_function_type (ptr_type_node, tmp); + ftype = build_function_type (integer_type_node, tmp); local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP, "memcmp", ECF_PURE | ECF_NOTHROW); } diff --git a/contrib/gcc-4.0/gcc/varasm.c b/contrib/gcc-4.0/gcc/varasm.c index dac8cbe62c..882c2dcd4e 100644 --- a/contrib/gcc-4.0/gcc/varasm.c +++ b/contrib/gcc-4.0/gcc/varasm.c @@ -1884,9 +1884,15 @@ mark_decl_referenced (tree decl) { if (TREE_CODE (decl) == FUNCTION_DECL) { - /* Extern inline functions don't become needed when referenced. */ - if (!DECL_EXTERNAL (decl)) - cgraph_mark_needed_node (cgraph_node (decl)); + /* Extern inline functions don't become needed when referenced. + If we know a method will be emitted in other TU and no new + functions can be marked reachable, just use the external + definition. */ + struct cgraph_node *node = cgraph_node (decl); + if (!DECL_EXTERNAL (decl) + && (!node->local.vtable_method || !cgraph_global_info_ready + || !node->local.finalized)) + cgraph_mark_needed_node (node); } else if (TREE_CODE (decl) == VAR_DECL) cgraph_varpool_mark_needed_node (cgraph_varpool_node (decl)); @@ -2262,6 +2268,11 @@ struct constant_descriptor_tree GTY(()) /* The value of the constant. */ tree value; + + /* Hash of value. Computing the hash from value each time + hashfn is called can't work properly, as that means recursive + use of the hash table during hash table expansion. */ + hashval_t hash; }; static GTY((param_is (struct constant_descriptor_tree))) @@ -2275,7 +2286,7 @@ static void maybe_output_constant_def_contents (struct constant_descriptor_tree static hashval_t const_desc_hash (const void *ptr) { - return const_hash_1 (((struct constant_descriptor_tree *)ptr)->value); + return ((struct constant_descriptor_tree *)ptr)->hash; } static hashval_t @@ -2370,8 +2381,11 @@ const_hash_1 (const tree exp) static int const_desc_eq (const void *p1, const void *p2) { - return compare_constant (((struct constant_descriptor_tree *)p1)->value, - ((struct constant_descriptor_tree *)p2)->value); + const struct constant_descriptor_tree *c1 = p1; + const struct constant_descriptor_tree *c2 = p2; + if (c1->hash != c2->hash) + return 0; + return compare_constant (c1->value, c2->value); } /* Compare t1 and t2, and return 1 only if they are known to result in @@ -2644,12 +2658,14 @@ output_constant_def (tree exp, int defer) /* Look up EXP in the table of constant descriptors. If we didn't find it, create a new one. */ key.value = exp; - loc = htab_find_slot (const_desc_htab, &key, INSERT); + key.hash = const_hash_1 (exp); + loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT); desc = *loc; if (desc == 0) { desc = build_constant_desc (exp); + desc->hash = key.hash; *loc = desc; } @@ -2752,7 +2768,8 @@ lookup_constant_def (tree exp) struct constant_descriptor_tree key; key.value = exp; - desc = htab_find (const_desc_htab, &key); + key.hash = const_hash_1 (exp); + desc = htab_find_with_hash (const_desc_htab, &key, key.hash); return (desc ? desc->rtl : NULL_RTX); } @@ -4219,7 +4236,21 @@ void merge_weak (tree newdecl, tree olddecl) { if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl)) - return; + { + if (DECL_WEAK (newdecl) && SUPPORTS_WEAK) + { + tree *pwd; + /* We put the NEWDECL on the weak_decls list at some point + and OLDDECL as well. Keep just OLDDECL on the list. */ + for (pwd = &weak_decls; *pwd; pwd = &TREE_CHAIN (*pwd)) + if (TREE_VALUE (*pwd) == newdecl) + { + *pwd = TREE_CHAIN (*pwd); + break; + } + } + return; + } if (DECL_WEAK (newdecl)) { @@ -4417,6 +4448,9 @@ find_decl_and_mark_needed (tree decl, tree target) static void do_assemble_alias (tree decl, tree target) { + if (TREE_ASM_WRITTEN (decl)) + return; + TREE_ASM_WRITTEN (decl) = 1; TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1; diff --git a/contrib/gcc-4.0/gcc/version.c b/contrib/gcc-4.0/gcc/version.c index 3a5cd5b032..d59faf7d0d 100644 --- a/contrib/gcc-4.0/gcc/version.c +++ b/contrib/gcc-4.0/gcc/version.c @@ -5,7 +5,7 @@ please modify this string to indicate that, e.g. by putting your organization's name in parentheses at the end of the string. */ -const char version_string[] = "4.0.0"; +const char version_string[] = "4.0.1"; /* This is the location of the online document giving instructions for reporting bugs. If you distribute a modified version of GCC, diff --git a/contrib/gcc-4.0/include/libiberty.h b/contrib/gcc-4.0/include/libiberty.h index c9f480aaf6..8078a4933e 100644 --- a/contrib/gcc-4.0/include/libiberty.h +++ b/contrib/gcc-4.0/include/libiberty.h @@ -1,6 +1,6 @@ /* Function declarations for libiberty. - Copyright 2001, 2002 Free Software Foundation, Inc. + Copyright 2001, 2002, 2005 Free Software Foundation, Inc. Note - certain prototypes declared in this header file are for functions whoes implementation copyright does not belong to the @@ -48,6 +48,28 @@ extern "C" { #include #endif +#include + +/* If the OS supports it, ensure that the supplied stream is setup to + avoid any multi-threaded locking. Otherwise leave the FILE pointer + unchanged. If the stream is NULL do nothing. */ + +extern void unlock_stream PARAMS ((FILE *)); + +/* If the OS supports it, ensure that the standard I/O streams, stdin, + stdout and stderr are setup to avoid any multi-threaded locking. + Otherwise do nothing. */ + +extern void unlock_std_streams PARAMS ((void)); + +/* Open and return a FILE pointer. If the OS supports it, ensure that + the stream is setup to avoid any multi-threaded locking. Otherwise + return the FILE pointer unchanged. */ + +extern FILE *fopen_unlocked PARAMS ((const char *, const char *)); +extern FILE *fdopen_unlocked PARAMS ((int, const char *)); +extern FILE *freopen_unlocked PARAMS ((const char *, const char *, FILE *)); + /* Build an argument vector from a string. Allocates memory using malloc. Use freeargv to free the vector. */ diff --git a/contrib/gcc-4.0/libcpp/line-map.c b/contrib/gcc-4.0/libcpp/line-map.c index e6dd48df75..1ace4c9585 100644 --- a/contrib/gcc-4.0/libcpp/line-map.c +++ b/contrib/gcc-4.0/libcpp/line-map.c @@ -199,6 +199,8 @@ linemap_line_start (struct line_maps *set, unsigned int to_line, int column_bits; if (max_column_hint > 100000 || highest > 0xC0000000) { + /* If the column number is ridiculous or we've allocated a huge + number of source_locations, give up on column numbers. */ max_column_hint = 0; if (highest >0xF0000000) return 0; @@ -211,13 +213,15 @@ linemap_line_start (struct line_maps *set, unsigned int to_line, column_bits++; max_column_hint = 1U << column_bits; } + /* Allocate the new line_map. However, if the current map only has a + single line we can sometimes just increase its column_bits instead. */ if (line_delta < 0 || last_line != map->to_line || SOURCE_COLUMN (map, highest) >= (1U << column_bits)) map = (struct line_map*) linemap_add (set, LC_RENAME, map->sysp, map->to_file, to_line); map->column_bits = column_bits; - r = map->start_location; + r = map->start_location + ((to_line - map->to_line) << column_bits); } else r = highest - SOURCE_COLUMN (map, highest) diff --git a/contrib/gcc-4.0/libcpp/system.h b/contrib/gcc-4.0/libcpp/system.h index 4f91aa5211..98ac118e35 100644 --- a/contrib/gcc-4.0/libcpp/system.h +++ b/contrib/gcc-4.0/libcpp/system.h @@ -38,6 +38,11 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define NULL 0 #endif +/* Use the unlocked open routines from libiberty. */ +#define fopen(PATH,MODE) fopen_unlocked(PATH,MODE) +#define fdopen(FILDES,MODE) fdopen_unlocked(FILDES,MODE) +#define freopen(PATH,MODE,STREAM) freopen_unlocked(PATH,MODE,STREAM) + /* The compiler is not a multi-threaded application and therefore we do not have to use the locking functions. In fact, using the locking functions can cause the compiler to be significantly slower under @@ -57,11 +62,65 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA # undef putc # define putc(C, Stream) putc_unlocked (C, Stream) # endif +# ifdef HAVE_PUTCHAR_UNLOCKED +# undef putchar +# define putchar(C) putchar_unlocked (C) +# endif +# ifdef HAVE_GETC_UNLOCKED +# undef getc +# define getc(Stream) getc_unlocked (Stream) +# endif +# ifdef HAVE_GETCHAR_UNLOCKED +# undef getchar +# define getchar() getchar_unlocked () +# endif # ifdef HAVE_FPUTC_UNLOCKED # undef fputc # define fputc(C, Stream) fputc_unlocked (C, Stream) # endif +# ifdef HAVE_CLEARERR_UNLOCKED +# undef clearerr +# define clearerr(Stream) clearerr_unlocked (Stream) +# if defined (HAVE_DECL_CLEARERR_UNLOCKED) && !HAVE_DECL_CLEARERR_UNLOCKED +extern void clearerr_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FEOF_UNLOCKED +# undef feof +# define feof(Stream) feof_unlocked (Stream) +# if defined (HAVE_DECL_FEOF_UNLOCKED) && !HAVE_DECL_FEOF_UNLOCKED +extern int feof_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FILENO_UNLOCKED +# undef fileno +# define fileno(Stream) fileno_unlocked (Stream) +# if defined (HAVE_DECL_FILENO_UNLOCKED) && !HAVE_DECL_FILENO_UNLOCKED +extern int fileno_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FFLUSH_UNLOCKED +# undef fflush +# define fflush(Stream) fflush_unlocked (Stream) +# if defined (HAVE_DECL_FFLUSH_UNLOCKED) && !HAVE_DECL_FFLUSH_UNLOCKED +extern int fflush_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FGETC_UNLOCKED +# undef fgetc +# define fgetc(Stream) fgetc_unlocked (Stream) +# if defined (HAVE_DECL_FGETC_UNLOCKED) && !HAVE_DECL_FGETC_UNLOCKED +extern int fgetc_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FGETS_UNLOCKED +# undef fgets +# define fgets(S, n, Stream) fgets_unlocked (S, n, Stream) +# if defined (HAVE_DECL_FGETS_UNLOCKED) && !HAVE_DECL_FGETS_UNLOCKED +extern char *fgets_unlocked (char *, int, FILE *); +# endif +# endif # ifdef HAVE_FPUTS_UNLOCKED # undef fputs # define fputs(String, Stream) fputs_unlocked (String, Stream) @@ -69,11 +128,25 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA extern int fputs_unlocked (const char *, FILE *); # endif # endif +# ifdef HAVE_FERROR_UNLOCKED +# undef ferror +# define ferror(Stream) ferror_unlocked (Stream) +# if defined (HAVE_DECL_FERROR_UNLOCKED) && !HAVE_DECL_FERROR_UNLOCKED +extern int ferror_unlocked (FILE *); +# endif +# endif +# ifdef HAVE_FREAD_UNLOCKED +# undef fread +# define fread(Ptr, Size, N, Stream) fread_unlocked (Ptr, Size, N, Stream) +# if defined (HAVE_DECL_FREAD_UNLOCKED) && !HAVE_DECL_FREAD_UNLOCKED +extern size_t fread_unlocked (void *, size_t, size_t, FILE *); +# endif +# endif # ifdef HAVE_FWRITE_UNLOCKED # undef fwrite # define fwrite(Ptr, Size, N, Stream) fwrite_unlocked (Ptr, Size, N, Stream) # if defined (HAVE_DECL_FWRITE_UNLOCKED) && !HAVE_DECL_FWRITE_UNLOCKED -extern int fwrite_unlocked (const void *, size_t, size_t, FILE *); +extern size_t fwrite_unlocked (const void *, size_t, size_t, FILE *); # endif # endif # ifdef HAVE_FPRINTF_UNLOCKED diff --git a/contrib/gcc-4.0/libiberty/configure b/contrib/gcc-4.0/libiberty/configure index fc461eb3d5..65a58b4e78 100644 --- a/contrib/gcc-4.0/libiberty/configure +++ b/contrib/gcc-4.0/libiberty/configure @@ -957,7 +957,7 @@ esac else echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi - cd "$ac_popdir" + cd $ac_popdir done fi @@ -2330,7 +2330,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2388,7 +2389,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2504,7 +2506,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2558,7 +2561,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2603,7 +2607,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -2647,7 +2652,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3103,7 +3109,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3163,7 +3170,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3239,7 +3247,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3280,7 +3289,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3530,7 +3540,8 @@ host_makefile_frag=${frag} -for ac_header in sys/file.h sys/param.h limits.h stdlib.h malloc.h string.h unistd.h strings.h sys/time.h time.h sys/resource.h sys/stat.h sys/mman.h fcntl.h alloca.h sys/pstat.h sys/sysmp.h sys/sysinfo.h machine/hal_sysinfo.h sys/table.h sys/sysctl.h sys/systemcfg.h stdint.h + +for ac_header in sys/file.h sys/param.h limits.h stdlib.h malloc.h string.h unistd.h strings.h sys/time.h time.h sys/resource.h sys/stat.h sys/mman.h fcntl.h alloca.h sys/pstat.h sys/sysmp.h sys/sysinfo.h machine/hal_sysinfo.h sys/table.h sys/sysctl.h sys/systemcfg.h stdint.h stdio_ext.h do as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh` echo "$as_me:$LINENO: checking for $ac_header" >&5 @@ -3622,7 +3633,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3686,7 +3698,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3747,7 +3760,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -3828,7 +3842,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4057,7 +4072,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4119,7 +4135,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4159,7 +4176,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4215,7 +4233,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4255,7 +4274,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4319,7 +4339,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4350,8 +4371,10 @@ See \`config.log' for more details." >&2;} esac else if test "$cross_compiling" = yes; then - { { echo "$as_me:$LINENO: error: internal error: not reached in cross-compile" >&5 -echo "$as_me: error: internal error: not reached in cross-compile" >&2;} + { { echo "$as_me:$LINENO: error: cannot run test program while cross compiling +See \`config.log' for more details." >&5 +echo "$as_me: error: cannot run test program while cross compiling +See \`config.log' for more details." >&2;} { (exit 1); exit 1; }; } else cat >conftest.$ac_ext <<_ACEOF @@ -4464,7 +4487,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4530,7 +4554,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4576,7 +4601,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4622,7 +4648,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4699,7 +4726,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -4789,7 +4817,7 @@ vars="sys_errlist sys_nerr sys_siglist" checkfuncs="getrusage on_exit psignal strerror strsignal sysconf times sbrk gettimeofday" checkfuncs="$checkfuncs realpath canonicalize_file_name pstat_getstatic pstat_getdynamic sysmp" -checkfuncs="$checkfuncs getsysinfo table sysctl" +checkfuncs="$checkfuncs getsysinfo table sysctl __fsetlocking" # These are neither executed nor required, but they help keep # autoheader happy without adding a bunch of text to acconfig.h. @@ -4857,6 +4885,7 @@ if test "x" = "y"; then + for ac_func in asprintf atexit basename bcmp bcopy bsearch bzero calloc clock \ getcwd getpagesize index insque mkstemps memchr memcmp memcpy \ memmove mempcpy memset putenv random rename rindex sigsetmask \ @@ -4865,7 +4894,7 @@ for ac_func in asprintf atexit basename bcmp bcopy bsearch bzero calloc clock \ vsprintf waitpid getrusage on_exit psignal strerror strsignal \ sysconf times sbrk gettimeofday ffs snprintf vsnprintf \ pstat_getstatic pstat_getdynamic sysmp getsysinfo table sysctl \ - realpath canonicalize_file_name + realpath canonicalize_file_name __fsetlocking do as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh` echo "$as_me:$LINENO: checking for $ac_func" >&5 @@ -4932,7 +4961,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5346,7 +5376,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5405,7 +5436,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5505,7 +5537,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5643,7 +5676,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -5864,7 +5898,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -6209,7 +6244,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -6320,7 +6356,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -6389,7 +6426,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -6454,7 +6492,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -6550,7 +6589,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -6626,7 +6666,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -6799,7 +6840,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5 cat conftest.err >&5 echo "$as_me:$LINENO: \$? = $ac_status" >&5 (exit $ac_status); } && - { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err' + { ac_try='test -z "$ac_c_werror_flag" + || test ! -s conftest.err' { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5 (eval $ac_try) 2>&5 ac_status=$? @@ -7987,6 +8029,11 @@ esac *) ac_INSTALL=$ac_top_builddir$INSTALL ;; esac + if test x"$ac_file" != x-; then + { echo "$as_me:$LINENO: creating $ac_file" >&5 +echo "$as_me: creating $ac_file" >&6;} + rm -f "$ac_file" + fi # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ @@ -8025,12 +8072,6 @@ echo "$as_me: error: cannot find input file: $f" >&2;} fi;; esac done` || { (exit 1); exit 1; } - - if test x"$ac_file" != x-; then - { echo "$as_me:$LINENO: creating $ac_file" >&5 -echo "$as_me: creating $ac_file" >&6;} - rm -f "$ac_file" - fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF sed "$ac_vpsub diff --git a/contrib/gcc-4.0/libiberty/fopen_unlocked.c b/contrib/gcc-4.0/libiberty/fopen_unlocked.c new file mode 100644 index 0000000000..4945435909 --- /dev/null +++ b/contrib/gcc-4.0/libiberty/fopen_unlocked.c @@ -0,0 +1,136 @@ +/* Implement fopen_unlocked and related functions. + Copyright (C) 2005 Free Software Foundation, Inc. + Written by Kaveh R. Ghazi . + +This file is part of the libiberty library. +Libiberty is free software; you can redistribute it and/or +modify it under the terms of the GNU Library General Public +License as published by the Free Software Foundation; either +version 2 of the License, or (at your option) any later version. + +Libiberty 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 +Library General Public License for more details. + +You should have received a copy of the GNU Library General Public +License along with libiberty; see the file COPYING.LIB. If +not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +/* + +@deftypefn Extension void unlock_stream (FILE * @var{stream}) + +If the OS supports it, ensure that the supplied stream is setup to +avoid any multi-threaded locking. Otherwise leave the @code{FILE} +pointer unchanged. If the @var{stream} is @code{NULL} do nothing. + +@end deftypefn + +@deftypefn Extension void unlock_std_streams (void) + +If the OS supports it, ensure that the standard I/O streams, +@code{stdin}, @code{stdout} and @code{stderr} are setup to avoid any +multi-threaded locking. Otherwise do nothing. + +@end deftypefn + +@deftypefn Extension FILE * fopen_unlocked (const char *@var{path}, const char * @var{mode}) + +Opens and returns a @code{FILE} pointer via @code{fopen}. If the +operating system supports it, ensure that the stream is setup to avoid +any multi-threaded locking. Otherwise return the @code{FILE} pointer +unchanged. + +@end deftypefn + +@deftypefn Extension FILE * fdopen_unlocked (int @var{fildes}, const char * @var{mode}) + +Opens and returns a @code{FILE} pointer via @code{fdopen}. If the +operating system supports it, ensure that the stream is setup to avoid +any multi-threaded locking. Otherwise return the @code{FILE} pointer +unchanged. + +@end deftypefn + +@deftypefn Extension FILE * freopen_unlocked (const char * @var{path}, const char * @var{mode}, FILE * @var{stream}) + +Opens and returns a @code{FILE} pointer via @code{freopen}. If the +operating system supports it, ensure that the stream is setup to avoid +any multi-threaded locking. Otherwise return the @code{FILE} pointer +unchanged. + +@end deftypefn + +*/ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include +#ifdef HAVE_STDIO_EXT_H +#include +#endif + +#include "libiberty.h" + +/* This is an inline helper function to consolidate attempts to unlock + a stream. */ + +static inline void unlock_1 PARAMS ((FILE *const fp ATTRIBUTE_UNUSED)); +static inline void +unlock_1 (fp) + FILE *const fp ATTRIBUTE_UNUSED; +{ +#if defined(HAVE___FSETLOCKING) && defined(FSETLOCKING_BYCALLER) + if (fp) + __fsetlocking (fp, FSETLOCKING_BYCALLER); +#endif +} + +void +unlock_stream (fp) + FILE *fp; +{ + unlock_1 (fp); +} + +void +unlock_std_streams () +{ + unlock_1 (stdin); + unlock_1 (stdout); + unlock_1 (stderr); +} + +FILE * +fopen_unlocked (path, mode) + const char *path; + const char *mode; +{ + FILE *const fp = fopen (path, mode); + unlock_1 (fp); + return fp; +} + +FILE * +fdopen_unlocked (fildes, mode) + int fildes; + const char *mode; +{ + FILE *const fp = fdopen (fildes, mode); + unlock_1 (fp); + return fp; +} + +FILE * +freopen_unlocked (path, mode, stream) + const char *path; + const char *mode; + FILE *stream; +{ + FILE *const fp = freopen (path, mode, stream); + unlock_1 (fp); + return fp; +} diff --git a/contrib/gcc-4.0/libstdc++-v3/config/abi/compatibility.h b/contrib/gcc-4.0/libstdc++-v3/config/abi/compatibility.h new file mode 100644 index 0000000000..9faa61d791 --- /dev/null +++ b/contrib/gcc-4.0/libstdc++-v3/config/abi/compatibility.h @@ -0,0 +1,214 @@ +// Compatibility symbols for previous versions -*- C++ -*- + +// Copyright (C) 2005 +// Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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, or (at your option) +// any later version. + +// This library 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 library; see the file COPYING. If not, write to the Free +// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +// Switch for symbol version macro. +#ifndef _GLIBCXX_APPLY_SYMVER +#error must define _GLIBCXX_APPLY_SYMVER before including __FILE__ +#endif + +/* gcc-3.4.4 +_ZNSt19istreambuf_iteratorIcSt11char_traitsIcEEppEv +_ZNSt19istreambuf_iteratorIwSt11char_traitsIwEEppEv + */ +namespace __gnu_internal +{ +_GLIBCXX_APPLY_SYMVER(_ZNSt21istreambuf_iteratorXXIcSt11char_traitsIcEEppEv, + _ZNSt19istreambuf_iteratorIcSt11char_traitsIcEEppEv) + +#ifdef _GLIBCXX_USE_WCHAR_T +_GLIBCXX_APPLY_SYMVER(_ZNSt21istreambuf_iteratorXXIwSt11char_traitsIwEEppEv, + _ZNSt19istreambuf_iteratorIwSt11char_traitsIwEEppEv) +#endif +} // namespace std + +/* gcc-4.0.0 +_ZNSs4_Rep26_M_set_length_and_sharableEj +_ZNSs7_M_copyEPcPKcj +_ZNSs7_M_moveEPcPKcj +_ZNSs9_M_assignEPcjc +_ZNKSs11_M_disjunctEPKc +_ZNKSs15_M_check_lengthEjjPKc +_ZNSbIwSt11char_traitsIwESaIwEE4_Rep26_M_set_length_and_sharableEj +_ZNSbIwSt11char_traitsIwESaIwEE7_M_copyEPwPKwj +_ZNSbIwSt11char_traitsIwESaIwEE7_M_moveEPwPKwj +_ZNSbIwSt11char_traitsIwESaIwEE9_M_assignEPwjw +_ZNKSbIwSt11char_traitsIwESaIwEE11_M_disjunctEPKw +_ZNKSbIwSt11char_traitsIwESaIwEE15_M_check_lengthEjjPKc + +_ZNKSt13basic_fstreamIcSt11char_traitsIcEE7is_openEv +_ZNKSt13basic_fstreamIwSt11char_traitsIwEE7is_openEv +_ZNKSt14basic_ifstreamIcSt11char_traitsIcEE7is_openEv +_ZNKSt14basic_ifstreamIwSt11char_traitsIwEE7is_openEv +_ZNKSt14basic_ofstreamIcSt11char_traitsIcEE7is_openEv +_ZNKSt14basic_ofstreamIwSt11char_traitsIwEE7is_openEv + +_ZNSi6ignoreEi +_ZNSi6ignoreEv +_ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreEi +_ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreEv + +_ZNSt11char_traitsIcE2eqERKcS2_ +_ZNSt11char_traitsIwE2eqERKwS2_ + */ +namespace __gnu_internal +{ +_GLIBCXX_APPLY_SYMVER(_ZNSt11char_traitsIcE4eqXXERKcS2_, + _ZNSt11char_traitsIcE2eqERKcS2_) + +#ifdef _GLIBCXX_SIZE_T_IS_UINT +_GLIBCXX_APPLY_SYMVER(_ZNSs9_M_copyXXEPcPKcj, + _ZNSs7_M_copyEPcPKcj) +#else +_GLIBCXX_APPLY_SYMVER(_ZNSs9_M_copyXXEPcPKcm, + _ZNSs7_M_copyEPcPKcm) +#endif + +#ifdef _GLIBCXX_SIZE_T_IS_UINT +_GLIBCXX_APPLY_SYMVER(_ZNSs9_M_moveXXEPcPKcj, + _ZNSs7_M_moveEPcPKcj) +#else +_GLIBCXX_APPLY_SYMVER(_ZNSs9_M_moveXXEPcPKcm, + _ZNSs7_M_moveEPcPKcm) +#endif + +#ifdef _GLIBCXX_SIZE_T_IS_UINT +_GLIBCXX_APPLY_SYMVER(_ZNSs11_M_assignXXEPcjc, + _ZNSs9_M_assignEPcjc) +#else +_GLIBCXX_APPLY_SYMVER(_ZNSs11_M_assignXXEPcmc, + _ZNSs9_M_assignEPcmc) +#endif + +_GLIBCXX_APPLY_SYMVER(_ZNKSs13_M_disjunctXXEPKc, + _ZNKSs11_M_disjunctEPKc) + +#ifdef _GLIBCXX_SIZE_T_IS_UINT +_GLIBCXX_APPLY_SYMVER(_ZNKSs17_M_check_lengthXXEjjPKc, + _ZNKSs15_M_check_lengthEjjPKc) +#else +_GLIBCXX_APPLY_SYMVER(_ZNKSs17_M_check_lengthXXEmmPKc, + _ZNKSs15_M_check_lengthEmmPKc) +#endif + +#ifdef _GLIBCXX_SIZE_T_IS_UINT + _GLIBCXX_APPLY_SYMVER(_ZNSs4_Rep28_M_set_length_and_sharableXXEj, + _ZNSs4_Rep26_M_set_length_and_sharableEj) +#else + _GLIBCXX_APPLY_SYMVER(_ZNSs4_Rep28_M_set_length_and_sharableXXEm, + _ZNSs4_Rep26_M_set_length_and_sharableEm) +#endif + +_GLIBCXX_APPLY_SYMVER(_ZNSi8ignoreXXEv, _ZNSi6ignoreEv) + +#ifdef _GLIBCXX_PTRDIFF_T_IS_INT +_GLIBCXX_APPLY_SYMVER(_ZNSi8ignoreXXEi, _ZNSi6ignoreEi) +#else +_GLIBCXX_APPLY_SYMVER(_ZNSi8ignoreXXEl, _ZNSi6ignoreEl) +#endif + +_GLIBCXX_APPLY_SYMVER(_ZNKSt15basic_fstreamXXIcSt11char_traitsIcEE7is_openEv, + _ZNKSt13basic_fstreamIcSt11char_traitsIcEE7is_openEv) + +_GLIBCXX_APPLY_SYMVER(_ZNKSt16basic_ifstreamXXIcSt11char_traitsIcEE7is_openEv, + _ZNKSt14basic_ifstreamIcSt11char_traitsIcEE7is_openEv) + +_GLIBCXX_APPLY_SYMVER(_ZNKSt16basic_ofstreamXXIcSt11char_traitsIcEE7is_openEv, + _ZNKSt14basic_ofstreamIcSt11char_traitsIcEE7is_openEv) + + // Support for wchar_t. +#ifdef _GLIBCXX_USE_WCHAR_T +_GLIBCXX_APPLY_SYMVER(_ZNSt11char_traitsIwE4eqXXERKwS2_, + _ZNSt11char_traitsIwE2eqERKwS2_) + +#ifdef _GLIBCXX_SIZE_T_IS_UINT +_GLIBCXX_APPLY_SYMVER(_ZNSbIwSt11char_traitsIwESaIwEE9_M_copyXXEPwPKwj, + _ZNSbIwSt11char_traitsIwESaIwEE7_M_copyEPwPKwj) +#else + _GLIBCXX_APPLY_SYMVER(_ZNSbIwSt11char_traitsIwESaIwEE9_M_copyXXEPwPKwm, + _ZNSbIwSt11char_traitsIwESaIwEE7_M_copyEPwPKwm) +#endif + +#ifdef _GLIBCXX_SIZE_T_IS_UINT +_GLIBCXX_APPLY_SYMVER(_ZNSbIwSt11char_traitsIwESaIwEE9_M_moveXXEPwPKwj, + _ZNSbIwSt11char_traitsIwESaIwEE7_M_moveEPwPKwj) +#else +_GLIBCXX_APPLY_SYMVER(_ZNSbIwSt11char_traitsIwESaIwEE9_M_moveXXEPwPKwm, + _ZNSbIwSt11char_traitsIwESaIwEE7_M_moveEPwPKwm) +#endif + +#ifdef _GLIBCXX_SIZE_T_IS_UINT +_GLIBCXX_APPLY_SYMVER(_ZNSbIwSt11char_traitsIwESaIwEE11_M_assignXXEPwjw, + _ZNSbIwSt11char_traitsIwESaIwEE9_M_assignEPwjw) +#else +_GLIBCXX_APPLY_SYMVER(_ZNSbIwSt11char_traitsIwESaIwEE11_M_assignXXEPwmw, + _ZNSbIwSt11char_traitsIwESaIwEE9_M_assignEPwmw) +#endif + +_GLIBCXX_APPLY_SYMVER(_ZNKSbIwSt11char_traitsIwESaIwEE13_M_disjunctXXEPKw, + _ZNKSbIwSt11char_traitsIwESaIwEE11_M_disjunctEPKw) + +#ifdef _GLIBCXX_SIZE_T_IS_UINT +_GLIBCXX_APPLY_SYMVER(_ZNKSbIwSt11char_traitsIwESaIwEE17_M_check_lengthXXEjjPKc, + _ZNKSbIwSt11char_traitsIwESaIwEE15_M_check_lengthEjjPKc) +#else +_GLIBCXX_APPLY_SYMVER(_ZNKSbIwSt11char_traitsIwESaIwEE17_M_check_lengthXXEmmPKc, + _ZNKSbIwSt11char_traitsIwESaIwEE15_M_check_lengthEmmPKc) +#endif + +#ifdef _GLIBCXX_SIZE_T_IS_UINT +_GLIBCXX_APPLY_SYMVER(_ZNSbIwSt11char_traitsIwESaIwEE4_Rep28_M_set_length_and_sharableXXEj, + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep26_M_set_length_and_sharableEj) +#else +_GLIBCXX_APPLY_SYMVER(_ZNSbIwSt11char_traitsIwESaIwEE4_Rep28_M_set_length_and_sharableXXEm, + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep26_M_set_length_and_sharableEm) +#endif + +_GLIBCXX_APPLY_SYMVER(_ZNSt13basic_istreamIwSt11char_traitsIwEE8ignoreXXEv, + _ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreEv) + +#ifdef _GLIBCXX_PTRDIFF_T_IS_INT +_GLIBCXX_APPLY_SYMVER(_ZNSt13basic_istreamIwSt11char_traitsIwEE8ignoreXXEi, + _ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreEi) +#else +_GLIBCXX_APPLY_SYMVER(_ZNSt13basic_istreamIwSt11char_traitsIwEE8ignoreXXEl, + _ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreEl) +#endif + +_GLIBCXX_APPLY_SYMVER(_ZNKSt15basic_fstreamXXIwSt11char_traitsIwEE7is_openEv, + _ZNKSt13basic_fstreamIwSt11char_traitsIwEE7is_openEv) + +_GLIBCXX_APPLY_SYMVER(_ZNKSt16basic_ifstreamXXIwSt11char_traitsIwEE7is_openEv, + _ZNKSt14basic_ifstreamIwSt11char_traitsIwEE7is_openEv) + +_GLIBCXX_APPLY_SYMVER(_ZNKSt16basic_ofstreamXXIwSt11char_traitsIwEE7is_openEv, + _ZNKSt14basic_ofstreamIwSt11char_traitsIwEE7is_openEv) +#endif +} + diff --git a/contrib/gcc-4.0/libstdc++-v3/config/linker-map.gnu b/contrib/gcc-4.0/libstdc++-v3/config/linker-map.gnu index a6f631a8d9..51c967ed0d 100644 --- a/contrib/gcc-4.0/libstdc++-v3/config/linker-map.gnu +++ b/contrib/gcc-4.0/libstdc++-v3/config/linker-map.gnu @@ -1,6 +1,6 @@ ## Linker script for GNU ld 2.13.91+ only. ## -## Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. +## Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc. ## ## This file is part of the libstdc++ version 3 distribution. ## @@ -27,14 +27,48 @@ GLIBCXX_3.4 { # Names inside the 'extern' block are demangled names. extern "C++" { - std::[A-Za-h]*; + std::[A-Za]*; + std::ba[a-r]*; + std::basic_[a-e]*; + std::basic_f[a-r]*; +# std::basic_fstream; + std::basic_f[t-z]*; + std::basic_[g-h]*; + std::basic_i[a-e]*; +# std::basic_ifstream; + std::basic_i[g-r]*; + std::basic_istr[a-d]*; +# std::basic_istream; + std::basic_istr[f-z]*; + std::basic_i[t-z]*; + std::basic_[j-n]*; + std::basic_o[a-e]*; +# std::basic_ofstream; + std::basic_o[g-z]*; + std::basic_[p-r]*; + std::basic_streambuf*; +# std::basic_string + std::basic_stringbuf*; + std::basic_stringstream*; + std::basic_[t-z]*; + std::ba[t-z]*; + std::b[b-z]*; + std::c[a-g]*; +# std::char_traits; + std::c[i-z]*; + std::[d-h]*; std::i[a-n]*; std::ios_base::[A-Ha-z]*; std::ios_base::_M_grow_words*; std::ios_base::_M_init*; std::ios_base::Init::[A-Za-z]*; std::ios_base::[J-Za-z]*; - std::i[p-z]*; + std::i[p-r]*; +# std::istream +# std::istreambuf_iterator + std::istringstream*; + std::istrstream*; + std::i[t-z]*; std::[A-Zj-k]*; std::length_error*; std::logic_error*; @@ -54,7 +88,14 @@ GLIBCXX_3.4 { std::locale::_[J-Ra-z]*; std::locale::_S_normalize_category*; std::locale::_[T-Za-z]*; - std::[A-Zm-z]*; + std::[A-Zm-r]*; + std::set_new_handler*; + std::set_terminate*; + std::set_unexpected*; +# std::string + std::strstream*; + std::strstreambuf*; + std::[A-Zt-z]*; std::_List_node_base::hook*; std::_List_node_base::swap*; std::_List_node_base::unhook*; @@ -82,30 +123,146 @@ GLIBCXX_3.4 { # Names not in an 'extern' block are mangled names. - # operator new(size_t) - _Znw[jm]; - # operator new(size_t, std::nothrow_t const&) - _Znw[jm]RKSt9nothrow_t; - - # operator delete(void*) - _ZdlPv; - # operator delete(void*, std::nothrow_t const&) - _ZdlPvRKSt9nothrow_t; - - # operator new[](size_t) - _Zna[jm]; - # operator new[](size_t, std::nothrow_t const&) - _Zna[jm]RKSt9nothrow_t; - - # operator delete[](void*) - _ZdaPv; - # operator delete[](void*, std::nothrow_t const&) - _ZdaPvRKSt9nothrow_t; + # std::string + _ZNSsC*; + _ZNSsD*; + _ZNSs[0-9][a-z]*; + _ZNSs12_Alloc_hiderC*; + _ZNSs12_M_leak_hardEv; + _ZNSs12_S_constructE[jm]cRKSaIcE; + _ZNSs12_S_empty_repEv; + _ZNSs13_S_copy_chars*; + _ZNSs[0-9][0-9]_M_replace*; + _ZNSs4_Rep10_M_destroy*; + _ZNSs4_Rep10_M_dispose*; + _ZNSs4_Rep10_M_refcopyEv; + _ZNSs4_Rep10_M_refdataEv; + _ZNSs4_Rep12_S_empty_repEv; + _ZNSs4_Rep13_M_set_leakedEv; + _ZNSs4_Rep15_M_set_sharableEv; + _ZNSs4_Rep7_M_grab*; + _ZNSs4_Rep8_M_clone*; + _ZNSs4_Rep9_S_createE[jm][jm]*; + _ZNSs7_M_dataEPc; + _ZNSs7_M_leakEv; + _ZNSs9_M_mutateE[jm][jm][jm]; + _ZNSs4_Rep20_S_empty_rep_storageE; + _ZNSs4_Rep11_S_max_sizeE; + _ZNSs4_Rep11_S_terminalE; + _ZNSsaSE*; + _ZNSsixE*; + _ZNSspLE*; + _ZNKSs[0-9][a-z]*; + _ZNKSs[0-9][0-9][a-z]*; + _ZNKSs[a-z]*; + _ZNKSs4_Rep12_M_is_leakedEv; + _ZNKSs4_Rep12_M_is_sharedEv; + _ZNKSs6_M_repEv; + _ZNKSs7_M_dataEv; + _ZNKSs7_M_iendEv; + _ZNKSs8_M_check*; + _ZNKSs8_M_limit*; + _ZNKSs9_M_ibeginEv; + _ZStplIcSt11char_traitsIcESaIcEESbIT_T0_T1_E*; + + # std::wstring + _ZNSbIwSt11char_traitsIwESaIwEEC*; + _ZNSbIwSt11char_traitsIwESaIwEED*; + _ZNSbIwSt11char_traitsIwESaIwEE[0-9][a-z]*; + _ZNSbIwSt11char_traitsIwESaIwEE12_Alloc_hiderC*; + _ZNSbIwSt11char_traitsIwESaIwEE12_M_leak_hardEv; + _ZNSbIwSt11char_traitsIwESaIwEE12_S_constructE[jm]wRKS1_; + _ZNSbIwSt11char_traitsIwESaIwEE12_S_empty_repEv; + _ZNSbIwSt11char_traitsIwESaIwEE13_S_copy_chars*; + _ZNSbIwSt11char_traitsIwESaIwEE[0-9][0-9]_M_replace*; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep10_M_destroy*; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep10_M_dispose*; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep10_M_refcopyEv; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep10_M_refdataEv; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep12_S_empty_repEv; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep13_M_set_leakedEv; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep15_M_set_sharableEv; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep7_M_grab*; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep8_M_clone*; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep9_S_createE[jm][jm]*; + _ZNSbIwSt11char_traitsIwESaIwEE7_M_dataEPw; + _ZNSbIwSt11char_traitsIwESaIwEE7_M_leakEv; + _ZNSbIwSt11char_traitsIwESaIwEE9_M_mutateE[jm][jm][jm]; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep20_S_empty_rep_storageE; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep11_S_max_sizeE; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep11_S_terminalE; + _ZNSbIwSt11char_traitsIwESaIwEEaSE*; + _ZNSbIwSt11char_traitsIwESaIwEEixE*; + _ZNSbIwSt11char_traitsIwESaIwEEpLE*; + _ZNKSbIwSt11char_traitsIwESaIwEE[0-9][a-z]*; + _ZNKSbIwSt11char_traitsIwESaIwEE[0-9][0-9][a-z]*; + _ZNKSbIwSt11char_traitsIwESaIwEE[a-z]*; + _ZNKSbIwSt11char_traitsIwESaIwEE4_Rep12_M_is_leakedEv; + _ZNKSbIwSt11char_traitsIwESaIwEE4_Rep12_M_is_sharedEv; + _ZNKSbIwSt11char_traitsIwESaIwEE6_M_repEv; + _ZNKSbIwSt11char_traitsIwESaIwEE7_M_dataEv; + _ZNKSbIwSt11char_traitsIwESaIwEE7_M_iendEv; + _ZNKSbIwSt11char_traitsIwESaIwEE8_M_check*; + _ZNKSbIwSt11char_traitsIwESaIwEE8_M_limit*; + _ZNKSbIwSt11char_traitsIwESaIwEE9_M_ibeginEv; + _ZStplIwSt11char_traitsIwESaIwEESbIT_T0_T1_E*; # std::basic_iostream constructors, destructors _ZNSdC*; _ZNSdD*; + # std::basic_fstream + _ZNSt13basic_fstreamI[cw]St11char_traitsI[cw]EEC*; + _ZNSt13basic_fstreamI[cw]St11char_traitsI[cw]EED*; + _ZNSt13basic_fstreamI[cw]St11char_traitsI[cw]EE5closeEv; + _ZNSt13basic_fstreamI[cw]St11char_traitsI[cw]EE7is_openEv; + _ZNSt13basic_fstreamI[cw]St11char_traitsI[cw]EE4open*; + _ZNKSt13basic_fstreamI[cw]St11char_traitsI[cw]EE5rdbufEv; + + # std::basic_ifstream + _ZNSt14basic_ifstreamI[cw]St11char_traitsI[cw]EEC*; + _ZNSt14basic_ifstreamI[cw]St11char_traitsI[cw]EED*; + _ZNSt14basic_ifstreamI[cw]St11char_traitsI[cw]EE5closeEv; + _ZNSt14basic_ifstreamI[cw]St11char_traitsI[cw]EE7is_openEv; + _ZNSt14basic_ifstreamI[cw]St11char_traitsI[cw]EE4open*; + _ZNKSt14basic_ifstreamI[cw]St11char_traitsI[cw]EE5rdbufEv; + + # std::basic_ofstream + _ZNSt14basic_ofstreamI[cw]St11char_traitsI[cw]EEC*; + _ZNSt14basic_ofstreamI[cw]St11char_traitsI[cw]EED*; + _ZNSt14basic_ofstreamI[cw]St11char_traitsI[cw]EE5closeEv; + _ZNSt14basic_ofstreamI[cw]St11char_traitsI[cw]EE7is_openEv; + _ZNSt14basic_ofstreamI[cw]St11char_traitsI[cw]EE4open*; + _ZNKSt14basic_ofstreamI[cw]St11char_traitsI[cw]EE5rdbufEv; + + # std::basic_istream + _ZNSiC*; + _ZNSiD*; + _ZNKSi[0-9][a-z]*; + _ZNSi[0-9][a-h]*; + _ZNSi[0-9][j-z]*; + _ZNSi6ignoreE[il][il]; + _ZNSirsE*; + + # std::basic_istream + _ZNSt13basic_istreamIwSt11char_traitsIwEEC*; + _ZNSt13basic_istreamIwSt11char_traitsIwEED*; + _ZNKSt13basic_istreamIwSt11char_traitsIwEE[0-9][a-z]*; + _ZNSt13basic_istreamIwSt11char_traitsIwEE[0-9][a-h]*; + _ZNSt13basic_istreamIwSt11char_traitsIwEE[0-9][j-z]*; + _ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreE[il][ijlm]; + _ZNSt13basic_istreamIwSt11char_traitsIwEErsE*; + + # std::istream operators and inserters + _ZSt7getlineI[cw]St11char_traitsI[cw]ESaI[cw]EERSt13basic_istream*; + _ZSt2wsI[cw]St11char_traitsI[cw]EE*; + _ZStrsI[cw]St11char_traitsI[cw]EERSt13basic_istream*; + _ZStrsI[cw]St11char_traitsI[cw]ESaI[cw]EERSt13basic_istream*; + _ZStrsISt11char_traitsI[cw]EERSt13basic_istream*; + _ZStrsId[cw]St11char_traitsI[cw]EERSt13basic_istream*; + _ZStrsIe[cw]St11char_traitsI[cw]EERSt13basic_istream*; + _ZStrsIf[cw]St11char_traitsI[cw]EERSt13basic_istream*; + # std::locale destructors _ZNSt6localeD*; @@ -120,10 +277,16 @@ GLIBCXX_3.4 { _ZNSt8ios_baseD*; _ZNSt8ios_base4InitD*; - # bool has_facet + # bool std::has_facet _ZSt9has_facet*; - # _Rb_tree + # std::num_get + _ZNKSt7num_getI[cw]St19istreambuf_iteratorI[cw]St11char_traitsI[cw]EEE*; + + # std::money_get + _ZNKSt9money_getI[cw]St19istreambuf_iteratorI[cw]St11char_traitsI[cw]EEE*; + + # std::_Rb_tree _ZSt18_Rb_tree_decrementPKSt18_Rb_tree_node_base; _ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base; _ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base; @@ -149,6 +312,37 @@ GLIBCXX_3.4 { _ZNSt12__basic_fileIcEC*; _ZNSt12__basic_fileIcED*; + # std::__convert_to_v + _ZSt14__convert_to_v*; + + # __gnu_cxx::stdio_sync_filebuf + _ZTVN9__gnu_cxx18stdio_sync_filebufI[cw]St11char_traitsI[cw]EEE; + + # __gnu_cxx::__atomic_add + # __gnu_cxx::__exchange_and_add + _ZN9__gnu_cxx12__atomic_add*; + _ZN9__gnu_cxx18__exchange_and_add*; + + # operator new(size_t) + _Znw[jm]; + # operator new(size_t, std::nothrow_t const&) + _Znw[jm]RKSt9nothrow_t; + + # operator delete(void*) + _ZdlPv; + # operator delete(void*, std::nothrow_t const&) + _ZdlPvRKSt9nothrow_t; + + # operator new[](size_t) + _Zna[jm]; + # operator new[](size_t, std::nothrow_t const&) + _Zna[jm]RKSt9nothrow_t; + + # operator delete[](void*) + _ZdaPv; + # operator delete[](void*, std::nothrow_t const&) + _ZdaPvRKSt9nothrow_t; + # virtual table _ZTVNSt8ios_base7failureE; _ZTVNSt6locale5facetE; @@ -199,9 +393,6 @@ GLIBCXX_3.4 { _ZTv0_n12_NS*; _ZTv0_n24_NS*; - # std::__convert_to_v - _ZSt14__convert_to_v*; - # stub functions from libmath sinf; sinl; @@ -235,13 +426,33 @@ GLIBCXX_3.4 { __signbitf; __signbitl; - # __gnu_cxx::stdio_sync_filebuf - _ZTVN9__gnu_cxx18stdio_sync_filebufI[cw]St11char_traitsI[cw]EEE; + # GLIBCXX_ABI compatibility only. + # std::string + _ZNKSs11_M_disjunctEPKc; + _ZNKSs15_M_check_lengthE[jm][jm]PKc; + _ZNSs4_Rep26_M_set_length_and_sharableE*; + _ZNSs7_M_copyEPcPKc[jm]; + _ZNSs7_M_moveEPcPKc[jm]; + _ZNSs9_M_assignEPc[jm]c; - # __gnu_cxx::__atomic_add - # __gnu_cxx::__exchange_and_add - _ZN9__gnu_cxx12__atomic_add*; - _ZN9__gnu_cxx18__exchange_and_add*; + # std::wstring + _ZNKSbIwSt11char_traitsIwESaIwEE11_M_disjunctEPKw; + _ZNKSbIwSt11char_traitsIwESaIwEE15_M_check_lengthE[jm][jm]PKc; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep26_M_set_length_and_sharableE*; + _ZNSbIwSt11char_traitsIwESaIwEE7_M_copyEPwPKw[jm]; + _ZNSbIwSt11char_traitsIwESaIwEE7_M_moveEPwPKw[jm]; + _ZNSbIwSt11char_traitsIwESaIwEE9_M_assignEPw[jm]w; + + _ZNKSt13basic_fstreamI[cw]St11char_traitsI[cw]EE7is_openEv; + _ZNKSt14basic_ifstreamI[cw]St11char_traitsI[cw]EE7is_openEv; + _ZNKSt14basic_ofstreamI[cw]St11char_traitsI[cw]EE7is_openEv; + + _ZNSi6ignoreE[ilv]; + _ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreE[ilv]; + + _ZNSt11char_traitsI[cw]E2eqERK[cw]S2_; + + _ZNSt19istreambuf_iteratorI[cw]St11char_traitsI[cw]EEppEv; # DO NOT DELETE THIS LINE. Port-specific symbols, if any, will be here. @@ -304,6 +515,37 @@ GLIBCXX_3.4.4 { } GLIBCXX_3.4.3; +GLIBCXX_3.4.5 { + + # std::string + _ZNKSs11_M_disjunctEPKc; + _ZNKSs15_M_check_lengthE[jm][jm]PKc; + _ZNSs4_Rep26_M_set_length_and_sharableE*; + _ZNSs7_M_copyEPcPKc[jm]; + _ZNSs7_M_moveEPcPKc[jm]; + _ZNSs9_M_assignEPc[jm]c; + + # std::wstring + _ZNKSbIwSt11char_traitsIwESaIwEE11_M_disjunctEPKw; + _ZNKSbIwSt11char_traitsIwESaIwEE15_M_check_lengthE[jm][jm]PKc; + _ZNSbIwSt11char_traitsIwESaIwEE4_Rep26_M_set_length_and_sharableE*; + _ZNSbIwSt11char_traitsIwESaIwEE7_M_copyEPwPKw[jm]; + _ZNSbIwSt11char_traitsIwESaIwEE7_M_moveEPwPKw[jm]; + _ZNSbIwSt11char_traitsIwESaIwEE9_M_assignEPw[jm]w; + + _ZNKSt13basic_fstreamI[cw]St11char_traitsI[cw]EE7is_openEv; + _ZNKSt14basic_ifstreamI[cw]St11char_traitsI[cw]EE7is_openEv; + _ZNKSt14basic_ofstreamI[cw]St11char_traitsI[cw]EE7is_openEv; + + _ZNSi6ignoreE[ilv]; + _ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreE[ilv]; + + _ZNSt11char_traitsI[cw]E2eqERK[cw]S2_; + + _ZNSt19istreambuf_iteratorI[cw]St11char_traitsI[cw]EEppEv; + +} GLIBCXX_3.4.4; + # Symbols in the support library (libsupc++) have their own tag. CXXABI_1.3 { diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/basic_string.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/basic_string.h index 2b26fc54d5..c889ce64b3 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/basic_string.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/basic_string.h @@ -198,7 +198,8 @@ namespace std { this->_M_set_sharable(); // One reference. this->_M_length = __n; - this->_M_refdata()[__n] = _S_terminal; // grrr. (per 21.3.4) + traits_type::assign(this->_M_refdata()[__n], _S_terminal); + // grrr. (per 21.3.4) // You cannot leave those LWG people alone for a second. } @@ -695,7 +696,10 @@ namespace std reference operator[](size_type __pos) { - _GLIBCXX_DEBUG_ASSERT(__pos < size()); + // allow pos == size() as v3 extension: + _GLIBCXX_DEBUG_ASSERT(__pos <= size()); + // but be strict in pedantic mode: + _GLIBCXX_DEBUG_PEDASSERT(__pos < size()); _M_leak(); return _M_data()[__pos]; } @@ -1905,9 +1909,11 @@ namespace std * * Returns an integer < 0 if this string is ordered before @a str, 0 if * their values are equivalent, or > 0 if this string is ordered after - * @a str. If the lengths of @a str and this string are different, the - * shorter one is ordered first. If they are the same, returns the - * result of traits::compare(data(),str.data(),size()); + * @a str. Determines the effective length rlen of the strings to + * compare as the smallest of size() and str.size(). The function + * then compares the two strings by calling traits::compare(data(), + * str.data(),rlen). If the result of the comparison is nonzero returns + * it, otherwise the shorter one is ordered first. */ int compare(const basic_string& __str) const @@ -1932,10 +1938,12 @@ namespace std * Form the substring of this string from the @a n characters starting * at @a pos. Returns an integer < 0 if the substring is ordered * before @a str, 0 if their values are equivalent, or > 0 if the - * substring is ordered after @a str. If the lengths @a of str and the - * substring are different, the shorter one is ordered first. If they - * are the same, returns the result of - * traits::compare(substring.data(),str.data(),size()); + * substring is ordered after @a str. Determines the effective length + * rlen of the strings to compare as the smallest of the length of the + * substring and @a str.size(). The function then compares the two + * strings by calling traits::compare(substring.data(),str.data(),rlen). + * If the result of the comparison is nonzero returns it, otherwise the + * shorter one is ordered first. */ int compare(size_type __pos, size_type __n, const basic_string& __str) const; @@ -1954,10 +1962,12 @@ namespace std * starting at @a pos2. Returns an integer < 0 if this substring is * ordered before the substring of @a str, 0 if their values are * equivalent, or > 0 if this substring is ordered after the substring - * of @a str. If the lengths of the substring of @a str and this - * substring are different, the shorter one is ordered first. If they - * are the same, returns the result of - * traits::compare(substring.data(),str.substr(pos2,n2).data(),size()); + * of @a str. Determines the effective length rlen of the strings + * to compare as the smallest of the lengths of the substrings. The + * function then compares the two strings by calling + * traits::compare(substring.data(),str.substr(pos2,n2).data(),rlen). + * If the result of the comparison is nonzero returns it, otherwise the + * shorter one is ordered first. */ int compare(size_type __pos1, size_type __n1, const basic_string& __str, @@ -1970,9 +1980,12 @@ namespace std * * Returns an integer < 0 if this string is ordered before @a s, 0 if * their values are equivalent, or > 0 if this string is ordered after - * @a s. If the lengths of @a s and this string are different, the - * shorter one is ordered first. If they are the same, returns the - * result of traits::compare(data(),s,size()); + * @a s. Determines the effective length rlen of the strings to + * compare as the smallest of size() and the length of a string + * constructed from @a s. The function then compares the two strings + * by calling traits::compare(data(),s,rlen). If the result of the + * comparison is nonzero returns it, otherwise the shorter one is + * ordered first. */ int compare(const _CharT* __s) const; @@ -1989,10 +2002,13 @@ namespace std * Form the substring of this string from the @a n1 characters starting * at @a pos. Returns an integer < 0 if the substring is ordered * before @a s, 0 if their values are equivalent, or > 0 if the - * substring is ordered after @a s. If the lengths of @a s and the - * substring are different, the shorter one is ordered first. If they - * are the same, returns the result of - * traits::compare(substring.data(),s,size()); + * substring is ordered after @a s. Determines the effective length + * rlen of the strings to compare as the smallest of the length of the + * substring and the length of a string constructed from @a s. The + * function then compares the two string by calling + * traits::compare(substring.data(),s,rlen). If the result of the + * comparison is nonzero returns it, otherwise the shorter one is + * ordered first. */ int compare(size_type __pos, size_type __n1, const _CharT* __s) const; @@ -2009,10 +2025,12 @@ namespace std * at @a pos1. Form a string from the first @a n2 characters of @a s. * Returns an integer < 0 if this substring is ordered before the string * from @a s, 0 if their values are equivalent, or > 0 if this substring - * is ordered after the string from @a s. If the lengths of this - * substring and @a n2 are different, the shorter one is ordered first. - * If they are the same, returns the result of - * traits::compare(substring.data(),s,size()); + * is ordered after the string from @a s. Determines the effective + * length rlen of the strings to compare as the smallest of the length + * of the substring and @a n2. The function then compares the two + * strings by calling traits::compare(substring.data(),s,rlen). If the + * result of the comparison is nonzero returns it, otherwise the shorter + * one is ordered first. * * NB: s must have at least n2 characters, '\0' has no special * meaning. diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/c++config b/contrib/gcc-4.0/libstdc++-v3/include/bits/c++config index df862727d2..78aa9d53b6 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/c++config +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/c++config @@ -35,7 +35,7 @@ #include // The current version of the C++ library in compressed ISO date format. -#define __GLIBCXX__ 20050421 +#define __GLIBCXX__ 20050707 // Allow use of "export template." This is currently not a feature // that g++ supports. diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/char_traits.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/char_traits.h index aedc8d816f..57a92ac108 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/char_traits.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/char_traits.h @@ -1,6 +1,6 @@ // Character Traits for use by standard string and iostream -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/cpp_type_traits.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/cpp_type_traits.h index 367a9d3055..e388719642 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/cpp_type_traits.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/cpp_type_traits.h @@ -103,10 +103,12 @@ namespace std struct __truth_type { typedef __true_type __type; }; + // N.B. The conversions to bool are needed due to the issue + // explained in c++/19404. template struct __traitor { - enum { __value = _Sp::__value || _Tp::__value }; + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; typedef typename __truth_type<__value>::__type __type; }; diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/deque.tcc b/contrib/gcc-4.0/libstdc++-v3/include/bits/deque.tcc index 0c57bd53a1..c5440b2241 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/deque.tcc +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/deque.tcc @@ -1,6 +1,6 @@ // Deque implementation (out of line) -*- C++ -*- -// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -203,7 +203,7 @@ namespace _GLIBCXX_STD void deque<_Tp, _Alloc> ::_M_assign_aux(_InputIterator __first, _InputIterator __last, - input_iterator_tag) + std::input_iterator_tag) { iterator __cur = begin(); for (; __first != __last && __cur != end(); ++__cur, ++__first) @@ -287,7 +287,7 @@ namespace _GLIBCXX_STD void deque<_Tp, _Alloc>:: _M_range_initialize(_InputIterator __first, _InputIterator __last, - input_iterator_tag) + std::input_iterator_tag) { this->_M_initialize_map(0); try @@ -307,7 +307,7 @@ namespace _GLIBCXX_STD void deque<_Tp, _Alloc>:: _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag) + std::forward_iterator_tag) { const size_type __n = std::distance(__first, __last); this->_M_initialize_map(__n); @@ -417,7 +417,7 @@ namespace _GLIBCXX_STD deque<_Tp, _Alloc>:: _M_range_insert_aux(iterator __pos, _InputIterator __first, _InputIterator __last, - input_iterator_tag) + std::input_iterator_tag) { std::copy(__first, __last, std::inserter(*this, __pos)); } template @@ -426,7 +426,7 @@ namespace _GLIBCXX_STD deque<_Tp, _Alloc>:: _M_range_insert_aux(iterator __pos, _ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag) + std::forward_iterator_tag) { const size_type __n = std::distance(__first, __last); if (__pos._M_cur == this->_M_impl._M_start._M_cur) diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/fstream.tcc b/contrib/gcc-4.0/libstdc++-v3/include/bits/fstream.tcc index 6915ea9b23..40bf428e2c 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/fstream.tcc +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/fstream.tcc @@ -531,15 +531,8 @@ namespace std const bool __testin = _M_mode & ios_base::in; const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1; -#if _GLIBCXX_HAVE_DOS_BASED_FILESYSTEM - // About this workaround, see libstdc++/20806. - const bool __testbinary = _M_mode & ios_base::binary; - if (__n > __buflen && __check_facet(_M_codecvt).always_noconv() - && __testin && __testbinary && !_M_writing) -#else if (__n > __buflen && __check_facet(_M_codecvt).always_noconv() && __testin && !_M_writing) -#endif { // First, copy the chars already present in the buffer. const streamsize __avail = this->egptr() - this->gptr(); @@ -555,13 +548,28 @@ namespace std __n -= __avail; } - const streamsize __len = _M_file.xsgetn(reinterpret_cast(__s), - __n); - if (__len == -1) - __throw_ios_failure(__N("basic_filebuf::xsgetn " - "error reading the file")); - __ret += __len; - if (__len == __n) + // Need to loop in case of short reads (relatively common + // with pipes). + streamsize __len; + for (;;) + { + __len = _M_file.xsgetn(reinterpret_cast(__s), + __n); + if (__len == -1) + __throw_ios_failure(__N("basic_filebuf::xsgetn " + "error reading the file")); + if (__len == 0) + break; + + __n -= __len; + __ret += __len; + if (__n == 0) + break; + + __s += __len; + } + + if (__n == 0) { _M_set_buffer(0); _M_reading = true; diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/locale_facets.tcc b/contrib/gcc-4.0/libstdc++-v3/include/bits/locale_facets.tcc index 0301781a2c..ff54c93ed9 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/locale_facets.tcc +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/locale_facets.tcc @@ -1,6 +1,6 @@ // Locale support -*- C++ -*- -// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 +// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -277,7 +277,7 @@ namespace std ios_base::iostate& __err, string& __xtrc) const { typedef char_traits<_CharT> __traits_type; - typedef typename numpunct<_CharT>::__cache_type __cache_type; + typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); @@ -440,6 +440,20 @@ namespace std return __beg; } + template + struct __to_unsigned_type + { typedef _ValueT __type; }; + + template<> + struct __to_unsigned_type + { typedef unsigned long __type; }; + +#ifdef _GLIBCXX_USE_LONG_LONG + template<> + struct __to_unsigned_type + { typedef unsigned long long __type; }; +#endif + template template _InIter @@ -447,8 +461,9 @@ namespace std _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io, ios_base::iostate& __err, _ValueT& __v) const { - typedef char_traits<_CharT> __traits_type; - typedef typename numpunct<_CharT>::__cache_type __cache_type; + typedef char_traits<_CharT> __traits_type; + typedef typename __to_unsigned_type<_ValueT>::__type __unsigned_type; + typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); @@ -536,103 +551,56 @@ namespace std __found_grouping.reserve(32); int __sep_pos = 0; bool __overflow = false; - _ValueT __result = 0; + const __unsigned_type __max = __negative ? + -numeric_limits<_ValueT>::min() : numeric_limits<_ValueT>::max(); + const __unsigned_type __smax = __max / __base; + __unsigned_type __result = 0; const char_type* __q; const char_type* __lit_zero = __lit + __num_base::_S_izero; - if (__negative) + while (!__testeof) { - const _ValueT __min = numeric_limits<_ValueT>::min() / __base; - while (!__testeof) + // According to 22.2.2.1.2, p8-9, first look for thousands_sep + // and decimal_point. + if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) { - // According to 22.2.2.1.2, p8-9, first look for thousands_sep - // and decimal_point. - if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + // NB: Thousands separator at the beginning of a string + // is a no-no, as is two consecutive thousands separators. + if (__sep_pos) { - // NB: Thousands separator at the beginning of a string - // is a no-no, as is two consecutive thousands separators. - if (__sep_pos) - { - __found_grouping += static_cast(__sep_pos); - __sep_pos = 0; - } - else - { - __err |= ios_base::failbit; - break; - } + __found_grouping += static_cast(__sep_pos); + __sep_pos = 0; } - else if (__c == __lc->_M_decimal_point) - break; - else if ((__q = __traits_type::find(__lit_zero, __len, __c))) + else { - int __digit = __q - __lit_zero; - if (__digit > 15) - __digit -= 6; - if (__result < __min) - __overflow = true; - else - { - const _ValueT __new_result = (__result * __base - - __digit); - __overflow |= __new_result > __result; - __result = __new_result; - ++__sep_pos; - } + __err |= ios_base::failbit; + break; } - else - // Not a valid input item. - break; - - if (++__beg != __end) - __c = *__beg; - else - __testeof = true; } - } - else - { - const _ValueT __max = numeric_limits<_ValueT>::max() / __base; - while (!__testeof) + else if (__c == __lc->_M_decimal_point) + break; + else if ((__q = __traits_type::find(__lit_zero, __len, __c))) { - if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) - { - if (__sep_pos) - { - __found_grouping += static_cast(__sep_pos); - __sep_pos = 0; - } - else - { - __err |= ios_base::failbit; - break; - } - } - else if (__c == __lc->_M_decimal_point) - break; - else if ((__q = __traits_type::find(__lit_zero, __len, __c))) + int __digit = __q - __lit_zero; + if (__digit > 15) + __digit -= 6; + if (__result > __smax) + __overflow = true; + else { - int __digit = __q - __lit_zero; - if (__digit > 15) - __digit -= 6; - if (__result > __max) - __overflow = true; - else - { - const _ValueT __new_result = (__result * __base - + __digit); - __overflow |= __new_result < __result; - __result = __new_result; - ++__sep_pos; - } + __result *= __base; + __overflow |= __result > __max - __digit; + __result += __digit; + ++__sep_pos; } - else - break; - - if (++__beg != __end) - __c = *__beg; - else - __testeof = true; } + else + // Not a valid input item. + break; + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; } // Digit grouping is checked. If grouping and found_grouping don't @@ -650,7 +618,7 @@ namespace std if (!(__err & ios_base::failbit) && !__overflow && (__sep_pos || __found_zero || __found_grouping.size())) - __v = __result; + __v = __negative ? -__result : __result; else __err |= ios_base::failbit; @@ -682,7 +650,7 @@ namespace std else { // Parse bool values as alphanumeric. - typedef typename numpunct<_CharT>::__cache_type __cache_type; + typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); @@ -853,24 +821,16 @@ namespace std ios_base::fmtflags __flags) { unsigned long __ul = static_cast(__v); - bool __neg = false; if (__v < 0) - { - __ul = -__ul; - __neg = true; - } - return __int_to_char(__bufend, __ul, __lit, __flags, __neg); + __ul = -__ul; + return __int_to_char(__bufend, __ul, __lit, __flags, false); } template inline int __int_to_char(_CharT* __bufend, unsigned long __v, const _CharT* __lit, ios_base::fmtflags __flags) - { - // About showpos, see Table 60 and C99 7.19.6.1, p6 (+). - return __int_to_char(__bufend, __v, __lit, - __flags & ~ios_base::showpos, false); - } + { return __int_to_char(__bufend, __v, __lit, __flags, false); } #ifdef _GLIBCXX_USE_LONG_LONG template @@ -879,59 +839,47 @@ namespace std ios_base::fmtflags __flags) { unsigned long long __ull = static_cast(__v); - bool __neg = false; if (__v < 0) - { - __ull = -__ull; - __neg = true; - } - return __int_to_char(__bufend, __ull, __lit, __flags, __neg); + __ull = -__ull; + return __int_to_char(__bufend, __ull, __lit, __flags, false); } template inline int __int_to_char(_CharT* __bufend, unsigned long long __v, const _CharT* __lit, ios_base::fmtflags __flags) - { return __int_to_char(__bufend, __v, __lit, - __flags & ~ios_base::showpos, false); } + { return __int_to_char(__bufend, __v, __lit, __flags, false); } #endif + // N.B. The last argument is currently unused (see libstdc++/20914). template int __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit, - ios_base::fmtflags __flags, bool __neg) + ios_base::fmtflags __flags, bool) { - // Don't write base if already 0. - const bool __showbase = (__flags & ios_base::showbase) && __v; const ios_base::fmtflags __basefield = __flags & ios_base::basefield; - _CharT* __buf = __bufend - 1; + _CharT* __buf = __bufend; - if (__builtin_expect(__basefield != ios_base::oct && - __basefield != ios_base::hex, true)) + if (__builtin_expect(__basefield != ios_base::oct + && __basefield != ios_base::hex, true)) { // Decimal. do { - *__buf-- = __lit[(__v % 10) + __num_base::_S_odigits]; + *--__buf = __lit[(__v % 10) + __num_base::_S_odigits]; __v /= 10; } while (__v != 0); - if (__neg) - *__buf-- = __lit[__num_base::_S_ominus]; - else if (__flags & ios_base::showpos) - *__buf-- = __lit[__num_base::_S_oplus]; } else if (__basefield == ios_base::oct) { // Octal. do { - *__buf-- = __lit[(__v & 0x7) + __num_base::_S_odigits]; + *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits]; __v >>= 3; } while (__v != 0); - if (__showbase) - *__buf-- = __lit[__num_base::_S_odigits]; } else { @@ -941,53 +889,25 @@ namespace std : __num_base::_S_odigits; do { - *__buf-- = __lit[(__v & 0xf) + __case_offset]; + *--__buf = __lit[(__v & 0xf) + __case_offset]; __v >>= 4; } while (__v != 0); - if (__showbase) - { - // 'x' or 'X' - *__buf-- = __lit[__num_base::_S_ox + __uppercase]; - // '0' - *__buf-- = __lit[__num_base::_S_odigits]; - } } - return __bufend - __buf - 1; + return __bufend - __buf; } template void num_put<_CharT, _OutIter>:: _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep, - ios_base& __io, _CharT* __new, _CharT* __cs, int& __len) const + ios_base&, _CharT* __new, _CharT* __cs, int& __len) const { - // By itself __add_grouping cannot deal correctly with __cs when - // ios::showbase is set and ios_base::oct || ios_base::hex. - // Therefore we take care "by hand" of the initial 0, 0x or 0X. - // However, remember that the latter do not occur if the number - // printed is '0' (__len == 1). - streamsize __off = 0; - const ios_base::fmtflags __basefield = __io.flags() - & ios_base::basefield; - if ((__io.flags() & ios_base::showbase) && __len > 1) - if (__basefield == ios_base::oct) - { - __off = 1; - __new[0] = __cs[0]; - } - else if (__basefield == ios_base::hex) - { - __off = 2; - __new[0] = __cs[0]; - __new[1] = __cs[1]; - } - _CharT* __p = std::__add_grouping(__new + __off, __sep, __grouping, - __grouping_size, __cs + __off, - __cs + __len); + _CharT* __p = std::__add_grouping(__new, __sep, __grouping, + __grouping_size, __cs, __cs + __len); __len = __p - __new; } - + template template _OutIter @@ -995,33 +915,69 @@ namespace std _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill, _ValueT __v) const { - typedef typename numpunct<_CharT>::__cache_type __cache_type; + typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); const _CharT* __lit = __lc->_M_atoms_out; + const ios_base::fmtflags __flags = __io.flags(); // Long enough to hold hex, dec, and octal representations. - const int __ilen = 4 * sizeof(_ValueT); + const int __ilen = 5 * sizeof(_ValueT); _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __ilen)); // [22.2.2.2.2] Stage 1, numeric conversion to character. // Result is returned right-justified in the buffer. - int __len; - __len = __int_to_char(__cs + __ilen, __v, __lit, __io.flags()); + int __len = __int_to_char(__cs + __ilen, __v, __lit, __flags); __cs += __ilen - __len; // Add grouping, if necessary. if (__lc->_M_use_grouping) { - // Grouping can add (almost) as many separators as the - // number of digits, but no more. + // Grouping can add (almost) as many separators as the number + // of digits + space is reserved for numeric base or sign. _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __len * 2)); + * (__len + 1) + * 2)); _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size, - __lc->_M_thousands_sep, __io, __cs2, __cs, __len); - __cs = __cs2; + __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len); + __cs = __cs2 + 2; + } + + // Complete Stage 1, prepend numeric base or sign. + const ios_base::fmtflags __basefield = __flags & ios_base::basefield; + if (__builtin_expect(__basefield != ios_base::oct + && __basefield != ios_base::hex, true)) + { + // Decimal. + if (__v > 0) + { + if (__flags & ios_base::showpos + && numeric_limits<_ValueT>::is_signed) + *--__cs = __lit[__num_base::_S_oplus], ++__len; + } + else if (__v) + *--__cs = __lit[__num_base::_S_ominus], ++__len; + } + else if (__basefield == ios_base::oct) + { + // Octal. + if (__flags & ios_base::showbase && __v) + *--__cs = __lit[__num_base::_S_odigits], ++__len; + } + else + { + // Hex. + if (__flags & ios_base::showbase && __v) + { + // 'x' or 'X' + const bool __uppercase = __flags & ios_base::uppercase; + *--__cs = __lit[__num_base::_S_ox + __uppercase]; + // '0' + *--__cs = __lit[__num_base::_S_odigits]; + __len += 2; + } } // Pad. @@ -1082,7 +1038,7 @@ namespace std _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod, _ValueT __v) const { - typedef typename numpunct<_CharT>::__cache_type __cache_type; + typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); @@ -1137,53 +1093,65 @@ namespace std _S_get_c_locale(), __prec); #endif - // [22.2.2.2.2] Stage 2, convert to char_type, using correct - // numpunct.decimal_point() values for '.' and adding grouping. - const ctype<_CharT>& __ctype = use_facet >(__loc); - - _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __len)); - __ctype.widen(__cs, __cs + __len, __ws); - - // Replace decimal point. - const _CharT __cdec = __ctype.widen('.'); - const _CharT __dec = __lc->_M_decimal_point; - const _CharT* __p = char_traits<_CharT>::find(__ws, __len, __cdec); - if (__p) - __ws[__p - __ws] = __dec; - - // Add grouping, if necessary. - // N.B. Make sure to not group things like 2e20, i.e., no decimal - // point, scientific notation. - if (__lc->_M_use_grouping - && (__p || __len < 3 || (__cs[1] != 'e' && __cs[2] != 'e' - && __cs[1] != 'E' && __cs[2] != 'E'))) - { - // Grouping can add (almost) as many separators as the - // number of digits, but no more. - _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __len * 2)); - _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size, - __lc->_M_thousands_sep, __p, __ws2, __ws, __len); - __ws = __ws2; - } - - // Pad. - const streamsize __w = __io.width(); - if (__w > static_cast(__len)) - { - _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __w)); - _M_pad(__fill, __w, __io, __ws3, __ws, __len); - __ws = __ws3; - } - __io.width(0); + // [22.2.2.2.2] Stage 2, convert to char_type, using correct + // numpunct.decimal_point() values for '.' and adding grouping. + const ctype<_CharT>& __ctype = use_facet >(__loc); + + _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len)); + __ctype.widen(__cs, __cs + __len, __ws); + + // Replace decimal point. + const _CharT __cdec = __ctype.widen('.'); + const _CharT __dec = __lc->_M_decimal_point; + const _CharT* __p = char_traits<_CharT>::find(__ws, __len, __cdec); + if (__p) + __ws[__p - __ws] = __dec; + + // Add grouping, if necessary. + // N.B. Make sure to not group things like 2e20, i.e., no decimal + // point, scientific notation. + if (__lc->_M_use_grouping + && (__p || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9' + && __cs[1] >= '0' && __cs[2] >= '0'))) + { + // Grouping can add (almost) as many separators as the + // number of digits, but no more. + _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len * 2)); + + streamsize __off = 0; + if (__cs[0] == '-' || __cs[0] == '+') + { + __off = 1; + __ws2[0] = __ws[0]; + __len -= 1; + } + + _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size, + __lc->_M_thousands_sep, __p, __ws2 + __off, + __ws + __off, __len); + __len += __off; + + __ws = __ws2; + } - // [22.2.2.2.2] Stage 4. - // Write resulting, fully-formatted string to output iterator. - return std::__write(__s, __ws, __len); + // Pad. + const streamsize __w = __io.width(); + if (__w > static_cast(__len)) + { + _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + _M_pad(__fill, __w, __io, __ws3, __ws, __len); + __ws = __ws3; + } + __io.width(0); + + // [22.2.2.2.2] Stage 4. + // Write resulting, fully-formatted string to output iterator. + return std::__write(__s, __ws, __len); } - + template _OutIter num_put<_CharT, _OutIter>:: @@ -1197,7 +1165,7 @@ namespace std } else { - typedef typename numpunct<_CharT>::__cache_type __cache_type; + typedef __numpunct_cache<_CharT> __cache_type; __use_cache<__cache_type> __uc; const locale& __loc = __io._M_getloc(); const __cache_type* __lc = __uc(__loc); @@ -1291,8 +1259,7 @@ namespace std typedef char_traits<_CharT> __traits_type; typedef typename string_type::size_type size_type; typedef money_base::part part; - typedef moneypunct<_CharT, _Intl> __moneypunct_type; - typedef typename __moneypunct_type::__cache_type __cache_type; + typedef __moneypunct_cache<_CharT, _Intl> __cache_type; const locale& __loc = __io._M_getloc(); const ctype<_CharT>& __ctype = use_facet >(__loc); @@ -1550,8 +1517,7 @@ namespace std { typedef typename string_type::size_type size_type; typedef money_base::part part; - typedef moneypunct<_CharT, _Intl> __moneypunct_type; - typedef typename __moneypunct_type::__cache_type __cache_type; + typedef __moneypunct_cache<_CharT, _Intl> __cache_type; const locale& __loc = __io._M_getloc(); const ctype<_CharT>& __ctype = use_facet >(__loc); @@ -1567,7 +1533,7 @@ namespace std money_base::pattern __p; const char_type* __sign; size_type __sign_size; - if (*__beg != __lit[money_base::_S_minus]) + if (!(*__beg == __lit[money_base::_S_minus])) { __p = __lc->_M_pos_format; __sign = __lc->_M_positive_sign; @@ -2052,7 +2018,7 @@ namespace std for (size_t __i3 = 0; __i3 < __nmatches;) { __name = __names[__matches[__i3]]; - if (__name[__pos] != *__beg) + if (!(__name[__pos] == *__beg)) __matches[__i3] = __matches[--__nmatches]; else ++__i3; diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_algo.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_algo.h index f568a0671e..469773cb3f 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_algo.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_algo.h @@ -1,6 +1,6 @@ // Algorithm implementation -*- C++ -*- -// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -413,9 +413,8 @@ namespace std { // concept requirements __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>) - __glibcxx_function_requires(_EqualityComparableConcept< - typename iterator_traits<_InputIterator>::value_type >) - __glibcxx_function_requires(_EqualityComparableConcept<_Tp>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_InputIterator>::value_type, _Tp>) __glibcxx_requires_valid_range(__first, __last); typename iterator_traits<_InputIterator>::difference_type __n = 0; for ( ; __first != __last; ++__first) @@ -627,9 +626,8 @@ namespace std { // concept requirements __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>) - __glibcxx_function_requires(_EqualityComparableConcept< - typename iterator_traits<_ForwardIterator>::value_type>) - __glibcxx_function_requires(_EqualityComparableConcept<_Tp>) + __glibcxx_function_requires(_EqualOpConcept< + typename iterator_traits<_ForwardIterator>::value_type, _Tp>) __glibcxx_requires_valid_range(__first, __last); if (__count <= 0) @@ -1637,7 +1635,7 @@ namespace std for (_Distance __i = 0; __i < __d; __i++) { - const _ValueType __tmp = *__first; + _ValueType __tmp = *__first; _RandomAccessIterator __p = __first; if (__k < __l) @@ -1736,7 +1734,8 @@ namespace std __glibcxx_requires_valid_range(__first, __middle); __glibcxx_requires_valid_range(__middle, __last); - return std::copy(__first, __middle, copy(__middle, __last, __result)); + return std::copy(__first, __middle, + std::copy(__middle, __last, __result)); } /** @@ -2211,10 +2210,10 @@ namespace std __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) { - if (__last - __first > _S_threshold) + if (__last - __first > int(_S_threshold)) { - std::__insertion_sort(__first, __first + _S_threshold); - std::__unguarded_insertion_sort(__first + _S_threshold, __last); + std::__insertion_sort(__first, __first + int(_S_threshold)); + std::__unguarded_insertion_sort(__first + int(_S_threshold), __last); } else std::__insertion_sort(__first, __last); @@ -2230,10 +2229,10 @@ namespace std __final_insertion_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) { - if (__last - __first > _S_threshold) + if (__last - __first > int(_S_threshold)) { - std::__insertion_sort(__first, __first + _S_threshold, __comp); - std::__unguarded_insertion_sort(__first + _S_threshold, __last, + std::__insertion_sort(__first, __first + int(_S_threshold), __comp); + std::__unguarded_insertion_sort(__first + int(_S_threshold), __last, __comp); } else @@ -2480,7 +2479,7 @@ namespace std typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; - while (__last - __first > _S_threshold) + while (__last - __first > int(_S_threshold)) { if (__depth_limit == 0) { @@ -2516,7 +2515,7 @@ namespace std typedef typename iterator_traits<_RandomAccessIterator>::value_type _ValueType; - while (__last - __first > _S_threshold) + while (__last - __first > int(_S_threshold)) { if (__depth_limit == 0) { diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_algobase.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_algobase.h index 426fcba029..a0f7c5041c 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_algobase.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_algobase.h @@ -94,7 +94,7 @@ namespace std // concept requirements __glibcxx_function_requires(_SGIAssignableConcept<_Tp>) - const _Tp __tmp = __a; + _Tp __tmp = __a; __a = __b; __b = __tmp; } @@ -111,7 +111,7 @@ namespace std { typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType1; - const _ValueType1 __tmp = *__a; + _ValueType1 __tmp = *__a; *__a = *__b; *__b = __tmp; } diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_bvector.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_bvector.h index 74985071ba..bdd21559fb 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_bvector.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_bvector.h @@ -106,7 +106,8 @@ namespace _GLIBCXX_STD { *_M_p ^= _M_mask; } }; - struct _Bit_iterator_base : public iterator + struct _Bit_iterator_base + : public std::iterator { _Bit_type * _M_p; unsigned int _M_offset; @@ -117,7 +118,7 @@ namespace _GLIBCXX_STD void _M_bump_up() { - if (_M_offset++ == _S_word_bit - 1) + if (_M_offset++ == int(_S_word_bit) - 1) { _M_offset = 0; ++_M_p; @@ -129,7 +130,7 @@ namespace _GLIBCXX_STD { if (_M_offset-- == 0) { - _M_offset = _S_word_bit - 1; + _M_offset = int(_S_word_bit) - 1; --_M_p; } } @@ -138,11 +139,11 @@ namespace _GLIBCXX_STD _M_incr(ptrdiff_t __i) { difference_type __n = __i + _M_offset; - _M_p += __n / _S_word_bit; - __n = __n % _S_word_bit; + _M_p += __n / int(_S_word_bit); + __n = __n % int(_S_word_bit); if (__n < 0) { - _M_offset = static_cast(__n + _S_word_bit); + _M_offset = static_cast(__n + int(_S_word_bit)); --_M_p; } else @@ -180,7 +181,8 @@ namespace _GLIBCXX_STD inline ptrdiff_t operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) { - return _S_word_bit * (__x._M_p - __y._M_p) + __x._M_offset - __y._M_offset; + return (int(_S_word_bit) * (__x._M_p - __y._M_p) + + __x._M_offset - __y._M_offset); } struct _Bit_iterator : public _Bit_iterator_base @@ -384,7 +386,8 @@ namespace _GLIBCXX_STD _Bit_type* _M_allocate(size_t __n) - { return _M_impl.allocate((__n + _S_word_bit - 1) / _S_word_bit); } + { return _M_impl.allocate((__n + int(_S_word_bit) - 1) + / int(_S_word_bit)); } void _M_deallocate() @@ -452,8 +455,8 @@ template { _Bit_type* __q = this->_M_allocate(__n); this->_M_impl._M_end_of_storage = (__q - + ((__n + _S_word_bit - 1) - / _S_word_bit)); + + ((__n + int(_S_word_bit) - 1) + / int(_S_word_bit))); this->_M_impl._M_start = iterator(__q, 0); this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n); } @@ -477,8 +480,9 @@ template *__i++ = __x; this->_M_impl._M_finish = std::copy(__position, end(), __i); this->_M_deallocate(); - this->_M_impl._M_end_of_storage = (__q + ((__len + _S_word_bit - 1) - / _S_word_bit)); + this->_M_impl._M_end_of_storage = (__q + ((__len + + int(_S_word_bit) - 1) + / int(_S_word_bit))); this->_M_impl._M_start = iterator(__q, 0); } } @@ -486,7 +490,7 @@ template template void _M_initialize_range(_InputIterator __first, _InputIterator __last, - input_iterator_tag) + std::input_iterator_tag) { this->_M_impl._M_start = iterator(); this->_M_impl._M_finish = iterator(); @@ -498,7 +502,7 @@ template template void _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag) + std::forward_iterator_tag) { const size_type __n = std::distance(__first, __last); _M_initialize(__n); @@ -508,7 +512,7 @@ template template void _M_insert_range(iterator __pos, _InputIterator __first, - _InputIterator __last, input_iterator_tag) + _InputIterator __last, std::input_iterator_tag) { for (; __first != __last; ++__first) { @@ -520,7 +524,7 @@ template template void _M_insert_range(iterator __position, _ForwardIterator __first, - _ForwardIterator __last, forward_iterator_tag) + _ForwardIterator __last, std::forward_iterator_tag) { if (__first != __last) { @@ -543,8 +547,9 @@ template this->_M_impl._M_finish = std::copy(__position, end(), __i); this->_M_deallocate(); this->_M_impl._M_end_of_storage = (__q - + ((__len + _S_word_bit - 1) - / _S_word_bit)); + + ((__len + + int(_S_word_bit) - 1) + / int(_S_word_bit))); this->_M_impl._M_start = iterator(__q, 0); } } @@ -742,7 +747,7 @@ template template void _M_assign_aux(_InputIterator __first, _InputIterator __last, - input_iterator_tag) + std::input_iterator_tag) { iterator __cur = begin(); for (; __first != __last && __cur != end(); ++__cur, ++__first) @@ -756,7 +761,7 @@ template template void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag) + std::forward_iterator_tag) { const size_type __len = std::distance(__first, __last); if (__len < size()) @@ -782,8 +787,8 @@ template iterator(__q, 0)); this->_M_deallocate(); this->_M_impl._M_start = iterator(__q, 0); - this->_M_impl._M_end_of_storage = (__q + (__n + _S_word_bit - 1) - / _S_word_bit); + this->_M_impl._M_end_of_storage = (__q + (__n + int(_S_word_bit) - 1) + / int(_S_word_bit)); } } @@ -888,8 +893,9 @@ template this->_M_impl._M_finish = std::copy(__position, end(), __i + difference_type(__n)); this->_M_deallocate(); - this->_M_impl._M_end_of_storage = (__q + ((__len + _S_word_bit - 1) - / _S_word_bit)); + this->_M_impl._M_end_of_storage = (__q + ((__len + + int(_S_word_bit) - 1) + / int(_S_word_bit))); this->_M_impl._M_start = iterator(__q, 0); } } diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_deque.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_deque.h index 27d0304ba0..fdee3d5aed 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_deque.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_deque.h @@ -106,14 +106,14 @@ namespace _GLIBCXX_STD static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); } - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Ptr pointer; - typedef _Ref reference; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef _Tp** _Map_pointer; - typedef _Deque_iterator _Self; + typedef std::random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef _Ptr pointer; + typedef _Ref reference; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Tp** _Map_pointer; + typedef _Deque_iterator _Self; _Tp* _M_cur; _Tp* _M_first; @@ -591,7 +591,7 @@ namespace _GLIBCXX_STD * and we can use other standard algorithms as well. * @endif */ - template > + template > class deque : protected _Deque_base<_Tp, _Alloc> { // concept requirements @@ -1214,8 +1214,8 @@ namespace _GLIBCXX_STD _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, __false_type) { - typedef typename iterator_traits<_InputIterator>::iterator_category - _IterCategory; + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; _M_range_initialize(__first, __last, _IterCategory()); } @@ -1236,13 +1236,13 @@ namespace _GLIBCXX_STD template void _M_range_initialize(_InputIterator __first, _InputIterator __last, - input_iterator_tag); + std::input_iterator_tag); // called by the second initialize_dispatch above template void _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag); + std::forward_iterator_tag); //@} /** @@ -1278,8 +1278,8 @@ namespace _GLIBCXX_STD _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type) { - typedef typename iterator_traits<_InputIterator>::iterator_category - _IterCategory; + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; _M_assign_aux(__first, __last, _IterCategory()); } @@ -1287,13 +1287,13 @@ namespace _GLIBCXX_STD template void _M_assign_aux(_InputIterator __first, _InputIterator __last, - input_iterator_tag); + std::input_iterator_tag); // called by the second assign_dispatch above template void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag) + std::forward_iterator_tag) { const size_type __len = std::distance(__first, __last); if (__len > size()) @@ -1356,8 +1356,8 @@ namespace _GLIBCXX_STD _InputIterator __first, _InputIterator __last, __false_type) { - typedef typename iterator_traits<_InputIterator>::iterator_category - _IterCategory; + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; _M_range_insert_aux(__pos, __first, __last, _IterCategory()); } @@ -1365,13 +1365,13 @@ namespace _GLIBCXX_STD template void _M_range_insert_aux(iterator __pos, _InputIterator __first, - _InputIterator __last, input_iterator_tag); + _InputIterator __last, std::input_iterator_tag); // called by the second insert_dispatch above template void _M_range_insert_aux(iterator __pos, _ForwardIterator __first, - _ForwardIterator __last, forward_iterator_tag); + _ForwardIterator __last, std::forward_iterator_tag); // Called by insert(p,n,x), and the range insert when it turns out to be // the same thing. Can use fill functions in optimal situations, diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_function.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_function.h index 74ddcce9d8..fbd22c3c8b 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_function.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_function.h @@ -1,6 +1,6 @@ // Functor implementations -*- C++ -*- -// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002, 2004, 2005 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -88,7 +88,7 @@ namespace std * \endcode * The addition and negation functions will be inlined directly. * - * The standard functiors are derived from structs named @c unary_function + * The standard functors are derived from structs named @c unary_function * and @c binary_function. These two classes contain nothing but typedefs, * to aid in generic (template) programming. If you write your own * functors, you might consider doing the same. @@ -360,7 +360,7 @@ namespace std /** @defgroup s20_3_6_binder Binder Classes * Binders turn functions/functors with two arguments into functors with * a single argument, storing an argument to be applied later. For - * example, an variable @c B of type @c binder1st is constructed from a + * example, a variable @c B of type @c binder1st is constructed from a * functor @c f and an argument @c x. Later, B's @c operator() is called * with a single argument @c y. The return value is the value of @c f(x,y). * @c B can be "called" with various arguments (y1, y2, ...) and will in diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_list.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_list.h index b928e00515..ce167ef80e 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_list.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_list.h @@ -110,14 +110,14 @@ namespace _GLIBCXX_STD template struct _List_iterator { - typedef _List_iterator<_Tp> _Self; - typedef _List_node<_Tp> _Node; + typedef _List_iterator<_Tp> _Self; + typedef _List_node<_Tp> _Node; - typedef ptrdiff_t difference_type; - typedef bidirectional_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Tp* pointer; - typedef _Tp& reference; + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef _Tp value_type; + typedef _Tp* pointer; + typedef _Tp& reference; _List_iterator() : _M_node() { } @@ -186,15 +186,15 @@ namespace _GLIBCXX_STD template struct _List_const_iterator { - typedef _List_const_iterator<_Tp> _Self; - typedef const _List_node<_Tp> _Node; - typedef _List_iterator<_Tp> iterator; + typedef _List_const_iterator<_Tp> _Self; + typedef const _List_node<_Tp> _Node; + typedef _List_iterator<_Tp> iterator; - typedef ptrdiff_t difference_type; - typedef bidirectional_iterator_tag iterator_category; - typedef _Tp value_type; - typedef const _Tp* pointer; - typedef const _Tp& reference; + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef _Tp value_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; _List_const_iterator() : _M_node() { } @@ -387,7 +387,7 @@ namespace _GLIBCXX_STD * iterator's next/previous pointers refer to itself, the %list is * %empty. @endif */ - template > + template > class list : protected _List_base<_Tp, _Alloc> { // concept requirements diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_map.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_map.h index 8535ae5f26..a0834a763b 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_map.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_map.h @@ -1,6 +1,6 @@ // Map implementation -*- C++ -*- -// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002, 2004, 2005 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -86,8 +86,8 @@ namespace _GLIBCXX_STD * called (*_unique versus *_equal, same as the standard). * @endif */ - template , - typename _Alloc = allocator > > + template , + typename _Alloc = std::allocator > > class map { // concept requirements @@ -98,11 +98,11 @@ namespace _GLIBCXX_STD public: typedef _Key key_type; typedef _Tp mapped_type; - typedef pair value_type; + typedef std::pair value_type; typedef _Compare key_compare; class value_compare - : public binary_function + : public std::binary_function { friend class map<_Key,_Tp,_Compare,_Alloc>; protected: @@ -355,7 +355,7 @@ namespace _GLIBCXX_STD * * Insertion requires logarithmic time. */ - pair + std::pair insert(const value_type& __x) { return _M_t.insert_unique(__x); } @@ -589,7 +589,7 @@ namespace _GLIBCXX_STD * * This function probably only makes sense for multimaps. */ - pair + std::pair equal_range(const key_type& __x) { return _M_t.equal_range(__x); } @@ -608,7 +608,7 @@ namespace _GLIBCXX_STD * * This function probably only makes sense for multimaps. */ - pair + std::pair equal_range(const key_type& __x) const { return _M_t.equal_range(__x); } diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_multimap.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_multimap.h index e080f9aaba..524b236681 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_multimap.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_multimap.h @@ -1,6 +1,6 @@ // Multimap implementation -*- C++ -*- -// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002, 2004, 2005 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -68,8 +68,8 @@ namespace _GLIBCXX_STD // Forward declaration of operators < and ==, needed for friend declaration. template , - typename _Alloc = allocator > > + typename _Compare = std::less<_Key>, + typename _Alloc = std::allocator > > class multimap; template @@ -114,11 +114,11 @@ namespace _GLIBCXX_STD public: typedef _Key key_type; typedef _Tp mapped_type; - typedef pair value_type; + typedef std::pair value_type; typedef _Compare key_compare; class value_compare - : public binary_function + : public std::binary_function { friend class multimap<_Key,_Tp,_Compare,_Alloc>; protected: @@ -573,7 +573,7 @@ namespace _GLIBCXX_STD * @endcode * (but is faster than making the calls separately). */ - pair + std::pair equal_range(const key_type& __x) { return _M_t.equal_range(__x); } @@ -590,7 +590,7 @@ namespace _GLIBCXX_STD * @endcode * (but is faster than making the calls separately). */ - pair + std::pair equal_range(const key_type& __x) const { return _M_t.equal_range(__x); } diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_multiset.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_multiset.h index c82dee68e4..3f42ef4c38 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_multiset.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_multiset.h @@ -1,6 +1,6 @@ // Multiset implementation -*- C++ -*- -// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002, 2004, 2005 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -67,8 +67,8 @@ namespace _GLIBCXX_STD { // Forward declaration of operators < and ==, needed for friend declaration. - template , - class _Alloc = allocator<_Key> > + template , + class _Alloc = std::allocator<_Key> > class multiset; template @@ -492,11 +492,11 @@ namespace _GLIBCXX_STD * * This function probably only makes sense for multisets. */ - pair + std::pair equal_range(const key_type& __x) { return _M_t.equal_range(__x); } - pair + std::pair equal_range(const key_type& __x) const { return _M_t.equal_range(__x); } diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_set.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_set.h index bb28bddc7a..1a15d1172c 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_set.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_set.h @@ -1,6 +1,6 @@ // Set implementation -*- C++ -*- -// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002, 2004, 2005 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -66,8 +66,8 @@ namespace _GLIBCXX_STD { // Forward declarations of operators < and ==, needed for friend declaration. - template, - class _Alloc = allocator<_Key> > + template, + class _Alloc = std::allocator<_Key> > class set; template @@ -308,11 +308,12 @@ namespace _GLIBCXX_STD * * Insertion requires logarithmic time. */ - pair + std::pair insert(const value_type& __x) { - pair __p = _M_t.insert_unique(__x); - return pair(__p.first, __p.second); + std::pair __p = + _M_t.insert_unique(__x); + return std::pair(__p.first, __p.second); } /** @@ -502,11 +503,11 @@ namespace _GLIBCXX_STD * * This function probably only makes sense for multisets. */ - pair + std::pair equal_range(const key_type& __x) { return _M_t.equal_range(__x); } - pair + std::pair equal_range(const key_type& __x) const { return _M_t.equal_range(__x); } //@} diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_tree.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_tree.h index 4da42c168f..c514563607 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_tree.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_tree.h @@ -786,12 +786,11 @@ namespace std _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: _M_insert(_Base_ptr __x, _Base_ptr __p, const _Val& __v) { - _Link_type __z = _M_create_node(__v); - bool __insert_left; + bool __insert_left = (__x != 0 || __p == _M_end() + || _M_impl._M_key_compare(_KeyOfValue()(__v), + _S_key(__p))); - __insert_left = (__x != 0 || __p == _M_end() - || _M_impl._M_key_compare(_KeyOfValue()(__v), - _S_key(__p))); + _Link_type __z = _M_create_node(__v); _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, this->_M_impl._M_header); diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_vector.h b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_vector.h index 3495d9312a..d532c2dc91 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_vector.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/stl_vector.h @@ -144,7 +144,7 @@ namespace _GLIBCXX_STD * memory and size allocation. Subscripting ( @c [] ) access is * also provided as with C-style arrays. */ - template > + template > class vector : protected _Vector_base<_Tp, _Alloc> { // Concept requirements. @@ -795,8 +795,8 @@ namespace _GLIBCXX_STD _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, __false_type) { - typedef typename iterator_traits<_InputIterator>::iterator_category - _IterCategory; + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; _M_range_initialize(__first, __last, _IterCategory()); } @@ -804,7 +804,7 @@ namespace _GLIBCXX_STD template void _M_range_initialize(_InputIterator __first, - _InputIterator __last, input_iterator_tag) + _InputIterator __last, std::input_iterator_tag) { for (; __first != __last; ++__first) push_back(*__first); @@ -814,7 +814,7 @@ namespace _GLIBCXX_STD template void _M_range_initialize(_ForwardIterator __first, - _ForwardIterator __last, forward_iterator_tag) + _ForwardIterator __last, std::forward_iterator_tag) { const size_type __n = std::distance(__first, __last); this->_M_impl._M_start = this->_M_allocate(__n); @@ -844,8 +844,8 @@ namespace _GLIBCXX_STD _M_assign_dispatch(_InputIterator __first, _InputIterator __last, __false_type) { - typedef typename iterator_traits<_InputIterator>::iterator_category - _IterCategory; + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; _M_assign_aux(__first, __last, _IterCategory()); } @@ -853,13 +853,13 @@ namespace _GLIBCXX_STD template void _M_assign_aux(_InputIterator __first, _InputIterator __last, - input_iterator_tag); + std::input_iterator_tag); // Called by the second assign_dispatch above template void _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag); + std::forward_iterator_tag); // Called by assign(n,t), and the range assign when it turns out // to be the same thing. @@ -885,8 +885,8 @@ namespace _GLIBCXX_STD _M_insert_dispatch(iterator __pos, _InputIterator __first, _InputIterator __last, __false_type) { - typedef typename iterator_traits<_InputIterator>::iterator_category - _IterCategory; + typedef typename std::iterator_traits<_InputIterator>:: + iterator_category _IterCategory; _M_range_insert(__pos, __first, __last, _IterCategory()); } @@ -894,13 +894,13 @@ namespace _GLIBCXX_STD template void _M_range_insert(iterator __pos, _InputIterator __first, - _InputIterator __last, input_iterator_tag); + _InputIterator __last, std::input_iterator_tag); // Called by the second insert_dispatch above template void _M_range_insert(iterator __pos, _ForwardIterator __first, - _ForwardIterator __last, forward_iterator_tag); + _ForwardIterator __last, std::forward_iterator_tag); // Called by insert(p,n,x), and the range insert when it turns out to be // the same thing. diff --git a/contrib/gcc-4.0/libstdc++-v3/include/bits/vector.tcc b/contrib/gcc-4.0/libstdc++-v3/include/bits/vector.tcc index 57144b073b..f9f5e5ac8a 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/bits/vector.tcc +++ b/contrib/gcc-4.0/libstdc++-v3/include/bits/vector.tcc @@ -1,6 +1,6 @@ // Vector implementation (out of line) -*- C++ -*- -// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -192,7 +192,7 @@ namespace _GLIBCXX_STD void vector<_Tp, _Alloc>:: _M_assign_aux(_InputIterator __first, _InputIterator __last, - input_iterator_tag) + std::input_iterator_tag) { iterator __cur(begin()); for (; __first != __last && __cur != end(); ++__cur, ++__first) @@ -208,7 +208,7 @@ namespace _GLIBCXX_STD void vector<_Tp, _Alloc>:: _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - forward_iterator_tag) + std::forward_iterator_tag) { const size_type __len = std::distance(__first, __last); @@ -392,7 +392,7 @@ namespace _GLIBCXX_STD void vector<_Tp, _Alloc>:: _M_range_insert(iterator __pos, _InputIterator __first, - _InputIterator __last, input_iterator_tag) + _InputIterator __last, std::input_iterator_tag) { for (; __first != __last; ++__first) { @@ -406,7 +406,7 @@ namespace _GLIBCXX_STD void vector<_Tp, _Alloc>:: _M_range_insert(iterator __position, _ForwardIterator __first, - _ForwardIterator __last, forward_iterator_tag) + _ForwardIterator __last, std::forward_iterator_tag) { if (__first != __last) { diff --git a/contrib/gcc-4.0/libstdc++-v3/include/debug/bitset b/contrib/gcc-4.0/libstdc++-v3/include/debug/bitset index 2e2364ff93..e292fea3d9 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/debug/bitset +++ b/contrib/gcc-4.0/libstdc++-v3/include/debug/bitset @@ -1,6 +1,6 @@ // Debugging bitset implementation -*- C++ -*- -// Copyright (C) 2003, 2004 +// Copyright (C) 2003, 2004, 2005 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -239,6 +239,28 @@ namespace __gnu_debug_def to_string() const { return _M_base().template to_string<_CharT, _Traits, _Allocator>(); } + // _GLIBCXX_RESOLVE_LIB_DEFECTS + // 434. bitset::to_string() hard to use. + template + std::basic_string<_CharT, _Traits, std::allocator<_CharT> > + to_string() const + { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); } + + template + std::basic_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> > + to_string() const + { + return to_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> >(); + } + + std::basic_string, std::allocator > + to_string() const + { + return to_string,std::allocator >(); + } + using _Base::count; using _Base::size; diff --git a/contrib/gcc-4.0/libstdc++-v3/include/debug/debug.h b/contrib/gcc-4.0/libstdc++-v3/include/debug/debug.h index 94c89e95fa..f371a6a47c 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/debug/debug.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/debug/debug.h @@ -226,7 +226,7 @@ _GLIBCXX_DEBUG_VERIFY(::std::__is_heap(_First, _Last, _Pred), \ #ifdef _GLIBCXX_DEBUG # define _GLIBCXX_DEBUG_ASSERT(_Condition) assert(_Condition) -# ifdef _GLIBXX_DEBUG_PEDANTIC +# ifdef _GLIBCXX_DEBUG_PEDANTIC # define _GLIBCXX_DEBUG_PEDASSERT(_Condition) assert(_Condition) # else # define _GLIBCXX_DEBUG_PEDASSERT(_Condition) diff --git a/contrib/gcc-4.0/libstdc++-v3/include/debug/formatter.h b/contrib/gcc-4.0/libstdc++-v3/include/debug/formatter.h index db555b0030..20836cfbb6 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/debug/formatter.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/debug/formatter.h @@ -1,7 +1,6 @@ // Debug-mode error formatting implementation -*- C++ -*- -// Copyright (C) 2003, 2004 -// Free Software Foundation, Inc. +// Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -310,7 +309,7 @@ namespace __gnu_debug const _Error_formatter& _M_iterator(const _Iterator& __it, const char* __name = 0) const { - if (_M_num_parameters < __max_parameters) + if (_M_num_parameters < size_t(__max_parameters)) _M_parameters[_M_num_parameters++] = _Parameter(__it, __name, _Is_iterator()); return *this; @@ -319,7 +318,7 @@ namespace __gnu_debug const _Error_formatter& _M_integer(long __value, const char* __name = 0) const { - if (_M_num_parameters < __max_parameters) + if (_M_num_parameters < size_t(__max_parameters)) _M_parameters[_M_num_parameters++] = _Parameter(__value, __name); return *this; } @@ -327,7 +326,7 @@ namespace __gnu_debug const _Error_formatter& _M_string(const char* __value, const char* __name = 0) const { - if (_M_num_parameters < __max_parameters) + if (_M_num_parameters < size_t(__max_parameters)) _M_parameters[_M_num_parameters++] = _Parameter(__value, __name); return *this; } @@ -336,7 +335,7 @@ namespace __gnu_debug const _Error_formatter& _M_sequence(const _Sequence& __seq, const char* __name = 0) const { - if (_M_num_parameters < __max_parameters) + if (_M_num_parameters < size_t(__max_parameters)) _M_parameters[_M_num_parameters++] = _Parameter(__seq, __name, _Is_sequence()); return *this; diff --git a/contrib/gcc-4.0/libstdc++-v3/include/debug/string b/contrib/gcc-4.0/libstdc++-v3/include/debug/string index a91c004e93..3893cd2b5f 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/debug/string +++ b/contrib/gcc-4.0/libstdc++-v3/include/debug/string @@ -1,6 +1,6 @@ // Debugging string implementation -*- C++ -*- -// Copyright (C) 2003 +// Copyright (C) 2003, 2005 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -37,7 +37,8 @@ namespace __gnu_debug { - template +template, + typename _Allocator = std::allocator<_CharT> > class basic_string : public std::basic_string<_CharT, _Traits, _Allocator>, public __gnu_debug::_Safe_sequencesize(), + _M_message(::__gnu_debug::__msg_subscript_oob) + ._M_sequence(*this, "this") + ._M_integer(__pos, "__pos") + ._M_integer(this->size(), "size")); +#endif return _M_base()[__pos]; } @@ -996,6 +1006,13 @@ namespace __gnu_debug __str._M_invalidate_all(); return __res; } + + typedef basic_string string; + +#ifdef _GLIBCXX_USE_WCHAR_T + typedef basic_string wstring; +#endif + } // namespace __gnu_debug #endif diff --git a/contrib/gcc-4.0/libstdc++-v3/include/ext/mt_allocator.h b/contrib/gcc-4.0/libstdc++-v3/include/ext/mt_allocator.h index de1656320a..6177ded4da 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/ext/mt_allocator.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/ext/mt_allocator.h @@ -503,7 +503,7 @@ namespace __gnu_cxx static _Tune _S_tune(__align, sizeof(_Tp) * 64, sizeof(_Tp) * 2 >= __align ? sizeof(_Tp) * 2 : __align, - sizeof(_Tp) * _Tune::_S_chunk_size, + sizeof(_Tp) * size_t(_Tune::_S_chunk_size), _Tune::_S_max_threads, _Tune::_S_freelist_headroom, getenv("GLIBCXX_FORCE_NEW") ? true : false); @@ -549,7 +549,7 @@ namespace __gnu_cxx static _Tune _S_tune(__align, sizeof(_Tp) * 64, sizeof(_Tp) * 2 >= __align ? sizeof(_Tp) * 2 : __align, - sizeof(_Tp) * _Tune::_S_chunk_size, + sizeof(_Tp) * size_t(_Tune::_S_chunk_size), _Tune::_S_max_threads, _Tune::_S_freelist_headroom, getenv("GLIBCXX_FORCE_NEW") ? true : false); diff --git a/contrib/gcc-4.0/libstdc++-v3/include/ext/pod_char_traits.h b/contrib/gcc-4.0/libstdc++-v3/include/ext/pod_char_traits.h index c2f5551247..a27b4cb237 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/ext/pod_char_traits.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/ext/pod_char_traits.h @@ -1,6 +1,6 @@ // POD character, std::char_traits specialization -*- C++ -*- -// Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. +// Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -41,24 +41,47 @@ namespace __gnu_cxx { + // POD character abstraction. + // NB: The char_type parameter is a subset of int_type, as to allow + // int_type to properly hold the full range of char_type values as + // well as EOF. /// @brief A POD class that serves as a character abstraction class. template struct character { - typedef V value_type; - typedef I int_type; - typedef S state_type; + typedef V value_type; + typedef I int_type; + typedef S state_type; + typedef character char_type; + value_type value; + + template + static char_type + from(const V2& v) + { + char_type ret = { static_cast(v) }; + return ret; + } + + template + static V2 + to(const char_type& c) + { + V2 ret = { static_cast(c.value) }; + return ret; + } + }; - template + template inline bool - operator==(const character& lhs, const character& rhs) + operator==(const character& lhs, const character& rhs) { return lhs.value == rhs.value; } - template + template inline bool - operator<(const character& lhs, const character& rhs) + operator<(const character& lhs, const character& rhs) { return lhs.value < rhs.value; } } // namespace __gnu_cxx @@ -69,13 +92,6 @@ namespace std struct char_traits<__gnu_cxx::character > { typedef __gnu_cxx::character char_type; - - // NB: This type should be bigger than char_type, so as to - // properly hold EOF values in addition to the full range of - // char_type values. - // Also, assumes - // int_type(value_type) is valid. - // int_type(-1) is possible. typedef typename char_type::int_type int_type; typedef typename char_type::state_type state_type; typedef fpos pos_type; @@ -122,41 +138,47 @@ namespace std static char_type* move(char_type* __s1, const char_type* __s2, size_t __n) - { return (char_type*) memmove(__s1, __s2, __n * sizeof(char_type)); } + { + return static_cast(std::memmove(__s1, __s2, + __n * sizeof(char_type))); + } static char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) - { return (char_type*) memcpy(__s1, __s2, __n * sizeof(char_type)); } + { + std::copy(__s2, __s2 + __n, __s1); + return __s1; + } static char_type* assign(char_type* __s, size_t __n, char_type __a) { - for (char_type* __p = __s; __p < __s + __n; ++__p) - assign(*__p, __a); + std::fill_n(__s, __n, __a); return __s; } static char_type - to_char_type(const int_type& __c) - { - char_type __r = { __c }; - return __r; - } + to_char_type(const int_type& __i) + { return char_type::template from(__i); } static int_type to_int_type(const char_type& __c) - { return int_type(__c.value); } + { return char_type::template to(__c); } static bool eq_int_type(const int_type& __c1, const int_type& __c2) { return __c1 == __c2; } static int_type - eof() { return static_cast(-1); } + eof() + { + int_type __r = { -1 }; + return __r; + } static int_type not_eof(const int_type& __c) - { return eq_int_type(__c, eof()) ? int_type(0) : __c; } + { return eq_int_type(__c, eof()) ? int_type() : __c; } }; } diff --git a/contrib/gcc-4.0/libstdc++-v3/include/ext/pool_allocator.h b/contrib/gcc-4.0/libstdc++-v3/include/ext/pool_allocator.h index c5b2bec3dc..afe2b32bf4 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/ext/pool_allocator.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/ext/pool_allocator.h @@ -80,7 +80,7 @@ namespace __gnu_cxx enum { _S_align = 8 }; enum { _S_max_bytes = 128 }; - enum { _S_free_list_size = _S_max_bytes / _S_align }; + enum { _S_free_list_size = (size_t)_S_max_bytes / (size_t)_S_align }; union _Obj { diff --git a/contrib/gcc-4.0/libstdc++-v3/include/ext/rope b/contrib/gcc-4.0/libstdc++-v3/include/ext/rope index 05ab668e67..0f691e8ccd 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/ext/rope +++ b/contrib/gcc-4.0/libstdc++-v3/include/ext/rope @@ -676,8 +676,8 @@ protected: return __size_with_eos; #else // Allow slop for in-place expansion. - return ((__size_with_eos + _S_alloc_granularity - 1) - &~ (_S_alloc_granularity - 1)); + return ((__size_with_eos + size_t(_S_alloc_granularity) - 1) + &~ (size_t(_S_alloc_granularity) - 1)); #endif } __GC_CONST _CharT* _M_data; /* Not necessarily 0 terminated. */ @@ -1998,7 +1998,7 @@ protected: size_type max_size() const { - return _S_min_len[_Rope_constants::_S_max_rope_depth - 1] - 1; + return _S_min_len[int(_Rope_constants::_S_max_rope_depth) - 1] - 1; // Guarantees that the result can be sufficirntly // balanced. Longer ropes will probably still work, // but it's harder to make guarantees. diff --git a/contrib/gcc-4.0/libstdc++-v3/include/ext/ropeimpl.h b/contrib/gcc-4.0/libstdc++-v3/include/ext/ropeimpl.h index 51877699cb..dad7ceef58 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/ext/ropeimpl.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/ext/ropeimpl.h @@ -116,7 +116,7 @@ namespace __gnu_cxx _Rope_iterator_base<_CharT, _Alloc>:: _S_setcache(_Rope_iterator_base<_CharT, _Alloc>& __x) { - const _RopeRep* __path[_Rope_constants::_S_max_rope_depth + 1]; + const _RopeRep* __path[int(_Rope_constants::_S_max_rope_depth) + 1]; const _RopeRep* __curr_rope; int __curr_depth = -1; /* index into path */ size_t __curr_start_pos = 0; @@ -175,7 +175,7 @@ namespace __gnu_cxx // Copy last section of path into _M_path_end. { int __i = -1; - int __j = __curr_depth + 1 - _S_path_cache_len; + int __j = __curr_depth + 1 - int(_S_path_cache_len); if (__j < 0) __j = 0; while (__j <= __curr_depth) @@ -236,10 +236,10 @@ namespace __gnu_cxx while (_Rope_constants::_S_concat == __current_node->_M_tag) { ++__current_index; - if (_S_path_cache_len == __current_index) + if (int(_S_path_cache_len) == __current_index) { int __i; - for (__i = 0; __i < _S_path_cache_len-1; __i++) + for (__i = 0; __i < int(_S_path_cache_len) - 1; __i++) __x._M_path_end[__i] = __x._M_path_end[__i+1]; --__current_index; } @@ -500,8 +500,9 @@ namespace __gnu_cxx get_allocator()); size_t __depth = __result->_M_depth; - if (__depth > 20 && (__result->_M_size < 1000 - || __depth > _Rope_constants::_S_max_rope_depth)) + if (__depth > 20 + && (__result->_M_size < 1000 + || __depth > size_t(_Rope_constants::_S_max_rope_depth))) { _RopeRep* __balanced; @@ -540,7 +541,7 @@ namespace __gnu_cxx return __STL_ROPE_FROM_UNOWNED_CHAR_PTR(__s, __slen, __r->get_allocator()); if (_Rope_constants::_S_leaf == __r->_M_tag - && __r->_M_size + __slen <= _S_copy_max) + && __r->_M_size + __slen <= size_t(_S_copy_max)) { __result = _S_leaf_concat_char_iter((_RopeLeaf*)__r, __s, __slen); return __result; @@ -551,7 +552,7 @@ namespace __gnu_cxx { _RopeLeaf* __right = (_RopeLeaf* )(((_RopeConcatenation* )__r)->_M_right); - if (__right->_M_size + __slen <= _S_copy_max) + if (__right->_M_size + __slen <= size_t(_S_copy_max)) { _RopeRep* __left = ((_RopeConcatenation*)__r)->_M_left; _RopeRep* __nright = @@ -603,7 +604,7 @@ namespace __gnu_cxx __r->_M_ref_count = 2; // One more than before return __r; } - if (__orig_size + __slen <= _S_copy_max + if (__orig_size + __slen <= size_t(_S_copy_max) && _Rope_constants::_S_leaf == __r->_M_tag) { __result = _S_destr_leaf_concat_char_iter((_RopeLeaf*)__r, __s, @@ -615,7 +616,7 @@ namespace __gnu_cxx _RopeLeaf* __right = (_RopeLeaf*)(((_RopeConcatenation*) __r)->_M_right); if (_Rope_constants::_S_leaf == __right->_M_tag - && __right->_M_size + __slen <= _S_copy_max) + && __right->_M_size + __slen <= size_t(_S_copy_max)) { _RopeRep* __new_right = _S_destr_leaf_concat_char_iter(__right, __s, __slen); @@ -668,7 +669,7 @@ namespace __gnu_cxx { if (_Rope_constants::_S_leaf == __left->_M_tag) { - if (__right->_M_size + __left->_M_size <= _S_copy_max) + if (__right->_M_size + __left->_M_size <= size_t(_S_copy_max)) return _S_leaf_concat_char_iter((_RopeLeaf*)__left, ((_RopeLeaf*)__right)->_M_data, __right->_M_size); @@ -679,7 +680,8 @@ namespace __gnu_cxx { _RopeLeaf* __leftright = (_RopeLeaf*)(((_RopeConcatenation*)__left)->_M_right); - if (__leftright->_M_size + __right->_M_size <= _S_copy_max) + if (__leftright->_M_size + + __right->_M_size <= size_t(_S_copy_max)) { _RopeRep* __leftleft = ((_RopeConcatenation*)__left)->_M_left; _RopeRep* __rest = _S_leaf_concat_char_iter(__leftright, @@ -1184,7 +1186,7 @@ namespace __gnu_cxx template const unsigned long rope<_CharT, _Alloc>:: - _S_min_len[_Rope_constants::_S_max_rope_depth + 1] = { + _S_min_len[int(_Rope_constants::_S_max_rope_depth) + 1] = { /* 0 */1, /* 1 */2, /* 2 */3, /* 3 */5, /* 4 */8, /* 5 */13, /* 6 */21, /* 7 */34, /* 8 */55, /* 9 */89, /* 10 */144, /* 11 */233, /* 12 */377, /* 13 */610, /* 14 */987, /* 15 */1597, /* 16 */2584, /* 17 */4181, @@ -1203,7 +1205,7 @@ namespace __gnu_cxx rope<_CharT, _Alloc>:: _S_balance(_RopeRep* __r) { - _RopeRep* __forest[_Rope_constants::_S_max_rope_depth + 1]; + _RopeRep* __forest[int(_Rope_constants::_S_max_rope_depth) + 1]; _RopeRep* __result = 0; int __i; // Invariant: @@ -1212,12 +1214,12 @@ namespace __gnu_cxx // __forest[__i]._M_depth = __i // References from forest are included in refcount. - for (__i = 0; __i <= _Rope_constants::_S_max_rope_depth; ++__i) + for (__i = 0; __i <= int(_Rope_constants::_S_max_rope_depth); ++__i) __forest[__i] = 0; try { _S_add_to_forest(__r, __forest); - for (__i = 0; __i <= _Rope_constants::_S_max_rope_depth; ++__i) + for (__i = 0; __i <= int(_Rope_constants::_S_max_rope_depth); ++__i) if (0 != __forest[__i]) { #ifndef __GC @@ -1232,12 +1234,12 @@ namespace __gnu_cxx } catch(...) { - for(__i = 0; __i <= _Rope_constants::_S_max_rope_depth; __i++) + for(__i = 0; __i <= int(_Rope_constants::_S_max_rope_depth); __i++) _S_unref(__forest[__i]); __throw_exception_again; } - if (__result->_M_depth > _Rope_constants::_S_max_rope_depth) + if (__result->_M_depth > int(_Rope_constants::_S_max_rope_depth)) __throw_length_error(__N("rope::_S_balance")); return(__result); } @@ -1305,7 +1307,7 @@ namespace __gnu_cxx __forest[__i]->_M_unref_nonnil(); __forest[__i] = 0; } - if (__i == _Rope_constants::_S_max_rope_depth + if (__i == int(_Rope_constants::_S_max_rope_depth) || __insertee->_M_size < _S_min_len[__i+1]) { __forest[__i] = __insertee; diff --git a/contrib/gcc-4.0/libstdc++-v3/include/std/std_bitset.h b/contrib/gcc-4.0/libstdc++-v3/include/std/std_bitset.h index dc677786a2..76be09d821 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/std/std_bitset.h +++ b/contrib/gcc-4.0/libstdc++-v3/include/std/std_bitset.h @@ -1,6 +1,6 @@ // -*- C++ -*- -// Copyright (C) 2001, 2002, 2003, 2004 Free Software Foundation, Inc. +// Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free // software; you can redistribute it and/or modify it under the @@ -751,7 +751,7 @@ namespace _GLIBCXX_STD */ template explicit - bitset(const basic_string<_CharT, _Traits, _Alloc>& __s, + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __position = 0) : _Base() { @@ -759,7 +759,7 @@ namespace _GLIBCXX_STD __throw_out_of_range(__N("bitset::bitset initial position " "not valid")); _M_copy_from_string(__s, __position, - basic_string<_CharT, _Traits, _Alloc>::npos); + std::basic_string<_CharT, _Traits, _Alloc>::npos); } /** @@ -772,7 +772,7 @@ namespace _GLIBCXX_STD * which is neither '0' nor '1'. */ template - bitset(const basic_string<_CharT, _Traits, _Alloc>& __s, + bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __position, size_t __n) : _Base() { @@ -1014,10 +1014,10 @@ namespace _GLIBCXX_STD * an example). */ template - basic_string<_CharT, _Traits, _Alloc> + std::basic_string<_CharT, _Traits, _Alloc> to_string() const { - basic_string<_CharT, _Traits, _Alloc> __result; + std::basic_string<_CharT, _Traits, _Alloc> __result; _M_copy_to_string(__result); return __result; } @@ -1025,28 +1025,36 @@ namespace _GLIBCXX_STD // _GLIBCXX_RESOLVE_LIB_DEFECTS // 434. bitset::to_string() hard to use. template - basic_string<_CharT, _Traits, allocator<_CharT> > + std::basic_string<_CharT, _Traits, std::allocator<_CharT> > to_string() const - { return to_string<_CharT, _Traits, allocator<_CharT> >(); } + { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); } template - basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > + std::basic_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> > to_string() const - { return to_string<_CharT, char_traits<_CharT>, allocator<_CharT> >(); } + { + return to_string<_CharT, std::char_traits<_CharT>, + std::allocator<_CharT> >(); + } - basic_string, allocator > + std::basic_string, std::allocator > to_string() const - { return to_string, allocator >(); } + { + return to_string, + std::allocator >(); + } // Helper functions for string operations. template void - _M_copy_from_string(const basic_string<_CharT, _Traits, _Alloc>& __s, + _M_copy_from_string(const std::basic_string<_CharT, + _Traits, _Alloc>& __s, size_t, size_t); template void - _M_copy_to_string(basic_string<_CharT, _Traits, _Alloc>&) const; + _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&) const; /// Returns the number of bits which are set. size_t @@ -1136,7 +1144,7 @@ namespace _GLIBCXX_STD template template void - bitset<_Nb>::_M_copy_from_string(const basic_string<_CharT, _Traits, + bitset<_Nb>::_M_copy_from_string(const std::basic_string<_CharT, _Traits, _Alloc>& __s, size_t __pos, size_t __n) { reset(); @@ -1159,7 +1167,7 @@ namespace _GLIBCXX_STD template template void - bitset<_Nb>::_M_copy_to_string(basic_string<_CharT, _Traits, + bitset<_Nb>::_M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s) const { __s.assign(_Nb, '0'); @@ -1216,15 +1224,15 @@ namespace _GLIBCXX_STD * hold. */ template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) + std::basic_istream<_CharT, _Traits>& + operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x) { typedef typename _Traits::char_type char_type; - basic_string<_CharT, _Traits> __tmp; + std::basic_string<_CharT, _Traits> __tmp; __tmp.reserve(_Nb); - ios_base::iostate __state = ios_base::goodbit; - typename basic_istream<_CharT, _Traits>::sentry __sentry(__is); + std::ios_base::iostate __state = std::ios_base::goodbit; + typename std::basic_istream<_CharT, _Traits>::sentry __sentry(__is); if (__sentry) { try @@ -1241,7 +1249,7 @@ namespace _GLIBCXX_STD typename _Traits::int_type __c1 = __buf->sbumpc(); if (_Traits::eq_int_type(__c1, __eof)) { - __state |= ios_base::eofbit; + __state |= std::ios_base::eofbit; break; } else @@ -1254,18 +1262,18 @@ namespace _GLIBCXX_STD else if (_Traits::eq_int_type(__buf->sputbackc(__c2), __eof)) { - __state |= ios_base::failbit; + __state |= std::ios_base::failbit; break; } } } } catch(...) - { __is._M_setstate(ios_base::badbit); } + { __is._M_setstate(std::ios_base::badbit); } } if (__tmp.empty() && _Nb) - __state |= ios_base::failbit; + __state |= std::ios_base::failbit; else __x._M_copy_from_string(__tmp, static_cast(0), _Nb); if (__state) @@ -1274,10 +1282,11 @@ namespace _GLIBCXX_STD } template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Nb>& __x) + std::basic_ostream<_CharT, _Traits>& + operator<<(std::basic_ostream<_CharT, _Traits>& __os, + const bitset<_Nb>& __x) { - basic_string<_CharT, _Traits> __tmp; + std::basic_string<_CharT, _Traits> __tmp; __x._M_copy_to_string(__tmp); return __os << __tmp; } diff --git a/contrib/gcc-4.0/libstdc++-v3/include/tr1/type_traits b/contrib/gcc-4.0/libstdc++-v3/include/tr1/type_traits index 55f585f9f4..176a4c3340 100644 --- a/contrib/gcc-4.0/libstdc++-v3/include/tr1/type_traits +++ b/contrib/gcc-4.0/libstdc++-v3/include/tr1/type_traits @@ -366,14 +366,11 @@ namespace tr1 template struct has_trivial_copy - : public integral_constant::value - && !is_volatile<_Tp>::value)> { }; + : public integral_constant::value> { }; template struct has_trivial_assign - : public integral_constant::value - && !is_const<_Tp>::value - && !is_volatile<_Tp>::value)> { }; + : public integral_constant::value> { }; template struct has_trivial_destructor @@ -385,14 +382,11 @@ namespace tr1 template struct has_nothrow_copy - : public integral_constant::value - && !is_volatile<_Tp>::value)> { }; + : public integral_constant::value> { }; template struct has_nothrow_assign - : public integral_constant::value - && !is_const<_Tp>::value - && !is_volatile<_Tp>::value)> { }; + : public integral_constant::value> { }; template struct has_virtual_destructor @@ -507,7 +501,8 @@ namespace tr1 }; template::value || is_array<_To>::value + bool = (is_void<_From>::value || is_void<_To>::value + || is_function<_To>::value || is_array<_To>::value // This special case is here only to avoid warnings. || (is_floating_point::type>::value @@ -521,7 +516,9 @@ namespace tr1 template struct __is_convertible_helper<_From, _To, true> - { static const bool __value = __is_int_or_cref<_To>::__value; }; + { static const bool __value = (is_void<_To>::value + || (__is_int_or_cref<_To>::__value + && !is_void<_From>::value)); }; template struct is_convertible diff --git a/contrib/gcc-4.0/libstdc++-v3/libmath/stubs.c b/contrib/gcc-4.0/libstdc++-v3/libmath/stubs.c index 797b2017fb..bbbe0fe3d1 100644 --- a/contrib/gcc-4.0/libstdc++-v3/libmath/stubs.c +++ b/contrib/gcc-4.0/libstdc++-v3/libmath/stubs.c @@ -34,6 +34,23 @@ we use the crude approximation. We'll do better later. */ +#ifndef HAVE_FABSF +float +fabsf(float x) +{ + return (float) fabs(x); +} +#endif + +#ifndef HAVE_FABSL +long double +fabsl(long double x) +{ + return fabs((double) x); +} +#endif + + #ifndef HAVE_ACOSF float acosf(float x) diff --git a/contrib/gcc-4.0/libstdc++-v3/src/compatibility.cc b/contrib/gcc-4.0/libstdc++-v3/src/compatibility.cc new file mode 100644 index 0000000000..1deb56c3f3 --- /dev/null +++ b/contrib/gcc-4.0/libstdc++-v3/src/compatibility.cc @@ -0,0 +1,363 @@ +// Compatibility symbols for previous versions -*- C++ -*- + +// Copyright (C) 2005 +// Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library 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, or (at your option) +// any later version. + +// This library 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 library; see the file COPYING. If not, write to the Free +// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +#include + +#if defined(_GLIBCXX_SYMVER) && defined(PIC) +#define istreambuf_iterator istreambuf_iteratorXX +#define basic_fstream basic_fstreamXX +#define basic_ifstream basic_ifstreamXX +#define basic_ofstream basic_ofstreamXX +#define _M_copy(a, b, c) _M_copyXX(a, b, c) +#define _M_move(a, b, c) _M_moveXX(a, b, c) +#define _M_assign(a, b, c) _M_assignXX(a, b, c) +#define _M_disjunct(a) _M_disjunctXX(a) +#define _M_check_length(a, b, c) _M_check_lengthXX(a, b, c) +#define _M_set_length_and_sharable(a) _M_set_length_and_sharableXX(a) +#define ignore ignoreXX +#define eq eqXX +#endif + +#include +#include +#include +#include + +namespace std +{ + // std::istream ignore explicit specializations. + + template<> + basic_istream& + basic_istream:: + ignore(streamsize __n) + { + if (__n == 1) + return ignore(); + + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb && __n > 0) + { + ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + // See comment in istream.tcc. + bool __large_ignore = false; + while (true) + { + while (_M_gcount < __n + && !traits_type::eq_int_type(__c, __eof)) + { + streamsize __size = std::min(streamsize(__sb->egptr() + - __sb->gptr()), + streamsize(__n - _M_gcount)); + if (__size > 1) + { + __sb->gbump(__size); + _M_gcount += __size; + __c = __sb->sgetc(); + } + else + { + ++_M_gcount; + __c = __sb->snextc(); + } + } + if (__n == numeric_limits::max() + && !traits_type::eq_int_type(__c, __eof)) + { + _M_gcount = numeric_limits::min(); + __large_ignore = true; + } + else + break; + } + + if (__large_ignore) + _M_gcount = numeric_limits::max(); + + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + +#ifdef _GLIBCXX_USE_WCHAR_T + template<> + basic_istream& + basic_istream:: + ignore(streamsize __n) + { + if (__n == 1) + return ignore(); + + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb && __n > 0) + { + ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + bool __large_ignore = false; + while (true) + { + while (_M_gcount < __n + && !traits_type::eq_int_type(__c, __eof)) + { + streamsize __size = std::min(streamsize(__sb->egptr() + - __sb->gptr()), + streamsize(__n - _M_gcount)); + if (__size > 1) + { + __sb->gbump(__size); + _M_gcount += __size; + __c = __sb->sgetc(); + } + else + { + ++_M_gcount; + __c = __sb->snextc(); + } + } + if (__n == numeric_limits::max() + && !traits_type::eq_int_type(__c, __eof)) + { + _M_gcount = numeric_limits::min(); + __large_ignore = true; + } + else + break; + } + + if (__large_ignore) + _M_gcount = numeric_limits::max(); + + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } +#endif +} + +// NB: These symbols renames should go into the shared library only, +// and only those shared libraries that support versioning. +#if defined(_GLIBCXX_SYMVER) && defined(PIC) + +/* gcc-3.4.4 +_ZNSt19istreambuf_iteratorIcSt11char_traitsIcEEppEv +_ZNSt19istreambuf_iteratorIwSt11char_traitsIwEEppEv + */ +namespace std +{ + template + istreambuf_iterator& + istreambuf_iterator::operator++(); + +#ifdef _GLIBCXX_USE_WCHAR_T + template + istreambuf_iterator& + istreambuf_iterator::operator++(); +#endif +} // namespace std + +/* gcc-4.0.0 +_ZNSs4_Rep26_M_set_length_and_sharableEj +_ZNSs7_M_copyEPcPKcj +_ZNSs7_M_moveEPcPKcj +_ZNSs9_M_assignEPcjc +_ZNKSs11_M_disjunctEPKc +_ZNKSs15_M_check_lengthEjjPKc +_ZNSbIwSt11char_traitsIwESaIwEE4_Rep26_M_set_length_and_sharableEj +_ZNSbIwSt11char_traitsIwESaIwEE7_M_copyEPwPKwj +_ZNSbIwSt11char_traitsIwESaIwEE7_M_moveEPwPKwj +_ZNSbIwSt11char_traitsIwESaIwEE9_M_assignEPwjw +_ZNKSbIwSt11char_traitsIwESaIwEE11_M_disjunctEPKw +_ZNKSbIwSt11char_traitsIwESaIwEE15_M_check_lengthEjjPKc + +_ZNKSt13basic_fstreamIcSt11char_traitsIcEE7is_openEv +_ZNKSt13basic_fstreamIwSt11char_traitsIwEE7is_openEv +_ZNKSt14basic_ifstreamIcSt11char_traitsIcEE7is_openEv +_ZNKSt14basic_ifstreamIwSt11char_traitsIwEE7is_openEv +_ZNKSt14basic_ofstreamIcSt11char_traitsIcEE7is_openEv +_ZNKSt14basic_ofstreamIwSt11char_traitsIwEE7is_openEv + +_ZNSi6ignoreEi +_ZNSi6ignoreEv +_ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreEi +_ZNSt13basic_istreamIwSt11char_traitsIwEE6ignoreEv + +_ZNSt11char_traitsIcE2eqERKcS2_ +_ZNSt11char_traitsIwE2eqERKwS2_ + */ +namespace std +{ + // std::char_traits is explicitly specialized + bool (* __p1)(const char&, const char&) = &char_traits::eq; + + // std::string + template + void + basic_string::_M_copy(char*, const char*, size_t); + + template + void + basic_string::_M_move(char*, const char*, size_t); + + template + void + basic_string::_M_assign(char*, size_t, char); + + template + bool + basic_string::_M_disjunct(const char*) const; + + template + void + basic_string::_M_check_length(size_t, size_t, const char*) const; + + template + void + basic_string::_Rep::_M_set_length_and_sharable(size_t); + + + // std::istream + template + basic_istream& + basic_istream::ignore(); + + template + bool + basic_fstream::is_open() const; + + template + bool + basic_ifstream::is_open() const; + + template + bool + basic_ofstream::is_open() const; + +#ifdef _GLIBCXX_USE_WCHAR_T + bool (* __p2)(const wchar_t&, const wchar_t&) = &char_traits::eq; + + // std::wstring + template + void + basic_string::_M_copy(wchar_t*, const wchar_t*, size_t); + + template + void + basic_string::_M_move(wchar_t*, const wchar_t*, size_t); + + template + void + basic_string::_M_assign(wchar_t*, size_t, wchar_t); + + template + bool + basic_string::_M_disjunct(const wchar_t*) const; + + template + void + basic_string::_M_check_length(size_t, size_t, + const char*) const; + + template + void + basic_string::_Rep::_M_set_length_and_sharable(size_t); + + template + basic_istream& + basic_istream::ignore(); + + template + bool + basic_fstream::is_open() const; + + template + bool + basic_ifstream::is_open() const; + + template + bool + basic_ofstream::is_open() const; +#endif +} + +// The rename syntax for default exported names is +// asm (".symver name1,exportedname@GLIBCXX_3.4") +// asm (".symver name2,exportedname@@GLIBCXX_3.4.5") +// In the future, GLIBCXX_ABI > 6 should remove all uses of +// _GLIBCXX_*_SYMVER macros in this file. + +#define _GLIBCXX_3_4_SYMVER(XXname, name) \ + extern "C" void \ + _X##name() \ + __attribute__ ((alias(#XXname))); \ + asm (".symver " "_X" #name "," #name "@GLIBCXX_3.4"); + +#define _GLIBCXX_3_4_5_SYMVER(XXname, name) \ + extern "C" void \ + _Y##name() \ + __attribute__ ((alias(#XXname))); \ + asm (".symver " "_Y" #name "," #name "@@GLIBCXX_3.4.5"); + +#define _GLIBCXX_ASM_SYMVER(cur, old, version) \ + asm (".symver " #cur "," #old "@@" #version); + +#define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_SYMVER +#include +#undef _GLIBCXX_APPLY_SYMVER + +#define _GLIBCXX_APPLY_SYMVER _GLIBCXX_3_4_5_SYMVER +#include +#undef _GLIBCXX_APPLY_SYMVER + +#endif diff --git a/contrib/gcc-4.0/libstdc++-v3/src/istream.cc b/contrib/gcc-4.0/libstdc++-v3/src/istream.cc index 2ecd948585..e8da16ce93 100644 --- a/contrib/gcc-4.0/libstdc++-v3/src/istream.cc +++ b/contrib/gcc-4.0/libstdc++-v3/src/istream.cc @@ -108,71 +108,6 @@ namespace std template<> basic_istream& basic_istream:: - ignore(streamsize __n) - { - if (__n == 1) - return ignore(); - - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb && __n > 0) - { - ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); - try - { - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - int_type __c = __sb->sgetc(); - - // See comment in istream.tcc. - bool __large_ignore = false; - while (true) - { - while (_M_gcount < __n - && !traits_type::eq_int_type(__c, __eof)) - { - streamsize __size = std::min(streamsize(__sb->egptr() - - __sb->gptr()), - streamsize(__n - _M_gcount)); - if (__size > 1) - { - __sb->gbump(__size); - _M_gcount += __size; - __c = __sb->sgetc(); - } - else - { - ++_M_gcount; - __c = __sb->snextc(); - } - } - if (__n == numeric_limits::max() - && !traits_type::eq_int_type(__c, __eof)) - { - _M_gcount = numeric_limits::min(); - __large_ignore = true; - } - else - break; - } - - if (__large_ignore) - _M_gcount = numeric_limits::max(); - - if (traits_type::eq_int_type(__c, __eof)) - __err |= ios_base::eofbit; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template<> - basic_istream& - basic_istream:: ignore(streamsize __n, int_type __delim) { if (traits_type::eq_int_type(__delim, traits_type::eof())) @@ -402,70 +337,6 @@ namespace std template<> basic_istream& basic_istream:: - ignore(streamsize __n) - { - if (__n == 1) - return ignore(); - - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb && __n > 0) - { - ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); - try - { - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - int_type __c = __sb->sgetc(); - - bool __large_ignore = false; - while (true) - { - while (_M_gcount < __n - && !traits_type::eq_int_type(__c, __eof)) - { - streamsize __size = std::min(streamsize(__sb->egptr() - - __sb->gptr()), - streamsize(__n - _M_gcount)); - if (__size > 1) - { - __sb->gbump(__size); - _M_gcount += __size; - __c = __sb->sgetc(); - } - else - { - ++_M_gcount; - __c = __sb->snextc(); - } - } - if (__n == numeric_limits::max() - && !traits_type::eq_int_type(__c, __eof)) - { - _M_gcount = numeric_limits::min(); - __large_ignore = true; - } - else - break; - } - - if (__large_ignore) - _M_gcount = numeric_limits::max(); - - if (traits_type::eq_int_type(__c, __eof)) - __err |= ios_base::eofbit; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template<> - basic_istream& - basic_istream:: ignore(streamsize __n, int_type __delim) { if (traits_type::eq_int_type(__delim, traits_type::eof())) -- 2.11.4.GIT