diff --git a/WORKSPACE b/WORKSPACE index bcf954ef69..b34751bfbc 100644 --- a/WORKSPACE +++ b/WORKSPACE @@ -152,10 +152,79 @@ new_git_repository( load("@pybind11_bazel//:python_configure.bzl", "python_configure") python_configure(name = "local_config_python", python_version = "3") +# pcre source code repository +http_archive( + name = "pcre2", + build_file_content = """\ +cc_library( + name = 'pcre', + srcs = glob(['pcre32*.c']), + hdrs = ["pcre_chartables.c"] + glob(['*.h', 'pcre_*.c']), + copts = [ + "-DLINK_SIZE=4", + "-DNEWLINE", + "-DPOSIX_MALLOC_THRESHOLD=10", + "-DPARENS_NEST_LIMIT=250", + "-DMATCH_LIMIT=10000000", + "-DMATCH_LIMIT_RECURSION=10000000", + "-DMAX_NAME_SIZE=32", + "-DMAX_NAME_COUNT=10000", + ], + includes = ['.'], + visibility = ['//visibility:public'], +) + +genrule( + name = "chartables", + srcs = ["pcre_chartables.c.dist"], + outs = ["pcre_chartables.c"], + cmd = "cp $< $@", +) +""", + strip_prefix = "pcre-8.43", + urls = [ + "https://mirror.bazel.build/ftp.pcre.org/pub/pcre/pcre-8.43.tar.gz", + "https://ftp.pcre.org/pub/pcre/pcre-8.43.tar.gz", + ], + sha256 = "0b8e7465dc5e98c757cc3650a20a7843ee4c3edf50aaf60bb33fd879690d2c73", +) + +# pcre source code repository +http_archive( + name = "pcre2", + build_file = "//bazel:pcre2.BUILD", + patches = ["//bazel:pcre2.patch"], + strip_prefix = "pcre2-10.42", + urls = [ + "https://github.com/PCRE2Project/pcre2/releases/download/pcre2-10.42/pcre2-10.42.tar.gz", + ], + sha256 = "c33b418e3b936ee3153de2c61cc638e7e4fe3156022a5c77d0711bcbb9d64f1f", +) + +http_archive( + name = "rules_m4", + sha256 = "b0309baacfd1b736ed82dc2bb27b0ec38455a31a3d5d20f8d05e831ebeef1a8e", + urls = ["https://github.com/jmillikin/rules_m4/releases/download/v0.2.2/rules_m4-v0.2.2.tar.xz"], +) + +load("@rules_m4//m4:m4.bzl", "m4_register_toolchains") +m4_register_toolchains() + +http_archive( + name = "rules_bison", + urls = ["https://github.com/jmillikin/rules_bison/releases/download/v0.2.1/rules_bison-v0.2.1.tar.xz"], + sha256 = "9577455967bfcf52f9167274063ebb74696cb0fd576e4226e14ed23c5d67a693", +) + +load("@rules_bison//bison:bison.bzl", "bison_register_toolchains") +bison_register_toolchains() + new_git_repository( name = "swig", build_file = "//bazel:swig.BUILD", - tag = "v4.0.2", + patches = ["//bazel:swig.patch"], + patch_args = ["-p1"], + tag = "v4.1.1", remote = "https://github.com/swig/swig.git", ) diff --git a/bazel/BUILD.bazel b/bazel/BUILD.bazel index 65e13b761a..9e517a90ed 100644 --- a/bazel/BUILD.bazel +++ b/bazel/BUILD.bazel @@ -14,10 +14,13 @@ exports_files([ "gtest.BUILD", "glpk.BUILD", + "pcre2.BUILD", + "pcre2.patch", "re2.patch", - "swig.BUILD", "scip.BUILD", "scip.patch", + "swig.BUILD", + "swig.patch", "bliss.BUILD", "bliss-0.73.patch", # "zlib.BUILD", @@ -26,7 +29,7 @@ exports_files([ ]) sh_binary( - name = "mkdir_wrapper", - srcs = ["mkdir_wrapper.sh"], + name = "run_swig", + srcs = ["run_swig.sh"], visibility = ["//visibility:public"], ) diff --git a/bazel/pcre2.BUILD b/bazel/pcre2.BUILD new file mode 100644 index 0000000000..1bd314efc6 --- /dev/null +++ b/bazel/pcre2.BUILD @@ -0,0 +1,72 @@ +load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test") +load("@bazel_skylib//rules:copy_file.bzl", "copy_file") + +copy_file( + name = "config_h_generic", + src = "src/config.h.generic", + out = "src/config.h", +) + +copy_file( + name = "pcre2_h_generic", + src = "src/pcre2.h.generic", + out = "src/pcre2.h", +) + +copy_file( + name = "pcre2_chartables_c", + src = "src/pcre2_chartables.c.dist", + out = "src/pcre2_chartables.c", +) + +cc_library( + name = "pcre2", + srcs = [ + "src/pcre2_auto_possess.c", + "src/pcre2_compile.c", + "src/pcre2_config.c", + "src/pcre2_context.c", + "src/pcre2_convert.c", + "src/pcre2_dfa_match.c", + "src/pcre2_error.c", + "src/pcre2_extuni.c", + "src/pcre2_find_bracket.c", + "src/pcre2_maketables.c", + "src/pcre2_match.c", + "src/pcre2_match_data.c", + "src/pcre2_newline.c", + "src/pcre2_ord2utf.c", + "src/pcre2_pattern_info.c", + "src/pcre2_script_run.c", + "src/pcre2_serialize.c", + "src/pcre2_string_utils.c", + "src/pcre2_study.c", + "src/pcre2_substitute.c", + "src/pcre2_substring.c", + "src/pcre2_tables.c", + "src/pcre2_ucd.c", + "src/pcre2_ucptables.c", + "src/pcre2_valid_utf.c", + "src/pcre2_xclass.c", + ":pcre2_chartables_c", + ], + hdrs = glob(["src/*.h"]) + [ + ":config_h_generic", + ":pcre2_h_generic", + ], + defines = [ + "HAVE_CONFIG_H", + "PCRE2_CODE_UNIT_WIDTH=8", + "PCRE2_STATIC", + ], + includes = ["src"], + strip_include_prefix = "src", + visibility = ["//visibility:public"], +) + +cc_binary( + name = "pcre2demo", + srcs = ["src/pcre2demo.c"], + visibility = ["//visibility:public"], + deps = [":pcre2"], +) diff --git a/bazel/pcre2.patch b/bazel/pcre2.patch new file mode 100644 index 0000000000..0eab2aeb6d --- /dev/null +++ b/bazel/pcre2.patch @@ -0,0 +1,13 @@ +--- /dev/null 2022-12-31 10:33:36 ++++ WORKSPACE 2022-12-31 10:31:42 +@@ -0,0 +1,10 @@ ++load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository", "new_git_repository") ++ ++# Bazel Skylib rules. ++git_repository( ++ name = "bazel_skylib", ++ tag = "1.2.1", ++ remote = "https://github.com/bazelbuild/bazel-skylib.git", ++) ++load("@bazel_skylib//:workspace.bzl", "bazel_skylib_workspace") ++bazel_skylib_workspace() diff --git a/bazel/mkdir_wrapper.sh b/bazel/run_swig.sh similarity index 89% rename from bazel/mkdir_wrapper.sh rename to bazel/run_swig.sh index 66584729b3..2b871a16e8 100755 --- a/bazel/mkdir_wrapper.sh +++ b/bazel/run_swig.sh @@ -19,9 +19,4 @@ # # This is to work around https://github.com/bazelbuild/bazel/issues/6393 -readonly directory="$1" -readonly command="$2" -shift 2 - -mkdir -p "${directory}" -exec "${command}" "$@" \ No newline at end of file +exec swig "$@" \ No newline at end of file diff --git a/bazel/swig.BUILD b/bazel/swig.BUILD index c953d1e039..3d669a1b99 100644 --- a/bazel/swig.BUILD +++ b/bazel/swig.BUILD @@ -5,69 +5,94 @@ exports_files(["LICENSE"]) cc_binary( name = "swig", srcs = [ - "Source/CParse/cparse.h", - "Source/CParse/cscanner.c", - "Source/CParse/parser.c", - "Source/CParse/parser.h", - "Source/CParse/templ.c", - "Source/CParse/util.c", - "Source/DOH/base.c", - "Source/DOH/doh.h", + "Source/Include/swigconfig.h", "Source/DOH/dohint.h", - "Source/DOH/file.c", - "Source/DOH/fio.c", - "Source/DOH/hash.c", + "Source/DOH/doh.h", + "Source/Swig/swigfile.h", + "Source/Swig/swigtree.h", + "Source/Swig/swig.h", + "Source/Swig/swigparm.h", + "Source/Swig/swigwrap.h", + "Source/Swig/swigscan.h", + "Source/Swig/swigopt.h", + "Source/Include/swigwarn.h", + "Source/CParse/parser.h", + "Source/CParse/cparse.h", + "Source/Doxygen/doxycommands.h", + "Source/Doxygen/doxyentity.h", + "Source/Doxygen/javadoc.h", + "Source/Doxygen/doxytranslator.h", + "Source/Doxygen/doxyparser.h", + "Source/Doxygen/pydoc.h", + "Source/Modules/swigmod.h", + "Source/Preprocessor/preprocessor.h", "Source/DOH/list.c", "Source/DOH/memory.c", + "Source/DOH/base.c", "Source/DOH/string.c", + "Source/DOH/hash.c", + "Source/DOH/fio.c", "Source/DOH/void.c", - "Source/Include/swigconfig.h", - "Source/Include/swigwarn.h", - "Source/Modules/allocate.cxx", - "Source/Modules/browser.cxx", - "Source/Modules/contract.cxx", - "Source/Modules/directors.cxx", - "Source/Modules/emit.cxx", - "Source/Modules/lang.cxx", - "Source/Modules/main.cxx", - "Source/Modules/module.cxx", - "Source/Modules/nested.cxx", - "Source/Modules/overload.cxx", - "Source/Modules/python.cxx", - "Source/Modules/swigmain-lite.cxx", - "Source/Modules/swigmod.h", - "Source/Modules/typepass.cxx", - "Source/Modules/uffi.cxx", - "Source/Modules/utils.cxx", - "Source/Modules/xml.cxx", - "Source/Preprocessor/cpp.c", - "Source/Preprocessor/expr.c", - "Source/Preprocessor/preprocessor.h", - "Source/Swig/cwrap.c", - "Source/Swig/deprecate.c", - "Source/Swig/error.c", - "Source/Swig/extend.c", + "Source/DOH/file.c", + "Source/Swig/scanner.c", "Source/Swig/fragment.c", - "Source/Swig/getopt.c", - "Source/Swig/include.c", - "Source/Swig/misc.c", + "Source/Swig/typesys.c", "Source/Swig/naming.c", "Source/Swig/parms.c", - "Source/Swig/scanner.c", - "Source/Swig/stype.c", - "Source/Swig/swig.h", - "Source/Swig/swigfile.h", - "Source/Swig/swigopt.h", - "Source/Swig/swigparm.h", - "Source/Swig/swigscan.h", - "Source/Swig/swigtree.h", - "Source/Swig/swigwrap.h", - "Source/Swig/symbol.c", - "Source/Swig/tree.c", + "Source/Swig/deprecate.c", + "Source/Swig/extend.c", "Source/Swig/typemap.c", - "Source/Swig/typeobj.c", - "Source/Swig/typesys.c", + "Source/Swig/error.c", "Source/Swig/wrapfunc.c", + "Source/Swig/symbol.c", + "Source/Swig/stype.c", + "Source/Swig/cwrap.c", + "Source/Swig/include.c", + "Source/Swig/typeobj.c", + "Source/Swig/misc.c", + "Source/Swig/getopt.c", + "Source/Swig/tree.c", + "Source/CParse/templ.c", + "Source/CParse/util.c", + "Source/CParse/cscanner.c", + "Source/CParse/parser.c", + "Source/Preprocessor/cpp.c", + "Source/Preprocessor/expr.c", + "Source/Doxygen/doxytranslator.cxx", + "Source/Doxygen/javadoc.cxx", + "Source/Doxygen/doxyparser.cxx", + "Source/Doxygen/doxyentity.cxx", + "Source/Doxygen/pydoc.cxx", + "Source/Modules/nested.cxx", + "Source/Modules/python.cxx", + "Source/Modules/ruby.cxx", + "Source/Modules/main.cxx", + "Source/Modules/lang.cxx", + "Source/Modules/lua.cxx", + "Source/Modules/mzscheme.cxx", + "Source/Modules/tcl8.cxx", + "Source/Modules/xml.cxx", + "Source/Modules/javascript.cxx", + "Source/Modules/directors.cxx", + "Source/Modules/allocate.cxx", + "Source/Modules/interface.cxx", + "Source/Modules/java.cxx", + "Source/Modules/emit.cxx", + "Source/Modules/swigmain.cxx", + "Source/Modules/go.cxx", + "Source/Modules/csharp.cxx", + "Source/Modules/d.cxx", + "Source/Modules/typepass.cxx", + "Source/Modules/contract.cxx", + "Source/Modules/ocaml.cxx", + "Source/Modules/overload.cxx", + "Source/Modules/perl5.cxx", + "Source/Modules/r.cxx", + "Source/Modules/octave.cxx", + "Source/Modules/utils.cxx", + "Source/Modules/guile.cxx", + "Source/Modules/scilab.cxx", + "Source/Modules/php.cxx", ], copts = ["$(STACK_FRAME_UNLIMITED)"] + select({ ":x64_windows_msvc": [], @@ -81,6 +106,7 @@ cc_binary( includes = [ "Source/CParse", "Source/DOH", + "Source/Doxygen", "Source/Include", "Source/Modules", "Source/Preprocessor", @@ -88,196 +114,18 @@ cc_binary( ], output_licenses = ["unencumbered"], visibility = ["//visibility:public"], - deps = ["@pcre"], + deps = ["@pcre2//:pcre2"], ) filegroup( name = "templates", - srcs = [ - "Lib/allkw.swg", - "Lib/attribute.i", - "Lib/carrays.i", - "Lib/cdata.i", - "Lib/cffi/cffi.swg", - "Lib/cmalloc.i", - "Lib/constraints.i", - "Lib/cpointer.i", - "Lib/cstring.i", - "Lib/cwstring.i", - "Lib/exception.i", - "Lib/intrusive_ptr.i", - "Lib/inttypes.i", - "Lib/linkruntime.c", - "Lib/math.i", - "Lib/pointer.i", - "Lib/python/argcargv.i", - "Lib/python/attribute.i", - "Lib/python/boost_shared_ptr.i", - "Lib/python/builtin.swg", - "Lib/python/carrays.i", - "Lib/python/ccomplex.i", - "Lib/python/cdata.i", - "Lib/python/cmalloc.i", - "Lib/python/cni.i", - "Lib/python/complex.i", - "Lib/python/cpointer.i", - "Lib/python/cstring.i", - "Lib/python/cwstring.i", - "Lib/python/defarg.swg", - "Lib/python/director.swg", - "Lib/python/embed.i", - "Lib/python/embed15.i", - "Lib/python/exception.i", - "Lib/python/factory.i", - "Lib/python/file.i", - "Lib/python/implicit.i", - "Lib/python/jstring.i", - "Lib/python/pyabc.i", - "Lib/python/pyapi.swg", - "Lib/python/pybackward.swg", - "Lib/python/pybuffer.i", - "Lib/python/pyclasses.swg", - "Lib/python/pycomplex.swg", - "Lib/python/pycontainer.swg", - "Lib/python/pydocs.swg", - "Lib/python/pyerrors.swg", - "Lib/python/pyfragments.swg", - "Lib/python/pyhead.swg", - "Lib/python/pyinit.swg", - "Lib/python/pyiterators.swg", - "Lib/python/pymacros.swg", - "Lib/python/pyname_compat.i", - "Lib/python/pyopers.swg", - "Lib/python/pyprimtypes.swg", - "Lib/python/pyrun.swg", - "Lib/python/pyruntime.swg", - "Lib/python/pystdcommon.swg", - "Lib/python/pystrings.swg", - "Lib/python/python.swg", - "Lib/python/pythonkw.swg", - "Lib/python/pythreads.swg", - "Lib/python/pytuplehlp.swg", - "Lib/python/pytypemaps.swg", - "Lib/python/pyuserdir.swg", - "Lib/python/pywstrings.swg", - "Lib/python/std_alloc.i", - "Lib/python/std_auto_ptr.i", - "Lib/python/std_basic_string.i", - "Lib/python/std_carray.i", - "Lib/python/std_char_traits.i", - "Lib/python/std_common.i", - "Lib/python/std_complex.i", - "Lib/python/std_container.i", - "Lib/python/std_deque.i", - "Lib/python/std_except.i", - "Lib/python/std_ios.i", - "Lib/python/std_iostream.i", - "Lib/python/std_list.i", - "Lib/python/std_map.i", - "Lib/python/std_multimap.i", - "Lib/python/std_multiset.i", - "Lib/python/std_pair.i", - "Lib/python/std_set.i", - "Lib/python/std_shared_ptr.i", - "Lib/python/std_sstream.i", - "Lib/python/std_streambuf.i", - "Lib/python/std_string.i", - "Lib/python/std_unordered_map.i", - "Lib/python/std_unordered_multimap.i", - "Lib/python/std_unordered_multiset.i", - "Lib/python/std_unordered_set.i", - "Lib/python/std_vector.i", - "Lib/python/std_vectora.i", - "Lib/python/std_wios.i", - "Lib/python/std_wiostream.i", - "Lib/python/std_wsstream.i", - "Lib/python/std_wstreambuf.i", - "Lib/python/std_wstring.i", - "Lib/python/stl.i", - "Lib/python/typemaps.i", - "Lib/python/wchar.i", - "Lib/runtime.swg", - "Lib/shared_ptr.i", - "Lib/std/_std_deque.i", - "Lib/std/std_alloc.i", - "Lib/std/std_basic_string.i", - "Lib/std/std_carray.swg", - "Lib/std/std_char_traits.i", - "Lib/std/std_common.i", - "Lib/std/std_container.i", - "Lib/std/std_deque.i", - "Lib/std/std_except.i", - "Lib/std/std_ios.i", - "Lib/std/std_iostream.i", - "Lib/std/std_list.i", - "Lib/std/std_map.i", - "Lib/std/std_multimap.i", - "Lib/std/std_multiset.i", - "Lib/std/std_pair.i", - "Lib/std/std_queue.i", - "Lib/std/std_set.i", - "Lib/std/std_sstream.i", - "Lib/std/std_stack.i", - "Lib/std/std_streambuf.i", - "Lib/std/std_string.i", - "Lib/std/std_unordered_map.i", - "Lib/std/std_unordered_multimap.i", - "Lib/std/std_unordered_multiset.i", - "Lib/std/std_unordered_set.i", - "Lib/std/std_vector.i", - "Lib/std/std_vectora.i", - "Lib/std/std_wios.i", - "Lib/std/std_wiostream.i", - "Lib/std/std_wsstream.i", - "Lib/std/std_wstreambuf.i", - "Lib/std/std_wstring.i", - "Lib/std_except.i", - "Lib/stdint.i", - "Lib/stl.i", - "Lib/swig.swg", - "Lib/swigarch.i", - "Lib/swigerrors.swg", - "Lib/swiginit.swg", - "Lib/swiglabels.swg", - "Lib/swigrun.i", - "Lib/swigrun.swg", - "Lib/swigwarn.swg", - "Lib/swigwarnings.swg", - "Lib/typemaps/attribute.swg", - "Lib/typemaps/carrays.swg", - "Lib/typemaps/cdata.swg", - "Lib/typemaps/cmalloc.swg", - "Lib/typemaps/cpointer.swg", - "Lib/typemaps/cstring.swg", - "Lib/typemaps/cstrings.swg", - "Lib/typemaps/cwstring.swg", - "Lib/typemaps/enumint.swg", - "Lib/typemaps/exception.swg", - "Lib/typemaps/factory.swg", - "Lib/typemaps/fragments.swg", - "Lib/typemaps/implicit.swg", - "Lib/typemaps/inoutlist.swg", - "Lib/typemaps/misctypes.swg", - "Lib/typemaps/primtypes.swg", - "Lib/typemaps/ptrtypes.swg", - "Lib/typemaps/std_except.swg", - "Lib/typemaps/std_string.swg", - "Lib/typemaps/std_strings.swg", - "Lib/typemaps/std_wstring.swg", - "Lib/typemaps/string.swg", - "Lib/typemaps/strings.swg", - "Lib/typemaps/swigmacros.swg", - "Lib/typemaps/swigobject.swg", - "Lib/typemaps/swigtype.swg", - "Lib/typemaps/swigtypemaps.swg", - "Lib/typemaps/traits.swg", - "Lib/typemaps/typemaps.swg", - "Lib/typemaps/valtypes.swg", - "Lib/typemaps/void.swg", - "Lib/typemaps/wstring.swg", - "Lib/wchar.i", - "Lib/windows.i", - ], + srcs = glob([ + 'Lib/*', + 'Lib/python/*', + 'Lib/std/*', + 'Lib/java/*', + 'Lib/typemaps/*' + ]), licenses = ["notice"], # simple notice license for Lib/ path = "Lib", visibility = ["//visibility:public"], @@ -291,7 +139,7 @@ genrule( "#define HAVE_PCRE\n" + "#define HAVE_POPEN\n" + "#define PACKAGE_BUGREPORT \"http://www.swig.org\"\n" + - "#define PACKAGE_VERSION \"3.0.12\"\n" + + "#define PACKAGE_VERSION \"4.1.1\"\n" + "#define STDC_HEADERS\n" + "#define SWIG_CXX \"bazel4lyfe\"\n" + "#define SWIG_LIB \"external/swig/Lib\"\n" + @@ -300,36 +148,6 @@ genrule( "EOF", ) -genrule( - name = "get_rid_of_stuff_we_dont_need_yet", - srcs = ["Source/Modules/swigmain.cxx"], - outs = ["Source/Modules/swigmain-lite.cxx"], - cmd = "sed -e '/swig_allegrocl/d'" + - " -e '/swig_cffi/d'" + - " -e '/swig_chicken/d'" + - " -e '/swig_clisp/d'" + - " -e '/swig_csharp/d'" + - " -e '/swig_d/d'" + - " -e '/swig_go/d'" + - " -e '/swig_guile/d'" + - " -e '/swig_java/d'" + - " -e '/swig_lua/d'" + - " -e '/swig_modula3/d'" + - " -e '/swig_mzscheme/d'" + - " -e '/swig_ocaml/d'" + - " -e '/swig_octave/d'" + - " -e '/swig_perl/d'" + - " -e '/swig_php/d'" + - " -e '/swig_pike/d'" + - " -e '/swig_r/d'" + - " -e '/swig_ruby/d'" + - " -e '/swig_scilab/d'" + - " -e '/swig_sexp/d'" + - " -e '/swig_tcl/d'" + - " -e '/swig_uffi/d'" + - " $< >$@", -) - config_setting( name = "x64_windows_msvc", values = {"cpu": "x64_windows_msvc"}, diff --git a/bazel/swig.patch b/bazel/swig.patch new file mode 100644 index 0000000000..66dc971349 --- /dev/null +++ b/bazel/swig.patch @@ -0,0 +1,13513 @@ +diff --git a/Source/CParse/parser.c b/Source/CParse/parser.c +new file mode 100644 +index 000000000..cf61d0bef +--- /dev/null ++++ b/Source/CParse/parser.c +@@ -0,0 +1,13107 @@ ++/* A Bison parser, made by GNU Bison 2.3. */ ++ ++/* Skeleton implementation for Bison's Yacc-like parsers in C ++ ++ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 ++ 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., 51 Franklin Street, Fifth Floor, ++ Boston, MA 02110-1301, USA. */ ++ ++/* As a special exception, you may create a larger work that contains ++ part or all of the Bison parser skeleton and distribute that work ++ under terms of your choice, so long as that work isn't itself a ++ parser generator using the skeleton or a modified version thereof ++ as a parser skeleton. Alternatively, if you modify or redistribute ++ the parser skeleton itself, you may (at your option) remove this ++ special exception, which will cause the skeleton and the resulting ++ Bison output files to be licensed under the GNU General Public ++ License without this special exception. ++ ++ This special exception was added by the Free Software Foundation in ++ version 2.2 of Bison. */ ++ ++/* C LALR(1) parser skeleton 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 ++ ++/* Bison version. */ ++#define YYBISON_VERSION "2.3" ++ ++/* 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 { ++ END = 0, ++ ID = 258, ++ HBLOCK = 259, ++ POUND = 260, ++ STRING = 261, ++ WSTRING = 262, ++ INCLUDE = 263, ++ IMPORT = 264, ++ INSERT = 265, ++ CHARCONST = 266, ++ WCHARCONST = 267, ++ NUM_INT = 268, ++ NUM_FLOAT = 269, ++ NUM_UNSIGNED = 270, ++ NUM_LONG = 271, ++ NUM_ULONG = 272, ++ NUM_LONGLONG = 273, ++ NUM_ULONGLONG = 274, ++ NUM_BOOL = 275, ++ TYPEDEF = 276, ++ TYPE_INT = 277, ++ TYPE_UNSIGNED = 278, ++ TYPE_SHORT = 279, ++ TYPE_LONG = 280, ++ TYPE_FLOAT = 281, ++ TYPE_DOUBLE = 282, ++ TYPE_CHAR = 283, ++ TYPE_WCHAR = 284, ++ TYPE_VOID = 285, ++ TYPE_SIGNED = 286, ++ TYPE_BOOL = 287, ++ TYPE_COMPLEX = 288, ++ TYPE_TYPEDEF = 289, ++ TYPE_RAW = 290, ++ TYPE_NON_ISO_INT8 = 291, ++ TYPE_NON_ISO_INT16 = 292, ++ TYPE_NON_ISO_INT32 = 293, ++ TYPE_NON_ISO_INT64 = 294, ++ LPAREN = 295, ++ RPAREN = 296, ++ COMMA = 297, ++ SEMI = 298, ++ EXTERN = 299, ++ INIT = 300, ++ LBRACE = 301, ++ RBRACE = 302, ++ PERIOD = 303, ++ ELLIPSIS = 304, ++ CONST_QUAL = 305, ++ VOLATILE = 306, ++ REGISTER = 307, ++ STRUCT = 308, ++ UNION = 309, ++ EQUAL = 310, ++ SIZEOF = 311, ++ MODULE = 312, ++ LBRACKET = 313, ++ RBRACKET = 314, ++ BEGINFILE = 315, ++ ENDOFFILE = 316, ++ ILLEGAL = 317, ++ CONSTANT = 318, ++ NAME = 319, ++ RENAME = 320, ++ NAMEWARN = 321, ++ EXTEND = 322, ++ PRAGMA = 323, ++ FEATURE = 324, ++ VARARGS = 325, ++ ENUM = 326, ++ CLASS = 327, ++ TYPENAME = 328, ++ PRIVATE = 329, ++ PUBLIC = 330, ++ PROTECTED = 331, ++ COLON = 332, ++ STATIC = 333, ++ VIRTUAL = 334, ++ FRIEND = 335, ++ THROW = 336, ++ CATCH = 337, ++ EXPLICIT = 338, ++ STATIC_ASSERT = 339, ++ CONSTEXPR = 340, ++ THREAD_LOCAL = 341, ++ DECLTYPE = 342, ++ AUTO = 343, ++ NOEXCEPT = 344, ++ OVERRIDE = 345, ++ FINAL = 346, ++ USING = 347, ++ NAMESPACE = 348, ++ NATIVE = 349, ++ INLINE = 350, ++ TYPEMAP = 351, ++ EXCEPT = 352, ++ ECHO = 353, ++ APPLY = 354, ++ CLEAR = 355, ++ SWIGTEMPLATE = 356, ++ FRAGMENT = 357, ++ WARN = 358, ++ LESSTHAN = 359, ++ GREATERTHAN = 360, ++ DELETE_KW = 361, ++ DEFAULT = 362, ++ LESSTHANOREQUALTO = 363, ++ GREATERTHANOREQUALTO = 364, ++ EQUALTO = 365, ++ NOTEQUALTO = 366, ++ LESSEQUALGREATER = 367, ++ ARROW = 368, ++ QUESTIONMARK = 369, ++ TYPES = 370, ++ PARMS = 371, ++ NONID = 372, ++ DSTAR = 373, ++ DCNOT = 374, ++ TEMPLATE = 375, ++ OPERATOR = 376, ++ CONVERSIONOPERATOR = 377, ++ PARSETYPE = 378, ++ PARSEPARM = 379, ++ PARSEPARMS = 380, ++ DOXYGENSTRING = 381, ++ DOXYGENPOSTSTRING = 382, ++ CAST = 383, ++ LOR = 384, ++ LAND = 385, ++ OR = 386, ++ XOR = 387, ++ AND = 388, ++ RSHIFT = 389, ++ LSHIFT = 390, ++ MINUS = 391, ++ PLUS = 392, ++ MODULO = 393, ++ SLASH = 394, ++ STAR = 395, ++ LNOT = 396, ++ NOT = 397, ++ UMINUS = 398, ++ DCOLON = 399 ++ }; ++#endif ++/* Tokens. */ ++#define END 0 ++#define ID 258 ++#define HBLOCK 259 ++#define POUND 260 ++#define STRING 261 ++#define WSTRING 262 ++#define INCLUDE 263 ++#define IMPORT 264 ++#define INSERT 265 ++#define CHARCONST 266 ++#define WCHARCONST 267 ++#define NUM_INT 268 ++#define NUM_FLOAT 269 ++#define NUM_UNSIGNED 270 ++#define NUM_LONG 271 ++#define NUM_ULONG 272 ++#define NUM_LONGLONG 273 ++#define NUM_ULONGLONG 274 ++#define NUM_BOOL 275 ++#define TYPEDEF 276 ++#define TYPE_INT 277 ++#define TYPE_UNSIGNED 278 ++#define TYPE_SHORT 279 ++#define TYPE_LONG 280 ++#define TYPE_FLOAT 281 ++#define TYPE_DOUBLE 282 ++#define TYPE_CHAR 283 ++#define TYPE_WCHAR 284 ++#define TYPE_VOID 285 ++#define TYPE_SIGNED 286 ++#define TYPE_BOOL 287 ++#define TYPE_COMPLEX 288 ++#define TYPE_TYPEDEF 289 ++#define TYPE_RAW 290 ++#define TYPE_NON_ISO_INT8 291 ++#define TYPE_NON_ISO_INT16 292 ++#define TYPE_NON_ISO_INT32 293 ++#define TYPE_NON_ISO_INT64 294 ++#define LPAREN 295 ++#define RPAREN 296 ++#define COMMA 297 ++#define SEMI 298 ++#define EXTERN 299 ++#define INIT 300 ++#define LBRACE 301 ++#define RBRACE 302 ++#define PERIOD 303 ++#define ELLIPSIS 304 ++#define CONST_QUAL 305 ++#define VOLATILE 306 ++#define REGISTER 307 ++#define STRUCT 308 ++#define UNION 309 ++#define EQUAL 310 ++#define SIZEOF 311 ++#define MODULE 312 ++#define LBRACKET 313 ++#define RBRACKET 314 ++#define BEGINFILE 315 ++#define ENDOFFILE 316 ++#define ILLEGAL 317 ++#define CONSTANT 318 ++#define NAME 319 ++#define RENAME 320 ++#define NAMEWARN 321 ++#define EXTEND 322 ++#define PRAGMA 323 ++#define FEATURE 324 ++#define VARARGS 325 ++#define ENUM 326 ++#define CLASS 327 ++#define TYPENAME 328 ++#define PRIVATE 329 ++#define PUBLIC 330 ++#define PROTECTED 331 ++#define COLON 332 ++#define STATIC 333 ++#define VIRTUAL 334 ++#define FRIEND 335 ++#define THROW 336 ++#define CATCH 337 ++#define EXPLICIT 338 ++#define STATIC_ASSERT 339 ++#define CONSTEXPR 340 ++#define THREAD_LOCAL 341 ++#define DECLTYPE 342 ++#define AUTO 343 ++#define NOEXCEPT 344 ++#define OVERRIDE 345 ++#define FINAL 346 ++#define USING 347 ++#define NAMESPACE 348 ++#define NATIVE 349 ++#define INLINE 350 ++#define TYPEMAP 351 ++#define EXCEPT 352 ++#define ECHO 353 ++#define APPLY 354 ++#define CLEAR 355 ++#define SWIGTEMPLATE 356 ++#define FRAGMENT 357 ++#define WARN 358 ++#define LESSTHAN 359 ++#define GREATERTHAN 360 ++#define DELETE_KW 361 ++#define DEFAULT 362 ++#define LESSTHANOREQUALTO 363 ++#define GREATERTHANOREQUALTO 364 ++#define EQUALTO 365 ++#define NOTEQUALTO 366 ++#define LESSEQUALGREATER 367 ++#define ARROW 368 ++#define QUESTIONMARK 369 ++#define TYPES 370 ++#define PARMS 371 ++#define NONID 372 ++#define DSTAR 373 ++#define DCNOT 374 ++#define TEMPLATE 375 ++#define OPERATOR 376 ++#define CONVERSIONOPERATOR 377 ++#define PARSETYPE 378 ++#define PARSEPARM 379 ++#define PARSEPARMS 380 ++#define DOXYGENSTRING 381 ++#define DOXYGENPOSTSTRING 382 ++#define CAST 383 ++#define LOR 384 ++#define LAND 385 ++#define OR 386 ++#define XOR 387 ++#define AND 388 ++#define RSHIFT 389 ++#define LSHIFT 390 ++#define MINUS 391 ++#define PLUS 392 ++#define MODULO 393 ++#define SLASH 394 ++#define STAR 395 ++#define LNOT 396 ++#define NOT 397 ++#define UMINUS 398 ++#define DCOLON 399 ++ ++ ++ ++ ++/* Copy the first part of user declarations. */ ++#line 25 "parser.y" ++ ++#define yylex yylex ++ ++/* doh.h uses #pragma GCC poison with GCC to prevent direct calls to certain ++ * standard C library functions being introduced, but those cause errors due ++ * to checks like `#if defined YYMALLOC || defined malloc` in the bison ++ * template code. We can't easily arrange to include headers after that ++ * template code, so instead we disable the problematic poisoning for this ++ * file. ++ */ ++#define DOH_NO_POISON_MALLOC_FREE ++ ++#include "swig.h" ++#include "cparse.h" ++#include "preprocessor.h" ++#include ++ ++/* We do this for portability */ ++#undef alloca ++#define alloca Malloc ++ ++#define YYMALLOC Malloc ++#define YYFREE Free ++ ++/* ----------------------------------------------------------------------------- ++ * Externals ++ * ----------------------------------------------------------------------------- */ ++ ++int yyparse(void); ++ ++/* NEW Variables */ ++ ++static Node *top = 0; /* Top of the generated parse tree */ ++static int unnamed = 0; /* Unnamed datatype counter */ ++static Hash *classes = 0; /* Hash table of classes */ ++static Hash *classes_typedefs = 0; /* Hash table of typedef classes: typedef struct X {...} Y; */ ++static Symtab *prev_symtab = 0; ++static Node *current_class = 0; ++String *ModuleName = 0; ++static Node *module_node = 0; ++static String *Classprefix = 0; ++static String *Namespaceprefix = 0; ++static int inclass = 0; ++static Node *currentOuterClass = 0; /* for nested classes */ ++static const char *last_cpptype = 0; ++static int inherit_list = 0; ++static Parm *template_parameters = 0; ++static int parsing_template_declaration = 0; ++static int extendmode = 0; ++static int compact_default_args = 0; ++static int template_reduce = 0; ++static int cparse_externc = 0; ++int ignore_nested_classes = 0; ++int kwargs_supported = 0; ++/* ----------------------------------------------------------------------------- ++ * Doxygen Comment Globals ++ * ----------------------------------------------------------------------------- */ ++static String *currentDeclComment = NULL; /* Comment of C/C++ declaration. */ ++static Node *previousNode = NULL; /* Pointer to the previous node (for post comments) */ ++static Node *currentNode = NULL; /* Pointer to the current node (for post comments) */ ++ ++/* ----------------------------------------------------------------------------- ++ * Assist Functions ++ * ----------------------------------------------------------------------------- */ ++ ++ ++ ++/* Called by the parser (yyparse) when an error is found.*/ ++static void yyerror (const char *e) { ++ (void)e; ++} ++ ++static Node *new_node(const_String_or_char_ptr tag) { ++ Node *n = Swig_cparse_new_node(tag); ++ /* Remember the previous node in case it will need a post-comment */ ++ previousNode = currentNode; ++ currentNode = n; ++ return n; ++} ++ ++/* Copies a node. Does not copy tree links or symbol table data (except for ++ sym:name) */ ++ ++static Node *copy_node(Node *n) { ++ Node *nn; ++ Iterator k; ++ nn = NewHash(); ++ Setfile(nn,Getfile(n)); ++ Setline(nn,Getline(n)); ++ for (k = First(n); k.key; k = Next(k)) { ++ String *ci; ++ String *key = k.key; ++ char *ckey = Char(key); ++ if ((strcmp(ckey,"nextSibling") == 0) || ++ (strcmp(ckey,"previousSibling") == 0) || ++ (strcmp(ckey,"parentNode") == 0) || ++ (strcmp(ckey,"lastChild") == 0)) { ++ continue; ++ } ++ if (Strncmp(key,"csym:",5) == 0) continue; ++ /* We do copy sym:name. For templates */ ++ if ((strcmp(ckey,"sym:name") == 0) || ++ (strcmp(ckey,"sym:weak") == 0) || ++ (strcmp(ckey,"sym:typename") == 0)) { ++ String *ci = Copy(k.item); ++ Setattr(nn,key, ci); ++ Delete(ci); ++ continue; ++ } ++ if (strcmp(ckey,"sym:symtab") == 0) { ++ Setattr(nn,"sym:needs_symtab", "1"); ++ } ++ /* We don't copy any other symbol table attributes */ ++ if (strncmp(ckey,"sym:",4) == 0) { ++ continue; ++ } ++ /* If children. We copy them recursively using this function */ ++ if (strcmp(ckey,"firstChild") == 0) { ++ /* Copy children */ ++ Node *cn = k.item; ++ while (cn) { ++ Node *copy = copy_node(cn); ++ appendChild(nn,copy); ++ Delete(copy); ++ cn = nextSibling(cn); ++ } ++ continue; ++ } ++ /* We don't copy the symbol table. But we drop an attribute ++ requires_symtab so that functions know it needs to be built */ ++ ++ if (strcmp(ckey,"symtab") == 0) { ++ /* Node defined a symbol table. */ ++ Setattr(nn,"requires_symtab","1"); ++ continue; ++ } ++ /* Can't copy nodes */ ++ if (strcmp(ckey,"node") == 0) { ++ continue; ++ } ++ if ((strcmp(ckey,"parms") == 0) || (strcmp(ckey,"pattern") == 0) || (strcmp(ckey,"throws") == 0) ++ || (strcmp(ckey,"kwargs") == 0)) { ++ ParmList *pl = CopyParmList(k.item); ++ Setattr(nn,key,pl); ++ Delete(pl); ++ continue; ++ } ++ if (strcmp(ckey,"nested:outer") == 0) { /* don't copy outer classes links, they will be updated later */ ++ Setattr(nn, key, k.item); ++ continue; ++ } ++ /* defaultargs will be patched back in later in update_defaultargs() */ ++ if (strcmp(ckey,"defaultargs") == 0) { ++ Setattr(nn, "needs_defaultargs", "1"); ++ continue; ++ } ++ /* same for abstracts, which contains pointers to the source node children, and so will need to be patch too */ ++ if (strcmp(ckey,"abstracts") == 0) { ++ SetFlag(nn, "needs_abstracts"); ++ continue; ++ } ++ /* Looks okay. Just copy the data using Copy */ ++ ci = Copy(k.item); ++ Setattr(nn, key, ci); ++ Delete(ci); ++ } ++ return nn; ++} ++ ++static void set_comment(Node *n, String *comment) { ++ String *name; ++ Parm *p; ++ if (!n || !comment) ++ return; ++ ++ if (Getattr(n, "doxygen")) ++ Append(Getattr(n, "doxygen"), comment); ++ else { ++ Setattr(n, "doxygen", comment); ++ /* This is the first comment, populate it with @params, if any */ ++ p = Getattr(n, "parms"); ++ while (p) { ++ if (Getattr(p, "doxygen")) ++ Printv(comment, "\n@param ", Getattr(p, "name"), Getattr(p, "doxygen"), NIL); ++ p=nextSibling(p); ++ } ++ } ++ ++ /* Append same comment to every generated overload */ ++ name = Getattr(n, "name"); ++ if (!name) ++ return; ++ n = nextSibling(n); ++ while (n && Getattr(n, "name") && Strcmp(Getattr(n, "name"), name) == 0) { ++ Setattr(n, "doxygen", comment); ++ n = nextSibling(n); ++ } ++} ++ ++/* ----------------------------------------------------------------------------- ++ * Variables ++ * ----------------------------------------------------------------------------- */ ++ ++static char *typemap_lang = 0; /* Current language setting */ ++ ++static int cplus_mode = 0; ++ ++/* C++ modes */ ++ ++#define CPLUS_PUBLIC 1 ++#define CPLUS_PRIVATE 2 ++#define CPLUS_PROTECTED 3 ++ ++/* include types */ ++static int import_mode = 0; ++ ++void SWIG_typemap_lang(const char *tm_lang) { ++ typemap_lang = Swig_copy_string(tm_lang); ++} ++ ++void SWIG_cparse_set_compact_default_args(int defargs) { ++ compact_default_args = defargs; ++} ++ ++int SWIG_cparse_template_reduce(int treduce) { ++ template_reduce = treduce; ++ return treduce; ++} ++ ++/* ----------------------------------------------------------------------------- ++ * Assist functions ++ * ----------------------------------------------------------------------------- */ ++ ++static int promote_type(int t) { ++ if (t <= T_UCHAR || t == T_CHAR || t == T_WCHAR) return T_INT; ++ return t; ++} ++ ++/* Perform type-promotion for binary operators */ ++static int promote(int t1, int t2) { ++ t1 = promote_type(t1); ++ t2 = promote_type(t2); ++ return t1 > t2 ? t1 : t2; ++} ++ ++static String *yyrename = 0; ++ ++/* Forward renaming operator */ ++ ++static String *resolve_create_node_scope(String *cname, int is_class_definition); ++ ++ ++Hash *Swig_cparse_features(void) { ++ static Hash *features_hash = 0; ++ if (!features_hash) features_hash = NewHash(); ++ return features_hash; ++} ++ ++/* Fully qualify any template parameters */ ++static String *feature_identifier_fix(String *s) { ++ String *tp = SwigType_istemplate_templateprefix(s); ++ if (tp) { ++ String *ts, *ta, *tq; ++ ts = SwigType_templatesuffix(s); ++ ta = SwigType_templateargs(s); ++ tq = Swig_symbol_type_qualify(ta,0); ++ Append(tp,tq); ++ Append(tp,ts); ++ Delete(ts); ++ Delete(ta); ++ Delete(tq); ++ return tp; ++ } else { ++ return NewString(s); ++ } ++} ++ ++static void set_access_mode(Node *n) { ++ if (cplus_mode == CPLUS_PUBLIC) ++ Setattr(n, "access", "public"); ++ else if (cplus_mode == CPLUS_PROTECTED) ++ Setattr(n, "access", "protected"); ++ else ++ Setattr(n, "access", "private"); ++} ++ ++static void restore_access_mode(Node *n) { ++ String *mode = Getattr(n, "access"); ++ if (Strcmp(mode, "private") == 0) ++ cplus_mode = CPLUS_PRIVATE; ++ else if (Strcmp(mode, "protected") == 0) ++ cplus_mode = CPLUS_PROTECTED; ++ else ++ cplus_mode = CPLUS_PUBLIC; ++} ++ ++/* Generate the symbol table name for an object */ ++/* This is a bit of a mess. Need to clean up */ ++static String *add_oldname = 0; ++ ++ ++ ++static String *make_name(Node *n, String *name,SwigType *decl) { ++ String *made_name = 0; ++ int destructor = name && (*(Char(name)) == '~'); ++ ++ if (yyrename) { ++ String *s = NewString(yyrename); ++ Delete(yyrename); ++ yyrename = 0; ++ if (destructor && (*(Char(s)) != '~')) { ++ Insert(s,0,"~"); ++ } ++ return s; ++ } ++ ++ if (!name) return 0; ++ ++ if (parsing_template_declaration) ++ SetFlag(n, "parsing_template_declaration"); ++ made_name = Swig_name_make(n, Namespaceprefix, name, decl, add_oldname); ++ Delattr(n, "parsing_template_declaration"); ++ ++ return made_name; ++} ++ ++/* Generate an unnamed identifier */ ++static String *make_unnamed(void) { ++ unnamed++; ++ return NewStringf("$unnamed%d$",unnamed); ++} ++ ++/* Return if the node is a friend declaration */ ++static int is_friend(Node *n) { ++ return Cmp(Getattr(n,"storage"),"friend") == 0; ++} ++ ++static int is_operator(String *name) { ++ return Strncmp(name,"operator ", 9) == 0; ++} ++ ++ ++/* Add declaration list to symbol table */ ++static int add_only_one = 0; ++ ++static void add_symbols(Node *n) { ++ String *decl; ++ String *wrn = 0; ++ ++ if (inclass && n) { ++ cparse_normalize_void(n); ++ } ++ while (n) { ++ String *symname = 0; ++ /* for friends, we need to pop the scope once */ ++ String *old_prefix = 0; ++ Symtab *old_scope = 0; ++ int isfriend = inclass && is_friend(n); ++ int iscdecl = Cmp(nodeType(n),"cdecl") == 0; ++ int only_csymbol = 0; ++ ++ if (inclass) { ++ String *name = Getattr(n, "name"); ++ if (isfriend) { ++ /* for friends, we need to add the scopename if needed */ ++ String *prefix = name ? Swig_scopename_prefix(name) : 0; ++ old_prefix = Namespaceprefix; ++ old_scope = Swig_symbol_popscope(); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ if (!prefix) { ++ if (name && !is_operator(name) && Namespaceprefix) { ++ String *nname = NewStringf("%s::%s", Namespaceprefix, name); ++ Setattr(n,"name",nname); ++ Delete(nname); ++ } ++ } else { ++ Symtab *st = Swig_symbol_getscope(prefix); ++ String *ns = st ? Getattr(st,"name") : prefix; ++ String *base = Swig_scopename_last(name); ++ String *nname = NewStringf("%s::%s", ns, base); ++ Setattr(n,"name",nname); ++ Delete(nname); ++ Delete(base); ++ Delete(prefix); ++ } ++ Namespaceprefix = 0; ++ } else { ++ /* for member functions, we need to remove the redundant ++ class scope if provided, as in ++ ++ struct Foo { ++ int Foo::method(int a); ++ }; ++ ++ */ ++ String *prefix = name ? Swig_scopename_prefix(name) : 0; ++ if (prefix) { ++ if (Classprefix && (Equal(prefix,Classprefix))) { ++ String *base = Swig_scopename_last(name); ++ Setattr(n,"name",base); ++ Delete(base); ++ } ++ Delete(prefix); ++ } ++ } ++ } ++ ++ if (!isfriend && (inclass || extendmode)) { ++ Setattr(n,"ismember","1"); ++ } ++ ++ if (extendmode) { ++ if (!Getattr(n, "template")) ++ SetFlag(n,"isextendmember"); ++ } ++ ++ if (!isfriend && inclass) { ++ if ((cplus_mode != CPLUS_PUBLIC)) { ++ only_csymbol = 1; ++ if (cplus_mode == CPLUS_PROTECTED) { ++ Setattr(n,"access", "protected"); ++ only_csymbol = !Swig_need_protected(n); ++ } else { ++ Setattr(n,"access", "private"); ++ /* private are needed only when they are pure virtuals - why? */ ++ if ((Cmp(Getattr(n,"storage"),"virtual") == 0) && (Cmp(Getattr(n,"value"),"0") == 0)) { ++ only_csymbol = 0; ++ } ++ if (Cmp(nodeType(n),"destructor") == 0) { ++ /* Needed for "unref" feature */ ++ only_csymbol = 0; ++ } ++ } ++ } else { ++ Setattr(n,"access", "public"); ++ } ++ } ++ if (Getattr(n,"sym:name")) { ++ n = nextSibling(n); ++ continue; ++ } ++ decl = Getattr(n,"decl"); ++ if (!SwigType_isfunction(decl)) { ++ String *name = Getattr(n,"name"); ++ String *makename = Getattr(n,"parser:makename"); ++ if (iscdecl) { ++ String *storage = Getattr(n, "storage"); ++ if (Cmp(storage,"typedef") == 0) { ++ Setattr(n,"kind","typedef"); ++ } else { ++ SwigType *type = Getattr(n,"type"); ++ String *value = Getattr(n,"value"); ++ Setattr(n,"kind","variable"); ++ if (value && Len(value)) { ++ Setattr(n,"hasvalue","1"); ++ } ++ if (type) { ++ SwigType *ty; ++ SwigType *tmp = 0; ++ if (decl) { ++ ty = tmp = Copy(type); ++ SwigType_push(ty,decl); ++ } else { ++ ty = type; ++ } ++ if (!SwigType_ismutable(ty) || (storage && Strstr(storage, "constexpr"))) { ++ SetFlag(n,"hasconsttype"); ++ SetFlag(n,"feature:immutable"); ++ } ++ if (tmp) Delete(tmp); ++ } ++ if (!type) { ++ Printf(stderr,"notype name %s\n", name); ++ } ++ } ++ } ++ Swig_features_get(Swig_cparse_features(), Namespaceprefix, name, 0, n); ++ if (makename) { ++ symname = make_name(n, makename,0); ++ Delattr(n,"parser:makename"); /* temporary information, don't leave it hanging around */ ++ } else { ++ makename = name; ++ symname = make_name(n, makename,0); ++ } ++ ++ if (!symname) { ++ symname = Copy(Getattr(n,"unnamed")); ++ } ++ if (symname) { ++ if (parsing_template_declaration) ++ SetFlag(n, "parsing_template_declaration"); ++ wrn = Swig_name_warning(n, Namespaceprefix, symname,0); ++ Delattr(n, "parsing_template_declaration"); ++ } ++ } else { ++ String *name = Getattr(n,"name"); ++ SwigType *fdecl = Copy(decl); ++ SwigType *fun = SwigType_pop_function(fdecl); ++ if (iscdecl) { ++ Setattr(n,"kind","function"); ++ } ++ ++ Swig_features_get(Swig_cparse_features(),Namespaceprefix,name,fun,n); ++ ++ symname = make_name(n, name,fun); ++ if (parsing_template_declaration) ++ SetFlag(n, "parsing_template_declaration"); ++ wrn = Swig_name_warning(n, Namespaceprefix,symname,fun); ++ Delattr(n, "parsing_template_declaration"); ++ ++ Delete(fdecl); ++ Delete(fun); ++ ++ } ++ if (!symname) { ++ n = nextSibling(n); ++ continue; ++ } ++ if (cparse_cplusplus) { ++ String *value = Getattr(n, "value"); ++ if (value && Strcmp(value, "delete") == 0) { ++ /* C++11 deleted definition / deleted function */ ++ SetFlag(n,"deleted"); ++ SetFlag(n,"feature:ignore"); ++ } ++ if (SwigType_isrvalue_reference(Getattr(n, "refqualifier"))) { ++ /* Ignore rvalue ref-qualifiers by default ++ * Use Getattr instead of GetFlag to handle explicit ignore and explicit not ignore */ ++ if (!(Getattr(n, "feature:ignore") || Strncmp(symname, "$ignore", 7) == 0)) { ++ SWIG_WARN_NODE_BEGIN(n); ++ Swig_warning(WARN_TYPE_RVALUE_REF_QUALIFIER_IGNORED, Getfile(n), Getline(n), ++ "Method with rvalue ref-qualifier %s ignored.\n", Swig_name_decl(n)); ++ SWIG_WARN_NODE_END(n); ++ SetFlag(n, "feature:ignore"); ++ } ++ } ++ } ++ if (only_csymbol || GetFlag(n, "feature:ignore") || Strncmp(symname, "$ignore", 7) == 0) { ++ /* Only add to C symbol table and continue */ ++ Swig_symbol_add(0, n); ++ if (!only_csymbol && !GetFlag(n, "feature:ignore")) { ++ /* Print the warning attached to $ignore name, if any */ ++ char *c = Char(symname) + 7; ++ if (strlen(c)) { ++ SWIG_WARN_NODE_BEGIN(n); ++ Swig_warning(0,Getfile(n), Getline(n), "%s\n",c+1); ++ SWIG_WARN_NODE_END(n); ++ } ++ /* If the symbol was ignored via "rename" and is visible, set also feature:ignore*/ ++ SetFlag(n, "feature:ignore"); ++ } ++ if (!GetFlag(n, "feature:ignore") && Strcmp(symname,"$ignore") == 0) { ++ /* Add feature:ignore if the symbol was explicitly ignored, regardless of visibility */ ++ SetFlag(n, "feature:ignore"); ++ } ++ } else { ++ Node *c; ++ if ((wrn) && (Len(wrn))) { ++ String *metaname = symname; ++ if (!Getmeta(metaname,"already_warned")) { ++ SWIG_WARN_NODE_BEGIN(n); ++ Swig_warning(0,Getfile(n),Getline(n), "%s\n", wrn); ++ SWIG_WARN_NODE_END(n); ++ Setmeta(metaname,"already_warned","1"); ++ } ++ } ++ c = Swig_symbol_add(symname,n); ++ ++ if (c != n) { ++ /* symbol conflict attempting to add in the new symbol */ ++ if (Getattr(n,"sym:weak")) { ++ Setattr(n,"sym:name",symname); ++ } else { ++ String *e = NewStringEmpty(); ++ String *en = NewStringEmpty(); ++ String *ec = NewStringEmpty(); ++ int redefined = Swig_need_redefined_warn(n,c,inclass); ++ if (redefined) { ++ Printf(en,"Identifier '%s' redefined (ignored)",symname); ++ Printf(ec,"previous definition of '%s'",symname); ++ } else { ++ Printf(en,"Redundant redeclaration of '%s'",symname); ++ Printf(ec,"previous declaration of '%s'",symname); ++ } ++ if (Cmp(symname,Getattr(n,"name"))) { ++ Printf(en," (Renamed from '%s')", SwigType_namestr(Getattr(n,"name"))); ++ } ++ Printf(en,","); ++ if (Cmp(symname,Getattr(c,"name"))) { ++ Printf(ec," (Renamed from '%s')", SwigType_namestr(Getattr(c,"name"))); ++ } ++ Printf(ec,"."); ++ SWIG_WARN_NODE_BEGIN(n); ++ if (redefined) { ++ Swig_warning(WARN_PARSE_REDEFINED,Getfile(n),Getline(n),"%s\n",en); ++ Swig_warning(WARN_PARSE_REDEFINED,Getfile(c),Getline(c),"%s\n",ec); ++ } else if (!is_friend(n) && !is_friend(c)) { ++ Swig_warning(WARN_PARSE_REDUNDANT,Getfile(n),Getline(n),"%s\n",en); ++ Swig_warning(WARN_PARSE_REDUNDANT,Getfile(c),Getline(c),"%s\n",ec); ++ } ++ SWIG_WARN_NODE_END(n); ++ Printf(e,"%s:%d:%s\n%s:%d:%s\n",Getfile(n),Getline(n),en, ++ Getfile(c),Getline(c),ec); ++ Setattr(n,"error",e); ++ Delete(e); ++ Delete(en); ++ Delete(ec); ++ } ++ } ++ } ++ /* restore the class scope if needed */ ++ if (isfriend) { ++ Swig_symbol_setscope(old_scope); ++ if (old_prefix) { ++ Delete(Namespaceprefix); ++ Namespaceprefix = old_prefix; ++ } ++ } ++ Delete(symname); ++ ++ if (add_only_one) return; ++ n = nextSibling(n); ++ } ++} ++ ++ ++/* add symbols a parse tree node copy */ ++ ++static void add_symbols_copy(Node *n) { ++ String *name; ++ int emode = 0; ++ while (n) { ++ char *cnodeType = Char(nodeType(n)); ++ ++ if (strcmp(cnodeType,"access") == 0) { ++ String *kind = Getattr(n,"kind"); ++ if (Strcmp(kind,"public") == 0) { ++ cplus_mode = CPLUS_PUBLIC; ++ } else if (Strcmp(kind,"private") == 0) { ++ cplus_mode = CPLUS_PRIVATE; ++ } else if (Strcmp(kind,"protected") == 0) { ++ cplus_mode = CPLUS_PROTECTED; ++ } ++ n = nextSibling(n); ++ continue; ++ } ++ ++ add_oldname = Getattr(n,"sym:name"); ++ if ((add_oldname) || (Getattr(n,"sym:needs_symtab"))) { ++ int old_inclass = -1; ++ Node *old_current_class = 0; ++ if (add_oldname) { ++ DohIncref(add_oldname); ++ /* Disable this, it prevents %rename to work with templates */ ++ /* If already renamed, we used that name */ ++ /* ++ if (Strcmp(add_oldname, Getattr(n,"name")) != 0) { ++ Delete(yyrename); ++ yyrename = Copy(add_oldname); ++ } ++ */ ++ } ++ Delattr(n,"sym:needs_symtab"); ++ Delattr(n,"sym:name"); ++ ++ add_only_one = 1; ++ add_symbols(n); ++ ++ if (Getattr(n,"partialargs")) { ++ Swig_symbol_cadd(Getattr(n,"partialargs"),n); ++ } ++ add_only_one = 0; ++ name = Getattr(n,"name"); ++ if (Getattr(n,"requires_symtab")) { ++ Swig_symbol_newscope(); ++ Swig_symbol_setscopename(name); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ } ++ if (strcmp(cnodeType,"class") == 0) { ++ old_inclass = inclass; ++ inclass = 1; ++ old_current_class = current_class; ++ current_class = n; ++ if (Strcmp(Getattr(n,"kind"),"class") == 0) { ++ cplus_mode = CPLUS_PRIVATE; ++ } else { ++ cplus_mode = CPLUS_PUBLIC; ++ } ++ } ++ if (strcmp(cnodeType,"extend") == 0) { ++ emode = cplus_mode; ++ cplus_mode = CPLUS_PUBLIC; ++ } ++ add_symbols_copy(firstChild(n)); ++ if (strcmp(cnodeType,"extend") == 0) { ++ cplus_mode = emode; ++ } ++ if (Getattr(n,"requires_symtab")) { ++ Setattr(n,"symtab", Swig_symbol_popscope()); ++ Delattr(n,"requires_symtab"); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ } ++ if (add_oldname) { ++ Delete(add_oldname); ++ add_oldname = 0; ++ } ++ if (strcmp(cnodeType,"class") == 0) { ++ inclass = old_inclass; ++ current_class = old_current_class; ++ } ++ } else { ++ if (strcmp(cnodeType,"extend") == 0) { ++ emode = cplus_mode; ++ cplus_mode = CPLUS_PUBLIC; ++ } ++ add_symbols_copy(firstChild(n)); ++ if (strcmp(cnodeType,"extend") == 0) { ++ cplus_mode = emode; ++ } ++ } ++ n = nextSibling(n); ++ } ++} ++ ++/* Add in the "defaultargs" attribute for functions in instantiated templates. ++ * n should be any instantiated template (class or start of linked list of functions). */ ++static void update_defaultargs(Node *n) { ++ if (n) { ++ Node *firstdefaultargs = n; ++ update_defaultargs(firstChild(n)); ++ n = nextSibling(n); ++ /* recursively loop through nodes of all types, but all we really need are the overloaded functions */ ++ while (n) { ++ update_defaultargs(firstChild(n)); ++ if (!Getattr(n, "defaultargs")) { ++ if (Getattr(n, "needs_defaultargs")) { ++ Setattr(n, "defaultargs", firstdefaultargs); ++ Delattr(n, "needs_defaultargs"); ++ } else { ++ firstdefaultargs = n; ++ } ++ } else { ++ /* Functions added in with %extend (for specialized template classes) will already have default args patched up */ ++ assert(Getattr(n, "defaultargs") == firstdefaultargs); ++ } ++ n = nextSibling(n); ++ } ++ } ++} ++ ++/* Check a set of declarations to see if any are pure-abstract */ ++ ++static List *pure_abstracts(Node *n) { ++ List *abstracts = 0; ++ while (n) { ++ if (Cmp(nodeType(n),"cdecl") == 0) { ++ String *decl = Getattr(n,"decl"); ++ if (SwigType_isfunction(decl)) { ++ String *init = Getattr(n,"value"); ++ if (Cmp(init,"0") == 0) { ++ if (!abstracts) { ++ abstracts = NewList(); ++ } ++ Append(abstracts,n); ++ SetFlag(n,"abstract"); ++ } ++ } ++ } else if (Cmp(nodeType(n),"destructor") == 0) { ++ if (Cmp(Getattr(n,"value"),"0") == 0) { ++ if (!abstracts) { ++ abstracts = NewList(); ++ } ++ Append(abstracts,n); ++ SetFlag(n,"abstract"); ++ } ++ } ++ n = nextSibling(n); ++ } ++ return abstracts; ++} ++ ++/* Recompute the "abstracts" attribute for the classes in instantiated templates, similarly to update_defaultargs() above. */ ++static void update_abstracts(Node *n) { ++ for (; n; n = nextSibling(n)) { ++ Node* const child = firstChild(n); ++ if (!child) ++ continue; ++ ++ update_abstracts(child); ++ ++ if (Getattr(n, "needs_abstracts")) { ++ Setattr(n, "abstracts", pure_abstracts(child)); ++ Delattr(n, "needs_abstracts"); ++ } ++ } ++} ++ ++/* Make a classname */ ++ ++static String *make_class_name(String *name) { ++ String *nname = 0; ++ String *prefix; ++ if (Namespaceprefix) { ++ nname= NewStringf("%s::%s", Namespaceprefix, name); ++ } else { ++ nname = NewString(name); ++ } ++ prefix = SwigType_istemplate_templateprefix(nname); ++ if (prefix) { ++ String *args, *qargs; ++ args = SwigType_templateargs(nname); ++ qargs = Swig_symbol_type_qualify(args,0); ++ Append(prefix,qargs); ++ Delete(nname); ++ Delete(args); ++ Delete(qargs); ++ nname = prefix; ++ } ++ return nname; ++} ++ ++/* Use typedef name as class name */ ++ ++static void add_typedef_name(Node *n, Node *declnode, String *oldName, Symtab *cscope, String *scpname) { ++ String *class_rename = 0; ++ SwigType *decl = Getattr(declnode, "decl"); ++ if (!decl || !Len(decl)) { ++ String *cname; ++ String *tdscopename; ++ String *class_scope = Swig_symbol_qualifiedscopename(cscope); ++ String *name = Getattr(declnode, "name"); ++ cname = Copy(name); ++ Setattr(n, "tdname", cname); ++ tdscopename = class_scope ? NewStringf("%s::%s", class_scope, name) : Copy(name); ++ class_rename = Getattr(n, "class_rename"); ++ if (class_rename && (Strcmp(class_rename, oldName) == 0)) ++ Setattr(n, "class_rename", NewString(name)); ++ if (!classes_typedefs) classes_typedefs = NewHash(); ++ if (!Equal(scpname, tdscopename) && !Getattr(classes_typedefs, tdscopename)) { ++ Setattr(classes_typedefs, tdscopename, n); ++ } ++ Setattr(n, "decl", decl); ++ Delete(class_scope); ++ Delete(cname); ++ Delete(tdscopename); ++ } ++} ++ ++/* If the class name is qualified. We need to create or lookup namespace entries */ ++ ++static Symtab *set_scope_to_global(void) { ++ Symtab *symtab = Swig_symbol_global_scope(); ++ Swig_symbol_setscope(symtab); ++ return symtab; ++} ++ ++/* Remove the block braces, { and }, if the 'noblock' attribute is set. ++ * Node *kw can be either a Hash or Parmlist. */ ++static String *remove_block(Node *kw, const String *inputcode) { ++ String *modified_code = 0; ++ while (kw) { ++ String *name = Getattr(kw,"name"); ++ if (name && (Cmp(name,"noblock") == 0)) { ++ char *cstr = Char(inputcode); ++ int len = Len(inputcode); ++ if (len && cstr[0] == '{') { ++ --len; ++cstr; ++ if (len && cstr[len - 1] == '}') { --len; } ++ /* we now remove the extra spaces */ ++ while (len && isspace((int)cstr[0])) { --len; ++cstr; } ++ while (len && isspace((int)cstr[len - 1])) { --len; } ++ modified_code = NewStringWithSize(cstr, len); ++ break; ++ } ++ } ++ kw = nextSibling(kw); ++ } ++ return modified_code; ++} ++ ++/* ++#define RESOLVE_DEBUG 1 ++*/ ++static Node *nscope = 0; ++static Node *nscope_inner = 0; ++ ++/* Remove the scope prefix from cname and return the base name without the prefix. ++ * The scopes required for the symbol name are resolved and/or created, if required. ++ * For example AA::BB::CC as input returns CC and creates the namespace AA then inner ++ * namespace BB in the current scope. */ ++static String *resolve_create_node_scope(String *cname, int is_class_definition) { ++ Symtab *gscope = 0; ++ Node *cname_node = 0; ++ String *last = Swig_scopename_last(cname); ++ nscope = 0; ++ nscope_inner = 0; ++ ++ if (Strncmp(cname,"::" ,2) != 0) { ++ if (is_class_definition) { ++ /* Only lookup symbols which are in scope via a using declaration but not via a using directive. ++ For example find y via 'using x::y' but not y via a 'using namespace x'. */ ++ cname_node = Swig_symbol_clookup_no_inherit(cname, 0); ++ if (!cname_node) { ++ Node *full_lookup_node = Swig_symbol_clookup(cname, 0); ++ if (full_lookup_node) { ++ /* This finds a symbol brought into scope via both a using directive and a using declaration. */ ++ Node *last_node = Swig_symbol_clookup_no_inherit(last, 0); ++ if (last_node == full_lookup_node) ++ cname_node = last_node; ++ } ++ } ++ } else { ++ /* For %template, the template needs to be in scope via any means. */ ++ cname_node = Swig_symbol_clookup(cname, 0); ++ } ++ } ++#if RESOLVE_DEBUG ++ if (!cname_node) ++ Printf(stdout, "symbol does not yet exist (%d): [%s]\n", is_class_definition, cname); ++ else ++ Printf(stdout, "symbol does exist (%d): [%s]\n", is_class_definition, cname); ++#endif ++ ++ if (cname_node) { ++ /* The symbol has been defined already or is in another scope. ++ If it is a weak symbol, it needs replacing and if it was brought into the current scope, ++ the scope needs adjusting appropriately for the new symbol. ++ Similarly for defined templates. */ ++ Symtab *symtab = Getattr(cname_node, "sym:symtab"); ++ Node *sym_weak = Getattr(cname_node, "sym:weak"); ++ if ((symtab && sym_weak) || Equal(nodeType(cname_node), "template")) { ++ /* Check if the scope is the current scope */ ++ String *current_scopename = Swig_symbol_qualifiedscopename(0); ++ String *found_scopename = Swig_symbol_qualifiedscopename(symtab); ++ if (!current_scopename) ++ current_scopename = NewString(""); ++ if (!found_scopename) ++ found_scopename = NewString(""); ++ ++ { ++ int fail = 1; ++ List *current_scopes = Swig_scopename_tolist(current_scopename); ++ List *found_scopes = Swig_scopename_tolist(found_scopename); ++ Iterator cit = First(current_scopes); ++ Iterator fit = First(found_scopes); ++#if RESOLVE_DEBUG ++Printf(stdout, "comparing current: [%s] found: [%s]\n", current_scopename, found_scopename); ++#endif ++ for (; fit.item && cit.item; fit = Next(fit), cit = Next(cit)) { ++ String *current = cit.item; ++ String *found = fit.item; ++#if RESOLVE_DEBUG ++ Printf(stdout, " looping %s %s\n", current, found); ++#endif ++ if (Strcmp(current, found) != 0) ++ break; ++ } ++ ++ if (!cit.item) { ++ String *subscope = NewString(""); ++ for (; fit.item; fit = Next(fit)) { ++ if (Len(subscope) > 0) ++ Append(subscope, "::"); ++ Append(subscope, fit.item); ++ } ++ if (Len(subscope) > 0) ++ cname = NewStringf("%s::%s", subscope, last); ++ else ++ cname = Copy(last); ++#if RESOLVE_DEBUG ++ Printf(stdout, "subscope to create: [%s] cname: [%s]\n", subscope, cname); ++#endif ++ fail = 0; ++ Delete(subscope); ++ } else { ++ if (is_class_definition) { ++ if (!fit.item) { ++ /* It is valid to define a new class with the same name as one forward declared in a parent scope */ ++ fail = 0; ++ } else if (Swig_scopename_check(cname)) { ++ /* Classes defined with scope qualifiers must have a matching forward declaration in matching scope */ ++ fail = 1; ++ } else { ++ /* This may let through some invalid cases */ ++ fail = 0; ++ } ++#if RESOLVE_DEBUG ++ Printf(stdout, "scope for class definition, fail: %d\n", fail); ++#endif ++ } else { ++#if RESOLVE_DEBUG ++ Printf(stdout, "no matching base scope for template\n"); ++#endif ++ fail = 1; ++ } ++ } ++ ++ Delete(found_scopes); ++ Delete(current_scopes); ++ ++ if (fail) { ++ String *cname_resolved = NewStringf("%s::%s", found_scopename, last); ++ Swig_error(cparse_file, cparse_line, "'%s' resolves to '%s' and was incorrectly instantiated in scope '%s' instead of within scope '%s'.\n", cname, cname_resolved, current_scopename, found_scopename); ++ cname = Copy(last); ++ Delete(cname_resolved); ++ } ++ } ++ ++ Delete(current_scopename); ++ Delete(found_scopename); ++ } ++ } else if (!is_class_definition) { ++ /* A template instantiation requires a template to be found in scope... fail here too? ++ Swig_error(cparse_file, cparse_line, "No template found to instantiate '%s' with %%template.\n", cname); ++ */ ++ } ++ ++ if (Swig_scopename_check(cname)) { ++ Node *ns; ++ String *prefix = Swig_scopename_prefix(cname); ++ if (prefix && (Strncmp(prefix,"::",2) == 0)) { ++/* I don't think we can use :: global scope to declare classes and hence neither %template. - consider reporting error instead - wsfulton. */ ++ /* Use the global scope */ ++ String *nprefix = NewString(Char(prefix)+2); ++ Delete(prefix); ++ prefix= nprefix; ++ gscope = set_scope_to_global(); ++ } ++ if (Len(prefix) == 0) { ++ String *base = Copy(last); ++ /* Use the global scope, but we need to add a 'global' namespace. */ ++ if (!gscope) gscope = set_scope_to_global(); ++ /* note that this namespace is not the "unnamed" one, ++ and we don't use Setattr(nscope,"name", ""), ++ because the unnamed namespace is private */ ++ nscope = new_node("namespace"); ++ Setattr(nscope,"symtab", gscope);; ++ nscope_inner = nscope; ++ Delete(last); ++ return base; ++ } ++ /* Try to locate the scope */ ++ ns = Swig_symbol_clookup(prefix,0); ++ if (!ns) { ++ Swig_error(cparse_file,cparse_line,"Undefined scope '%s'\n", prefix); ++ } else { ++ Symtab *nstab = Getattr(ns,"symtab"); ++ if (!nstab) { ++ Swig_error(cparse_file,cparse_line, "'%s' is not defined as a valid scope.\n", prefix); ++ ns = 0; ++ } else { ++ /* Check if the node scope is the current scope */ ++ String *tname = Swig_symbol_qualifiedscopename(0); ++ String *nname = Swig_symbol_qualifiedscopename(nstab); ++ if (tname && (Strcmp(tname,nname) == 0)) { ++ ns = 0; ++ cname = Copy(last); ++ } ++ Delete(tname); ++ Delete(nname); ++ } ++ if (ns) { ++ /* we will try to create a new node using the namespaces we ++ can find in the scope name */ ++ List *scopes = Swig_scopename_tolist(prefix); ++ String *sname; ++ Iterator si; ++ ++ for (si = First(scopes); si.item; si = Next(si)) { ++ Node *ns1,*ns2; ++ sname = si.item; ++ ns1 = Swig_symbol_clookup(sname,0); ++ assert(ns1); ++ if (Strcmp(nodeType(ns1),"namespace") == 0) { ++ if (Getattr(ns1,"alias")) { ++ ns1 = Getattr(ns1,"namespace"); ++ } ++ } else { ++ /* now this last part is a class */ ++ si = Next(si); ++ /* or a nested class tree, which is unrolled here */ ++ for (; si.item; si = Next(si)) { ++ if (si.item) { ++ Printf(sname,"::%s",si.item); ++ } ++ } ++ /* we get the 'inner' class */ ++ nscope_inner = Swig_symbol_clookup(sname,0); ++ /* set the scope to the inner class */ ++ Swig_symbol_setscope(Getattr(nscope_inner,"symtab")); ++ /* save the last namespace prefix */ ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ /* and return the node name, including the inner class prefix */ ++ break; ++ } ++ /* here we just populate the namespace tree as usual */ ++ ns2 = new_node("namespace"); ++ Setattr(ns2,"name",sname); ++ Setattr(ns2,"symtab", Getattr(ns1,"symtab")); ++ add_symbols(ns2); ++ Swig_symbol_setscope(Getattr(ns1,"symtab")); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ if (nscope_inner) { ++ if (Getattr(nscope_inner,"symtab") != Getattr(ns2,"symtab")) { ++ appendChild(nscope_inner,ns2); ++ Delete(ns2); ++ } ++ } ++ nscope_inner = ns2; ++ if (!nscope) nscope = ns2; ++ } ++ cname = Copy(last); ++ Delete(scopes); ++ } ++ } ++ Delete(prefix); ++ } ++ Delete(last); ++ ++ return cname; ++} ++ ++/* look for simple typedef name in typedef list */ ++static String *try_to_find_a_name_for_unnamed_structure(const char *storage, Node *decls) { ++ String *name = 0; ++ Node *n = decls; ++ if (storage && (strcmp(storage, "typedef") == 0)) { ++ for (; n; n = nextSibling(n)) { ++ if (!Len(Getattr(n, "decl"))) { ++ name = Copy(Getattr(n, "name")); ++ break; ++ } ++ } ++ } ++ return name; ++} ++ ++/* traverse copied tree segment, and update outer class links*/ ++static void update_nested_classes(Node *n) ++{ ++ Node *c = firstChild(n); ++ while (c) { ++ if (Getattr(c, "nested:outer")) ++ Setattr(c, "nested:outer", n); ++ update_nested_classes(c); ++ c = nextSibling(c); ++ } ++} ++ ++/* ----------------------------------------------------------------------------- ++ * nested_forward_declaration() ++ * ++ * Nested struct handling for C++ code if the nested classes are disabled. ++ * Create the nested class/struct/union as a forward declaration. ++ * ----------------------------------------------------------------------------- */ ++ ++static Node *nested_forward_declaration(const char *storage, const char *kind, String *sname, String *name, Node *cpp_opt_declarators) { ++ Node *nn = 0; ++ ++ if (sname) { ++ /* Add forward declaration of the nested type */ ++ Node *n = new_node("classforward"); ++ Setattr(n, "kind", kind); ++ Setattr(n, "name", sname); ++ Setattr(n, "storage", storage); ++ Setattr(n, "sym:weak", "1"); ++ add_symbols(n); ++ nn = n; ++ } ++ ++ /* Add any variable instances. Also add in any further typedefs of the nested type. ++ Note that anonymous typedefs (eg typedef struct {...} a, b;) are treated as class forward declarations */ ++ if (cpp_opt_declarators) { ++ int storage_typedef = (storage && (strcmp(storage, "typedef") == 0)); ++ int variable_of_anonymous_type = !sname && !storage_typedef; ++ if (!variable_of_anonymous_type) { ++ int anonymous_typedef = !sname && (storage && (strcmp(storage, "typedef") == 0)); ++ Node *n = cpp_opt_declarators; ++ SwigType *type = name; ++ while (n) { ++ Setattr(n, "type", type); ++ Setattr(n, "storage", storage); ++ if (anonymous_typedef) { ++ Setattr(n, "nodeType", "classforward"); ++ Setattr(n, "sym:weak", "1"); ++ } ++ n = nextSibling(n); ++ } ++ add_symbols(cpp_opt_declarators); ++ ++ if (nn) { ++ set_nextSibling(nn, cpp_opt_declarators); ++ } else { ++ nn = cpp_opt_declarators; ++ } ++ } ++ } ++ ++ if (!currentOuterClass || !GetFlag(currentOuterClass, "nested")) { ++ if (nn && Equal(nodeType(nn), "classforward")) { ++ Node *n = nn; ++ if (!GetFlag(n, "feature:ignore")) { ++ SWIG_WARN_NODE_BEGIN(n); ++ Swig_warning(WARN_PARSE_NAMED_NESTED_CLASS, cparse_file, cparse_line,"Nested %s not currently supported (%s ignored)\n", kind, sname ? sname : name); ++ SWIG_WARN_NODE_END(n); ++ } ++ } else { ++ Swig_warning(WARN_PARSE_UNNAMED_NESTED_CLASS, cparse_file, cparse_line, "Nested %s not currently supported (ignored).\n", kind); ++ } ++ } ++ ++ return nn; ++} ++ ++ ++Node *Swig_cparse(File *f) { ++ scanner_file(f); ++ top = 0; ++ yyparse(); ++ return top; ++} ++ ++static void single_new_feature(const char *featurename, String *val, Hash *featureattribs, char *declaratorid, SwigType *type, ParmList *declaratorparms, String *qualifier) { ++ String *fname; ++ String *name; ++ String *fixname; ++ SwigType *t = Copy(type); ++ ++ /* Printf(stdout, "single_new_feature: [%s] [%s] [%s] [%s] [%s] [%s]\n", featurename, val, declaratorid, t, ParmList_str_defaultargs(declaratorparms), qualifier); */ ++ ++ /* Warn about deprecated features */ ++ if (strcmp(featurename, "nestedworkaround") == 0) ++ Swig_warning(WARN_DEPRECATED_NESTED_WORKAROUND, cparse_file, cparse_line, "The 'nestedworkaround' feature is deprecated.\n"); ++ ++ fname = NewStringf("feature:%s",featurename); ++ if (declaratorid) { ++ fixname = feature_identifier_fix(declaratorid); ++ } else { ++ fixname = NewStringEmpty(); ++ } ++ if (Namespaceprefix) { ++ name = NewStringf("%s::%s",Namespaceprefix, fixname); ++ } else { ++ name = fixname; ++ } ++ ++ if (declaratorparms) Setmeta(val,"parms",declaratorparms); ++ if (!Len(t)) t = 0; ++ if (t) { ++ if (qualifier) SwigType_push(t,qualifier); ++ if (SwigType_isfunction(t)) { ++ SwigType *decl = SwigType_pop_function(t); ++ if (SwigType_ispointer(t)) { ++ String *nname = NewStringf("*%s",name); ++ Swig_feature_set(Swig_cparse_features(), nname, decl, fname, val, featureattribs); ++ Delete(nname); ++ } else { ++ Swig_feature_set(Swig_cparse_features(), name, decl, fname, val, featureattribs); ++ } ++ Delete(decl); ++ } else if (SwigType_ispointer(t)) { ++ String *nname = NewStringf("*%s",name); ++ Swig_feature_set(Swig_cparse_features(),nname,0,fname,val, featureattribs); ++ Delete(nname); ++ } ++ } else { ++ /* Global feature, that is, feature not associated with any particular symbol */ ++ Swig_feature_set(Swig_cparse_features(),name,0,fname,val, featureattribs); ++ } ++ Delete(fname); ++ Delete(name); ++} ++ ++/* Add a new feature to the Hash. Additional features are added if the feature has a parameter list (declaratorparms) ++ * and one or more of the parameters have a default argument. An extra feature is added for each defaulted parameter, ++ * simulating the equivalent overloaded method. */ ++static void new_feature(const char *featurename, String *val, Hash *featureattribs, char *declaratorid, SwigType *type, ParmList *declaratorparms, String *qualifier) { ++ ++ ParmList *declparms = declaratorparms; ++ ++ /* remove the { and } braces if the noblock attribute is set */ ++ String *newval = remove_block(featureattribs, val); ++ val = newval ? newval : val; ++ ++ /* Add the feature */ ++ single_new_feature(featurename, val, featureattribs, declaratorid, type, declaratorparms, qualifier); ++ ++ /* Add extra features if there are default parameters in the parameter list */ ++ if (type) { ++ while (declparms) { ++ if (ParmList_has_defaultargs(declparms)) { ++ ++ /* Create a parameter list for the new feature by copying all ++ but the last (defaulted) parameter */ ++ ParmList* newparms = CopyParmListMax(declparms, ParmList_len(declparms)-1); ++ ++ /* Create new declaration - with the last parameter removed */ ++ SwigType *newtype = Copy(type); ++ Delete(SwigType_pop_function(newtype)); /* remove the old parameter list from newtype */ ++ SwigType_add_function(newtype,newparms); ++ ++ single_new_feature(featurename, Copy(val), featureattribs, declaratorid, newtype, newparms, qualifier); ++ declparms = newparms; ++ } else { ++ declparms = 0; ++ } ++ } ++ } ++} ++ ++/* check if a function declaration is a plain C object */ ++static int is_cfunction(Node *n) { ++ if (!cparse_cplusplus || cparse_externc) ++ return 1; ++ if (Swig_storage_isexternc(n)) { ++ return 1; ++ } ++ return 0; ++} ++ ++/* If the Node is a function with parameters, check to see if any of the parameters ++ * have default arguments. If so create a new function for each defaulted argument. ++ * The additional functions form a linked list of nodes with the head being the original Node n. */ ++static void default_arguments(Node *n) { ++ Node *function = n; ++ ++ if (function) { ++ ParmList *varargs = Getattr(function,"feature:varargs"); ++ if (varargs) { ++ /* Handles the %varargs directive by looking for "feature:varargs" and ++ * substituting ... with an alternative set of arguments. */ ++ Parm *p = Getattr(function,"parms"); ++ Parm *pp = 0; ++ while (p) { ++ SwigType *t = Getattr(p,"type"); ++ if (Strcmp(t,"v(...)") == 0) { ++ if (pp) { ++ ParmList *cv = Copy(varargs); ++ set_nextSibling(pp,cv); ++ Delete(cv); ++ } else { ++ ParmList *cv = Copy(varargs); ++ Setattr(function,"parms", cv); ++ Delete(cv); ++ } ++ break; ++ } ++ pp = p; ++ p = nextSibling(p); ++ } ++ } ++ ++ /* Do not add in functions if kwargs is being used or if user wants old default argument wrapping ++ (one wrapped method per function irrespective of number of default arguments) */ ++ if (compact_default_args ++ || is_cfunction(function) ++ || GetFlag(function,"feature:compactdefaultargs") ++ || (GetFlag(function,"feature:kwargs") && kwargs_supported)) { ++ ParmList *p = Getattr(function,"parms"); ++ if (p) ++ Setattr(p,"compactdefargs", "1"); /* mark parameters for special handling */ ++ function = 0; /* don't add in extra methods */ ++ } ++ } ++ ++ while (function) { ++ ParmList *parms = Getattr(function,"parms"); ++ if (ParmList_has_defaultargs(parms)) { ++ ++ /* Create a parameter list for the new function by copying all ++ but the last (defaulted) parameter */ ++ ParmList* newparms = CopyParmListMax(parms,ParmList_len(parms)-1); ++ ++ /* Create new function and add to symbol table */ ++ { ++ SwigType *ntype = Copy(nodeType(function)); ++ char *cntype = Char(ntype); ++ Node *new_function = new_node(ntype); ++ SwigType *decl = Copy(Getattr(function,"decl")); ++ int constqualifier = SwigType_isconst(decl); ++ String *ccode = Copy(Getattr(function,"code")); ++ String *cstorage = Copy(Getattr(function,"storage")); ++ String *cvalue = Copy(Getattr(function,"value")); ++ SwigType *ctype = Copy(Getattr(function,"type")); ++ String *cthrow = Copy(Getattr(function,"throw")); ++ ++ Delete(SwigType_pop_function(decl)); /* remove the old parameter list from decl */ ++ SwigType_add_function(decl,newparms); ++ if (constqualifier) ++ SwigType_add_qualifier(decl,"const"); ++ ++ Setattr(new_function,"name", Getattr(function,"name")); ++ Setattr(new_function,"code", ccode); ++ Setattr(new_function,"decl", decl); ++ Setattr(new_function,"parms", newparms); ++ Setattr(new_function,"storage", cstorage); ++ Setattr(new_function,"value", cvalue); ++ Setattr(new_function,"type", ctype); ++ Setattr(new_function,"throw", cthrow); ++ ++ Delete(ccode); ++ Delete(cstorage); ++ Delete(cvalue); ++ Delete(ctype); ++ Delete(cthrow); ++ Delete(decl); ++ ++ { ++ Node *throws = Getattr(function,"throws"); ++ ParmList *pl = CopyParmList(throws); ++ if (throws) Setattr(new_function,"throws",pl); ++ Delete(pl); ++ } ++ ++ /* copy specific attributes for global (or in a namespace) template functions - these are not templated class methods */ ++ if (strcmp(cntype,"template") == 0) { ++ Node *templatetype = Getattr(function,"templatetype"); ++ Node *symtypename = Getattr(function,"sym:typename"); ++ Parm *templateparms = Getattr(function,"templateparms"); ++ if (templatetype) { ++ Node *tmp = Copy(templatetype); ++ Setattr(new_function,"templatetype",tmp); ++ Delete(tmp); ++ } ++ if (symtypename) { ++ Node *tmp = Copy(symtypename); ++ Setattr(new_function,"sym:typename",tmp); ++ Delete(tmp); ++ } ++ if (templateparms) { ++ Parm *tmp = CopyParmList(templateparms); ++ Setattr(new_function,"templateparms",tmp); ++ Delete(tmp); ++ } ++ } else if (strcmp(cntype,"constructor") == 0) { ++ /* only copied for constructors as this is not a user defined feature - it is hard coded in the parser */ ++ if (GetFlag(function,"feature:new")) SetFlag(new_function,"feature:new"); ++ } ++ ++ add_symbols(new_function); ++ /* mark added functions as ones with overloaded parameters and point to the parsed method */ ++ Setattr(new_function,"defaultargs", n); ++ ++ /* Point to the new function, extending the linked list */ ++ set_nextSibling(function, new_function); ++ Delete(new_function); ++ function = new_function; ++ ++ Delete(ntype); ++ } ++ } else { ++ function = 0; ++ } ++ } ++} ++ ++/* ----------------------------------------------------------------------------- ++ * mark_nodes_as_extend() ++ * ++ * Used by the %extend to mark subtypes with "feature:extend". ++ * template instances declared within %extend are skipped ++ * ----------------------------------------------------------------------------- */ ++ ++static void mark_nodes_as_extend(Node *n) { ++ for (; n; n = nextSibling(n)) { ++ if (Getattr(n, "template") && Strcmp(nodeType(n), "class") == 0) ++ continue; ++ /* Fix me: extend is not a feature. Replace with isextendmember? */ ++ Setattr(n, "feature:extend", "1"); ++ mark_nodes_as_extend(firstChild(n)); ++ } ++} ++ ++/* ----------------------------------------------------------------------------- ++ * add_qualifier_to_declarator() ++ * ++ * Normally the qualifier is pushed on to the front of the type. ++ * Adding a qualifier to a pointer to member function is a special case. ++ * For example : typedef double (Cls::*pmf)(void) const; ++ * The qualifier is : q(const). ++ * The declarator is : m(Cls).f(void). ++ * We need : m(Cls).q(const).f(void). ++ * ----------------------------------------------------------------------------- */ ++ ++static String *add_qualifier_to_declarator(SwigType *type, SwigType *qualifier) { ++ int is_pointer_to_member_function = 0; ++ String *decl = Copy(type); ++ String *poppedtype = NewString(""); ++ assert(qualifier); ++ ++ while (decl) { ++ if (SwigType_ismemberpointer(decl)) { ++ String *memberptr = SwigType_pop(decl); ++ if (SwigType_isfunction(decl)) { ++ is_pointer_to_member_function = 1; ++ SwigType_push(decl, qualifier); ++ SwigType_push(decl, memberptr); ++ Insert(decl, 0, poppedtype); ++ Delete(memberptr); ++ break; ++ } else { ++ Append(poppedtype, memberptr); ++ } ++ Delete(memberptr); ++ } else { ++ String *popped = SwigType_pop(decl); ++ if (!popped) ++ break; ++ Append(poppedtype, popped); ++ Delete(popped); ++ } ++ } ++ ++ if (!is_pointer_to_member_function) { ++ Delete(decl); ++ decl = Copy(type); ++ SwigType_push(decl, qualifier); ++ } ++ ++ Delete(poppedtype); ++ return decl; ++} ++ ++ ++ ++/* 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 ++ ++/* Enabling the token table. */ ++#ifndef YYTOKEN_TABLE ++# define YYTOKEN_TABLE 0 ++#endif ++ ++#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED ++typedef union YYSTYPE ++#line 1554 "parser.y" ++{ ++ const char *id; ++ List *bases; ++ struct Define { ++ String *val; ++ String *rawval; ++ int type; ++ String *qualifier; ++ String *refqualifier; ++ String *bitfield; ++ Parm *throws; ++ String *throwf; ++ String *nexcept; ++ String *final; ++ } dtype; ++ struct { ++ const char *type; ++ String *filename; ++ int line; ++ } loc; ++ struct { ++ char *id; ++ SwigType *type; ++ String *defarg; ++ ParmList *parms; ++ short have_parms; ++ ParmList *throws; ++ String *throwf; ++ String *nexcept; ++ String *final; ++ } decl; ++ Parm *tparms; ++ struct { ++ String *method; ++ Hash *kwargs; ++ } tmap; ++ struct { ++ String *type; ++ String *us; ++ } ptype; ++ SwigType *type; ++ String *str; ++ Parm *p; ++ ParmList *pl; ++ int intvalue; ++ Node *node; ++} ++/* Line 193 of yacc.c. */ ++#line 1963 "parser.c" ++ YYSTYPE; ++# 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 216 of yacc.c. */ ++#line 1976 "parser.c" ++ ++#ifdef short ++# undef short ++#endif ++ ++#ifdef YYTYPE_UINT8 ++typedef YYTYPE_UINT8 yytype_uint8; ++#else ++typedef unsigned char yytype_uint8; ++#endif ++ ++#ifdef YYTYPE_INT8 ++typedef YYTYPE_INT8 yytype_int8; ++#elif (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++typedef signed char yytype_int8; ++#else ++typedef short int yytype_int8; ++#endif ++ ++#ifdef YYTYPE_UINT16 ++typedef YYTYPE_UINT16 yytype_uint16; ++#else ++typedef unsigned short int yytype_uint16; ++#endif ++ ++#ifdef YYTYPE_INT16 ++typedef YYTYPE_INT16 yytype_int16; ++#else ++typedef short int yytype_int16; ++#endif ++ ++#ifndef YYSIZE_T ++# ifdef __SIZE_TYPE__ ++# define YYSIZE_T __SIZE_TYPE__ ++# elif defined size_t ++# define YYSIZE_T size_t ++# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++# include /* INFRINGES ON USER NAME SPACE */ ++# define YYSIZE_T size_t ++# else ++# define YYSIZE_T unsigned int ++# endif ++#endif ++ ++#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) ++ ++#ifndef YY_ ++# if defined YYENABLE_NLS && YYENABLE_NLS ++# if ENABLE_NLS ++# include /* INFRINGES ON USER NAME SPACE */ ++# define YY_(msgid) dgettext ("bison-runtime", msgid) ++# endif ++# endif ++# ifndef YY_ ++# define YY_(msgid) msgid ++# endif ++#endif ++ ++/* Suppress unused-variable warnings by "using" E. */ ++#if ! defined lint || defined __GNUC__ ++# define YYUSE(e) ((void) (e)) ++#else ++# define YYUSE(e) /* empty */ ++#endif ++ ++/* Identity function, used to suppress warnings about constant conditions. */ ++#ifndef lint ++# define YYID(n) (n) ++#else ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++static int ++YYID (int i) ++#else ++static int ++YYID (i) ++ int i; ++#endif ++{ ++ return i; ++} ++#endif ++ ++#if ! defined yyoverflow || YYERROR_VERBOSE ++ ++/* 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 ++# elif defined __BUILTIN_VA_ARG_INCR ++# include /* INFRINGES ON USER NAME SPACE */ ++# elif defined _AIX ++# define YYSTACK_ALLOC __alloca ++# elif defined _MSC_VER ++# include /* INFRINGES ON USER NAME SPACE */ ++# define alloca _alloca ++# else ++# define YYSTACK_ALLOC alloca ++# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++# include /* INFRINGES ON USER NAME SPACE */ ++# ifndef _STDLIB_H ++# define _STDLIB_H 1 ++# endif ++# endif ++# endif ++# endif ++# endif ++ ++# ifdef YYSTACK_ALLOC ++ /* Pacify GCC's `empty if-body' warning. */ ++# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) ++# ifndef YYSTACK_ALLOC_MAXIMUM ++ /* The OS might guarantee only one guard page at the bottom of the stack, ++ and a page size can be as small as 4096 bytes. So we cannot safely ++ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number ++ to allow for a few compiler-allocated temporary stack slots. */ ++# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ ++# endif ++# else ++# define YYSTACK_ALLOC YYMALLOC ++# define YYSTACK_FREE YYFREE ++# ifndef YYSTACK_ALLOC_MAXIMUM ++# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM ++# endif ++# if (defined __cplusplus && ! defined _STDLIB_H \ ++ && ! ((defined YYMALLOC || defined malloc) \ ++ && (defined YYFREE || defined free))) ++# include /* INFRINGES ON USER NAME SPACE */ ++# ifndef _STDLIB_H ++# define _STDLIB_H 1 ++# endif ++# endif ++# ifndef YYMALLOC ++# define YYMALLOC malloc ++# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ ++# endif ++# endif ++# ifndef YYFREE ++# define YYFREE free ++# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++void free (void *); /* INFRINGES ON USER NAME SPACE */ ++# endif ++# endif ++# 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 ++{ ++ yytype_int16 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 (yytype_int16) + 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 \ ++ { \ ++ YYSIZE_T yyi; \ ++ for (yyi = 0; yyi < (Count); yyi++) \ ++ (To)[yyi] = (From)[yyi]; \ ++ } \ ++ while (YYID (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 (YYID (0)) ++ ++#endif ++ ++/* YYFINAL -- State number of the termination state. */ ++#define YYFINAL 62 ++/* YYLAST -- Last index in YYTABLE. */ ++#define YYLAST 6281 ++ ++/* YYNTOKENS -- Number of terminals. */ ++#define YYNTOKENS 145 ++/* YYNNTS -- Number of nonterminals. */ ++#define YYNNTS 185 ++/* YYNRULES -- Number of rules. */ ++#define YYNRULES 632 ++/* YYNRULES -- Number of states. */ ++#define YYNSTATES 1204 ++ ++/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ ++#define YYUNDEFTOK 2 ++#define YYMAXUTOK 399 ++ ++#define YYTRANSLATE(YYX) \ ++ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) ++ ++/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ ++static const yytype_uint8 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, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ++ 2, 2, 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, 42, 43, 44, ++ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, ++ 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, ++ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, ++ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, ++ 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, ++ 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, ++ 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, ++ 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, ++ 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, ++ 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 ++}; ++ ++#if YYDEBUG ++/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in ++ YYRHS. */ ++static const yytype_uint16 yyprhs[] = ++{ ++ 0, 0, 3, 5, 9, 12, 16, 19, 25, 29, ++ 32, 35, 38, 40, 42, 44, 46, 48, 50, 52, ++ 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, ++ 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, ++ 95, 97, 98, 107, 113, 117, 123, 129, 139, 143, ++ 147, 150, 153, 159, 162, 168, 171, 176, 178, 180, ++ 188, 196, 202, 203, 211, 213, 215, 218, 221, 223, ++ 229, 235, 241, 245, 250, 254, 262, 271, 277, 281, ++ 283, 285, 289, 291, 296, 304, 311, 313, 315, 323, ++ 333, 342, 353, 359, 367, 374, 383, 385, 387, 393, ++ 398, 404, 412, 414, 418, 425, 432, 441, 443, 446, ++ 450, 452, 455, 459, 466, 472, 482, 485, 487, 489, ++ 491, 492, 499, 501, 508, 519, 521, 528, 538, 540, ++ 546, 548, 550, 552, 554, 556, 558, 560, 562, 565, ++ 567, 580, 595, 604, 606, 608, 610, 612, 614, 615, ++ 619, 621, 624, 627, 630, 632, 638, 647, 659, 666, ++ 668, 670, 672, 674, 676, 678, 679, 690, 691, 700, ++ 702, 707, 712, 713, 720, 724, 731, 736, 744, 746, ++ 748, 750, 752, 754, 756, 758, 761, 763, 766, 768, ++ 772, 774, 778, 783, 784, 791, 792, 798, 804, 807, ++ 808, 809, 817, 819, 821, 822, 826, 828, 830, 832, ++ 834, 836, 838, 840, 842, 846, 848, 850, 852, 854, ++ 856, 858, 860, 862, 864, 866, 869, 872, 879, 886, ++ 894, 903, 912, 921, 931, 939, 945, 948, 951, 954, ++ 957, 959, 961, 963, 965, 967, 969, 971, 973, 975, ++ 977, 979, 982, 987, 990, 993, 998, 1001, 1007, 1009, ++ 1011, 1013, 1015, 1017, 1020, 1022, 1024, 1027, 1030, 1032, ++ 1034, 1036, 1038, 1040, 1042, 1045, 1048, 1051, 1054, 1056, ++ 1059, 1062, 1065, 1068, 1070, 1072, 1075, 1077, 1081, 1086, ++ 1088, 1091, 1099, 1101, 1103, 1106, 1109, 1111, 1114, 1116, ++ 1120, 1122, 1124, 1126, 1129, 1131, 1135, 1137, 1140, 1146, ++ 1149, 1152, 1154, 1157, 1160, 1162, 1168, 1170, 1172, 1178, ++ 1180, 1183, 1187, 1191, 1193, 1196, 1199, 1203, 1208, 1214, ++ 1219, 1223, 1228, 1233, 1236, 1240, 1244, 1249, 1255, 1262, ++ 1269, 1275, 1281, 1283, 1286, 1290, 1295, 1301, 1305, 1310, ++ 1315, 1317, 1320, 1325, 1330, 1335, 1341, 1348, 1354, 1361, ++ 1365, 1370, 1375, 1381, 1383, 1386, 1389, 1392, 1396, 1400, ++ 1402, 1405, 1408, 1410, 1412, 1415, 1419, 1423, 1428, 1432, ++ 1437, 1440, 1444, 1448, 1453, 1459, 1463, 1467, 1470, 1473, ++ 1475, 1477, 1480, 1482, 1484, 1486, 1488, 1491, 1493, 1495, ++ 1497, 1499, 1502, 1504, 1507, 1511, 1513, 1515, 1517, 1520, ++ 1522, 1524, 1527, 1529, 1534, 1536, 1538, 1541, 1543, 1545, ++ 1547, 1549, 1551, 1553, 1555, 1557, 1559, 1561, 1563, 1565, ++ 1567, 1569, 1570, 1573, 1575, 1577, 1579, 1581, 1583, 1585, ++ 1587, 1589, 1592, 1594, 1596, 1598, 1601, 1605, 1610, 1612, ++ 1616, 1618, 1621, 1623, 1627, 1629, 1631, 1633, 1637, 1644, ++ 1648, 1655, 1659, 1666, 1670, 1677, 1679, 1681, 1683, 1689, ++ 1696, 1701, 1704, 1706, 1708, 1710, 1712, 1714, 1718, 1723, ++ 1729, 1735, 1741, 1748, 1755, 1758, 1761, 1763, 1765, 1767, ++ 1769, 1771, 1773, 1775, 1777, 1781, 1785, 1789, 1793, 1797, ++ 1801, 1805, 1809, 1813, 1817, 1821, 1825, 1829, 1833, 1839, ++ 1845, 1849, 1853, 1857, 1863, 1866, 1869, 1872, 1875, 1878, ++ 1880, 1882, 1884, 1885, 1889, 1891, 1893, 1897, 1898, 1903, ++ 1904, 1911, 1913, 1915, 1917, 1919, 1921, 1924, 1927, 1929, ++ 1931, 1933, 1935, 1937, 1939, 1941, 1943, 1945, 1947, 1949, ++ 1951, 1954, 1957, 1959, 1961, 1963, 1965, 1970, 1972, 1974, ++ 1980, 1983, 1988, 1990, 1992, 1995, 1997, 1999, 2003, 2007, ++ 2012, 2017, 2021, 2026, 2029, 2031, 2033, 2037, 2040, 2045, ++ 2048, 2051, 2055, 2057, 2059, 2061, 2063, 2065, 2067, 2069, ++ 2071, 2074, 2079, 2081, 2085, 2087, 2090, 2094, 2098, 2101, ++ 2104, 2107, 2109, 2112, 2114, 2118, 2121, 2126, 2128, 2132, ++ 2134, 2138, 2142, 2145, 2148, 2151, 2154, 2156, 2159, 2161, ++ 2163, 2165, 2167, 2171, 2173, 2177, 2183, 2185, 2189, 2193, ++ 2199, 2201, 2203 ++}; ++ ++/* YYRHS -- A `-1'-separated list of the rules' RHS. */ ++static const yytype_int16 yyrhs[] = ++{ ++ 146, 0, -1, 147, -1, 123, 243, 43, -1, 123, ++ 1, -1, 124, 243, 43, -1, 124, 1, -1, 125, ++ 40, 239, 41, 43, -1, 125, 1, 43, -1, 147, ++ 148, -1, 147, 126, -1, 147, 127, -1, 329, -1, ++ 149, -1, 186, -1, 203, -1, 43, -1, 1, -1, ++ 202, -1, 1, 122, -1, 150, -1, 152, -1, 153, ++ -1, 154, -1, 155, -1, 156, -1, 159, -1, 160, ++ -1, 163, -1, 164, -1, 165, -1, 166, -1, 167, ++ -1, 168, -1, 171, -1, 173, -1, 176, -1, 178, ++ -1, 183, -1, 184, -1, 185, -1, -1, 67, 326, ++ 301, 317, 46, 151, 220, 47, -1, 99, 182, 46, ++ 180, 47, -1, 100, 180, 43, -1, 63, 314, 55, ++ 270, 43, -1, 63, 263, 253, 250, 43, -1, 63, ++ 263, 255, 40, 239, 41, 259, 250, 43, -1, 63, ++ 1, 43, -1, 63, 1, 0, -1, 98, 4, -1, ++ 98, 323, -1, 97, 40, 314, 41, 46, -1, 97, ++ 46, -1, 97, 40, 314, 41, 43, -1, 97, 43, ++ -1, 323, 46, 243, 47, -1, 323, -1, 157, -1, ++ 102, 40, 158, 42, 327, 41, 4, -1, 102, 40, ++ 158, 42, 327, 41, 46, -1, 102, 40, 158, 41, ++ 43, -1, -1, 162, 326, 323, 60, 161, 147, 61, ++ -1, 8, -1, 9, -1, 95, 4, -1, 95, 46, ++ -1, 4, -1, 10, 40, 315, 41, 323, -1, 10, ++ 40, 315, 41, 4, -1, 10, 40, 315, 41, 46, ++ -1, 57, 326, 315, -1, 64, 40, 315, 41, -1, ++ 64, 40, 41, -1, 94, 40, 314, 41, 238, 314, ++ 43, -1, 94, 40, 314, 41, 238, 263, 253, 43, ++ -1, 68, 170, 314, 55, 169, -1, 68, 170, 314, ++ -1, 323, -1, 4, -1, 40, 314, 41, -1, 329, ++ -1, 172, 253, 315, 43, -1, 172, 40, 327, 41, ++ 253, 308, 43, -1, 172, 40, 327, 41, 323, 43, ++ -1, 65, -1, 66, -1, 69, 40, 315, 41, 253, ++ 308, 174, -1, 69, 40, 315, 42, 328, 41, 253, ++ 308, 43, -1, 69, 40, 315, 175, 41, 253, 308, ++ 174, -1, 69, 40, 315, 42, 328, 175, 41, 253, ++ 308, 43, -1, 69, 40, 315, 41, 174, -1, 69, ++ 40, 315, 42, 328, 41, 43, -1, 69, 40, 315, ++ 175, 41, 174, -1, 69, 40, 315, 42, 328, 175, ++ 41, 43, -1, 325, -1, 43, -1, 116, 40, 239, ++ 41, 43, -1, 42, 315, 55, 328, -1, 42, 315, ++ 55, 328, 175, -1, 70, 40, 177, 41, 253, 308, ++ 43, -1, 239, -1, 13, 42, 243, -1, 96, 40, ++ 179, 41, 180, 325, -1, 96, 40, 179, 41, 180, ++ 43, -1, 96, 40, 179, 41, 180, 55, 182, 43, ++ -1, 327, -1, 182, 181, -1, 42, 182, 181, -1, ++ 329, -1, 263, 252, -1, 40, 239, 41, -1, 40, ++ 239, 41, 40, 239, 41, -1, 115, 40, 239, 41, ++ 174, -1, 101, 40, 316, 41, 321, 104, 244, 105, ++ 43, -1, 103, 323, -1, 188, -1, 201, -1, 200, ++ -1, -1, 44, 323, 46, 187, 147, 47, -1, 192, ++ -1, 92, 317, 55, 263, 252, 43, -1, 120, 104, ++ 212, 105, 92, 317, 55, 263, 252, 43, -1, 230, ++ -1, 238, 263, 253, 308, 190, 189, -1, 238, 88, ++ 253, 308, 113, 191, 304, 190, 189, -1, 43, -1, ++ 42, 253, 308, 190, 189, -1, 46, -1, 1, -1, ++ 250, -1, 267, -1, 32, -1, 30, -1, 35, -1, ++ 317, -1, 317, 133, -1, 266, -1, 238, 88, 317, ++ 55, 193, 194, 40, 239, 41, 308, 195, 196, -1, ++ 238, 88, 317, 55, 193, 194, 40, 239, 41, 308, ++ 113, 263, 195, 196, -1, 238, 88, 317, 55, 193, ++ 194, 195, 196, -1, 58, -1, 104, -1, 329, -1, ++ 46, -1, 43, -1, -1, 40, 197, 43, -1, 71, ++ -1, 71, 72, -1, 71, 53, -1, 77, 265, -1, ++ 329, -1, 238, 198, 275, 199, 43, -1, 238, 198, ++ 275, 199, 46, 278, 47, 43, -1, 238, 198, 275, ++ 199, 46, 278, 47, 253, 308, 190, 189, -1, 238, ++ 263, 40, 239, 41, 309, -1, 204, -1, 208, -1, ++ 209, -1, 216, -1, 217, -1, 229, -1, -1, 238, ++ 299, 317, 305, 290, 46, 205, 220, 47, 207, -1, ++ -1, 238, 299, 290, 46, 206, 220, 47, 207, -1, ++ 43, -1, 253, 308, 190, 189, -1, 238, 299, 317, ++ 43, -1, -1, 120, 104, 212, 105, 210, 211, -1, ++ 120, 299, 317, -1, 120, 191, 317, 40, 239, 41, ++ -1, 44, 120, 299, 317, -1, 44, 120, 191, 317, ++ 40, 239, 41, -1, 188, -1, 204, -1, 226, -1, ++ 209, -1, 208, -1, 228, -1, 213, -1, 214, 215, ++ -1, 329, -1, 298, 250, -1, 243, -1, 42, 214, ++ 215, -1, 329, -1, 92, 317, 43, -1, 92, 93, ++ 317, 43, -1, -1, 93, 317, 46, 218, 147, 47, ++ -1, -1, 93, 46, 219, 147, 47, -1, 93, 314, ++ 55, 317, 43, -1, 225, 220, -1, -1, -1, 67, ++ 46, 221, 220, 47, 222, 220, -1, 160, -1, 329, ++ -1, -1, 1, 223, 220, -1, 186, -1, 226, -1, ++ 227, -1, 231, -1, 232, -1, 228, -1, 208, -1, ++ 204, -1, 238, 317, 43, -1, 216, -1, 209, -1, ++ 229, -1, 184, -1, 185, -1, 235, -1, 159, -1, ++ 183, -1, 43, -1, 224, -1, 126, 224, -1, 224, ++ 127, -1, 238, 263, 40, 239, 41, 309, -1, 142, ++ 319, 40, 239, 41, 233, -1, 79, 142, 319, 40, ++ 239, 41, 234, -1, 238, 122, 263, 258, 40, 239, ++ 41, 234, -1, 238, 122, 263, 133, 40, 239, 41, ++ 234, -1, 238, 122, 263, 130, 40, 239, 41, 234, ++ -1, 238, 122, 263, 258, 133, 40, 239, 41, 234, ++ -1, 238, 122, 263, 40, 239, 41, 234, -1, 82, ++ 40, 239, 41, 46, -1, 84, 40, -1, 75, 77, ++ -1, 74, 77, -1, 76, 77, -1, 168, -1, 154, ++ -1, 166, -1, 171, -1, 173, -1, 176, -1, 164, ++ -1, 178, -1, 152, -1, 153, -1, 155, -1, 308, ++ 43, -1, 308, 55, 272, 43, -1, 308, 46, -1, ++ 308, 43, -1, 308, 55, 270, 43, -1, 308, 46, ++ -1, 238, 236, 77, 283, 43, -1, 267, -1, 32, ++ -1, 30, -1, 35, -1, 317, -1, 44, 323, -1, ++ 44, -1, 237, -1, 237, 86, -1, 237, 21, -1, ++ 78, -1, 21, -1, 79, -1, 80, -1, 83, -1, ++ 85, -1, 83, 85, -1, 85, 83, -1, 78, 85, ++ -1, 85, 78, -1, 86, -1, 86, 78, -1, 78, ++ 86, -1, 44, 86, -1, 86, 44, -1, 329, -1, ++ 240, -1, 243, 241, -1, 329, -1, 42, 243, 241, ++ -1, 42, 127, 243, 241, -1, 329, -1, 264, 251, ++ -1, 120, 104, 299, 105, 299, 317, 250, -1, 49, ++ -1, 242, -1, 126, 242, -1, 242, 127, -1, 245, ++ -1, 247, 246, -1, 329, -1, 42, 247, 246, -1, ++ 329, -1, 243, -1, 286, -1, 286, 249, -1, 329, ++ -1, 42, 286, 249, -1, 329, -1, 55, 270, -1, ++ 55, 270, 58, 283, 59, -1, 55, 46, -1, 77, ++ 283, -1, 329, -1, 253, 250, -1, 256, 250, -1, ++ 250, -1, 255, 40, 239, 41, 259, -1, 253, -1, ++ 256, -1, 255, 40, 239, 41, 259, -1, 329, -1, ++ 258, 254, -1, 258, 133, 254, -1, 258, 130, 254, ++ -1, 255, -1, 133, 254, -1, 130, 254, -1, 317, ++ 118, 254, -1, 258, 317, 118, 254, -1, 258, 317, ++ 118, 133, 254, -1, 317, 118, 133, 254, -1, 258, ++ 49, 254, -1, 258, 133, 49, 254, -1, 258, 130, ++ 49, 254, -1, 49, 255, -1, 133, 49, 254, -1, ++ 130, 49, 254, -1, 317, 118, 49, 254, -1, 258, ++ 317, 118, 49, 254, -1, 258, 317, 118, 133, 49, ++ 254, -1, 258, 317, 118, 130, 49, 254, -1, 317, ++ 118, 133, 49, 254, -1, 317, 118, 130, 49, 254, ++ -1, 317, -1, 142, 317, -1, 40, 317, 41, -1, ++ 40, 258, 254, 41, -1, 40, 317, 118, 254, 41, ++ -1, 254, 58, 59, -1, 254, 58, 283, 59, -1, ++ 254, 40, 239, 41, -1, 317, -1, 142, 317, -1, ++ 40, 258, 255, 41, -1, 40, 133, 255, 41, -1, ++ 40, 130, 255, 41, -1, 40, 317, 118, 253, 41, ++ -1, 40, 317, 118, 261, 253, 41, -1, 40, 317, ++ 118, 256, 41, -1, 40, 317, 118, 261, 256, 41, ++ -1, 255, 58, 59, -1, 255, 58, 283, 59, -1, ++ 255, 40, 239, 41, -1, 121, 3, 40, 239, 41, ++ -1, 258, -1, 258, 257, -1, 258, 133, -1, 258, ++ 130, -1, 258, 133, 257, -1, 258, 130, 257, -1, ++ 257, -1, 133, 257, -1, 130, 257, -1, 133, -1, ++ 130, -1, 317, 118, -1, 317, 118, 261, -1, 258, ++ 317, 118, -1, 258, 317, 118, 257, -1, 257, 58, ++ 59, -1, 257, 58, 283, 59, -1, 58, 59, -1, ++ 58, 283, 59, -1, 40, 256, 41, -1, 257, 40, ++ 239, 41, -1, 257, 40, 239, 41, 259, -1, 40, ++ 239, 41, -1, 140, 261, 258, -1, 140, 258, -1, ++ 140, 261, -1, 140, -1, 261, -1, 261, 260, -1, ++ 260, -1, 133, -1, 130, -1, 262, -1, 262, 261, ++ -1, 50, -1, 51, -1, 52, -1, 264, -1, 261, ++ 265, -1, 265, -1, 265, 261, -1, 261, 265, 261, ++ -1, 267, -1, 32, -1, 30, -1, 198, 317, -1, ++ 35, -1, 317, -1, 299, 317, -1, 266, -1, 87, ++ 40, 317, 41, -1, 268, -1, 269, -1, 269, 268, ++ -1, 22, -1, 24, -1, 25, -1, 28, -1, 29, ++ -1, 26, -1, 27, -1, 31, -1, 23, -1, 33, ++ -1, 36, -1, 37, -1, 38, -1, 39, -1, -1, ++ 271, 283, -1, 272, -1, 273, -1, 274, -1, 106, ++ -1, 107, -1, 314, -1, 329, -1, 154, -1, 154, ++ 276, -1, 276, -1, 329, -1, 279, -1, 279, 127, ++ -1, 279, 42, 278, -1, 279, 42, 127, 278, -1, ++ 277, -1, 277, 280, 277, -1, 281, -1, 126, 281, ++ -1, 314, -1, 314, 55, 282, -1, 283, -1, 286, ++ -1, 263, -1, 3, 113, 3, -1, 3, 113, 3, ++ 40, 248, 41, -1, 284, 113, 3, -1, 284, 113, ++ 3, 40, 248, 41, -1, 3, 48, 3, -1, 3, ++ 48, 3, 40, 248, 41, -1, 284, 48, 3, -1, ++ 284, 48, 3, 40, 248, 41, -1, 287, -1, 284, ++ -1, 323, -1, 56, 40, 263, 251, 41, -1, 56, ++ 49, 40, 263, 251, 41, -1, 56, 40, 285, 41, ++ -1, 56, 285, -1, 324, -1, 11, -1, 12, -1, ++ 285, -1, 288, -1, 40, 283, 41, -1, 40, 283, ++ 41, 283, -1, 40, 283, 258, 41, 283, -1, 40, ++ 283, 133, 41, 283, -1, 40, 283, 130, 41, 283, ++ -1, 40, 283, 258, 133, 41, 283, -1, 40, 283, ++ 258, 130, 41, 283, -1, 133, 283, -1, 140, 283, ++ -1, 13, -1, 14, -1, 15, -1, 16, -1, 17, ++ -1, 18, -1, 19, -1, 20, -1, 283, 137, 283, ++ -1, 283, 136, 283, -1, 283, 140, 283, -1, 283, ++ 139, 283, -1, 283, 138, 283, -1, 283, 133, 283, ++ -1, 283, 131, 283, -1, 283, 132, 283, -1, 283, ++ 135, 283, -1, 283, 134, 283, -1, 283, 130, 283, ++ -1, 283, 129, 283, -1, 283, 110, 283, -1, 283, ++ 111, 283, -1, 40, 283, 105, 283, 41, -1, 40, ++ 285, 104, 283, 41, -1, 283, 109, 283, -1, 283, ++ 108, 283, -1, 283, 112, 283, -1, 283, 114, 283, ++ 77, 283, -1, 136, 283, -1, 137, 283, -1, 142, ++ 283, -1, 141, 283, -1, 263, 40, -1, 49, -1, ++ 329, -1, 291, -1, -1, 77, 292, 293, -1, 329, ++ -1, 294, -1, 293, 42, 294, -1, -1, 302, 295, ++ 317, 289, -1, -1, 302, 297, 296, 302, 317, 289, ++ -1, 75, -1, 74, -1, 76, -1, 72, -1, 73, ++ -1, 72, 49, -1, 73, 49, -1, 298, -1, 53, ++ -1, 54, -1, 72, -1, 53, -1, 54, -1, 300, ++ -1, 329, -1, 79, -1, 329, -1, 90, -1, 91, ++ -1, 91, 90, -1, 90, 91, -1, 303, -1, 329, ++ -1, 91, -1, 329, -1, 81, 40, 239, 41, -1, ++ 89, -1, 303, -1, 81, 40, 239, 41, 303, -1, ++ 89, 303, -1, 89, 40, 283, 41, -1, 259, -1, ++ 306, -1, 259, 306, -1, 307, -1, 329, -1, 308, ++ 310, 43, -1, 308, 310, 46, -1, 40, 239, 41, ++ 43, -1, 40, 239, 41, 46, -1, 55, 270, 43, ++ -1, 306, 55, 272, 43, -1, 77, 311, -1, 329, ++ -1, 312, -1, 311, 42, 312, -1, 312, 49, -1, ++ 311, 42, 312, 49, -1, 317, 40, -1, 317, 46, ++ -1, 104, 244, 105, -1, 3, -1, 90, -1, 91, ++ -1, 314, -1, 272, -1, 323, -1, 315, -1, 329, ++ -1, 319, 318, -1, 117, 144, 320, 318, -1, 319, ++ -1, 117, 144, 320, -1, 121, -1, 121, 313, -1, ++ 117, 144, 121, -1, 144, 320, 318, -1, 144, 320, ++ -1, 144, 121, -1, 119, 319, -1, 314, -1, 314, ++ 313, -1, 319, -1, 120, 314, 313, -1, 314, 322, ++ -1, 117, 144, 314, 322, -1, 314, -1, 117, 144, ++ 314, -1, 121, -1, 117, 144, 121, -1, 144, 314, ++ 322, -1, 144, 314, -1, 144, 121, -1, 119, 314, ++ -1, 323, 6, -1, 6, -1, 324, 7, -1, 7, ++ -1, 323, -1, 46, -1, 4, -1, 40, 327, 41, ++ -1, 329, -1, 315, 55, 328, -1, 315, 55, 328, ++ 42, 327, -1, 315, -1, 315, 42, 327, -1, 315, ++ 55, 157, -1, 315, 55, 157, 42, 327, -1, 323, ++ -1, 287, -1, -1 ++}; ++ ++/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ ++static const yytype_uint16 yyrline[] = ++{ ++ 0, 1730, 1730, 1742, 1746, 1749, 1752, 1755, 1758, 1763, ++ 1772, 1776, 1783, 1788, 1789, 1790, 1791, 1792, 1802, 1818, ++ 1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, ++ 1838, 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, ++ 1848, 1855, 1855, 1937, 1947, 1961, 1981, 2005, 2029, 2033, ++ 2044, 2053, 2072, 2078, 2084, 2089, 2096, 2103, 2107, 2120, ++ 2129, 2144, 2157, 2157, 2213, 2214, 2221, 2240, 2271, 2275, ++ 2285, 2290, 2308, 2351, 2357, 2370, 2376, 2402, 2408, 2415, ++ 2416, 2419, 2420, 2427, 2473, 2519, 2530, 2533, 2560, 2566, ++ 2572, 2578, 2586, 2592, 2598, 2604, 2612, 2613, 2614, 2617, ++ 2622, 2632, 2668, 2669, 2704, 2721, 2729, 2742, 2764, 2770, ++ 2774, 2777, 2788, 2793, 2806, 2818, 3117, 3127, 3134, 3135, ++ 3139, 3139, 3172, 3178, 3188, 3200, 3209, 3289, 3352, 3356, ++ 3381, 3385, 3396, 3401, 3402, 3403, 3407, 3408, 3409, 3413, ++ 3424, 3429, 3434, 3441, 3447, 3451, 3454, 3459, 3462, 3462, ++ 3475, 3478, 3481, 3490, 3493, 3500, 3522, 3551, 3649, 3702, ++ 3703, 3704, 3705, 3706, 3707, 3716, 3716, 3965, 3965, 4112, ++ 4113, 4125, 4143, 4143, 4404, 4410, 4416, 4422, 4428, 4431, ++ 4434, 4437, 4440, 4443, 4448, 4484, 4488, 4491, 4495, 4500, ++ 4504, 4509, 4519, 4550, 4550, 4608, 4608, 4630, 4657, 4674, ++ 4679, 4674, 4687, 4688, 4689, 4689, 4703, 4704, 4721, 4722, ++ 4723, 4724, 4725, 4726, 4727, 4728, 4729, 4730, 4731, 4732, ++ 4733, 4734, 4735, 4736, 4738, 4741, 4745, 4757, 4786, 4816, ++ 4849, 4868, 4889, 4911, 4934, 4957, 4965, 4972, 4979, 4987, ++ 4995, 4998, 5002, 5005, 5006, 5007, 5008, 5009, 5010, 5011, ++ 5012, 5015, 5026, 5037, 5050, 5061, 5072, 5086, 5089, 5092, ++ 5093, 5097, 5099, 5107, 5119, 5120, 5121, 5128, 5129, 5130, ++ 5131, 5132, 5133, 5134, 5135, 5136, 5137, 5138, 5139, 5140, ++ 5141, 5142, 5143, 5144, 5151, 5162, 5166, 5173, 5177, 5182, ++ 5186, 5198, 5208, 5218, 5221, 5225, 5231, 5244, 5248, 5251, ++ 5255, 5259, 5287, 5295, 5299, 5302, 5306, 5309, 5322, 5338, ++ 5349, 5359, 5371, 5375, 5379, 5386, 5408, 5425, 5444, 5463, ++ 5470, 5478, 5487, 5496, 5500, 5509, 5520, 5531, 5543, 5553, ++ 5567, 5575, 5584, 5593, 5597, 5606, 5617, 5628, 5640, 5650, ++ 5660, 5671, 5684, 5691, 5699, 5715, 5723, 5734, 5745, 5756, ++ 5775, 5783, 5800, 5808, 5815, 5822, 5833, 5845, 5856, 5868, ++ 5879, 5890, 5910, 5931, 5937, 5943, 5950, 5957, 5966, 5975, ++ 5978, 5987, 5996, 6003, 6010, 6017, 6025, 6035, 6046, 6057, ++ 6068, 6075, 6082, 6085, 6102, 6120, 6130, 6137, 6143, 6148, ++ 6155, 6159, 6164, 6171, 6175, 6181, 6185, 6191, 6192, 6193, ++ 6199, 6205, 6209, 6210, 6214, 6221, 6224, 6225, 6229, 6230, ++ 6232, 6235, 6238, 6243, 6254, 6279, 6282, 6336, 6340, 6344, ++ 6348, 6352, 6356, 6360, 6364, 6368, 6372, 6376, 6380, 6384, ++ 6388, 6394, 6394, 6410, 6415, 6418, 6424, 6439, 6455, 6456, ++ 6459, 6460, 6464, 6465, 6475, 6479, 6484, 6494, 6505, 6510, ++ 6515, 6518, 6524, 6532, 6544, 6559, 6560, 6580, 6584, 6588, ++ 6592, 6596, 6600, 6604, 6608, 6615, 6618, 6621, 6625, 6630, ++ 6642, 6650, 6654, 6659, 6673, 6690, 6691, 6694, 6704, 6722, ++ 6729, 6736, 6743, 6751, 6759, 6763, 6769, 6770, 6771, 6772, ++ 6773, 6774, 6775, 6776, 6779, 6783, 6787, 6791, 6795, 6799, ++ 6803, 6807, 6811, 6815, 6819, 6823, 6827, 6831, 6839, 6849, ++ 6853, 6857, 6861, 6870, 6876, 6880, 6884, 6888, 6892, 6908, ++ 6911, 6916, 6921, 6921, 6922, 6925, 6942, 6951, 6951, 6969, ++ 6969, 6987, 6988, 6989, 6992, 6996, 7000, 7004, 7010, 7013, ++ 7017, 7023, 7027, 7031, 7037, 7040, 7045, 7046, 7049, 7052, ++ 7055, 7058, 7063, 7066, 7071, 7074, 7079, 7085, 7091, 7097, ++ 7103, 7109, 7117, 7125, 7130, 7137, 7140, 7150, 7161, 7172, ++ 7182, 7192, 7200, 7212, 7213, 7216, 7217, 7218, 7219, 7222, ++ 7234, 7240, 7249, 7250, 7251, 7254, 7255, 7256, 7259, 7260, ++ 7263, 7268, 7272, 7275, 7278, 7281, 7284, 7289, 7293, 7296, ++ 7303, 7309, 7312, 7317, 7320, 7326, 7331, 7335, 7338, 7341, ++ 7344, 7349, 7353, 7356, 7359, 7365, 7368, 7371, 7379, 7382, ++ 7385, 7389, 7394, 7407, 7411, 7416, 7422, 7426, 7431, 7435, ++ 7442, 7445, 7450 ++}; ++#endif ++ ++#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE ++/* YYTNAME[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", "ID", "HBLOCK", "POUND", "STRING", ++ "WSTRING", "INCLUDE", "IMPORT", "INSERT", "CHARCONST", "WCHARCONST", ++ "NUM_INT", "NUM_FLOAT", "NUM_UNSIGNED", "NUM_LONG", "NUM_ULONG", ++ "NUM_LONGLONG", "NUM_ULONGLONG", "NUM_BOOL", "TYPEDEF", "TYPE_INT", ++ "TYPE_UNSIGNED", "TYPE_SHORT", "TYPE_LONG", "TYPE_FLOAT", "TYPE_DOUBLE", ++ "TYPE_CHAR", "TYPE_WCHAR", "TYPE_VOID", "TYPE_SIGNED", "TYPE_BOOL", ++ "TYPE_COMPLEX", "TYPE_TYPEDEF", "TYPE_RAW", "TYPE_NON_ISO_INT8", ++ "TYPE_NON_ISO_INT16", "TYPE_NON_ISO_INT32", "TYPE_NON_ISO_INT64", ++ "LPAREN", "RPAREN", "COMMA", "SEMI", "EXTERN", "INIT", "LBRACE", ++ "RBRACE", "PERIOD", "ELLIPSIS", "CONST_QUAL", "VOLATILE", "REGISTER", ++ "STRUCT", "UNION", "EQUAL", "SIZEOF", "MODULE", "LBRACKET", "RBRACKET", ++ "BEGINFILE", "ENDOFFILE", "ILLEGAL", "CONSTANT", "NAME", "RENAME", ++ "NAMEWARN", "EXTEND", "PRAGMA", "FEATURE", "VARARGS", "ENUM", "CLASS", ++ "TYPENAME", "PRIVATE", "PUBLIC", "PROTECTED", "COLON", "STATIC", ++ "VIRTUAL", "FRIEND", "THROW", "CATCH", "EXPLICIT", "STATIC_ASSERT", ++ "CONSTEXPR", "THREAD_LOCAL", "DECLTYPE", "AUTO", "NOEXCEPT", "OVERRIDE", ++ "FINAL", "USING", "NAMESPACE", "NATIVE", "INLINE", "TYPEMAP", "EXCEPT", ++ "ECHO", "APPLY", "CLEAR", "SWIGTEMPLATE", "FRAGMENT", "WARN", "LESSTHAN", ++ "GREATERTHAN", "DELETE_KW", "DEFAULT", "LESSTHANOREQUALTO", ++ "GREATERTHANOREQUALTO", "EQUALTO", "NOTEQUALTO", "LESSEQUALGREATER", ++ "ARROW", "QUESTIONMARK", "TYPES", "PARMS", "NONID", "DSTAR", "DCNOT", ++ "TEMPLATE", "OPERATOR", "CONVERSIONOPERATOR", "PARSETYPE", "PARSEPARM", ++ "PARSEPARMS", "DOXYGENSTRING", "DOXYGENPOSTSTRING", "CAST", "LOR", ++ "LAND", "OR", "XOR", "AND", "RSHIFT", "LSHIFT", "MINUS", "PLUS", ++ "MODULO", "SLASH", "STAR", "LNOT", "NOT", "UMINUS", "DCOLON", "$accept", ++ "program", "interface", "declaration", "swig_directive", ++ "extend_directive", "@1", "apply_directive", "clear_directive", ++ "constant_directive", "echo_directive", "except_directive", "stringtype", ++ "fname", "fragment_directive", "include_directive", "@2", "includetype", ++ "inline_directive", "insert_directive", "module_directive", ++ "name_directive", "native_directive", "pragma_directive", "pragma_arg", ++ "pragma_lang", "rename_directive", "rename_namewarn", ++ "feature_directive", "stringbracesemi", "featattr", "varargs_directive", ++ "varargs_parms", "typemap_directive", "typemap_type", "tm_list", ++ "tm_tail", "typemap_parm", "types_directive", "template_directive", ++ "warn_directive", "c_declaration", "@3", "c_decl", "c_decl_tail", ++ "initializer", "cpp_alternate_rettype", "cpp_lambda_decl", ++ "lambda_introducer", "lambda_template", "lambda_body", "lambda_tail", ++ "@4", "c_enum_key", "c_enum_inherit", "c_enum_forward_decl", ++ "c_enum_decl", "c_constructor_decl", "cpp_declaration", "cpp_class_decl", ++ "@5", "@6", "cpp_opt_declarators", "cpp_forward_class_decl", ++ "cpp_template_decl", "@7", "cpp_template_possible", "template_parms", ++ "templateparameters", "templateparameter", "templateparameterstail", ++ "cpp_using_decl", "cpp_namespace_decl", "@8", "@9", "cpp_members", "@10", ++ "@11", "@12", "cpp_member_no_dox", "cpp_member", "cpp_constructor_decl", ++ "cpp_destructor_decl", "cpp_conversion_operator", "cpp_catch_decl", ++ "cpp_static_assert", "cpp_protection_decl", "cpp_swig_directive", ++ "cpp_end", "cpp_vend", "anonymous_bitfield", "anon_bitfield_type", ++ "extern_string", "storage_class", "parms", "rawparms", "ptail", ++ "parm_no_dox", "parm", "valparms", "rawvalparms", "valptail", "valparm", ++ "callparms", "callptail", "def_args", "parameter_declarator", ++ "plain_declarator", "declarator", "notso_direct_declarator", ++ "direct_declarator", "abstract_declarator", "direct_abstract_declarator", ++ "pointer", "cv_ref_qualifier", "ref_qualifier", "type_qualifier", ++ "type_qualifier_raw", "type", "rawtype", "type_right", "decltype", ++ "primitive_type", "primitive_type_list", "type_specifier", "definetype", ++ "@13", "default_delete", "deleted_definition", "explicit_default", ++ "ename", "constant_directives", "optional_ignored_defines", "enumlist", ++ "enumlist_item", "edecl_with_dox", "edecl", "etype", "expr", "exprmem", ++ "exprsimple", "valexpr", "exprnum", "exprcompound", "variadic", ++ "inherit", "raw_inherit", "@14", "base_list", "base_specifier", "@15", ++ "@16", "access_specifier", "templcpptype", "cpptype", "classkey", ++ "classkeyopt", "opt_virtual", "virt_specifier_seq", ++ "virt_specifier_seq_opt", "class_virt_specifier_opt", ++ "exception_specification", "qualifiers_exception_specification", ++ "cpp_const", "ctor_end", "ctor_initializer", "mem_initializer_list", ++ "mem_initializer", "less_valparms_greater", "identifier", "idstring", ++ "idstringopt", "idcolon", "idcolontail", "idtemplate", ++ "idtemplatetemplate", "idcolonnt", "idcolontailnt", "string", "wstring", ++ "stringbrace", "options", "kwargs", "stringnum", "empty", 0 ++}; ++#endif ++ ++# ifdef YYPRINT ++/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to ++ token YYLEX-NUM. */ ++static const yytype_uint16 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, 297, 298, 299, 300, 301, 302, 303, 304, ++ 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, ++ 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, ++ 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, ++ 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, ++ 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, ++ 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, ++ 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, ++ 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, ++ 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, ++ 395, 396, 397, 398, 399 ++}; ++# endif ++ ++/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ ++static const yytype_uint16 yyr1[] = ++{ ++ 0, 145, 146, 146, 146, 146, 146, 146, 146, 147, ++ 147, 147, 147, 148, 148, 148, 148, 148, 148, 148, ++ 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, ++ 149, 149, 149, 149, 149, 149, 149, 149, 149, 149, ++ 149, 151, 150, 152, 153, 154, 154, 154, 154, 154, ++ 155, 155, 156, 156, 156, 156, 157, 158, 158, 159, ++ 159, 159, 161, 160, 162, 162, 163, 163, 164, 164, ++ 164, 164, 165, 166, 166, 167, 167, 168, 168, 169, ++ 169, 170, 170, 171, 171, 171, 172, 172, 173, 173, ++ 173, 173, 173, 173, 173, 173, 174, 174, 174, 175, ++ 175, 176, 177, 177, 178, 178, 178, 179, 180, 181, ++ 181, 182, 182, 182, 183, 184, 185, 186, 186, 186, ++ 187, 186, 186, 186, 186, 186, 188, 188, 189, 189, ++ 189, 189, 190, 191, 191, 191, 191, 191, 191, 191, ++ 192, 192, 192, 193, 194, 194, 195, 196, 197, 196, ++ 198, 198, 198, 199, 199, 200, 201, 201, 202, 203, ++ 203, 203, 203, 203, 203, 205, 204, 206, 204, 207, ++ 207, 208, 210, 209, 209, 209, 209, 209, 211, 211, ++ 211, 211, 211, 211, 212, 213, 213, 214, 214, 215, ++ 215, 216, 216, 218, 217, 219, 217, 217, 220, 221, ++ 222, 220, 220, 220, 223, 220, 224, 224, 224, 224, ++ 224, 224, 224, 224, 224, 224, 224, 224, 224, 224, ++ 224, 224, 224, 224, 225, 225, 225, 226, 227, 227, ++ 228, 228, 228, 228, 228, 229, 230, 231, 231, 231, ++ 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, ++ 232, 233, 233, 233, 234, 234, 234, 235, 236, 236, ++ 236, 236, 236, 237, 238, 238, 238, 238, 238, 238, ++ 238, 238, 238, 238, 238, 238, 238, 238, 238, 238, ++ 238, 238, 238, 238, 239, 240, 240, 241, 241, 241, ++ 242, 242, 242, 243, 243, 243, 244, 245, 245, 246, ++ 246, 247, 247, 248, 248, 249, 249, 250, 250, 250, ++ 250, 250, 251, 251, 251, 251, 252, 252, 252, 252, ++ 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, ++ 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, ++ 253, 253, 254, 254, 254, 254, 254, 254, 254, 254, ++ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, ++ 255, 255, 255, 256, 256, 256, 256, 256, 256, 256, ++ 256, 256, 256, 256, 256, 256, 256, 256, 257, 257, ++ 257, 257, 257, 257, 257, 257, 258, 258, 258, 258, ++ 259, 259, 259, 260, 260, 261, 261, 262, 262, 262, ++ 263, 264, 264, 264, 264, 265, 265, 265, 265, 265, ++ 265, 265, 265, 266, 267, 268, 268, 269, 269, 269, ++ 269, 269, 269, 269, 269, 269, 269, 269, 269, 269, ++ 269, 271, 270, 270, 272, 272, 273, 274, 275, 275, ++ 276, 276, 277, 277, 278, 278, 278, 278, 278, 279, ++ 280, 280, 281, 281, 282, 283, 283, 284, 284, 284, ++ 284, 284, 284, 284, 284, 285, 285, 285, 285, 285, ++ 285, 285, 285, 285, 285, 286, 286, 286, 286, 286, ++ 286, 286, 286, 286, 286, 286, 287, 287, 287, 287, ++ 287, 287, 287, 287, 288, 288, 288, 288, 288, 288, ++ 288, 288, 288, 288, 288, 288, 288, 288, 288, 288, ++ 288, 288, 288, 288, 288, 288, 288, 288, 288, 289, ++ 289, 290, 292, 291, 291, 293, 293, 295, 294, 296, ++ 294, 297, 297, 297, 298, 298, 298, 298, 299, 299, ++ 299, 300, 300, 300, 301, 301, 302, 302, 303, 303, ++ 303, 303, 304, 304, 305, 305, 306, 306, 306, 306, ++ 306, 306, 307, 307, 307, 308, 308, 309, 309, 309, ++ 309, 309, 309, 310, 310, 311, 311, 311, 311, 312, ++ 312, 313, 314, 314, 314, 315, 315, 315, 316, 316, ++ 317, 317, 317, 317, 317, 317, 317, 318, 318, 318, ++ 318, 319, 319, 320, 320, 321, 321, 321, 321, 321, ++ 321, 322, 322, 322, 322, 323, 323, 324, 324, 325, ++ 325, 325, 326, 326, 327, 327, 327, 327, 327, 327, ++ 328, 328, 329 ++}; ++ ++/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ ++static const yytype_uint8 yyr2[] = ++{ ++ 0, 2, 1, 3, 2, 3, 2, 5, 3, 2, ++ 2, 2, 1, 1, 1, 1, 1, 1, 1, 2, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 0, 8, 5, 3, 5, 5, 9, 3, 3, ++ 2, 2, 5, 2, 5, 2, 4, 1, 1, 7, ++ 7, 5, 0, 7, 1, 1, 2, 2, 1, 5, ++ 5, 5, 3, 4, 3, 7, 8, 5, 3, 1, ++ 1, 3, 1, 4, 7, 6, 1, 1, 7, 9, ++ 8, 10, 5, 7, 6, 8, 1, 1, 5, 4, ++ 5, 7, 1, 3, 6, 6, 8, 1, 2, 3, ++ 1, 2, 3, 6, 5, 9, 2, 1, 1, 1, ++ 0, 6, 1, 6, 10, 1, 6, 9, 1, 5, ++ 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, ++ 12, 14, 8, 1, 1, 1, 1, 1, 0, 3, ++ 1, 2, 2, 2, 1, 5, 8, 11, 6, 1, ++ 1, 1, 1, 1, 1, 0, 10, 0, 8, 1, ++ 4, 4, 0, 6, 3, 6, 4, 7, 1, 1, ++ 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, ++ 1, 3, 4, 0, 6, 0, 5, 5, 2, 0, ++ 0, 7, 1, 1, 0, 3, 1, 1, 1, 1, ++ 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, ++ 1, 1, 1, 1, 1, 2, 2, 6, 6, 7, ++ 8, 8, 8, 9, 7, 5, 2, 2, 2, 2, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 2, 4, 2, 2, 4, 2, 5, 1, 1, ++ 1, 1, 1, 2, 1, 1, 2, 2, 1, 1, ++ 1, 1, 1, 1, 2, 2, 2, 2, 1, 2, ++ 2, 2, 2, 1, 1, 2, 1, 3, 4, 1, ++ 2, 7, 1, 1, 2, 2, 1, 2, 1, 3, ++ 1, 1, 1, 2, 1, 3, 1, 2, 5, 2, ++ 2, 1, 2, 2, 1, 5, 1, 1, 5, 1, ++ 2, 3, 3, 1, 2, 2, 3, 4, 5, 4, ++ 3, 4, 4, 2, 3, 3, 4, 5, 6, 6, ++ 5, 5, 1, 2, 3, 4, 5, 3, 4, 4, ++ 1, 2, 4, 4, 4, 5, 6, 5, 6, 3, ++ 4, 4, 5, 1, 2, 2, 2, 3, 3, 1, ++ 2, 2, 1, 1, 2, 3, 3, 4, 3, 4, ++ 2, 3, 3, 4, 5, 3, 3, 2, 2, 1, ++ 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, ++ 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, ++ 1, 2, 1, 4, 1, 1, 2, 1, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 1, 0, 2, 1, 1, 1, 1, 1, 1, 1, ++ 1, 2, 1, 1, 1, 2, 3, 4, 1, 3, ++ 1, 2, 1, 3, 1, 1, 1, 3, 6, 3, ++ 6, 3, 6, 3, 6, 1, 1, 1, 5, 6, ++ 4, 2, 1, 1, 1, 1, 1, 3, 4, 5, ++ 5, 5, 6, 6, 2, 2, 1, 1, 1, 1, ++ 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, ++ 3, 3, 3, 3, 3, 3, 3, 3, 5, 5, ++ 3, 3, 3, 5, 2, 2, 2, 2, 2, 1, ++ 1, 1, 0, 3, 1, 1, 3, 0, 4, 0, ++ 6, 1, 1, 1, 1, 1, 2, 2, 1, 1, ++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ++ 2, 2, 1, 1, 1, 1, 4, 1, 1, 5, ++ 2, 4, 1, 1, 2, 1, 1, 3, 3, 4, ++ 4, 3, 4, 2, 1, 1, 3, 2, 4, 2, ++ 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, ++ 2, 4, 1, 3, 1, 2, 3, 3, 2, 2, ++ 2, 1, 2, 1, 3, 2, 4, 1, 3, 1, ++ 3, 3, 2, 2, 2, 2, 1, 2, 1, 1, ++ 1, 1, 3, 1, 3, 5, 1, 3, 3, 5, ++ 1, 1, 0 ++}; ++ ++/* 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 yytype_uint16 yydefact[] = ++{ ++ 632, 0, 0, 0, 0, 0, 12, 4, 582, 417, ++ 425, 418, 419, 422, 423, 420, 421, 407, 424, 406, ++ 426, 409, 427, 428, 429, 430, 292, 397, 398, 399, ++ 539, 540, 150, 534, 535, 0, 583, 584, 0, 0, ++ 594, 0, 0, 293, 0, 0, 395, 632, 402, 412, ++ 405, 414, 415, 538, 0, 601, 410, 592, 6, 0, ++ 0, 632, 1, 17, 68, 64, 65, 0, 269, 16, ++ 264, 632, 0, 0, 86, 87, 632, 632, 0, 0, ++ 268, 270, 271, 0, 272, 0, 273, 278, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 10, 11, 9, 13, 20, 21, 22, 23, ++ 24, 25, 26, 27, 632, 28, 29, 30, 31, 32, ++ 33, 34, 0, 35, 36, 37, 38, 39, 40, 14, ++ 117, 122, 119, 118, 18, 15, 159, 160, 161, 162, ++ 163, 164, 125, 265, 0, 283, 152, 151, 536, 537, ++ 0, 0, 0, 632, 595, 294, 408, 295, 3, 401, ++ 396, 632, 0, 431, 0, 0, 594, 373, 372, 389, ++ 0, 314, 290, 632, 323, 632, 369, 363, 350, 311, ++ 403, 416, 411, 602, 0, 0, 590, 5, 8, 0, ++ 284, 632, 286, 19, 0, 616, 281, 0, 263, 0, ++ 0, 623, 0, 0, 400, 601, 0, 632, 0, 0, ++ 82, 0, 632, 276, 280, 632, 274, 236, 277, 275, ++ 282, 279, 0, 0, 195, 601, 0, 0, 66, 67, ++ 0, 0, 55, 53, 50, 51, 632, 0, 632, 0, ++ 632, 632, 0, 116, 632, 135, 134, 136, 632, 0, ++ 139, 133, 0, 137, 0, 0, 0, 0, 0, 323, ++ 0, 350, 267, 266, 0, 632, 0, 632, 0, 0, ++ 596, 603, 593, 0, 582, 618, 473, 474, 486, 487, ++ 488, 489, 490, 491, 492, 493, 0, 0, 0, 0, ++ 0, 0, 0, 0, 301, 0, 296, 632, 456, 400, ++ 0, 466, 475, 455, 465, 476, 467, 472, 298, 404, ++ 632, 373, 372, 0, 0, 363, 410, 0, 333, 350, ++ 309, 436, 437, 307, 0, 433, 434, 435, 380, 0, ++ 455, 310, 0, 632, 0, 0, 325, 371, 342, 0, ++ 324, 370, 387, 388, 351, 312, 632, 0, 313, 632, ++ 0, 0, 366, 365, 320, 364, 342, 374, 600, 599, ++ 598, 0, 0, 285, 289, 586, 585, 0, 587, 0, ++ 0, 615, 120, 626, 0, 72, 49, 48, 632, 323, ++ 431, 74, 0, 542, 543, 541, 544, 0, 545, 0, ++ 78, 0, 0, 0, 102, 0, 0, 191, 0, 632, ++ 0, 193, 0, 0, 107, 0, 0, 0, 111, 316, ++ 323, 317, 319, 44, 0, 108, 110, 588, 0, 589, ++ 58, 0, 57, 0, 0, 184, 632, 188, 538, 186, ++ 0, 174, 138, 0, 0, 0, 0, 585, 0, 0, ++ 0, 0, 632, 0, 0, 342, 0, 632, 350, 632, ++ 601, 439, 632, 632, 522, 0, 521, 411, 524, 413, ++ 0, 591, 0, 0, 0, 0, 475, 0, 0, 0, ++ 471, 484, 514, 515, 485, 517, 516, 581, 0, 297, ++ 300, 518, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 617, 373, 372, 363, 410, 0, 0, 385, ++ 382, 366, 365, 0, 350, 374, 0, 432, 381, 632, ++ 363, 410, 335, 343, 632, 0, 334, 386, 0, 359, ++ 0, 0, 378, 0, 330, 0, 322, 368, 0, 321, ++ 367, 376, 0, 0, 0, 326, 375, 597, 7, 0, ++ 632, 0, 0, 176, 632, 0, 0, 622, 0, 632, ++ 0, 73, 0, 81, 0, 0, 0, 0, 0, 0, ++ 0, 192, 632, 0, 0, 632, 632, 0, 0, 112, ++ 0, 632, 632, 0, 0, 0, 0, 0, 172, 0, ++ 185, 190, 187, 632, 62, 0, 0, 0, 0, 83, ++ 0, 0, 0, 557, 548, 549, 394, 393, 562, 392, ++ 390, 558, 563, 565, 0, 566, 0, 0, 0, 154, ++ 0, 410, 632, 632, 167, 171, 554, 632, 555, 604, ++ 0, 461, 457, 477, 0, 0, 0, 389, 0, 0, ++ 632, 0, 0, 632, 511, 510, 506, 507, 512, 0, ++ 505, 504, 500, 501, 499, 503, 502, 495, 494, 498, ++ 497, 496, 463, 459, 0, 374, 354, 353, 352, 376, ++ 0, 0, 375, 0, 0, 0, 342, 344, 374, 0, ++ 347, 0, 361, 360, 383, 379, 332, 331, 0, 0, ++ 0, 327, 377, 336, 0, 0, 329, 632, 287, 70, ++ 71, 69, 632, 0, 627, 628, 631, 630, 624, 46, ++ 0, 45, 41, 80, 77, 79, 621, 97, 620, 0, ++ 92, 632, 619, 96, 0, 630, 0, 0, 103, 632, ++ 235, 0, 196, 197, 0, 264, 0, 0, 54, 52, ++ 632, 43, 0, 109, 0, 609, 607, 0, 61, 0, ++ 0, 114, 0, 632, 632, 0, 632, 0, 632, 0, ++ 0, 361, 632, 0, 560, 551, 550, 564, 391, 0, ++ 143, 632, 153, 155, 632, 632, 0, 132, 546, 523, ++ 525, 527, 547, 0, 0, 632, 632, 632, 478, 0, ++ 0, 0, 389, 388, 0, 0, 0, 0, 0, 470, ++ 632, 299, 0, 632, 632, 355, 357, 0, 0, 308, ++ 362, 345, 0, 349, 348, 315, 384, 337, 0, 0, ++ 328, 341, 340, 288, 0, 121, 0, 0, 361, 0, ++ 632, 0, 0, 0, 0, 0, 94, 632, 0, 123, ++ 194, 263, 0, 601, 105, 0, 104, 0, 361, 0, ++ 0, 0, 605, 632, 0, 56, 0, 264, 0, 178, ++ 179, 182, 181, 173, 180, 183, 0, 189, 175, 0, ++ 0, 85, 0, 0, 632, 144, 0, 145, 440, 442, ++ 448, 0, 444, 443, 632, 431, 563, 632, 158, 131, ++ 0, 128, 130, 126, 632, 532, 531, 533, 0, 529, ++ 204, 223, 0, 0, 0, 0, 270, 632, 0, 248, ++ 249, 241, 250, 221, 202, 246, 242, 240, 243, 244, ++ 245, 247, 222, 218, 219, 206, 213, 212, 216, 215, ++ 0, 224, 0, 207, 208, 211, 217, 209, 210, 220, ++ 0, 283, 165, 291, 0, 455, 304, 0, 508, 481, ++ 480, 479, 0, 0, 509, 468, 0, 513, 0, 0, ++ 356, 358, 346, 339, 338, 177, 629, 625, 632, 0, ++ 0, 88, 630, 99, 93, 632, 0, 0, 101, 0, ++ 75, 0, 113, 318, 610, 608, 614, 613, 612, 0, ++ 59, 60, 0, 632, 0, 0, 0, 63, 84, 556, ++ 561, 552, 632, 553, 632, 146, 0, 441, 0, 632, ++ 450, 452, 0, 632, 445, 0, 0, 0, 0, 0, ++ 574, 632, 526, 632, 632, 0, 199, 238, 237, 239, ++ 0, 225, 0, 0, 226, 198, 407, 406, 409, 0, ++ 405, 410, 0, 462, 0, 303, 306, 458, 483, 482, ++ 469, 464, 460, 0, 42, 0, 100, 0, 95, 632, ++ 90, 76, 106, 606, 611, 0, 632, 0, 0, 632, ++ 559, 0, 0, 148, 147, 142, 451, 449, 0, 156, ++ 632, 632, 446, 0, 571, 0, 573, 575, 0, 567, ++ 568, 632, 519, 528, 520, 0, 205, 0, 0, 632, ++ 169, 168, 632, 0, 214, 0, 455, 47, 98, 89, ++ 0, 115, 0, 172, 632, 0, 0, 0, 0, 127, ++ 632, 0, 453, 454, 632, 447, 569, 570, 572, 0, ++ 577, 579, 580, 0, 632, 0, 632, 0, 632, 0, ++ 0, 305, 91, 124, 0, 632, 632, 632, 0, 632, ++ 0, 149, 0, 576, 129, 530, 200, 0, 632, 0, ++ 257, 166, 632, 0, 0, 0, 632, 227, 0, 0, ++ 157, 578, 0, 632, 228, 0, 170, 234, 0, 632, ++ 632, 632, 0, 0, 140, 201, 229, 251, 253, 0, ++ 254, 256, 431, 232, 231, 230, 632, 0, 0, 0, ++ 233, 141, 252, 255 ++}; ++ ++/* YYDEFGOTO[NTERM-NUM]. */ ++static const yytype_int16 yydefgoto[] = ++{ ++ -1, 4, 5, 104, 105, 106, 829, 909, 910, 911, ++ 912, 111, 420, 421, 913, 914, 756, 114, 115, 915, ++ 117, 916, 119, 917, 714, 209, 918, 122, 919, 720, ++ 567, 920, 393, 921, 403, 239, 415, 240, 922, 923, ++ 924, 925, 554, 130, 893, 776, 249, 131, 771, 876, ++ 1006, 1075, 1121, 42, 618, 132, 133, 134, 135, 926, ++ 1042, 783, 1101, 927, 928, 753, 863, 424, 425, 426, ++ 590, 929, 140, 575, 399, 930, 1097, 1172, 1025, 931, ++ 932, 933, 934, 935, 936, 142, 937, 938, 1174, 1177, ++ 939, 1039, 143, 940, 313, 190, 363, 43, 191, 295, ++ 296, 479, 297, 944, 1045, 777, 172, 408, 173, 336, ++ 259, 175, 176, 260, 608, 609, 45, 46, 298, 204, ++ 48, 49, 50, 51, 52, 323, 324, 365, 326, 327, ++ 449, 879, 880, 881, 882, 1009, 1010, 1122, 300, 301, ++ 302, 330, 304, 305, 1093, 455, 456, 623, 779, 780, ++ 898, 1024, 899, 53, 54, 386, 387, 781, 611, 1002, ++ 627, 612, 613, 1178, 888, 1019, 1086, 1087, 183, 55, ++ 373, 418, 56, 186, 57, 272, 747, 852, 306, 307, ++ 723, 200, 374, 708, 192 ++}; ++ ++/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing ++ STATE-NUM. */ ++#define YYPACT_NINF -1090 ++static const yytype_int16 yypact[] = ++{ ++ 674, 4663, 4768, 51, 86, 4097, -1090, -1090, -1090, -1090, ++ -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, ++ -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, ++ -1090, -1090, 398, 30, 61, 150, -1090, -1090, 62, 109, ++ 197, 5491, 195, 95, 302, 5778, 693, 403, 693, -1090, ++ -1090, -1090, 3190, -1090, 195, 197, -1090, 196, -1090, 315, ++ 333, 5084, -1090, 263, -1090, -1090, -1090, 356, -1090, -1090, ++ 48, 380, 5161, 415, -1090, -1090, 380, 438, 445, 458, ++ 378, -1090, -1090, 488, 406, 509, 451, 249, 136, 320, ++ 513, 303, 517, 599, 600, 5563, 5563, 539, 556, 399, ++ 580, 5849, -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, ++ -1090, -1090, -1090, -1090, 380, -1090, -1090, -1090, -1090, -1090, ++ -1090, -1090, 1398, -1090, -1090, -1090, -1090, -1090, -1090, -1090, ++ -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, ++ -1090, -1090, -1090, 36, 5635, -1090, -1090, -1090, -1090, -1090, ++ 195, 234, 423, 2309, -1090, -1090, -1090, -1090, -1090, 693, ++ -1090, 3682, 875, 214, 2575, 3367, 53, 1024, 1194, 46, ++ 195, -1090, -1090, 165, 334, 165, 360, 114, 512, -1090, ++ -1090, -1090, -1090, -1090, 133, 541, -1090, -1090, -1090, 612, ++ -1090, 617, -1090, -1090, 946, -1090, -1090, 6049, 58, 946, ++ 946, -1090, 89, 1869, -1090, 179, 456, 350, 133, 133, ++ -1090, 946, 4979, -1090, -1090, 5084, -1090, -1090, -1090, -1090, ++ -1090, -1090, 195, 555, -1090, 191, 633, 133, -1090, -1090, ++ 946, 133, -1090, -1090, -1090, 681, 5084, 643, 1035, 657, ++ 670, 946, 399, 681, 5084, -1090, -1090, -1090, 5084, 195, ++ -1090, -1090, 195, 581, 399, 1805, 240, 2026, 946, 467, ++ 1406, 615, -1090, -1090, 1869, 195, 1903, 431, 678, 133, ++ -1090, -1090, 196, 631, 47, -1090, -1090, -1090, -1090, -1090, ++ -1090, -1090, -1090, -1090, -1090, -1090, 3367, 1645, 3367, 3367, ++ 3367, 3367, 3367, 3367, -1090, 642, -1090, 710, 719, 339, ++ 2675, 123, -1090, 25, -1090, -1090, 681, 765, -1090, -1090, ++ 3801, 527, 527, 735, 753, 1937, 675, 142, 467, -1090, ++ -1090, -1090, -1090, 743, 3367, -1090, -1090, -1090, -1090, 6042, ++ -1090, 2675, 766, 3801, 1309, 195, 473, 360, -1090, 1309, ++ 473, 360, -1090, 694, -1090, -1090, 5084, 2707, -1090, 5084, ++ 2839, 1309, 1665, 1688, 473, 360, 697, 1412, -1090, -1090, ++ 196, 790, 4873, -1090, -1090, -1090, -1090, 795, 681, 195, ++ 195, -1090, -1090, 393, 798, -1090, -1090, -1090, 165, 483, ++ 559, -1090, 803, -1090, -1090, -1090, -1090, 195, -1090, 809, ++ 796, 593, 818, 820, -1090, 822, 821, -1090, 5707, -1090, ++ 195, -1090, 826, 831, -1090, 835, 839, 5563, -1090, -1090, ++ 528, -1090, -1090, -1090, 5563, -1090, -1090, -1090, 840, -1090, ++ -1090, 654, 366, 843, 791, -1090, 856, -1090, 286, -1090, ++ 860, -1090, -1090, 158, 875, 875, 875, 265, 783, 865, ++ 227, 868, 5084, 2101, 2106, 799, 1430, 2161, 52, 836, ++ 313, -1090, 3920, 2161, -1090, 872, -1090, 355, -1090, -1090, ++ 197, -1090, 423, 911, 919, 2544, 819, 47, 5418, 889, ++ -1090, 2944, -1090, -1090, -1090, -1090, -1090, -1090, 2309, -1090, ++ -1090, -1090, 3367, 3367, 3367, 3367, 3367, 3367, 3367, 3367, ++ 3367, 3367, 3367, 3367, 3367, 3367, 3367, 3367, 3367, 3367, ++ 932, 933, -1090, 544, 544, 1800, 823, 448, 498, -1090, ++ -1090, 544, 544, 520, 824, 1274, 3367, 2675, -1090, 5084, ++ 1981, 37, 473, -1090, 5084, 2971, 473, -1090, 898, -1090, ++ 6075, 899, -1090, 6087, 473, 1309, 473, 360, 1309, 473, ++ 360, 384, 1309, 894, 2124, 473, -1090, -1090, -1090, 5084, ++ 617, 273, 907, -1090, -1090, 946, 2337, -1090, 908, 5084, ++ 914, -1090, 904, -1090, 607, 1227, 2404, 917, 5084, 1869, ++ 915, -1090, 1035, 4212, 921, -1090, 925, 5563, 425, 920, ++ 923, 5084, 670, 534, 924, 946, 5084, 81, 879, 5084, ++ -1090, -1090, -1090, 5084, -1090, 1274, 1585, 1309, 65, -1090, ++ 931, 1970, 938, 171, 888, 891, -1090, -1090, 601, -1090, ++ 540, -1090, -1090, -1090, 870, -1090, 929, 5778, 663, -1090, ++ 947, 783, 165, 912, -1090, -1090, -1090, 930, -1090, -1090, ++ 195, 954, 958, 3367, 3367, 3103, 3235, 3499, 173, 3367, ++ 403, 959, 5707, 710, 1370, 1370, 2150, 2150, 1946, 2805, ++ 3069, 3201, 2166, 2813, 2944, 752, 752, 688, 688, -1090, ++ -1090, -1090, 974, 975, 824, 693, -1090, -1090, -1090, 544, ++ 977, 978, 1035, 6129, 979, 525, 824, -1090, 218, 981, ++ -1090, 6141, 199, -1090, 199, -1090, 473, 473, 1309, 967, ++ 2139, 473, 360, 473, 1309, 1309, 473, 617, -1090, -1090, ++ -1090, 681, 5084, 4327, -1090, 987, -1090, 366, 990, -1090, ++ 993, -1090, -1090, -1090, -1090, 681, -1090, -1090, -1090, 995, ++ -1090, 2161, 681, -1090, 984, 281, 698, 1227, -1090, 2161, ++ -1090, 997, -1090, -1090, 4442, 57, 5707, 672, -1090, -1090, ++ 5084, -1090, 1002, -1090, 902, -1090, 321, 943, -1090, 1007, ++ 1003, -1090, 195, 1033, 856, 1008, -1090, 1035, 2161, 365, ++ 1309, -1090, 5084, 3367, -1090, -1090, -1090, -1090, -1090, 3758, ++ -1090, 951, -1090, -1090, 994, 2701, 444, -1090, -1090, 1014, ++ -1090, 852, -1090, 2454, 1012, 165, 3367, 3367, 2675, 3772, ++ 3367, 3367, 3499, 3991, 3367, 1020, 1022, 4734, 1026, -1090, ++ 403, -1090, 3367, 3367, 3367, -1090, -1090, 1027, 1028, -1090, ++ -1090, -1090, 530, -1090, -1090, -1090, -1090, 473, 1309, 1309, ++ 473, 473, 473, -1090, 1029, -1090, 946, 946, 199, 2454, ++ 5084, 81, 2337, 1630, 946, 1030, -1090, 2161, 1031, -1090, ++ -1090, 681, 1869, 27, -1090, 5563, -1090, 1037, 199, 71, ++ 133, 118, -1090, 2309, 318, -1090, 1010, 48, 5949, -1090, ++ -1090, -1090, -1090, -1090, -1090, -1090, 5233, -1090, -1090, 4557, ++ 1043, -1090, 1046, 4839, 679, -1090, 29, -1090, 994, -1090, ++ 59, 1042, 31, -1090, 5084, 559, 1021, 1013, -1090, -1090, ++ 1869, -1090, -1090, -1090, 912, -1090, -1090, -1090, 195, -1090, ++ -1090, -1090, 1050, 1015, 1044, 1051, 957, 3581, 133, -1090, ++ -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, ++ -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, -1090, ++ 1054, 976, 2454, -1090, -1090, -1090, -1090, -1090, -1090, -1090, ++ 5306, 1057, -1090, -1090, 1064, 767, -1090, 1067, -1090, 2675, ++ 2675, 2675, 3367, 3367, -1090, -1090, 1069, 2937, 1082, 1086, ++ -1090, -1090, -1090, 473, 473, -1090, -1090, -1090, 165, 1084, ++ 1091, -1090, 681, 1094, -1090, 2161, 1650, 81, -1090, 1090, ++ -1090, 1100, -1090, -1090, -1090, 321, -1090, -1090, 321, 1032, ++ -1090, -1090, 5707, 5084, 1869, 5707, 1998, -1090, -1090, 679, ++ -1090, -1090, 165, -1090, 5084, -1090, 668, -1090, 133, 994, ++ -1090, 1089, 1745, 139, -1090, 1105, 1107, 559, 195, 680, ++ -1090, 2161, -1090, 1099, 912, 2454, -1090, -1090, -1090, -1090, ++ 133, -1090, 1111, 1858, -1090, -1090, 1078, 1080, 1083, 1087, ++ 1093, 270, 2454, -1090, 3367, -1090, -1090, -1090, 2675, 2675, ++ -1090, -1090, -1090, 1118, -1090, 1124, -1090, 1128, -1090, 2161, ++ -1090, -1090, -1090, -1090, -1090, 1131, 1035, 1079, 141, 3920, ++ -1090, 444, 1142, -1090, -1090, -1090, -1090, -1090, 3367, -1090, ++ 2161, 994, -1090, 682, -1090, 1145, 1148, 1146, 385, -1090, ++ -1090, 165, -1090, -1090, -1090, 195, -1090, 2454, 1154, 5084, ++ -1090, -1090, 2161, 3367, -1090, 1151, 767, -1090, -1090, -1090, ++ 1162, -1090, 1164, -1090, 5084, 1170, 1173, 19, 1176, -1090, ++ 2161, 1171, -1090, 2675, 165, -1090, -1090, -1090, -1090, 195, ++ -1090, -1090, -1090, 444, 1099, 1172, 5084, 1180, 165, 4945, ++ 1858, -1090, -1090, -1090, 1181, 5084, 5084, 5084, 1184, 2701, ++ 15, -1090, 444, 1178, -1090, -1090, -1090, 1187, 2161, 444, ++ -1090, -1090, 2161, 1188, 1198, 1199, 5084, -1090, 5707, 668, ++ -1090, -1090, 2454, 2161, -1090, 548, -1090, -1090, 595, 2161, ++ 2161, 2161, 1200, 1179, -1090, -1090, -1090, -1090, -1090, 559, ++ -1090, -1090, 559, -1090, -1090, -1090, 2161, 668, 1202, 1203, ++ -1090, -1090, -1090, -1090 ++}; ++ ++/* YYPGOTO[NTERM-NUM]. */ ++static const yytype_int16 yypgoto[] = ++{ ++ -1090, -1090, -376, -1090, -1090, -1090, -1090, -4, 28, 17, ++ 34, -1090, 686, -1090, 85, 87, -1090, -1090, -1090, 104, ++ -1090, 107, -1090, 108, -1090, -1090, 111, -1090, 113, -558, ++ -681, 115, -1090, 120, -1090, -361, 665, -81, 121, 128, ++ 132, 137, -1090, 495, -956, -944, -169, -1090, -1090, -1090, ++ -1078, -1089, -1090, -120, -1090, -1090, -1090, -1090, -1090, 14, ++ -1090, -1090, 110, 43, 79, -1090, -1090, 258, -1090, 664, ++ 500, 143, -1090, -1090, -1090, -797, -1090, -1090, -1090, 348, ++ -1090, 505, -1090, 506, 182, -1090, -1090, -1090, -1090, -271, ++ -1090, -1090, -1090, 4, 90, -1090, -497, 1220, 6, 409, ++ -1090, 621, 787, -304, 162, -35, -590, -557, 390, 1619, ++ -21, -145, -1, 620, -633, 659, 20, -1090, -61, 40, ++ -20, -95, -97, 1219, -1090, -370, -1090, -161, -1090, -1090, ++ -1090, 394, 266, -958, -1090, -1090, 274, -1090, 1330, -1090, ++ -243, -140, -536, -1090, 140, 651, -1090, -1090, -1090, 387, ++ -1090, -1090, -1090, -227, -41, -1090, -1090, 259, -576, -1090, ++ -1090, -591, -1090, 491, 138, -1090, -1090, 157, -22, 1359, ++ -112, -1090, 1041, -241, -148, 1103, -1090, -253, 1639, -1090, ++ 552, 98, -190, -528, 0 ++}; ++ ++/* 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 -633 ++static const yytype_int16 yytable[] = ++{ ++ 6, 107, 325, 271, 251, 145, 250, 44, 59, 144, ++ 560, 203, 171, 303, 237, 731, 314, 767, 154, 136, ++ 706, 428, 109, 573, 265, 159, 174, 764, 369, 751, ++ 706, 461, 969, 108, 238, 238, 358, 271, 726, 110, ++ 404, 47, 47, 466, 470, 835, 580, 179, 137, 815, ++ 798, 816, 60, 698, 195, 1082, 332, 262, 1071, 1147, ++ 252, 1005, 8, 195, 371, 439, 160, -302, 180, 1004, ++ 980, 201, 1169, 1013, 8, 1005, 201, 210, 677, 148, ++ 1184, 47, 367, 266, 138, 716, 62, 195, 375, 376, ++ 112, 61, 113, 411, 382, 463, 27, 28, 29, 391, ++ 251, 47, 250, 267, 372, 1197, 677, 616, 1201, 116, ++ 149, 273, 118, 120, 201, 1119, 121, 8, 123, 547, ++ 124, 8, 263, 1125, 717, 125, 126, 718, 1168, 417, ++ -302, 153, 377, 127, 196, 1035, 8, 128, 345, 8, ++ 348, 318, 129, 196, 154, 8, 441, 1133, 139, 36, ++ 37, 189, 1148, 308, 333, 678, 370, 153, 1014, 294, ++ 464, 36, 37, 351, 371, 314, 337, 341, 197, 836, ++ 446, 500, 164, 179, 207, 179, 355, 1154, 703, 309, ++ 1152, 1114, 379, 760, 886, 1008, 169, 141, 314, 343, ++ 150, 364, 984, 299, 1159, 968, 1170, 719, 8, 734, ++ 823, 47, 72, 1176, 36, 37, 151, 388, 36, 37, ++ 956, 763, 254, 152, 794, 983, 737, 410, 594, 325, ++ 163, 8, 157, 36, 37, 641, 36, 37, 1096, 222, ++ 8, 38, 36, 37, 380, 40, 501, 8, 412, 987, ++ 416, 419, 165, 8, 352, 1105, 400, 353, 429, 27, ++ 28, 29, 47, 38, 427, 47, 335, 40, 440, 38, ++ 320, 604, 605, 40, 171, 451, 1081, 458, 27, 28, ++ 29, 1115, 434, 971, 1116, 435, 47, 699, 174, 195, ++ 440, 169, 169, 153, 47, 36, 37, 371, 47, 334, ++ 507, 508, 1056, 220, 513, 153, 706, 480, 1001, 179, ++ 1135, 153, 394, 795, 973, 395, 796, 228, 36, 37, ++ 337, 341, 38, 1104, 355, 184, 40, 36, 37, 700, ++ 321, 322, 990, 8, 36, 37, 406, 221, -632, 606, ++ 36, 37, 607, 582, 423, 38, -587, 572, 303, 40, ++ 185, 163, 8, 558, 38, 158, 238, -262, 40, 229, ++ 47, 537, 540, 238, 269, 270, -438, 38, 187, -438, ++ 335, 40, 428, 165, 991, 704, 224, 169, 550, 153, ++ 671, 371, 371, 47, 346, 1185, 188, 546, 179, 161, ++ 869, -632, 335, -601, -601, 193, 47, 8, 162, 47, ++ -438, -632, 347, 592, 163, 749, 194, 164, 625, 6, ++ 349, -632, 47, 383, 384, 195, 8, 640, 871, -601, ++ 36, 37, 586, 507, 508, 513, 165, 153, 350, 1060, ++ 199, 630, 385, 1070, 333, 1131, 591, 411, 179, 36, ++ 37, 1132, -632, 688, 8, 555, 528, 38, 629, 531, ++ 850, 40, 164, 161, -632, 889, 626, 615, 556, 619, ++ 671, 146, 162, 615, 724, 206, 38, 628, 163, 8, ++ 166, 164, 195, 213, 214, 851, -632, 610, 738, 167, ++ 147, 739, 168, 610, 36, 37, 30, 31, 208, 169, ++ 165, 170, 47, 947, 294, 211, 890, 891, 442, 666, ++ 892, 216, 47, 36, 37, 33, 34, 381, 212, 958, ++ 959, 38, 337, 341, 355, 40, 347, 442, 454, 1112, ++ 537, 540, 258, 524, 689, 1016, 238, 690, 299, 355, ++ 38, 36, 37, 559, 166, 347, 335, 808, 215, 218, ++ 8, 525, 600, 167, 219, 672, 168, 8, 442, 667, ++ 692, 347, 620, 169, 8, 170, 36, 37, 38, 217, ++ 364, 410, 40, 227, 6, 697, 347, 230, 886, 47, ++ 442, 668, 321, 322, 47, 524, 811, 161, 581, 107, ++ 524, 962, 412, 145, 728, 6, 145, 144, 347, 241, ++ 736, 800, 416, 525, 310, 164, 347, 136, 525, 47, ++ 109, 1187, 750, 378, 1188, 427, 242, 772, 397, 47, ++ 874, 108, 164, 1189, 234, 171, 195, 110, 47, 674, ++ 398, 713, 808, 195, 679, 757, 137, 36, 37, 174, ++ 244, 47, 179, 782, 36, 37, 47, 458, 409, 47, ++ 357, 36, 37, 47, 565, 566, 966, 967, 1190, 231, ++ 179, 1191, 232, 480, 38, 233, 945, 945, 166, 710, ++ 1192, 744, 138, 361, 447, 745, 453, 793, 112, 362, ++ 113, 269, 359, 945, 945, 321, 322, 177, 692, 170, ++ 606, 742, 251, 607, 250, 842, 716, 116, 195, 401, ++ 118, 120, 602, 755, 121, 546, 123, 371, 124, 407, ++ 603, 604, 605, 125, 126, 584, 585, 364, 546, 107, ++ 413, 127, 610, 145, 610, 128, 773, 144, 1073, 774, ++ 129, 1074, 414, 303, 432, 844, 139, 136, 718, 459, ++ 109, 615, 724, 1089, 325, 1126, 1090, 845, 1127, 615, ++ 107, 108, 1063, 446, 145, 1064, 462, 110, 144, 833, ++ 834, 610, 47, 27, 28, 29, 137, 477, 136, 610, ++ 943, 109, 478, 145, 591, 141, 6, 866, 615, 481, ++ 1032, 251, 108, 250, 981, 171, 428, 860, 110, 604, ++ 605, 877, 502, 159, 883, 615, 509, 137, 610, 174, ++ 47, 315, 138, 941, 238, 179, 946, 946, 112, 342, ++ 113, 878, 824, 515, 510, 610, 861, 1, 2, 3, ++ 179, 516, 47, 946, 946, 996, 519, 116, -632, 1044, ++ 118, 120, 793, 138, 121, 541, 123, 252, 124, 112, ++ 265, 113, 1199, 125, 126, 267, 497, 498, 499, 941, ++ 847, 127, 862, 548, 169, 128, 551, 615, 116, 557, ++ 129, 118, 120, 1040, 561, 121, 139, 123, 610, 124, ++ 563, 564, 872, 308, 125, 126, 1085, 610, 177, 294, ++ 568, 569, 127, 570, 571, 107, 128, 576, 610, 145, ++ 47, 129, 577, 144, 1003, 436, 578, 139, 8, 996, ++ 579, 583, 1098, 136, 587, 141, 109, 1020, 495, 496, ++ 497, 498, 499, 299, 782, 878, 588, 108, 589, 267, ++ 593, 595, 1186, 110, 1106, 670, 596, 145, 1193, 1194, ++ 1195, 599, 137, 617, 631, 317, 141, 601, 624, 177, ++ 970, 411, 632, 639, 47, 1200, 895, 896, 897, 642, ++ 505, 1066, 941, 1053, 1068, 662, 663, 436, 614, 682, ++ 684, 665, 669, 694, 622, 1046, 68, 702, 138, 8, ++ 712, 709, 195, 520, 112, 721, 113, 711, 727, 729, ++ 740, 730, 409, 527, 733, 36, 37, 748, 179, 735, ++ 741, 752, 761, 116, 1015, 615, 118, 120, 762, 765, ++ 121, 766, 123, 769, 124, 670, 758, 770, 775, 125, ++ 126, 778, 38, 429, 786, 610, 166, 127, 787, 427, ++ 799, 128, 179, 80, 81, 82, 129, 454, 84, 883, ++ 86, 87, 139, 883, 803, 804, 818, 170, 805, 806, ++ 810, 615, 813, 1094, 782, 941, 878, 8, 1198, 826, ++ 878, 325, 827, 47, 828, 830, 36, 37, 8, 832, ++ 839, 610, 941, 848, 47, 410, 849, 853, 854, 868, ++ 855, 141, 321, 322, 68, 875, 894, 72, 942, 615, ++ 597, 952, 807, 953, 333, 992, 412, 955, 960, 961, ++ 965, 976, 436, 334, 978, 161, 1017, 857, 982, 610, ++ 615, 883, 164, 156, 162, 638, 998, 999, 178, 1012, ++ 1018, 179, 1027, 164, 1072, 182, 1026, 941, 878, 1030, ++ 610, 1033, 615, 1034, -203, 1043, 1046, 1183, 1047, 47, ++ 1050, 80, 81, 82, 36, 37, 84, 837, 86, 87, ++ 615, 1028, 610, 1051, 179, 36, 37, 1052, 1029, 223, ++ 226, 1054, 1055, 1061, 1094, 177, 834, 1065, 179, 47, ++ 610, 38, 253, 1062, 1078, 40, 1083, 807, 1092, 615, ++ 1084, 1099, 38, 858, 47, -260, 166, -259, 615, 1118, ++ -261, 1107, 615, 261, 1103, 167, 335, 1108, 168, 610, ++ -258, 1109, 941, 615, 1111, 169, 47, 170, 610, 615, ++ 615, 615, 610, 1120, 1113, 47, 47, 47, 1128, 1137, ++ 1129, 268, 177, 610, 1136, 1130, 615, 8, 1140, 610, ++ 610, 610, 316, 319, 1144, 1142, 47, 1143, 338, 338, ++ 1145, 344, 831, 1146, 1151, 177, 610, 1149, 356, 1156, ++ 838, 1158, 1162, 975, 1166, 1005, 1157, 1171, 1173, 1179, ++ 8, 716, 979, 195, 333, 1163, 1164, 1165, 253, 1180, ++ 1181, 1196, 705, 339, 261, 1202, 1203, 743, 859, 870, ++ 1161, 1067, 164, 754, 867, 1031, 1182, 342, 864, 865, ++ 177, 155, 989, 396, 801, 643, 887, 317, 1141, 768, ++ 717, 181, 1007, 718, 1155, 1077, 162, 8, 784, 178, ++ 1021, 1022, 1076, 1095, 36, 37, 1153, 1167, 360, 846, ++ 430, 0, 177, 431, 0, 0, 438, 338, 338, 0, ++ 0, 445, 0, 0, 0, 448, 156, 261, 457, 0, ++ 0, 38, 8, 0, 161, 40, 0, 36, 37, 0, ++ 0, 0, 0, 162, 27, 28, 29, 0, 977, 0, ++ 0, 0, 164, 0, 0, 0, 335, 0, 0, 0, ++ 178, 0, 0, 719, 38, 0, 0, 0, 166, 440, ++ 0, 506, 319, 319, 0, 0, 514, 256, 438, 0, ++ 257, 0, 0, 0, 36, 37, 1059, 169, 0, 170, ++ 0, 0, 0, 0, 521, 338, 523, 177, 0, 0, ++ 338, 0, 0, 0, 447, 0, 453, 0, 0, 0, ++ 0, 38, 338, 338, 338, 166, 0, 0, 338, 36, ++ 37, 8, 1080, 0, 167, 0, 0, 168, 0, 8, ++ 552, 553, 342, 527, 169, 8, 170, 0, 0, 0, ++ 177, 0, 0, 1102, 0, 0, 38, 0, 562, 0, ++ 40, 205, 0, 8, 0, 0, 0, 0, 255, 0, ++ 0, 574, 0, 0, 0, 0, 440, 162, 225, 0, ++ 0, 335, 440, 0, 0, 351, 409, 0, 0, 0, ++ 0, 542, 27, 28, 29, 0, 1057, 0, 0, 0, ++ 440, 0, 0, 0, 0, 319, 319, 319, 0, 542, ++ 0, 598, 486, 0, 338, 338, 0, 338, 36, 37, ++ 0, 0, 0, 621, 329, 331, 36, 37, 0, 0, ++ 0, 0, 36, 37, 493, 494, 495, 496, 497, 498, ++ 499, 0, 1091, 0, 0, 38, 0, 0, 0, 166, ++ 36, 37, 0, 38, 0, 0, 0, 40, 256, 38, ++ 1102, 257, 0, 40, 0, 0, 443, 0, 169, 444, ++ 170, 0, 543, 0, 0, 544, 664, 38, 335, 0, ++ 1110, 40, 0, 366, 335, 0, 178, 0, 366, 366, ++ 543, 676, 0, 544, 0, 366, 0, 389, 390, 0, ++ 366, 1124, 335, 0, 0, 0, 338, 0, 0, 338, ++ 0, 0, 338, 338, 0, 338, 402, 0, 8, 366, ++ 405, 195, 0, 1138, 0, 0, 0, 0, 0, 0, ++ 366, 0, 0, 0, 0, 0, 261, 0, 0, 0, ++ 261, 1150, 0, 178, 437, 0, 465, 366, 471, 472, ++ 473, 474, 475, 476, 450, 317, 0, 0, 460, 0, ++ 0, 0, 0, 8, 162, 0, 178, 261, 338, 0, ++ 887, 0, 338, 0, 0, 0, 0, 0, 467, 1175, ++ 0, 195, 275, 8, 517, 0, 276, 277, 278, 279, ++ 280, 281, 282, 283, 284, 285, 0, 0, 8, 0, ++ 317, 785, 0, 974, 0, 36, 37, 530, 0, 162, ++ 533, 178, 0, 0, 0, 468, 177, 0, 1117, 436, ++ 317, 8, 0, 1058, 469, 0, 0, 0, 0, 162, ++ 0, 287, 38, 0, 0, 333, 166, 0, 0, 198, ++ 0, 0, 0, 178, 535, 256, 0, 0, 257, 338, ++ 36, 37, 0, 164, 0, 169, 0, 170, 333, 338, ++ 0, 338, 0, 235, 0, 338, 338, 538, 243, 0, ++ 36, 37, 0, 0, 0, 0, 164, 38, 8, 0, ++ 0, 166, 0, 0, 0, 36, 37, 0, 0, 0, ++ 256, 0, 0, 257, 0, 0, 0, 38, 261, 0, ++ 169, 166, 170, 0, 0, 0, 0, 0, 36, 37, ++ 256, 0, 38, 257, 0, 317, 40, 340, 1079, 0, ++ 169, 0, 170, 856, 162, 0, 354, 0, 178, 0, ++ 0, 338, 0, 8, 0, 38, 0, 335, 8, 40, ++ 253, 195, 644, 645, 646, 647, 648, 649, 650, 651, ++ 652, 653, 654, 655, 656, 657, 658, 659, 660, 661, ++ 335, 0, 0, 368, 0, 36, 37, 0, 368, 368, ++ 310, 178, 0, 0, 0, 368, 673, 0, 0, 0, ++ 368, 0, 0, 0, 0, 681, 0, 0, 164, 338, ++ 338, 8, 38, 0, 0, 0, 166, 0, 0, 368, ++ 0, 0, 8, 0, 261, 256, 340, 0, 257, 354, ++ 368, 422, 0, 261, 0, 169, 0, 170, 0, 0, ++ 36, 37, 0, 433, 368, 36, 37, 368, 317, 253, ++ 0, 1100, 0, 0, 0, 0, 8, 162, 0, 317, ++ 0, 321, 322, 0, 366, 0, 0, 38, 162, 0, ++ 0, 40, 38, 0, 0, 366, 40, 0, 0, 0, ++ 511, 261, 0, 512, 0, 434, 0, 0, 435, 1023, ++ 8, 0, 746, 452, 366, 169, 0, 0, 36, 37, ++ 0, 0, 162, 522, 0, 0, 0, 0, 526, 36, ++ 37, 0, 0, 788, 789, 651, 654, 661, 0, 797, ++ 534, 536, 539, 8, 0, 38, 545, 161, 0, 166, ++ 0, 1041, 0, 0, 8, 0, 38, 0, 256, 0, ++ 166, 257, 0, 36, 37, 164, 0, 0, 169, 256, ++ 170, 8, 257, 0, 0, 0, 0, 0, 0, 169, ++ 440, 170, 0, 0, 0, 0, 0, 261, 0, 688, ++ 38, 333, 0, 0, 166, 0, 0, 36, 37, 8, ++ 0, 0, 0, 256, 0, 261, 257, 261, 1069, 164, ++ 0, 0, 0, 169, 0, 170, 0, 162, 0, 0, ++ 0, 0, 0, 261, 38, 0, 0, 0, 166, 1088, ++ 36, 37, 536, 539, 0, 545, 440, 511, 0, 0, ++ 512, 36, 37, 0, 261, 339, 0, 0, 0, 170, ++ 493, 494, 495, 496, 497, 498, 499, 38, 36, 37, ++ 0, 40, 0, 873, 0, 843, 0, 0, 38, 0, ++ 689, 0, 40, 690, 8, 0, 0, 178, 0, 8, ++ 621, 511, 335, 0, 512, 38, 36, 37, 0, 166, ++ 949, 950, 474, 335, 951, 0, 0, 8, 256, 0, ++ 0, 257, 957, 0, 0, 0, 1134, 0, 169, 675, ++ 170, 440, 8, 38, 0, 0, 440, 40, 0, 0, ++ 535, 0, 0, 0, 686, 538, 0, 687, 0, 0, ++ 691, 693, 0, 696, 440, 0, 0, 0, 335, 0, ++ 1088, 0, 0, 695, 0, 0, 0, 0, 0, 440, ++ 0, 261, 0, 0, 0, 366, 366, 0, 819, 0, ++ 701, 36, 37, 366, 368, 707, 36, 37, 0, 0, ++ 0, 0, 0, 715, 722, 725, 0, 0, 985, 986, ++ 988, 27, 28, 29, 36, 37, 675, 0, 38, 0, ++ 691, 0, 40, 38, 368, 0, 722, 40, 0, 36, ++ 37, 0, 0, 0, 0, 759, 0, 0, 0, 1011, ++ 0, 38, 602, 335, 0, 40, 0, 0, 335, 0, ++ 603, 604, 605, 0, 0, 0, 38, 0, 482, 483, ++ 40, 0, 486, 0, 0, 0, 335, 0, 0, 0, ++ 0, 0, 0, 0, 482, 483, 484, 485, 486, 0, ++ 0, 335, 1048, 1049, 493, 494, 495, 496, 497, 498, ++ 499, 606, 0, 0, 607, 0, 0, 812, 491, 492, ++ 493, 494, 495, 496, 497, 498, 499, 817, 0, 820, ++ 0, 0, 274, 821, 822, 195, 275, 0, 0, 0, ++ 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, ++ 0, 9, 10, 11, 12, 13, 14, 15, 16, 17, ++ 18, 19, 20, 195, 21, 22, 23, 24, 25, 286, ++ 278, 279, 280, 281, 282, 283, 284, 285, 26, 27, ++ 28, 29, 30, 31, 0, 287, 722, 1011, 0, 0, ++ 0, 0, 0, 0, 841, 0, 722, 0, 0, 812, ++ 32, 33, 34, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 35, 0, 0, 36, ++ 37, 0, 0, 0, 0, 0, 0, 8, 1123, 0, ++ 195, 0, 0, 0, 0, 0, 0, 278, 279, 280, ++ 281, 282, 283, 284, 285, 0, 38, 0, 0, 39, ++ 40, 0, 0, 1139, 0, 41, 0, 963, 964, 0, ++ 0, 0, 288, 0, 0, 289, 290, 0, 0, 291, ++ 292, 293, 0, 0, 0, 900, 0, -632, 64, 0, ++ 0, 0, 65, 66, 67, 368, 368, 0, 0, 0, ++ 722, 972, 0, 368, 0, 68, -632, -632, -632, -632, ++ -632, -632, -632, -632, -632, -632, -632, -632, 0, -632, ++ -632, -632, -632, -632, 36, 37, 841, 901, 70, 0, ++ 0, -632, 0, 0, -632, -632, -632, -632, -632, 0, ++ 321, 322, 0, 0, 0, 0, 0, 72, 73, 74, ++ 75, 902, 77, 78, 79, -632, -632, -632, 903, 904, ++ 905, 0, 80, 906, 82, 0, 83, 84, 85, 86, ++ 87, -632, -632, 0, -632, -632, 88, 0, 0, 0, ++ 92, 0, 94, 95, 96, 97, 98, 99, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 100, ++ 0, -632, 0, 0, 101, -632, -632, 0, 274, 0, ++ 907, 195, 275, 0, 0, 633, 276, 277, 278, 279, ++ 280, 281, 282, 283, 284, 285, 908, 9, 10, 11, ++ 12, 13, 14, 15, 16, 17, 18, 19, 20, 0, ++ 21, 22, 23, 24, 25, 286, 722, 0, 0, 0, ++ 0, 0, 0, 0, 0, 27, 28, 29, 30, 31, ++ 0, 287, 0, 0, 328, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 32, 33, 34, 634, ++ 0, 0, 482, 483, 484, 485, 486, 0, 487, 0, ++ 0, 0, 35, 0, 0, 36, 37, 0, 0, 0, ++ 0, 0, 0, 488, 635, 490, 491, 636, 493, 494, ++ 495, 496, 497, 498, 637, 0, 0, 0, 0, 0, ++ 0, 0, 38, 0, 0, 0, 40, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 288, 0, ++ 274, 289, 290, 195, 275, 291, 292, 293, 276, 277, ++ 278, 279, 280, 281, 282, 283, 284, 285, 0, 9, ++ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ++ 20, 884, 21, 22, 23, 24, 25, 286, 0, 0, ++ 0, 27, 28, 29, 0, 0, 885, 27, 28, 29, ++ 30, 31, 0, 287, 0, 0, 529, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 32, 33, ++ 34, 0, 602, 482, 483, 484, 485, 486, 0, 487, ++ 603, 604, 605, 0, 35, 0, 0, 36, 37, 0, ++ 0, 0, 0, 0, 488, 489, 490, 491, 492, 493, ++ 494, 495, 496, 497, 498, 499, 0, 0, 0, 0, ++ 0, 0, 0, 0, 38, 0, 0, 0, 40, 0, ++ 0, 606, 0, 0, 607, 0, 0, 0, 0, 0, ++ 288, 0, 274, 289, 290, 195, 275, 291, 292, 293, ++ 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, ++ 0, 9, 10, 11, 12, 13, 14, 15, 16, 17, ++ 18, 19, 20, 0, 21, 22, 23, 24, 25, 286, ++ 0, 0, 802, 0, 0, 0, 0, 0, 0, 27, ++ 28, 29, 30, 31, 0, 287, 0, 0, 532, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 32, 33, 34, 482, 483, 484, 485, 486, 0, 487, ++ 0, 482, 483, 484, 485, 486, 35, 0, 0, 36, ++ 37, 0, 0, 0, 488, 489, 490, 491, 492, 493, ++ 494, 495, 496, 497, 498, 499, 492, 493, 494, 495, ++ 496, 497, 498, 499, 0, 0, 38, 0, 0, 0, ++ 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 288, 0, 274, 289, 290, 195, 275, 291, ++ 292, 293, 276, 277, 278, 279, 280, 281, 282, 283, ++ 284, 285, 0, 9, 10, 11, 12, 13, 14, 15, ++ 16, 17, 18, 19, 20, 0, 21, 22, 23, 24, ++ 25, 286, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 27, 28, 29, 30, 31, 0, 287, 0, 0, ++ 680, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 32, 33, 34, 482, 483, 484, 485, 486, ++ 0, 0, 482, 483, 484, 485, 486, 0, 35, 0, ++ 0, 36, 37, 0, 0, 0, 488, 489, 490, 491, ++ 492, 493, 494, 495, 496, 497, 498, 499, 493, 494, ++ 495, 496, 497, 498, 499, 0, 0, 0, 38, 0, ++ 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 288, 0, 274, 289, 290, 195, ++ 275, 291, 292, 293, 276, 277, 278, 279, 280, 281, ++ 282, 283, 284, 285, 0, 9, 10, 11, 12, 13, ++ 14, 15, 16, 17, 18, 19, 20, 0, 21, 22, ++ 23, 24, 25, 286, 790, 0, 0, 0, 0, 0, ++ 0, 0, 0, 27, 28, 29, 30, 31, 0, 287, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 32, 33, 34, 482, 483, 484, ++ 485, 486, 0, 0, 0, 0, 0, 0, 0, 0, ++ 35, 0, 0, 36, 37, 0, 0, 0, 0, 489, ++ 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, ++ 0, 0, 9, 10, 11, 12, 13, 14, 15, 16, ++ 38, 18, 0, 20, 40, 0, 22, 23, 24, 25, ++ 0, 0, 0, 0, 0, 0, 288, 0, 274, 289, ++ 290, 195, 275, 291, 292, 293, 276, 277, 278, 279, ++ 280, 281, 282, 283, 284, 285, 0, 9, 10, 11, ++ 12, 13, 14, 15, 16, 17, 18, 19, 20, 0, ++ 21, 22, 23, 24, 25, 286, 791, 0, 0, 0, ++ 0, 0, 0, 0, 0, 27, 28, 29, 30, 31, ++ 0, 287, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 32, 33, 34, 482, ++ 483, 484, 485, 486, 0, 0, 0, 0, 0, 0, ++ 0, 0, 35, 0, 0, 36, 37, 0, 0, 0, ++ 0, 0, 490, 491, 492, 493, 494, 495, 496, 497, ++ 498, 499, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 38, 0, 0, 0, 40, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 288, 0, ++ 274, 289, 290, 195, 275, 291, 292, 293, 276, 277, ++ 278, 279, 280, 281, 282, 283, 284, 285, 0, 9, ++ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ++ 20, 0, 21, 22, 23, 24, 25, 286, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 27, 28, 29, ++ 30, 31, 0, 287, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 32, 33, ++ 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 35, 0, 0, 36, 37, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 38, 0, 0, 0, 40, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 288, 0, 274, 289, 290, 195, 275, 291, 292, 293, ++ 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, ++ 0, 9, 10, 11, 12, 13, 14, 15, 16, 17, ++ 18, 19, 20, 0, 21, 22, 23, 24, 25, 286, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, ++ 28, 29, 30, 31, 0, 287, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 32, 33, 34, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 64, 35, 0, 0, 36, ++ 37, 67, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 38, 0, 0, 0, ++ 40, 0, 0, 0, 901, 70, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 289, 290, 0, 0, 792, ++ 292, 293, 0, 0, 72, 73, 74, 75, 0, 77, ++ 78, 79, 0, 0, 0, 903, 904, 905, 0, 80, ++ 906, 82, 0, 83, 84, 85, 86, 87, 0, 0, ++ 0, 0, 0, 88, 0, 0, 0, 92, 0, 94, ++ 95, 96, 97, 98, 99, 8, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 100, 0, 0, 0, ++ 0, 101, 0, 0, 9, 10, 11, 12, 13, 14, ++ 15, 16, 17, 18, 19, 20, 0, 21, 22, 23, ++ 24, 25, 310, 908, 0, 0, 0, 0, 0, 0, ++ 0, 26, 27, 28, 29, 30, 31, 0, 0, 0, ++ 164, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 32, 33, 34, 0, 0, 0, 0, ++ 0, 8, 0, 0, 0, 0, 0, 0, 0, 35, ++ 0, 0, 36, 37, 0, 0, 0, 0, 0, 0, ++ 9, 10, 11, 12, 13, 14, 15, 16, 245, 18, ++ 246, 20, 0, 247, 22, 23, 24, 25, 0, 38, ++ 0, 0, 39, 40, 8, 0, 0, 0, 41, 0, ++ 0, 0, 311, 948, 0, 312, 0, 0, 0, 0, ++ 0, 0, 169, 9, 10, 11, 12, 13, 14, 15, ++ 16, 17, 18, 19, 20, 0, 21, 22, 23, 24, ++ 25, 310, 0, 0, 0, 35, 0, 0, 36, 37, ++ 26, 27, 28, 29, 30, 31, 0, 0, 0, 164, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 32, 33, 34, 38, 0, 0, 0, 40, ++ 482, 483, 484, 485, 486, 0, 487, 0, 35, 0, ++ 0, 36, 37, 0, 0, 0, 0, 0, 0, 0, ++ 0, 488, 489, 490, 491, 492, 493, 494, 495, 496, ++ 497, 498, 499, 0, 0, 0, 0, 0, 38, 0, ++ 0, 39, 40, 8, 0, 0, 0, 41, 0, 0, ++ 0, 503, 0, 0, 504, 0, 0, 0, 0, 0, ++ 0, 169, 9, 10, 11, 12, 13, 14, 15, 16, ++ 17, 18, 19, 20, 0, 21, 22, 23, 24, 25, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, ++ 27, 28, 29, 30, 31, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 32, 33, 34, 8, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, ++ 36, 37, 0, 9, 10, 11, 12, 13, 14, 15, ++ 16, 17, 18, 19, 20, 0, 21, 22, 23, 24, ++ 25, 0, 0, 0, 0, 0, 0, 38, 0, 0, ++ 39, 40, 0, 0, 30, 31, 41, 0, 0, 0, ++ 434, 0, 0, 435, 0, 0, 0, 0, 0, 0, ++ 169, 0, 32, 33, 34, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, ++ 0, 36, 37, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, -2, 63, 0, ++ -632, 64, 0, 0, 0, 65, 66, 67, 38, 0, ++ 0, 0, 40, 0, 0, 0, 0, 0, 68, -632, ++ -632, -632, -632, -632, -632, -632, -632, -632, -632, -632, ++ -632, 169, -632, -632, -632, -632, -632, 0, 0, 0, ++ 69, 70, 0, 0, 0, 0, 0, -632, -632, -632, ++ -632, -632, 0, 0, 71, 0, 0, 0, 0, 0, ++ 72, 73, 74, 75, 76, 77, 78, 79, -632, -632, ++ -632, 0, 0, 0, 0, 80, 81, 82, 0, 83, ++ 84, 85, 86, 87, -632, -632, 0, -632, -632, 88, ++ 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, ++ 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 100, 63, -632, -632, 64, 101, -632, 0, ++ 65, 66, 67, 102, 103, 0, 0, 0, 0, 0, ++ 0, 0, 0, 68, -632, -632, -632, -632, -632, -632, ++ -632, -632, -632, -632, -632, -632, 0, -632, -632, -632, ++ -632, -632, 0, 0, 0, 69, 70, 0, 0, 732, ++ 0, 0, -632, -632, -632, -632, -632, 0, 0, 71, ++ 0, 0, 0, 0, 0, 72, 73, 74, 75, 76, ++ 77, 78, 79, -632, -632, -632, 0, 0, 0, 0, ++ 80, 81, 82, 0, 83, 84, 85, 86, 87, -632, ++ -632, 0, -632, -632, 88, 89, 90, 91, 92, 93, ++ 94, 95, 96, 97, 98, 99, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 100, 63, -632, ++ -632, 64, 101, -632, 0, 65, 66, 67, 102, 103, ++ 0, 0, 0, 0, 0, 0, 0, 0, 68, -632, ++ -632, -632, -632, -632, -632, -632, -632, -632, -632, -632, ++ -632, 0, -632, -632, -632, -632, -632, 0, 0, 0, ++ 69, 70, 0, 0, 825, 0, 0, -632, -632, -632, ++ -632, -632, 0, 0, 71, 0, 0, 0, 0, 0, ++ 72, 73, 74, 75, 76, 77, 78, 79, -632, -632, ++ -632, 0, 0, 0, 0, 80, 81, 82, 0, 83, ++ 84, 85, 86, 87, -632, -632, 0, -632, -632, 88, ++ 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, ++ 99, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 100, 63, -632, -632, 64, 101, -632, 0, ++ 65, 66, 67, 102, 103, 0, 0, 0, 0, 0, ++ 0, 0, 0, 68, -632, -632, -632, -632, -632, -632, ++ -632, -632, -632, -632, -632, -632, 0, -632, -632, -632, ++ -632, -632, 0, 0, 0, 69, 70, 0, 0, 840, ++ 0, 0, -632, -632, -632, -632, -632, 0, 0, 71, ++ 0, 0, 0, 0, 0, 72, 73, 74, 75, 76, ++ 77, 78, 79, -632, -632, -632, 0, 0, 0, 0, ++ 80, 81, 82, 0, 83, 84, 85, 86, 87, -632, ++ -632, 0, -632, -632, 88, 89, 90, 91, 92, 93, ++ 94, 95, 96, 97, 98, 99, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 100, 63, -632, ++ -632, 64, 101, -632, 0, 65, 66, 67, 102, 103, ++ 0, 0, 0, 0, 0, 0, 0, 0, 68, -632, ++ -632, -632, -632, -632, -632, -632, -632, -632, -632, -632, ++ -632, 0, -632, -632, -632, -632, -632, 0, 0, 0, ++ 69, 70, 0, 0, 0, 0, 0, -632, -632, -632, ++ -632, -632, 0, 0, 71, 0, 0, 0, 997, 0, ++ 72, 73, 74, 75, 76, 77, 78, 79, -632, -632, ++ -632, 0, 0, 0, 0, 80, 81, 82, 0, 83, ++ 84, 85, 86, 87, -632, -632, 0, -632, -632, 88, ++ 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, ++ 99, 0, 0, 0, 7, 0, 8, 0, 0, 0, ++ 0, 0, 100, 0, -632, 0, 0, 101, -632, 0, ++ 0, 0, 0, 102, 103, 9, 10, 11, 12, 13, ++ 14, 15, 16, 17, 18, 19, 20, 0, 21, 22, ++ 23, 24, 25, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 26, 27, 28, 29, 30, 31, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 32, 33, 34, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 35, 0, 0, 36, 37, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 58, ++ 0, 8, 0, 0, 0, 954, 0, 0, 0, 0, ++ 38, 0, 0, 39, 40, 0, 0, 0, 0, 41, ++ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, ++ 19, 20, 0, 21, 22, 23, 24, 25, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 26, 27, 28, ++ 29, 30, 31, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, ++ 33, 34, 482, 483, 484, 485, 486, 0, 487, 0, ++ 0, 0, 0, 0, 0, 35, 0, 0, 36, 37, ++ 0, 0, 0, 488, 489, 490, 491, 492, 493, 494, ++ 495, 496, 497, 498, 499, 0, 8, 0, 0, 0, ++ 1000, 0, 0, 0, 0, 38, 0, 0, 39, 40, ++ 0, 0, 0, 0, 41, 9, 10, 11, 12, 13, ++ 14, 15, 16, 17, 18, 19, 20, 0, 21, 22, ++ 23, 24, 25, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 26, 27, 28, 29, 30, 31, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 32, 33, 34, 482, 483, 484, ++ 485, 486, 0, 487, 0, 0, 0, 0, 0, 0, ++ 35, 0, 0, 36, 37, 0, 0, 0, 488, 489, ++ 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, ++ 0, 0, 8, 0, 0, 0, 0, 0, 1160, 0, ++ 38, 0, 392, 39, 40, 0, 0, 0, 0, 41, ++ 549, 9, 10, 11, 12, 13, 14, 15, 16, 17, ++ 18, 19, 20, 0, 21, 22, 23, 24, 25, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 26, 27, ++ 28, 29, 30, 31, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 32, 33, 34, 482, 483, 484, 485, 486, 0, 487, ++ 0, 0, 0, 0, 0, 0, 35, 0, 0, 36, ++ 37, 0, 0, 0, 488, 489, 490, 491, 492, 493, ++ 494, 495, 496, 497, 498, 499, 0, 8, 0, 0, ++ 0, 0, 0, 0, 0, 0, 38, 0, 0, 39, ++ 40, 0, 0, 0, 0, 41, 9, 10, 11, 12, ++ 13, 14, 15, 16, 17, 18, 19, 20, 0, 21, ++ 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 26, 27, 28, 29, 30, 31, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 32, 33, 34, 0, 0, ++ 0, 0, 202, 0, 8, 0, 0, 0, 0, 0, ++ 0, 35, 0, 0, 36, 37, 0, 0, 0, 0, ++ 0, 0, 0, 9, 10, 11, 12, 13, 14, 15, ++ 16, 17, 18, 19, 20, 0, 21, 22, 23, 24, ++ 25, 38, 0, 0, 39, 40, 0, 0, 0, 0, ++ 41, 27, 28, 29, 30, 31, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 32, 33, 34, 0, 8, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, ++ 0, 36, 37, 0, 0, 9, 10, 11, 12, 13, ++ 14, 15, 16, 17, 18, 19, 20, 0, 21, 22, ++ 23, 24, 25, 0, 0, 0, 0, 0, 38, 0, ++ 0, 0, 40, 27, 28, 29, 30, 31, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 32, 33, 34, 0, 0, 8, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 35, 994, 0, 36, 37, 0, 0, 0, 9, 10, ++ 11, 12, 13, 14, 15, 16, 1036, 18, 1037, 20, ++ 0, 1038, 22, 23, 24, 25, 0, 0, 0, 0, ++ 38, 0, 0, 0, 40, 995, 27, 28, 29, 30, ++ 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 32, 33, 34, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 35, 264, 0, 36, 37, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 274, 0, 38, 195, 275, 0, 40, 995, 276, ++ 277, 278, 279, 280, 281, 282, 283, 284, 285, 0, ++ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, ++ 19, 20, 0, 21, 22, 23, 24, 25, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 27, 28, ++ 29, 30, 31, 0, 287, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, ++ 33, 34, 0, 0, 8, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 35, 0, 0, 36, 37, ++ 0, 0, 0, 9, 10, 11, 12, 13, 14, 15, ++ 16, 17, 18, 19, 20, 0, 21, 22, 23, 24, ++ 25, 0, 0, 0, 0, 38, 0, 0, 0, 40, ++ 26, 27, 28, 29, 30, 31, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 32, 33, 34, 0, 8, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, ++ 0, 36, 37, 0, 0, 9, 10, 11, 12, 13, ++ 14, 15, 16, 17, 18, 19, 20, 0, 21, 22, ++ 23, 24, 25, 236, 0, 0, 0, 0, 38, 0, ++ 0, 39, 40, 27, 28, 29, 30, 31, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 32, 33, 34, 0, 8, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 35, 0, 0, 36, 37, 0, 0, 9, 10, 11, ++ 12, 13, 14, 15, 16, 17, 18, 19, 20, 0, ++ 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, ++ 38, 0, 0, 0, 40, 27, 28, 29, 30, 31, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 32, 33, 34, 0, ++ 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 35, 264, 0, 36, 37, 0, 0, 9, ++ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ++ 20, 0, 21, 22, 23, 24, 25, 0, 0, 0, ++ 0, 0, 38, 0, 0, 0, 40, 27, 28, 29, ++ 30, 31, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 32, 33, ++ 34, 8, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 35, 0, 0, 36, 37, 0, ++ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, ++ 19, 20, 0, 21, 22, 23, 24, 25, 0, 0, ++ 0, 0, 0, 0, 38, 0, 0, 0, 40, 0, ++ 0, 30, 31, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, ++ 33, 34, 8, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 35, 0, 0, 36, 37, ++ 0, 9, 10, 11, 12, 13, 14, 15, 16, 245, ++ 18, 246, 20, 0, 247, 22, 23, 24, 25, 0, ++ 0, 0, 0, 0, 0, 38, 0, 0, 0, 40, ++ 0, 0, 30, 31, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 33, 34, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 35, 0, 0, 36, ++ 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 8, 248, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 38, 0, 0, 0, ++ 40, 9, 10, 11, 12, 13, 14, 15, 16, 245, ++ 18, 246, 20, 0, 247, 22, 23, 24, 25, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 30, 31, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 33, 34, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 35, 0, 0, 36, ++ 37, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 8, 993, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 38, 0, 0, 0, ++ 40, 9, 10, 11, 12, 13, 14, 15, 16, 245, ++ 18, 246, 20, 0, 247, 22, 23, 24, 25, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 518, 30, 31, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ++ 0, 33, 34, 0, 0, 0, 0, 0, 0, 0, ++ 0, 0, 0, 0, 683, 0, 35, 0, 0, 36, ++ 37, 0, 0, 0, 0, 0, 685, 0, 0, 0, ++ 482, 483, 484, 485, 486, 0, 487, 0, 0, 0, ++ 0, 0, 0, 0, 0, 0, 38, 0, 0, 0, ++ 40, 488, 489, 490, 491, 492, 493, 494, 495, 496, ++ 497, 498, 499, 482, 483, 484, 485, 486, 809, 487, ++ 0, 0, 0, 0, 0, 482, 483, 484, 485, 486, ++ 814, 487, 0, 0, 488, 489, 490, 491, 492, 493, ++ 494, 495, 496, 497, 498, 499, 488, 489, 490, 491, ++ 492, 493, 494, 495, 496, 497, 498, 499, 0, 0, ++ 0, 0, 0, 0, 0, 0, 0, 482, 483, 484, ++ 485, 486, 0, 487, 0, 0, 0, 0, 0, 482, ++ 483, 484, 485, 486, 0, 487, 0, 0, 488, 489, ++ 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, ++ 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, ++ 498, 499 ++}; ++ ++static const yytype_int16 yycheck[] = ++{ ++ 0, 5, 163, 151, 101, 5, 101, 1, 2, 5, ++ 380, 72, 47, 153, 95, 572, 161, 608, 40, 5, ++ 556, 248, 5, 399, 144, 45, 47, 603, 197, 587, ++ 566, 272, 829, 5, 95, 96, 184, 185, 566, 5, ++ 230, 1, 2, 286, 287, 726, 407, 47, 5, 682, ++ 640, 684, 1, 550, 6, 1013, 3, 21, 1002, 40, ++ 101, 46, 3, 6, 6, 255, 46, 42, 48, 40, ++ 43, 71, 1150, 42, 3, 46, 76, 77, 41, 49, ++ 1169, 41, 194, 144, 5, 4, 0, 6, 200, 0, ++ 5, 40, 5, 238, 206, 48, 50, 51, 52, 211, ++ 197, 61, 197, 144, 46, 1183, 41, 55, 1197, 5, ++ 49, 152, 5, 5, 114, 1071, 5, 3, 5, 360, ++ 5, 3, 86, 1081, 43, 5, 5, 46, 113, 241, ++ 105, 104, 43, 5, 86, 932, 3, 5, 173, 3, ++ 175, 162, 5, 86, 166, 3, 258, 1091, 5, 90, ++ 91, 61, 133, 153, 40, 118, 197, 104, 127, 153, ++ 113, 90, 91, 49, 6, 310, 167, 168, 120, 727, ++ 118, 48, 58, 173, 76, 175, 177, 1133, 554, 159, ++ 1124, 40, 203, 118, 775, 126, 140, 5, 333, 169, ++ 40, 191, 121, 153, 1138, 828, 1152, 116, 3, 575, ++ 697, 161, 63, 1159, 90, 91, 144, 207, 90, 91, ++ 800, 40, 114, 104, 41, 848, 577, 238, 60, 380, ++ 55, 3, 127, 90, 91, 468, 90, 91, 1025, 93, ++ 3, 117, 90, 91, 55, 121, 113, 3, 238, 121, ++ 240, 241, 77, 3, 130, 1042, 55, 133, 248, 50, ++ 51, 52, 212, 117, 248, 215, 142, 121, 40, 117, ++ 46, 90, 91, 121, 299, 265, 127, 267, 50, 51, ++ 52, 130, 130, 831, 133, 133, 236, 4, 299, 6, ++ 40, 140, 140, 104, 244, 90, 91, 6, 248, 49, ++ 311, 312, 973, 44, 315, 104, 832, 297, 874, 299, ++ 1097, 104, 212, 130, 832, 215, 133, 4, 90, 91, ++ 311, 312, 117, 43, 315, 119, 121, 90, 91, 46, ++ 106, 107, 4, 3, 90, 91, 236, 78, 42, 130, ++ 90, 91, 133, 414, 244, 117, 55, 398, 478, 121, ++ 144, 55, 3, 378, 117, 43, 407, 77, 121, 46, ++ 310, 352, 353, 414, 120, 121, 43, 117, 43, 46, ++ 142, 121, 589, 77, 46, 555, 46, 140, 362, 104, ++ 515, 6, 6, 333, 40, 1172, 43, 357, 378, 40, ++ 756, 42, 142, 118, 119, 122, 346, 3, 49, 349, ++ 77, 105, 58, 428, 55, 585, 40, 58, 43, 399, ++ 40, 46, 362, 53, 54, 6, 3, 468, 43, 144, ++ 90, 91, 46, 434, 435, 436, 77, 104, 58, 977, ++ 40, 462, 72, 999, 40, 40, 426, 572, 428, 90, ++ 91, 46, 77, 49, 3, 42, 346, 117, 460, 349, ++ 119, 121, 58, 40, 105, 1, 91, 447, 55, 449, ++ 595, 53, 49, 453, 566, 40, 117, 457, 55, 3, ++ 121, 58, 6, 85, 86, 144, 127, 447, 43, 130, ++ 72, 46, 133, 453, 90, 91, 53, 54, 40, 140, ++ 77, 142, 442, 787, 478, 40, 42, 43, 40, 41, ++ 46, 85, 452, 90, 91, 72, 73, 41, 40, 803, ++ 804, 117, 503, 504, 505, 121, 58, 40, 77, 1066, ++ 511, 512, 122, 40, 130, 885, 577, 133, 478, 520, ++ 117, 90, 91, 40, 121, 58, 142, 672, 40, 78, ++ 3, 58, 442, 130, 83, 515, 133, 3, 40, 41, ++ 541, 58, 452, 140, 3, 142, 90, 91, 117, 40, ++ 550, 572, 121, 40, 554, 549, 58, 40, 1149, 519, ++ 40, 41, 106, 107, 524, 40, 41, 40, 40, 573, ++ 40, 41, 572, 573, 568, 575, 576, 573, 58, 40, ++ 576, 642, 582, 58, 40, 58, 58, 573, 58, 549, ++ 573, 43, 586, 203, 46, 589, 40, 617, 43, 559, ++ 769, 573, 58, 55, 4, 640, 6, 573, 568, 519, ++ 55, 4, 757, 6, 524, 595, 573, 90, 91, 640, ++ 40, 581, 622, 623, 90, 91, 586, 627, 238, 589, ++ 118, 90, 91, 593, 41, 42, 826, 827, 43, 40, ++ 640, 46, 43, 643, 117, 46, 786, 787, 121, 559, ++ 55, 117, 573, 41, 264, 121, 266, 637, 573, 42, ++ 573, 120, 121, 803, 804, 106, 107, 47, 669, 142, ++ 130, 581, 769, 133, 769, 736, 4, 573, 6, 46, ++ 573, 573, 81, 593, 573, 665, 573, 6, 573, 46, ++ 89, 90, 91, 573, 573, 41, 42, 697, 678, 703, ++ 43, 573, 682, 703, 684, 573, 43, 703, 40, 46, ++ 573, 43, 42, 853, 133, 43, 573, 703, 46, 41, ++ 703, 721, 834, 43, 885, 43, 46, 55, 46, 729, ++ 734, 703, 985, 118, 734, 988, 105, 703, 734, 41, ++ 42, 721, 702, 50, 51, 52, 703, 105, 734, 729, ++ 785, 734, 42, 753, 754, 573, 756, 753, 758, 40, ++ 908, 858, 734, 858, 845, 800, 993, 753, 734, 90, ++ 91, 771, 7, 793, 774, 775, 41, 734, 758, 800, ++ 740, 161, 703, 783, 845, 785, 786, 787, 703, 169, ++ 703, 774, 702, 118, 41, 775, 753, 123, 124, 125, ++ 800, 58, 762, 803, 804, 866, 40, 703, 41, 42, ++ 703, 703, 792, 734, 703, 118, 703, 858, 703, 734, ++ 940, 734, 1192, 703, 703, 866, 138, 139, 140, 829, ++ 740, 703, 753, 43, 140, 703, 41, 837, 734, 41, ++ 703, 734, 734, 940, 41, 734, 703, 734, 828, 734, ++ 41, 55, 762, 853, 734, 734, 1017, 837, 238, 853, ++ 42, 41, 734, 41, 43, 869, 734, 41, 848, 869, ++ 830, 734, 41, 869, 874, 255, 41, 734, 3, 940, ++ 41, 41, 1030, 869, 41, 703, 869, 887, 136, 137, ++ 138, 139, 140, 853, 894, 878, 105, 869, 42, 940, ++ 40, 118, 1173, 869, 1044, 515, 41, 907, 1179, 1180, ++ 1181, 43, 869, 77, 3, 40, 734, 118, 46, 299, ++ 830, 1066, 3, 104, 884, 1196, 74, 75, 76, 40, ++ 310, 992, 932, 968, 995, 3, 3, 317, 447, 41, ++ 41, 118, 118, 49, 453, 945, 21, 40, 869, 3, ++ 46, 43, 6, 333, 869, 565, 869, 43, 41, 569, ++ 40, 46, 572, 343, 43, 90, 91, 43, 968, 44, ++ 47, 92, 41, 869, 884, 975, 869, 869, 40, 91, ++ 869, 90, 869, 113, 869, 595, 596, 58, 41, 869, ++ 869, 79, 117, 993, 40, 975, 121, 869, 40, 993, ++ 41, 869, 1002, 78, 79, 80, 869, 77, 83, 1009, ++ 85, 86, 869, 1013, 40, 40, 49, 142, 41, 41, ++ 41, 1021, 41, 1023, 1024, 1025, 1009, 3, 1189, 42, ++ 1013, 1192, 42, 993, 41, 40, 90, 91, 3, 55, ++ 43, 1021, 1042, 41, 1004, 1066, 144, 104, 41, 41, ++ 47, 869, 106, 107, 21, 104, 42, 63, 46, 1059, ++ 440, 41, 672, 41, 40, 55, 1066, 41, 41, 41, ++ 41, 41, 452, 49, 43, 40, 55, 44, 41, 1059, ++ 1080, 1081, 58, 42, 49, 465, 43, 41, 47, 47, ++ 77, 1091, 77, 58, 1004, 54, 46, 1097, 1081, 142, ++ 1080, 47, 1102, 127, 47, 41, 1106, 1168, 41, 1069, ++ 41, 78, 79, 80, 90, 91, 83, 727, 85, 86, ++ 1120, 77, 1102, 41, 1124, 90, 91, 41, 77, 88, ++ 89, 47, 41, 43, 1134, 515, 42, 105, 1138, 1099, ++ 1120, 117, 101, 43, 55, 121, 41, 757, 49, 1149, ++ 43, 40, 117, 120, 1114, 77, 121, 77, 1158, 1069, ++ 77, 43, 1162, 122, 77, 130, 142, 43, 133, 1149, ++ 77, 43, 1172, 1173, 43, 140, 1136, 142, 1158, 1179, ++ 1180, 1181, 1162, 41, 105, 1145, 1146, 1147, 43, 1099, ++ 42, 150, 572, 1173, 40, 49, 1196, 3, 47, 1179, ++ 1180, 1181, 161, 162, 1114, 43, 1166, 43, 167, 168, ++ 40, 170, 721, 40, 43, 595, 1196, 41, 177, 47, ++ 729, 41, 41, 833, 40, 46, 1136, 49, 41, 41, ++ 3, 4, 842, 6, 40, 1145, 1146, 1147, 197, 41, ++ 41, 41, 556, 49, 203, 43, 43, 582, 753, 758, ++ 1140, 993, 58, 589, 754, 907, 1166, 637, 753, 753, ++ 640, 41, 853, 222, 643, 478, 775, 40, 1106, 610, ++ 43, 52, 878, 46, 1134, 1009, 49, 3, 627, 238, ++ 890, 894, 1008, 1024, 90, 91, 1129, 1149, 185, 737, ++ 249, -1, 672, 252, -1, -1, 255, 256, 257, -1, ++ -1, 260, -1, -1, -1, 264, 265, 266, 267, -1, ++ -1, 117, 3, -1, 40, 121, -1, 90, 91, -1, ++ -1, -1, -1, 49, 50, 51, 52, -1, 837, -1, ++ -1, -1, 58, -1, -1, -1, 142, -1, -1, -1, ++ 299, -1, -1, 116, 117, -1, -1, -1, 121, 40, ++ -1, 310, 311, 312, -1, -1, 315, 130, 317, -1, ++ 133, -1, -1, -1, 90, 91, 976, 140, -1, 142, ++ -1, -1, -1, -1, 333, 334, 335, 757, -1, -1, ++ 339, -1, -1, -1, 994, -1, 996, -1, -1, -1, ++ -1, 117, 351, 352, 353, 121, -1, -1, 357, 90, ++ 91, 3, 1012, -1, 130, -1, -1, 133, -1, 3, ++ 369, 370, 792, 793, 140, 3, 142, -1, -1, -1, ++ 800, -1, -1, 1033, -1, -1, 117, -1, 387, -1, ++ 121, 72, -1, 3, -1, -1, -1, -1, 40, -1, ++ -1, 400, -1, -1, -1, -1, 40, 49, 89, -1, ++ -1, 142, 40, -1, -1, 49, 1066, -1, -1, -1, ++ -1, 49, 50, 51, 52, -1, 975, -1, -1, -1, ++ 40, -1, -1, -1, -1, 434, 435, 436, -1, 49, ++ -1, 440, 112, -1, 443, 444, -1, 446, 90, 91, ++ -1, -1, -1, 452, 164, 165, 90, 91, -1, -1, ++ -1, -1, 90, 91, 134, 135, 136, 137, 138, 139, ++ 140, -1, 1021, -1, -1, 117, -1, -1, -1, 121, ++ 90, 91, -1, 117, -1, -1, -1, 121, 130, 117, ++ 1140, 133, -1, 121, -1, -1, 130, -1, 140, 133, ++ 142, -1, 130, -1, -1, 133, 505, 117, 142, -1, ++ 1059, 121, -1, 194, 142, -1, 515, -1, 199, 200, ++ 130, 520, -1, 133, -1, 206, -1, 208, 209, -1, ++ 211, 1080, 142, -1, -1, -1, 535, -1, -1, 538, ++ -1, -1, 541, 542, -1, 544, 227, -1, 3, 230, ++ 231, 6, -1, 1102, -1, -1, -1, -1, -1, -1, ++ 241, -1, -1, -1, -1, -1, 565, -1, -1, -1, ++ 569, 1120, -1, 572, 255, -1, 286, 258, 288, 289, ++ 290, 291, 292, 293, 265, 40, -1, -1, 269, -1, ++ -1, -1, -1, 3, 49, -1, 595, 596, 597, -1, ++ 1149, -1, 601, -1, -1, -1, -1, -1, 3, 1158, ++ -1, 6, 7, 3, 324, -1, 11, 12, 13, 14, ++ 15, 16, 17, 18, 19, 20, -1, -1, 3, -1, ++ 40, 630, -1, 43, -1, 90, 91, 347, -1, 49, ++ 350, 640, -1, -1, -1, 40, 1066, -1, 1068, 1069, ++ 40, 3, -1, 43, 49, -1, -1, -1, -1, 49, ++ -1, 56, 117, -1, -1, 40, 121, -1, -1, 70, ++ -1, -1, -1, 672, 49, 130, -1, -1, 133, 678, ++ 90, 91, -1, 58, -1, 140, -1, 142, 40, 688, ++ -1, 690, -1, 94, -1, 694, 695, 49, 99, -1, ++ 90, 91, -1, -1, -1, -1, 58, 117, 3, -1, ++ -1, 121, -1, -1, -1, 90, 91, -1, -1, -1, ++ 130, -1, -1, 133, -1, -1, -1, 117, 727, -1, ++ 140, 121, 142, -1, -1, -1, -1, -1, 90, 91, ++ 130, -1, 117, 133, -1, 40, 121, 168, 43, -1, ++ 140, -1, 142, 752, 49, -1, 177, -1, 757, -1, ++ -1, 760, -1, 3, -1, 117, -1, 142, 3, 121, ++ 769, 6, 482, 483, 484, 485, 486, 487, 488, 489, ++ 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, ++ 142, -1, -1, 194, -1, 90, 91, -1, 199, 200, ++ 40, 800, -1, -1, -1, 206, 516, -1, -1, -1, ++ 211, -1, -1, -1, -1, 525, -1, -1, 58, 818, ++ 819, 3, 117, -1, -1, -1, 121, -1, -1, 230, ++ -1, -1, 3, -1, 833, 130, 257, -1, 133, 260, ++ 241, 242, -1, 842, -1, 140, -1, 142, -1, -1, ++ 90, 91, -1, 254, 255, 90, 91, 258, 40, 858, ++ -1, 43, -1, -1, -1, -1, 3, 49, -1, 40, ++ -1, 106, 107, -1, 555, -1, -1, 117, 49, -1, ++ -1, 121, 117, -1, -1, 566, 121, -1, -1, -1, ++ 130, 890, -1, 133, -1, 130, -1, -1, 133, 898, ++ 3, -1, 583, 40, 585, 140, -1, -1, 90, 91, ++ -1, -1, 49, 334, -1, -1, -1, -1, 339, 90, ++ 91, -1, -1, 633, 634, 635, 636, 637, -1, 639, ++ 351, 352, 353, 3, -1, 117, 357, 40, -1, 121, ++ -1, 940, -1, -1, 3, -1, 117, -1, 130, -1, ++ 121, 133, -1, 90, 91, 58, -1, -1, 140, 130, ++ 142, 3, 133, -1, -1, -1, -1, -1, -1, 140, ++ 40, 142, -1, -1, -1, -1, -1, 976, -1, 49, ++ 117, 40, -1, -1, 121, -1, -1, 90, 91, 3, ++ -1, -1, -1, 130, -1, 994, 133, 996, 40, 58, ++ -1, -1, -1, 140, -1, 142, -1, 49, -1, -1, ++ -1, -1, -1, 1012, 117, -1, -1, -1, 121, 1018, ++ 90, 91, 443, 444, -1, 446, 40, 130, -1, -1, ++ 133, 90, 91, -1, 1033, 49, -1, -1, -1, 142, ++ 134, 135, 136, 137, 138, 139, 140, 117, 90, 91, ++ -1, 121, -1, 763, -1, 736, -1, -1, 117, -1, ++ 130, -1, 121, 133, 3, -1, -1, 1066, -1, 3, ++ 1069, 130, 142, -1, 133, 117, 90, 91, -1, 121, ++ 790, 791, 792, 142, 794, -1, -1, 3, 130, -1, ++ -1, 133, 802, -1, -1, -1, 1095, -1, 140, 520, ++ 142, 40, 3, 117, -1, -1, 40, 121, -1, -1, ++ 49, -1, -1, -1, 535, 49, -1, 538, -1, -1, ++ 541, 542, -1, 544, 40, -1, -1, -1, 142, -1, ++ 1129, -1, -1, 49, -1, -1, -1, -1, -1, 40, ++ -1, 1140, -1, -1, -1, 826, 827, -1, 49, -1, ++ 551, 90, 91, 834, 555, 556, 90, 91, -1, -1, ++ -1, -1, -1, 564, 565, 566, -1, -1, 849, 850, ++ 851, 50, 51, 52, 90, 91, 597, -1, 117, -1, ++ 601, -1, 121, 117, 585, -1, 587, 121, -1, 90, ++ 91, -1, -1, -1, -1, 596, -1, -1, -1, 880, ++ -1, 117, 81, 142, -1, 121, -1, -1, 142, -1, ++ 89, 90, 91, -1, -1, -1, 117, -1, 108, 109, ++ 121, -1, 112, -1, -1, -1, 142, -1, -1, -1, ++ -1, -1, -1, -1, 108, 109, 110, 111, 112, -1, ++ -1, 142, 952, 953, 134, 135, 136, 137, 138, 139, ++ 140, 130, -1, -1, 133, -1, -1, 678, 132, 133, ++ 134, 135, 136, 137, 138, 139, 140, 688, -1, 690, ++ -1, -1, 3, 694, 695, 6, 7, -1, -1, -1, ++ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ++ -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, ++ 31, 32, 33, 6, 35, 36, 37, 38, 39, 40, ++ 13, 14, 15, 16, 17, 18, 19, 20, 49, 50, ++ 51, 52, 53, 54, -1, 56, 727, 1008, -1, -1, ++ -1, -1, -1, -1, 735, -1, 737, -1, -1, 760, ++ 71, 72, 73, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 87, -1, -1, 90, ++ 91, -1, -1, -1, -1, -1, -1, 3, 1078, -1, ++ 6, -1, -1, -1, -1, -1, -1, 13, 14, 15, ++ 16, 17, 18, 19, 20, -1, 117, -1, -1, 120, ++ 121, -1, -1, 1103, -1, 126, -1, 818, 819, -1, ++ -1, -1, 133, -1, -1, 136, 137, -1, -1, 140, ++ 141, 142, -1, -1, -1, 1, -1, 3, 4, -1, ++ -1, -1, 8, 9, 10, 826, 827, -1, -1, -1, ++ 831, 832, -1, 834, -1, 21, 22, 23, 24, 25, ++ 26, 27, 28, 29, 30, 31, 32, 33, -1, 35, ++ 36, 37, 38, 39, 90, 91, 857, 43, 44, -1, ++ -1, 47, -1, -1, 50, 51, 52, 53, 54, -1, ++ 106, 107, -1, -1, -1, -1, -1, 63, 64, 65, ++ 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, ++ 76, -1, 78, 79, 80, -1, 82, 83, 84, 85, ++ 86, 87, 88, -1, 90, 91, 92, -1, -1, -1, ++ 96, -1, 98, 99, 100, 101, 102, 103, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, 115, ++ -1, 117, -1, -1, 120, 121, 122, -1, 3, -1, ++ 126, 6, 7, -1, -1, 41, 11, 12, 13, 14, ++ 15, 16, 17, 18, 19, 20, 142, 22, 23, 24, ++ 25, 26, 27, 28, 29, 30, 31, 32, 33, -1, ++ 35, 36, 37, 38, 39, 40, 977, -1, -1, -1, ++ -1, -1, -1, -1, -1, 50, 51, 52, 53, 54, ++ -1, 56, -1, -1, 59, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 71, 72, 73, 105, ++ -1, -1, 108, 109, 110, 111, 112, -1, 114, -1, ++ -1, -1, 87, -1, -1, 90, 91, -1, -1, -1, ++ -1, -1, -1, 129, 130, 131, 132, 133, 134, 135, ++ 136, 137, 138, 139, 140, -1, -1, -1, -1, -1, ++ -1, -1, 117, -1, -1, -1, 121, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, 133, -1, ++ 3, 136, 137, 6, 7, 140, 141, 142, 11, 12, ++ 13, 14, 15, 16, 17, 18, 19, 20, -1, 22, ++ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, ++ 33, 40, 35, 36, 37, 38, 39, 40, -1, -1, ++ -1, 50, 51, 52, -1, -1, 55, 50, 51, 52, ++ 53, 54, -1, 56, -1, -1, 59, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, 71, 72, ++ 73, -1, 81, 108, 109, 110, 111, 112, -1, 114, ++ 89, 90, 91, -1, 87, -1, -1, 90, 91, -1, ++ -1, -1, -1, -1, 129, 130, 131, 132, 133, 134, ++ 135, 136, 137, 138, 139, 140, -1, -1, -1, -1, ++ -1, -1, -1, -1, 117, -1, -1, -1, 121, -1, ++ -1, 130, -1, -1, 133, -1, -1, -1, -1, -1, ++ 133, -1, 3, 136, 137, 6, 7, 140, 141, 142, ++ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ++ -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, ++ 31, 32, 33, -1, 35, 36, 37, 38, 39, 40, ++ -1, -1, 77, -1, -1, -1, -1, -1, -1, 50, ++ 51, 52, 53, 54, -1, 56, -1, -1, 59, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ 71, 72, 73, 108, 109, 110, 111, 112, -1, 114, ++ -1, 108, 109, 110, 111, 112, 87, -1, -1, 90, ++ 91, -1, -1, -1, 129, 130, 131, 132, 133, 134, ++ 135, 136, 137, 138, 139, 140, 133, 134, 135, 136, ++ 137, 138, 139, 140, -1, -1, 117, -1, -1, -1, ++ 121, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 133, -1, 3, 136, 137, 6, 7, 140, ++ 141, 142, 11, 12, 13, 14, 15, 16, 17, 18, ++ 19, 20, -1, 22, 23, 24, 25, 26, 27, 28, ++ 29, 30, 31, 32, 33, -1, 35, 36, 37, 38, ++ 39, 40, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, 50, 51, 52, 53, 54, -1, 56, -1, -1, ++ 59, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 71, 72, 73, 108, 109, 110, 111, 112, ++ -1, -1, 108, 109, 110, 111, 112, -1, 87, -1, ++ -1, 90, 91, -1, -1, -1, 129, 130, 131, 132, ++ 133, 134, 135, 136, 137, 138, 139, 140, 134, 135, ++ 136, 137, 138, 139, 140, -1, -1, -1, 117, -1, ++ -1, -1, 121, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 133, -1, 3, 136, 137, 6, ++ 7, 140, 141, 142, 11, 12, 13, 14, 15, 16, ++ 17, 18, 19, 20, -1, 22, 23, 24, 25, 26, ++ 27, 28, 29, 30, 31, 32, 33, -1, 35, 36, ++ 37, 38, 39, 40, 41, -1, -1, -1, -1, -1, ++ -1, -1, -1, 50, 51, 52, 53, 54, -1, 56, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 71, 72, 73, 108, 109, 110, ++ 111, 112, -1, -1, -1, -1, -1, -1, -1, -1, ++ 87, -1, -1, 90, 91, -1, -1, -1, -1, 130, ++ 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, ++ -1, -1, 22, 23, 24, 25, 26, 27, 28, 29, ++ 117, 31, -1, 33, 121, -1, 36, 37, 38, 39, ++ -1, -1, -1, -1, -1, -1, 133, -1, 3, 136, ++ 137, 6, 7, 140, 141, 142, 11, 12, 13, 14, ++ 15, 16, 17, 18, 19, 20, -1, 22, 23, 24, ++ 25, 26, 27, 28, 29, 30, 31, 32, 33, -1, ++ 35, 36, 37, 38, 39, 40, 41, -1, -1, -1, ++ -1, -1, -1, -1, -1, 50, 51, 52, 53, 54, ++ -1, 56, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 71, 72, 73, 108, ++ 109, 110, 111, 112, -1, -1, -1, -1, -1, -1, ++ -1, -1, 87, -1, -1, 90, 91, -1, -1, -1, ++ -1, -1, 131, 132, 133, 134, 135, 136, 137, 138, ++ 139, 140, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 117, -1, -1, -1, 121, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, 133, -1, ++ 3, 136, 137, 6, 7, 140, 141, 142, 11, 12, ++ 13, 14, 15, 16, 17, 18, 19, 20, -1, 22, ++ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, ++ 33, -1, 35, 36, 37, 38, 39, 40, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, 50, 51, 52, ++ 53, 54, -1, 56, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, 71, 72, ++ 73, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 87, -1, -1, 90, 91, -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, 117, -1, -1, -1, 121, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ 133, -1, 3, 136, 137, 6, 7, 140, 141, 142, ++ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ++ -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, ++ 31, 32, 33, -1, 35, 36, 37, 38, 39, 40, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, 50, ++ 51, 52, 53, 54, -1, 56, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ 71, 72, 73, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, 4, 87, -1, -1, 90, ++ 91, 10, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 21, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 117, -1, -1, -1, ++ 121, -1, -1, -1, 43, 44, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, 136, 137, -1, -1, 140, ++ 141, 142, -1, -1, 63, 64, 65, 66, -1, 68, ++ 69, 70, -1, -1, -1, 74, 75, 76, -1, 78, ++ 79, 80, -1, 82, 83, 84, 85, 86, -1, -1, ++ -1, -1, -1, 92, -1, -1, -1, 96, -1, 98, ++ 99, 100, 101, 102, 103, 3, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 115, -1, -1, -1, ++ -1, 120, -1, -1, 22, 23, 24, 25, 26, 27, ++ 28, 29, 30, 31, 32, 33, -1, 35, 36, 37, ++ 38, 39, 40, 142, -1, -1, -1, -1, -1, -1, ++ -1, 49, 50, 51, 52, 53, 54, -1, -1, -1, ++ 58, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, 71, 72, 73, -1, -1, -1, -1, ++ -1, 3, -1, -1, -1, -1, -1, -1, -1, 87, ++ -1, -1, 90, 91, -1, -1, -1, -1, -1, -1, ++ 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, ++ 32, 33, -1, 35, 36, 37, 38, 39, -1, 117, ++ -1, -1, 120, 121, 3, -1, -1, -1, 126, -1, ++ -1, -1, 130, 41, -1, 133, -1, -1, -1, -1, ++ -1, -1, 140, 22, 23, 24, 25, 26, 27, 28, ++ 29, 30, 31, 32, 33, -1, 35, 36, 37, 38, ++ 39, 40, -1, -1, -1, 87, -1, -1, 90, 91, ++ 49, 50, 51, 52, 53, 54, -1, -1, -1, 58, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 71, 72, 73, 117, -1, -1, -1, 121, ++ 108, 109, 110, 111, 112, -1, 114, -1, 87, -1, ++ -1, 90, 91, -1, -1, -1, -1, -1, -1, -1, ++ -1, 129, 130, 131, 132, 133, 134, 135, 136, 137, ++ 138, 139, 140, -1, -1, -1, -1, -1, 117, -1, ++ -1, 120, 121, 3, -1, -1, -1, 126, -1, -1, ++ -1, 130, -1, -1, 133, -1, -1, -1, -1, -1, ++ -1, 140, 22, 23, 24, 25, 26, 27, 28, 29, ++ 30, 31, 32, 33, -1, 35, 36, 37, 38, 39, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, 49, ++ 50, 51, 52, 53, 54, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, 71, 72, 73, 3, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, 87, -1, -1, ++ 90, 91, -1, 22, 23, 24, 25, 26, 27, 28, ++ 29, 30, 31, 32, 33, -1, 35, 36, 37, 38, ++ 39, -1, -1, -1, -1, -1, -1, 117, -1, -1, ++ 120, 121, -1, -1, 53, 54, 126, -1, -1, -1, ++ 130, -1, -1, 133, -1, -1, -1, -1, -1, -1, ++ 140, -1, 71, 72, 73, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, 87, -1, ++ -1, 90, 91, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, 0, 1, -1, ++ 3, 4, -1, -1, -1, 8, 9, 10, 117, -1, ++ -1, -1, 121, -1, -1, -1, -1, -1, 21, 22, ++ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, ++ 33, 140, 35, 36, 37, 38, 39, -1, -1, -1, ++ 43, 44, -1, -1, -1, -1, -1, 50, 51, 52, ++ 53, 54, -1, -1, 57, -1, -1, -1, -1, -1, ++ 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, ++ 73, -1, -1, -1, -1, 78, 79, 80, -1, 82, ++ 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, ++ 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, ++ 103, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 115, 1, 117, 3, 4, 120, 121, -1, ++ 8, 9, 10, 126, 127, -1, -1, -1, -1, -1, ++ -1, -1, -1, 21, 22, 23, 24, 25, 26, 27, ++ 28, 29, 30, 31, 32, 33, -1, 35, 36, 37, ++ 38, 39, -1, -1, -1, 43, 44, -1, -1, 47, ++ -1, -1, 50, 51, 52, 53, 54, -1, -1, 57, ++ -1, -1, -1, -1, -1, 63, 64, 65, 66, 67, ++ 68, 69, 70, 71, 72, 73, -1, -1, -1, -1, ++ 78, 79, 80, -1, 82, 83, 84, 85, 86, 87, ++ 88, -1, 90, 91, 92, 93, 94, 95, 96, 97, ++ 98, 99, 100, 101, 102, 103, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, 115, 1, 117, ++ 3, 4, 120, 121, -1, 8, 9, 10, 126, 127, ++ -1, -1, -1, -1, -1, -1, -1, -1, 21, 22, ++ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, ++ 33, -1, 35, 36, 37, 38, 39, -1, -1, -1, ++ 43, 44, -1, -1, 47, -1, -1, 50, 51, 52, ++ 53, 54, -1, -1, 57, -1, -1, -1, -1, -1, ++ 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, ++ 73, -1, -1, -1, -1, 78, 79, 80, -1, 82, ++ 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, ++ 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, ++ 103, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 115, 1, 117, 3, 4, 120, 121, -1, ++ 8, 9, 10, 126, 127, -1, -1, -1, -1, -1, ++ -1, -1, -1, 21, 22, 23, 24, 25, 26, 27, ++ 28, 29, 30, 31, 32, 33, -1, 35, 36, 37, ++ 38, 39, -1, -1, -1, 43, 44, -1, -1, 47, ++ -1, -1, 50, 51, 52, 53, 54, -1, -1, 57, ++ -1, -1, -1, -1, -1, 63, 64, 65, 66, 67, ++ 68, 69, 70, 71, 72, 73, -1, -1, -1, -1, ++ 78, 79, 80, -1, 82, 83, 84, 85, 86, 87, ++ 88, -1, 90, 91, 92, 93, 94, 95, 96, 97, ++ 98, 99, 100, 101, 102, 103, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, 115, 1, 117, ++ 3, 4, 120, 121, -1, 8, 9, 10, 126, 127, ++ -1, -1, -1, -1, -1, -1, -1, -1, 21, 22, ++ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, ++ 33, -1, 35, 36, 37, 38, 39, -1, -1, -1, ++ 43, 44, -1, -1, -1, -1, -1, 50, 51, 52, ++ 53, 54, -1, -1, 57, -1, -1, -1, 61, -1, ++ 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, ++ 73, -1, -1, -1, -1, 78, 79, 80, -1, 82, ++ 83, 84, 85, 86, 87, 88, -1, 90, 91, 92, ++ 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, ++ 103, -1, -1, -1, 1, -1, 3, -1, -1, -1, ++ -1, -1, 115, -1, 117, -1, -1, 120, 121, -1, ++ -1, -1, -1, 126, 127, 22, 23, 24, 25, 26, ++ 27, 28, 29, 30, 31, 32, 33, -1, 35, 36, ++ 37, 38, 39, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 49, 50, 51, 52, 53, 54, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 71, 72, 73, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ 87, -1, -1, 90, 91, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, ++ -1, 3, -1, -1, -1, 41, -1, -1, -1, -1, ++ 117, -1, -1, 120, 121, -1, -1, -1, -1, 126, ++ 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, ++ 32, 33, -1, 35, 36, 37, 38, 39, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, 49, 50, 51, ++ 52, 53, 54, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, 71, ++ 72, 73, 108, 109, 110, 111, 112, -1, 114, -1, ++ -1, -1, -1, -1, -1, 87, -1, -1, 90, 91, ++ -1, -1, -1, 129, 130, 131, 132, 133, 134, 135, ++ 136, 137, 138, 139, 140, -1, 3, -1, -1, -1, ++ 41, -1, -1, -1, -1, 117, -1, -1, 120, 121, ++ -1, -1, -1, -1, 126, 22, 23, 24, 25, 26, ++ 27, 28, 29, 30, 31, 32, 33, -1, 35, 36, ++ 37, 38, 39, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 49, 50, 51, 52, 53, 54, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 71, 72, 73, 108, 109, 110, ++ 111, 112, -1, 114, -1, -1, -1, -1, -1, -1, ++ 87, -1, -1, 90, 91, -1, -1, -1, 129, 130, ++ 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, ++ -1, -1, 3, -1, -1, -1, -1, -1, 43, -1, ++ 117, -1, 13, 120, 121, -1, -1, -1, -1, 126, ++ 127, 22, 23, 24, 25, 26, 27, 28, 29, 30, ++ 31, 32, 33, -1, 35, 36, 37, 38, 39, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, 49, 50, ++ 51, 52, 53, 54, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ 71, 72, 73, 108, 109, 110, 111, 112, -1, 114, ++ -1, -1, -1, -1, -1, -1, 87, -1, -1, 90, ++ 91, -1, -1, -1, 129, 130, 131, 132, 133, 134, ++ 135, 136, 137, 138, 139, 140, -1, 3, -1, -1, ++ -1, -1, -1, -1, -1, -1, 117, -1, -1, 120, ++ 121, -1, -1, -1, -1, 126, 22, 23, 24, 25, ++ 26, 27, 28, 29, 30, 31, 32, 33, -1, 35, ++ 36, 37, 38, 39, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, 49, 50, 51, 52, 53, 54, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, 71, 72, 73, -1, -1, ++ -1, -1, 1, -1, 3, -1, -1, -1, -1, -1, ++ -1, 87, -1, -1, 90, 91, -1, -1, -1, -1, ++ -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, ++ 29, 30, 31, 32, 33, -1, 35, 36, 37, 38, ++ 39, 117, -1, -1, 120, 121, -1, -1, -1, -1, ++ 126, 50, 51, 52, 53, 54, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 71, 72, 73, -1, 3, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, 87, -1, ++ -1, 90, 91, -1, -1, 22, 23, 24, 25, 26, ++ 27, 28, 29, 30, 31, 32, 33, -1, 35, 36, ++ 37, 38, 39, -1, -1, -1, -1, -1, 117, -1, ++ -1, -1, 121, 50, 51, 52, 53, 54, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 71, 72, 73, -1, -1, 3, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ 87, 88, -1, 90, 91, -1, -1, -1, 22, 23, ++ 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, ++ -1, 35, 36, 37, 38, 39, -1, -1, -1, -1, ++ 117, -1, -1, -1, 121, 122, 50, 51, 52, 53, ++ 54, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, 71, 72, 73, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, 87, 88, -1, 90, 91, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, 3, -1, 117, 6, 7, -1, 121, 122, 11, ++ 12, 13, 14, 15, 16, 17, 18, 19, 20, -1, ++ 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, ++ 32, 33, -1, 35, 36, 37, 38, 39, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, 50, 51, ++ 52, 53, 54, -1, 56, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, 71, ++ 72, 73, -1, -1, 3, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, 87, -1, -1, 90, 91, ++ -1, -1, -1, 22, 23, 24, 25, 26, 27, 28, ++ 29, 30, 31, 32, 33, -1, 35, 36, 37, 38, ++ 39, -1, -1, -1, -1, 117, -1, -1, -1, 121, ++ 49, 50, 51, 52, 53, 54, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 71, 72, 73, -1, 3, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, 87, -1, ++ -1, 90, 91, -1, -1, 22, 23, 24, 25, 26, ++ 27, 28, 29, 30, 31, 32, 33, -1, 35, 36, ++ 37, 38, 39, 40, -1, -1, -1, -1, 117, -1, ++ -1, 120, 121, 50, 51, 52, 53, 54, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 71, 72, 73, -1, 3, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ 87, -1, -1, 90, 91, -1, -1, 22, 23, 24, ++ 25, 26, 27, 28, 29, 30, 31, 32, 33, -1, ++ 35, 36, 37, 38, 39, -1, -1, -1, -1, -1, ++ 117, -1, -1, -1, 121, 50, 51, 52, 53, 54, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 71, 72, 73, -1, ++ 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 87, 88, -1, 90, 91, -1, -1, 22, ++ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, ++ 33, -1, 35, 36, 37, 38, 39, -1, -1, -1, ++ -1, -1, 117, -1, -1, -1, 121, 50, 51, 52, ++ 53, 54, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, 71, 72, ++ 73, 3, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 87, -1, -1, 90, 91, -1, ++ 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, ++ 32, 33, -1, 35, 36, 37, 38, 39, -1, -1, ++ -1, -1, -1, -1, 117, -1, -1, -1, 121, -1, ++ -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, 71, ++ 72, 73, 3, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, 87, -1, -1, 90, 91, ++ -1, 22, 23, 24, 25, 26, 27, 28, 29, 30, ++ 31, 32, 33, -1, 35, 36, 37, 38, 39, -1, ++ -1, -1, -1, -1, -1, 117, -1, -1, -1, 121, ++ -1, -1, 53, 54, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, 72, 73, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 87, -1, -1, 90, ++ 91, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 3, 104, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 117, -1, -1, -1, ++ 121, 22, 23, 24, 25, 26, 27, 28, 29, 30, ++ 31, 32, 33, -1, 35, 36, 37, 38, 39, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 53, 54, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, 72, 73, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 87, -1, -1, 90, ++ 91, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, 3, 104, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 117, -1, -1, -1, ++ 121, 22, 23, 24, 25, 26, 27, 28, 29, 30, ++ 31, 32, 33, -1, 35, 36, 37, 38, 39, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, 59, 53, 54, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ++ -1, 72, 73, -1, -1, -1, -1, -1, -1, -1, ++ -1, -1, -1, -1, 59, -1, 87, -1, -1, 90, ++ 91, -1, -1, -1, -1, -1, 59, -1, -1, -1, ++ 108, 109, 110, 111, 112, -1, 114, -1, -1, -1, ++ -1, -1, -1, -1, -1, -1, 117, -1, -1, -1, ++ 121, 129, 130, 131, 132, 133, 134, 135, 136, 137, ++ 138, 139, 140, 108, 109, 110, 111, 112, 59, 114, ++ -1, -1, -1, -1, -1, 108, 109, 110, 111, 112, ++ 59, 114, -1, -1, 129, 130, 131, 132, 133, 134, ++ 135, 136, 137, 138, 139, 140, 129, 130, 131, 132, ++ 133, 134, 135, 136, 137, 138, 139, 140, -1, -1, ++ -1, -1, -1, -1, -1, -1, -1, 108, 109, 110, ++ 111, 112, -1, 114, -1, -1, -1, -1, -1, 108, ++ 109, 110, 111, 112, -1, 114, -1, -1, 129, 130, ++ 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, ++ 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, ++ 139, 140 ++}; ++ ++/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing ++ symbol of state STATE-NUM. */ ++static const yytype_uint16 yystos[] = ++{ ++ 0, 123, 124, 125, 146, 147, 329, 1, 3, 22, ++ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, ++ 33, 35, 36, 37, 38, 39, 49, 50, 51, 52, ++ 53, 54, 71, 72, 73, 87, 90, 91, 117, 120, ++ 121, 126, 198, 242, 243, 261, 262, 264, 265, 266, ++ 267, 268, 269, 298, 299, 314, 317, 319, 1, 243, ++ 1, 40, 0, 1, 4, 8, 9, 10, 21, 43, ++ 44, 57, 63, 64, 65, 66, 67, 68, 69, 70, ++ 78, 79, 80, 82, 83, 84, 85, 86, 92, 93, ++ 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, ++ 115, 120, 126, 127, 148, 149, 150, 152, 153, 154, ++ 155, 156, 159, 160, 162, 163, 164, 165, 166, 167, ++ 168, 171, 172, 173, 176, 178, 183, 184, 185, 186, ++ 188, 192, 200, 201, 202, 203, 204, 208, 209, 216, ++ 217, 229, 230, 237, 238, 329, 53, 72, 49, 49, ++ 40, 144, 104, 104, 313, 242, 317, 127, 43, 265, ++ 261, 40, 49, 55, 58, 77, 121, 130, 133, 140, ++ 142, 250, 251, 253, 255, 256, 257, 258, 317, 329, ++ 261, 268, 317, 313, 119, 144, 318, 43, 43, 239, ++ 240, 243, 329, 122, 40, 6, 86, 120, 323, 40, ++ 326, 329, 1, 263, 264, 314, 40, 326, 40, 170, ++ 329, 40, 40, 85, 86, 40, 85, 40, 78, 83, ++ 44, 78, 93, 317, 46, 314, 317, 40, 4, 46, ++ 40, 40, 43, 46, 4, 323, 40, 182, 263, 180, ++ 182, 40, 40, 323, 40, 30, 32, 35, 104, 191, ++ 266, 267, 299, 317, 326, 40, 130, 133, 253, 255, ++ 258, 317, 21, 86, 88, 198, 263, 299, 317, 120, ++ 121, 319, 320, 299, 3, 7, 11, 12, 13, 14, ++ 15, 16, 17, 18, 19, 20, 40, 56, 133, 136, ++ 137, 140, 141, 142, 243, 244, 245, 247, 263, 264, ++ 283, 284, 285, 286, 287, 288, 323, 324, 329, 261, ++ 40, 130, 133, 239, 256, 258, 317, 40, 255, 317, ++ 46, 106, 107, 270, 271, 272, 273, 274, 59, 283, ++ 286, 283, 3, 40, 49, 142, 254, 257, 317, 49, ++ 254, 257, 258, 261, 317, 250, 40, 58, 250, 40, ++ 58, 49, 130, 133, 254, 257, 317, 118, 319, 121, ++ 320, 41, 42, 241, 329, 272, 314, 315, 323, 191, ++ 299, 6, 46, 315, 327, 315, 0, 43, 253, 255, ++ 55, 41, 315, 53, 54, 72, 300, 301, 329, 314, ++ 314, 315, 13, 177, 239, 239, 317, 43, 55, 219, ++ 55, 46, 314, 179, 327, 314, 239, 46, 252, 253, ++ 255, 256, 329, 43, 42, 181, 329, 315, 316, 329, ++ 157, 158, 323, 239, 212, 213, 214, 243, 298, 329, ++ 317, 317, 133, 323, 130, 133, 258, 314, 317, 327, ++ 40, 315, 40, 130, 133, 317, 118, 253, 317, 275, ++ 314, 329, 40, 253, 77, 290, 291, 317, 329, 41, ++ 314, 318, 105, 48, 113, 283, 285, 3, 40, 49, ++ 285, 283, 283, 283, 283, 283, 283, 105, 42, 246, ++ 329, 40, 108, 109, 110, 111, 112, 114, 129, 130, ++ 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, ++ 48, 113, 7, 130, 133, 258, 317, 255, 255, 41, ++ 41, 130, 133, 255, 317, 118, 58, 283, 59, 40, ++ 258, 317, 254, 317, 40, 58, 254, 258, 239, 59, ++ 283, 239, 59, 283, 254, 49, 254, 257, 49, 254, ++ 257, 118, 49, 130, 133, 254, 261, 318, 43, 127, ++ 243, 41, 317, 317, 187, 42, 55, 41, 250, 40, ++ 270, 41, 317, 41, 55, 41, 42, 175, 42, 41, ++ 41, 43, 263, 147, 317, 218, 41, 41, 41, 41, ++ 180, 40, 182, 41, 41, 42, 46, 41, 105, 42, ++ 215, 329, 250, 40, 60, 118, 41, 258, 317, 43, ++ 239, 118, 81, 89, 90, 91, 130, 133, 259, 260, ++ 261, 303, 306, 307, 308, 329, 55, 77, 199, 329, ++ 239, 317, 308, 292, 46, 43, 91, 305, 329, 313, ++ 299, 3, 3, 41, 105, 130, 133, 140, 258, 104, ++ 263, 285, 40, 247, 283, 283, 283, 283, 283, 283, ++ 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, ++ 283, 283, 3, 3, 317, 118, 41, 41, 41, 118, ++ 253, 256, 261, 283, 239, 254, 317, 41, 118, 239, ++ 59, 283, 41, 59, 41, 59, 254, 254, 49, 130, ++ 133, 254, 257, 254, 49, 49, 254, 243, 241, 4, ++ 46, 323, 40, 147, 327, 157, 287, 323, 328, 43, ++ 239, 43, 46, 4, 169, 323, 4, 43, 46, 116, ++ 174, 253, 323, 325, 315, 323, 328, 41, 243, 253, ++ 46, 252, 47, 43, 147, 44, 238, 180, 43, 46, ++ 40, 47, 239, 181, 117, 121, 314, 321, 43, 327, ++ 243, 174, 92, 210, 214, 239, 161, 261, 253, 323, ++ 118, 41, 40, 40, 303, 91, 90, 306, 260, 113, ++ 58, 193, 265, 43, 46, 41, 190, 250, 79, 293, ++ 294, 302, 329, 206, 290, 317, 40, 40, 283, 283, ++ 41, 41, 140, 261, 41, 130, 133, 283, 251, 41, ++ 263, 246, 77, 40, 40, 41, 41, 253, 256, 59, ++ 41, 41, 254, 41, 59, 259, 259, 254, 49, 49, ++ 254, 254, 254, 241, 239, 47, 42, 42, 41, 151, ++ 40, 308, 55, 41, 42, 175, 174, 253, 308, 43, ++ 47, 323, 263, 314, 43, 55, 325, 239, 41, 144, ++ 119, 144, 322, 104, 41, 47, 317, 44, 120, 188, ++ 204, 208, 209, 211, 226, 228, 238, 215, 41, 147, ++ 308, 43, 239, 283, 191, 104, 194, 329, 154, 276, ++ 277, 278, 279, 329, 40, 55, 306, 308, 309, 1, ++ 42, 43, 46, 189, 42, 74, 75, 76, 295, 297, ++ 1, 43, 67, 74, 75, 76, 79, 126, 142, 152, ++ 153, 154, 155, 159, 160, 164, 166, 168, 171, 173, ++ 176, 178, 183, 184, 185, 186, 204, 208, 209, 216, ++ 220, 224, 225, 226, 227, 228, 229, 231, 232, 235, ++ 238, 329, 46, 250, 248, 286, 329, 248, 41, 283, ++ 283, 283, 41, 41, 41, 41, 251, 283, 248, 248, ++ 41, 41, 41, 254, 254, 41, 327, 327, 259, 220, ++ 239, 174, 323, 328, 43, 253, 41, 308, 43, 253, ++ 43, 182, 41, 259, 121, 314, 314, 121, 314, 244, ++ 4, 46, 55, 104, 88, 122, 263, 61, 43, 41, ++ 41, 303, 304, 329, 40, 46, 195, 276, 126, 280, ++ 281, 314, 47, 42, 127, 239, 270, 55, 77, 310, ++ 329, 253, 294, 317, 296, 223, 46, 77, 77, 77, ++ 142, 224, 319, 47, 127, 220, 30, 32, 35, 236, ++ 267, 317, 205, 41, 42, 249, 329, 41, 283, 283, ++ 41, 41, 41, 250, 47, 41, 175, 308, 43, 253, ++ 174, 43, 43, 322, 322, 105, 263, 212, 263, 40, ++ 303, 190, 239, 40, 43, 196, 281, 277, 55, 43, ++ 253, 127, 278, 41, 43, 272, 311, 312, 317, 43, ++ 46, 308, 49, 289, 329, 302, 220, 221, 319, 40, ++ 43, 207, 253, 77, 43, 220, 286, 43, 43, 43, ++ 308, 43, 252, 105, 40, 130, 133, 258, 239, 189, ++ 41, 197, 282, 283, 308, 278, 43, 46, 43, 42, ++ 49, 40, 46, 190, 317, 220, 40, 239, 308, 283, ++ 47, 249, 43, 43, 239, 40, 40, 40, 133, 41, ++ 308, 43, 190, 312, 189, 289, 47, 239, 41, 190, ++ 43, 207, 41, 239, 239, 239, 40, 309, 113, 195, ++ 189, 49, 222, 41, 233, 308, 189, 234, 308, 41, ++ 41, 41, 239, 263, 196, 220, 234, 43, 46, 55, ++ 43, 46, 55, 234, 234, 234, 41, 195, 272, 270, ++ 234, 196, 43, 43 ++}; ++ ++#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 (1); \ ++ goto yybackup; \ ++ } \ ++ else \ ++ { \ ++ yyerror (YY_("syntax error: cannot back up")); \ ++ YYERROR; \ ++ } \ ++while (YYID (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 (YYID (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 (YYID (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 defined YYLTYPE_IS_TRIVIAL && 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 (YYID (0)) ++ ++# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ ++do { \ ++ if (yydebug) \ ++ { \ ++ YYFPRINTF (stderr, "%s ", Title); \ ++ yy_symbol_print (stderr, \ ++ Type, Value); \ ++ YYFPRINTF (stderr, "\n"); \ ++ } \ ++} while (YYID (0)) ++ ++ ++/*--------------------------------. ++| Print this symbol on YYOUTPUT. | ++`--------------------------------*/ ++ ++/*ARGSUSED*/ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++static void ++yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) ++#else ++static void ++yy_symbol_value_print (yyoutput, yytype, yyvaluep) ++ FILE *yyoutput; ++ int yytype; ++ YYSTYPE const * const yyvaluep; ++#endif ++{ ++ if (!yyvaluep) ++ return; ++# ifdef YYPRINT ++ if (yytype < YYNTOKENS) ++ YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); ++# else ++ YYUSE (yyoutput); ++# endif ++ switch (yytype) ++ { ++ default: ++ break; ++ } ++} ++ ++ ++/*--------------------------------. ++| Print this symbol on YYOUTPUT. | ++`--------------------------------*/ ++ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++static void ++yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) ++#else ++static void ++yy_symbol_print (yyoutput, yytype, yyvaluep) ++ FILE *yyoutput; ++ int yytype; ++ YYSTYPE const * const yyvaluep; ++#endif ++{ ++ if (yytype < YYNTOKENS) ++ YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); ++ else ++ YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); ++ ++ yy_symbol_value_print (yyoutput, yytype, yyvaluep); ++ YYFPRINTF (yyoutput, ")"); ++} ++ ++/*------------------------------------------------------------------. ++| yy_stack_print -- Print the state stack from its BOTTOM up to its | ++| TOP (included). | ++`------------------------------------------------------------------*/ ++ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++static void ++yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) ++#else ++static void ++yy_stack_print (bottom, top) ++ yytype_int16 *bottom; ++ yytype_int16 *top; ++#endif ++{ ++ YYFPRINTF (stderr, "Stack now"); ++ for (; 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 (YYID (0)) ++ ++ ++/*------------------------------------------------. ++| Report that the YYRULE is going to be reduced. | ++`------------------------------------------------*/ ++ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++static void ++yy_reduce_print (YYSTYPE *yyvsp, int yyrule) ++#else ++static void ++yy_reduce_print (yyvsp, yyrule) ++ YYSTYPE *yyvsp; ++ int yyrule; ++#endif ++{ ++ int yynrhs = yyr2[yyrule]; ++ int yyi; ++ unsigned long int yylno = yyrline[yyrule]; ++ YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", ++ yyrule - 1, yylno); ++ /* The symbols being reduced. */ ++ for (yyi = 0; yyi < yynrhs; yyi++) ++ { ++ fprintf (stderr, " $%d = ", yyi + 1); ++ yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], ++ &(yyvsp[(yyi + 1) - (yynrhs)]) ++ ); ++ fprintf (stderr, "\n"); ++ } ++} ++ ++# define YY_REDUCE_PRINT(Rule) \ ++do { \ ++ if (yydebug) \ ++ yy_reduce_print (yyvsp, Rule); \ ++} while (YYID (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 ++ YYSTACK_ALLOC_MAXIMUM < 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. */ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++static YYSIZE_T ++yystrlen (const char *yystr) ++#else ++static YYSIZE_T ++yystrlen (yystr) ++ const char *yystr; ++#endif ++{ ++ YYSIZE_T yylen; ++ for (yylen = 0; yystr[yylen]; yylen++) ++ continue; ++ return yylen; ++} ++# 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. */ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++static char * ++yystpcpy (char *yydest, const char *yysrc) ++#else ++static char * ++yystpcpy (yydest, yysrc) ++ char *yydest; ++ const char *yysrc; ++#endif ++{ ++ char *yyd = yydest; ++ const char *yys = yysrc; ++ ++ while ((*yyd++ = *yys++) != '\0') ++ continue; ++ ++ return yyd - 1; ++} ++# endif ++# endif ++ ++# ifndef yytnamerr ++/* Copy to YYRES the contents of YYSTR after stripping away unnecessary ++ quotes and backslashes, so that it's suitable for yyerror. The ++ heuristic is that double-quoting is unnecessary unless the string ++ contains an apostrophe, a comma, or backslash (other than ++ backslash-backslash). YYSTR is taken from yytname. If YYRES is ++ null, do not copy; instead, return the length of what the result ++ would have been. */ ++static YYSIZE_T ++yytnamerr (char *yyres, const char *yystr) ++{ ++ if (*yystr == '"') ++ { ++ YYSIZE_T yyn = 0; ++ char const *yyp = yystr; ++ ++ for (;;) ++ switch (*++yyp) ++ { ++ case '\'': ++ case ',': ++ goto do_not_strip_quotes; ++ ++ case '\\': ++ if (*++yyp != '\\') ++ goto do_not_strip_quotes; ++ /* Fall through. */ ++ default: ++ if (yyres) ++ yyres[yyn] = *yyp; ++ yyn++; ++ break; ++ ++ case '"': ++ if (yyres) ++ yyres[yyn] = '\0'; ++ return yyn; ++ } ++ do_not_strip_quotes: ; ++ } ++ ++ if (! yyres) ++ return yystrlen (yystr); ++ ++ return yystpcpy (yyres, yystr) - yyres; ++} ++# endif ++ ++/* Copy into YYRESULT an error message about the unexpected token ++ YYCHAR while in state YYSTATE. Return the number of bytes copied, ++ including the terminating null byte. If YYRESULT is null, do not ++ copy anything; just return the number of bytes that would be ++ copied. As a special case, return 0 if an ordinary "syntax error" ++ message will do. Return YYSIZE_MAXIMUM if overflow occurs during ++ size calculation. */ ++static YYSIZE_T ++yysyntax_error (char *yyresult, int yystate, int yychar) ++{ ++ int yyn = yypact[yystate]; ++ ++ if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) ++ return 0; ++ else ++ { ++ int yytype = YYTRANSLATE (yychar); ++ YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); ++ YYSIZE_T yysize = yysize0; ++ YYSIZE_T yysize1; ++ int yysize_overflow = 0; ++ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; ++ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; ++ int yyx; ++ ++# if 0 ++ /* This is so xgettext sees the translatable formats that are ++ constructed on the fly. */ ++ YY_("syntax error, unexpected %s"); ++ YY_("syntax error, unexpected %s, expecting %s"); ++ YY_("syntax error, unexpected %s, expecting %s or %s"); ++ YY_("syntax error, unexpected %s, expecting %s or %s or %s"); ++ YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); ++# endif ++ char *yyfmt; ++ char const *yyf; ++ static char const yyunexpected[] = "syntax error, unexpected %s"; ++ static char const yyexpecting[] = ", expecting %s"; ++ static char const yyor[] = " or %s"; ++ char yyformat[sizeof yyunexpected ++ + sizeof yyexpecting - 1 ++ + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) ++ * (sizeof yyor - 1))]; ++ char const *yyprefix = yyexpecting; ++ ++ /* 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 + 1; ++ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; ++ int yycount = 1; ++ ++ yyarg[0] = yytname[yytype]; ++ yyfmt = yystpcpy (yyformat, yyunexpected); ++ ++ for (yyx = yyxbegin; yyx < yyxend; ++yyx) ++ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) ++ { ++ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) ++ { ++ yycount = 1; ++ yysize = yysize0; ++ yyformat[sizeof yyunexpected - 1] = '\0'; ++ break; ++ } ++ yyarg[yycount++] = yytname[yyx]; ++ yysize1 = yysize + yytnamerr (0, yytname[yyx]); ++ yysize_overflow |= (yysize1 < yysize); ++ yysize = yysize1; ++ yyfmt = yystpcpy (yyfmt, yyprefix); ++ yyprefix = yyor; ++ } ++ ++ yyf = YY_(yyformat); ++ yysize1 = yysize + yystrlen (yyf); ++ yysize_overflow |= (yysize1 < yysize); ++ yysize = yysize1; ++ ++ if (yysize_overflow) ++ return YYSIZE_MAXIMUM; ++ ++ if (yyresult) ++ { ++ /* Avoid sprintf, as that infringes on the user's name space. ++ Don't have undefined behavior even if the translation ++ produced a string with the wrong number of "%s"s. */ ++ char *yyp = yyresult; ++ int yyi = 0; ++ while ((*yyp = *yyf) != '\0') ++ { ++ if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) ++ { ++ yyp += yytnamerr (yyp, yyarg[yyi++]); ++ yyf += 2; ++ } ++ else ++ { ++ yyp++; ++ yyf++; ++ } ++ } ++ } ++ return yysize; ++ } ++} ++#endif /* YYERROR_VERBOSE */ ++ ++ ++/*-----------------------------------------------. ++| Release the memory associated to this symbol. | ++`-----------------------------------------------*/ ++ ++/*ARGSUSED*/ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++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 ++{ ++ YYUSE (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 __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++int ++yyparse (void *YYPARSE_PARAM) ++#else ++int ++yyparse (YYPARSE_PARAM) ++ void *YYPARSE_PARAM; ++#endif ++#else /* ! YYPARSE_PARAM */ ++#if (defined __STDC__ || defined __C99__FUNC__ \ ++ || defined __cplusplus || defined _MSC_VER) ++int ++yyparse (void) ++#else ++int ++yyparse () ++ ++#endif ++#endif ++{ ++ ++ int yystate; ++ 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; ++#if YYERROR_VERBOSE ++ /* Buffer for error messages, and its allocated size. */ ++ char yymsgbuf[128]; ++ char *yymsg = yymsgbuf; ++ YYSIZE_T yymsg_alloc = sizeof yymsgbuf; ++#endif ++ ++ /* 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. */ ++ yytype_int16 yyssa[YYINITDEPTH]; ++ yytype_int16 *yyss = yyssa; ++ yytype_int16 *yyssp; ++ ++ /* The semantic value stack. */ ++ YYSTYPE yyvsa[YYINITDEPTH]; ++ YYSTYPE *yyvs = yyvsa; ++ YYSTYPE *yyvsp; ++ ++ ++ ++#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) ++ ++ YYSIZE_T yystacksize = YYINITDEPTH; ++ ++ /* The variables used to return semantic value and location from the ++ action routines. */ ++ YYSTYPE yyval; ++ ++ ++ /* The number of symbols on the RHS of the reduced rule. ++ Keep to zero when no symbol should be popped. */ ++ int yylen = 0; ++ ++ 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; ++ ++ 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; ++ yytype_int16 *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 (YY_("memory exhausted"), ++ &yyss1, yysize * sizeof (*yyssp), ++ &yyvs1, yysize * sizeof (*yyvsp), ++ ++ &yystacksize); ++ ++ yyss = yyss1; ++ yyvs = yyvs1; ++ } ++#else /* no yyoverflow */ ++# ifndef YYSTACK_RELOCATE ++ goto yyexhaustedlab; ++# else ++ /* Extend the stack our own way. */ ++ if (YYMAXDEPTH <= yystacksize) ++ goto yyexhaustedlab; ++ yystacksize *= 2; ++ if (YYMAXDEPTH < yystacksize) ++ yystacksize = YYMAXDEPTH; ++ ++ { ++ yytype_int16 *yyss1 = yyss; ++ union yyalloc *yyptr = ++ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); ++ if (! yyptr) ++ goto yyexhaustedlab; ++ 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. */ ++ ++ /* 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; ++ ++ /* Count tokens shifted since error; after three, turn off error ++ status. */ ++ if (yyerrstatus) ++ yyerrstatus--; ++ ++ /* Shift the look-ahead token. */ ++ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); ++ ++ /* Discard the shifted token unless it is eof. */ ++ if (yychar != YYEOF) ++ yychar = YYEMPTY; ++ ++ yystate = yyn; ++ *++yyvsp = yylval; ++ ++ 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 1730 "parser.y" ++ { ++ if (!classes) classes = NewHash(); ++ Setattr((yyvsp[(1) - (1)].node),"classes",classes); ++ Setattr((yyvsp[(1) - (1)].node),"name",ModuleName); ++ ++ if ((!module_node) && ModuleName) { ++ module_node = new_node("module"); ++ Setattr(module_node,"name",ModuleName); ++ } ++ Setattr((yyvsp[(1) - (1)].node),"module",module_node); ++ top = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 3: ++#line 1742 "parser.y" ++ { ++ top = Copy(Getattr((yyvsp[(2) - (3)].p),"type")); ++ Delete((yyvsp[(2) - (3)].p)); ++ ;} ++ break; ++ ++ case 4: ++#line 1746 "parser.y" ++ { ++ top = 0; ++ ;} ++ break; ++ ++ case 5: ++#line 1749 "parser.y" ++ { ++ top = (yyvsp[(2) - (3)].p); ++ ;} ++ break; ++ ++ case 6: ++#line 1752 "parser.y" ++ { ++ top = 0; ++ ;} ++ break; ++ ++ case 7: ++#line 1755 "parser.y" ++ { ++ top = (yyvsp[(3) - (5)].pl); ++ ;} ++ break; ++ ++ case 8: ++#line 1758 "parser.y" ++ { ++ top = 0; ++ ;} ++ break; ++ ++ case 9: ++#line 1763 "parser.y" ++ { ++ /* add declaration to end of linked list (the declaration isn't always a single declaration, sometimes it is a linked list itself) */ ++ if (currentDeclComment != NULL) { ++ set_comment((yyvsp[(2) - (2)].node), currentDeclComment); ++ currentDeclComment = NULL; ++ } ++ appendChild((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node)); ++ (yyval.node) = (yyvsp[(1) - (2)].node); ++ ;} ++ break; ++ ++ case 10: ++#line 1772 "parser.y" ++ { ++ currentDeclComment = (yyvsp[(2) - (2)].str); ++ (yyval.node) = (yyvsp[(1) - (2)].node); ++ ;} ++ break; ++ ++ case 11: ++#line 1776 "parser.y" ++ { ++ Node *node = lastChild((yyvsp[(1) - (2)].node)); ++ if (node) { ++ set_comment(node, (yyvsp[(2) - (2)].str)); ++ } ++ (yyval.node) = (yyvsp[(1) - (2)].node); ++ ;} ++ break; ++ ++ case 12: ++#line 1783 "parser.y" ++ { ++ (yyval.node) = new_node("top"); ++ ;} ++ break; ++ ++ case 13: ++#line 1788 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 14: ++#line 1789 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 15: ++#line 1790 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 16: ++#line 1791 "parser.y" ++ { (yyval.node) = 0; ;} ++ break; ++ ++ case 17: ++#line 1792 "parser.y" ++ { ++ (yyval.node) = 0; ++ if (cparse_unknown_directive) { ++ Swig_error(cparse_file, cparse_line, "Unknown directive '%s'.\n", cparse_unknown_directive); ++ } else { ++ Swig_error(cparse_file, cparse_line, "Syntax error in input(1).\n"); ++ } ++ Exit(EXIT_FAILURE); ++ ;} ++ break; ++ ++ case 18: ++#line 1802 "parser.y" ++ { ++ if ((yyval.node)) { ++ add_symbols((yyval.node)); ++ } ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 19: ++#line 1818 "parser.y" ++ { ++ (yyval.node) = 0; ++ skip_decl(); ++ ;} ++ break; ++ ++ case 20: ++#line 1828 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 21: ++#line 1829 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 22: ++#line 1830 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 23: ++#line 1831 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 24: ++#line 1832 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 25: ++#line 1833 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 26: ++#line 1834 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 27: ++#line 1835 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 28: ++#line 1836 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 29: ++#line 1837 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 30: ++#line 1838 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 31: ++#line 1839 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 32: ++#line 1840 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 33: ++#line 1841 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 34: ++#line 1842 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 35: ++#line 1843 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 36: ++#line 1844 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 37: ++#line 1845 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 38: ++#line 1846 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 39: ++#line 1847 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 40: ++#line 1848 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 41: ++#line 1855 "parser.y" ++ { ++ Node *cls; ++ String *clsname; ++ extendmode = 1; ++ cplus_mode = CPLUS_PUBLIC; ++ if (!classes) classes = NewHash(); ++ if (!classes_typedefs) classes_typedefs = NewHash(); ++ clsname = make_class_name((yyvsp[(4) - (5)].str)); ++ cls = Getattr(classes,clsname); ++ if (!cls) { ++ cls = Getattr(classes_typedefs, clsname); ++ if (!cls) { ++ /* No previous definition. Create a new scope */ ++ Node *am = Getattr(Swig_extend_hash(),clsname); ++ if (!am) { ++ Swig_symbol_newscope(); ++ Swig_symbol_setscopename((yyvsp[(4) - (5)].str)); ++ prev_symtab = 0; ++ } else { ++ prev_symtab = Swig_symbol_setscope(Getattr(am,"symtab")); ++ } ++ current_class = 0; ++ } else { ++ /* Previous typedef class definition. Use its symbol table. ++ Deprecated, just the real name should be used. ++ Note that %extend before the class typedef never worked, only %extend after the class typedef. */ ++ prev_symtab = Swig_symbol_setscope(Getattr(cls, "symtab")); ++ current_class = cls; ++ SWIG_WARN_NODE_BEGIN(cls); ++ Swig_warning(WARN_PARSE_EXTEND_NAME, cparse_file, cparse_line, "Deprecated %%extend name used - the %s name '%s' should be used instead of the typedef name '%s'.\n", Getattr(cls, "kind"), SwigType_namestr(Getattr(cls, "name")), (yyvsp[(4) - (5)].str)); ++ SWIG_WARN_NODE_END(cls); ++ } ++ } else { ++ /* Previous class definition. Use its symbol table */ ++ prev_symtab = Swig_symbol_setscope(Getattr(cls,"symtab")); ++ current_class = cls; ++ } ++ Classprefix = NewString((yyvsp[(4) - (5)].str)); ++ Namespaceprefix= Swig_symbol_qualifiedscopename(0); ++ Delete(clsname); ++ ;} ++ break; ++ ++ case 42: ++#line 1895 "parser.y" ++ { ++ String *clsname; ++ extendmode = 0; ++ (yyval.node) = new_node("extend"); ++ Setattr((yyval.node),"symtab",Swig_symbol_popscope()); ++ if (prev_symtab) { ++ Swig_symbol_setscope(prev_symtab); ++ } ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ clsname = make_class_name((yyvsp[(4) - (8)].str)); ++ Setattr((yyval.node),"name",clsname); ++ ++ mark_nodes_as_extend((yyvsp[(7) - (8)].node)); ++ if (current_class) { ++ /* We add the extension to the previously defined class */ ++ appendChild((yyval.node), (yyvsp[(7) - (8)].node)); ++ appendChild(current_class,(yyval.node)); ++ } else { ++ /* We store the extensions in the extensions hash */ ++ Node *am = Getattr(Swig_extend_hash(),clsname); ++ if (am) { ++ /* Append the members to the previous extend methods */ ++ appendChild(am, (yyvsp[(7) - (8)].node)); ++ } else { ++ appendChild((yyval.node), (yyvsp[(7) - (8)].node)); ++ Setattr(Swig_extend_hash(),clsname,(yyval.node)); ++ } ++ } ++ current_class = 0; ++ Delete(Classprefix); ++ Delete(clsname); ++ Classprefix = 0; ++ prev_symtab = 0; ++ (yyval.node) = 0; ++ ++ ;} ++ break; ++ ++ case 43: ++#line 1937 "parser.y" ++ { ++ (yyval.node) = new_node("apply"); ++ Setattr((yyval.node),"pattern",Getattr((yyvsp[(2) - (5)].p),"pattern")); ++ appendChild((yyval.node),(yyvsp[(4) - (5)].p)); ++ ;} ++ break; ++ ++ case 44: ++#line 1947 "parser.y" ++ { ++ (yyval.node) = new_node("clear"); ++ appendChild((yyval.node),(yyvsp[(2) - (3)].p)); ++ ;} ++ break; ++ ++ case 45: ++#line 1961 "parser.y" ++ { ++ if (((yyvsp[(4) - (5)].dtype).type != T_ERROR) && ((yyvsp[(4) - (5)].dtype).type != T_SYMBOL)) { ++ SwigType *type = NewSwigType((yyvsp[(4) - (5)].dtype).type); ++ (yyval.node) = new_node("constant"); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id)); ++ Setattr((yyval.node),"type",type); ++ Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val); ++ if ((yyvsp[(4) - (5)].dtype).rawval) Setattr((yyval.node),"rawval", (yyvsp[(4) - (5)].dtype).rawval); ++ Setattr((yyval.node),"storage","%constant"); ++ SetFlag((yyval.node),"feature:immutable"); ++ add_symbols((yyval.node)); ++ Delete(type); ++ } else { ++ if ((yyvsp[(4) - (5)].dtype).type == T_ERROR) { ++ Swig_warning(WARN_PARSE_UNSUPPORTED_VALUE,cparse_file,cparse_line,"Unsupported constant value (ignored)\n"); ++ } ++ (yyval.node) = 0; ++ } ++ ++ ;} ++ break; ++ ++ case 46: ++#line 1981 "parser.y" ++ { ++ if (((yyvsp[(4) - (5)].dtype).type != T_ERROR) && ((yyvsp[(4) - (5)].dtype).type != T_SYMBOL)) { ++ SwigType_push((yyvsp[(2) - (5)].type),(yyvsp[(3) - (5)].decl).type); ++ /* Sneaky callback function trick */ ++ if (SwigType_isfunction((yyvsp[(2) - (5)].type))) { ++ SwigType_add_pointer((yyvsp[(2) - (5)].type)); ++ } ++ (yyval.node) = new_node("constant"); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (5)].decl).id); ++ Setattr((yyval.node),"type",(yyvsp[(2) - (5)].type)); ++ Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val); ++ if ((yyvsp[(4) - (5)].dtype).rawval) Setattr((yyval.node),"rawval", (yyvsp[(4) - (5)].dtype).rawval); ++ Setattr((yyval.node),"storage","%constant"); ++ SetFlag((yyval.node),"feature:immutable"); ++ add_symbols((yyval.node)); ++ } else { ++ if ((yyvsp[(4) - (5)].dtype).type == T_ERROR) { ++ Swig_warning(WARN_PARSE_UNSUPPORTED_VALUE,cparse_file,cparse_line, "Unsupported constant value\n"); ++ } ++ (yyval.node) = 0; ++ } ++ ;} ++ break; ++ ++ case 47: ++#line 2005 "parser.y" ++ { ++ if (((yyvsp[(8) - (9)].dtype).type != T_ERROR) && ((yyvsp[(8) - (9)].dtype).type != T_SYMBOL)) { ++ SwigType_add_function((yyvsp[(2) - (9)].type), (yyvsp[(5) - (9)].pl)); ++ SwigType_push((yyvsp[(2) - (9)].type), (yyvsp[(7) - (9)].dtype).qualifier); ++ SwigType_push((yyvsp[(2) - (9)].type), (yyvsp[(3) - (9)].decl).type); ++ /* Sneaky callback function trick */ ++ if (SwigType_isfunction((yyvsp[(2) - (9)].type))) { ++ SwigType_add_pointer((yyvsp[(2) - (9)].type)); ++ } ++ (yyval.node) = new_node("constant"); ++ Setattr((yyval.node), "name", (yyvsp[(3) - (9)].decl).id); ++ Setattr((yyval.node), "type", (yyvsp[(2) - (9)].type)); ++ Setattr((yyval.node), "value", (yyvsp[(8) - (9)].dtype).val); ++ if ((yyvsp[(8) - (9)].dtype).rawval) Setattr((yyval.node), "rawval", (yyvsp[(8) - (9)].dtype).rawval); ++ Setattr((yyval.node), "storage", "%constant"); ++ SetFlag((yyval.node), "feature:immutable"); ++ add_symbols((yyval.node)); ++ } else { ++ if ((yyvsp[(8) - (9)].dtype).type == T_ERROR) { ++ Swig_warning(WARN_PARSE_UNSUPPORTED_VALUE,cparse_file,cparse_line, "Unsupported constant value\n"); ++ } ++ (yyval.node) = 0; ++ } ++ ;} ++ break; ++ ++ case 48: ++#line 2029 "parser.y" ++ { ++ Swig_warning(WARN_PARSE_BAD_VALUE,cparse_file,cparse_line,"Bad constant value (ignored).\n"); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 49: ++#line 2033 "parser.y" ++ { ++ Swig_error(cparse_file,cparse_line,"Missing semicolon (';') after %%constant.\n"); ++ Exit(EXIT_FAILURE); ++ ;} ++ break; ++ ++ case 50: ++#line 2044 "parser.y" ++ { ++ char temp[64]; ++ Replace((yyvsp[(2) - (2)].str),"$file",cparse_file, DOH_REPLACE_ANY); ++ sprintf(temp,"%d", cparse_line); ++ Replace((yyvsp[(2) - (2)].str),"$line",temp,DOH_REPLACE_ANY); ++ Printf(stderr,"%s\n", (yyvsp[(2) - (2)].str)); ++ Delete((yyvsp[(2) - (2)].str)); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 51: ++#line 2053 "parser.y" ++ { ++ char temp[64]; ++ String *s = (yyvsp[(2) - (2)].str); ++ Replace(s,"$file",cparse_file, DOH_REPLACE_ANY); ++ sprintf(temp,"%d", cparse_line); ++ Replace(s,"$line",temp,DOH_REPLACE_ANY); ++ Printf(stderr,"%s\n", s); ++ Delete(s); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 52: ++#line 2072 "parser.y" ++ { ++ skip_balanced('{','}'); ++ (yyval.node) = 0; ++ Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n"); ++ ;} ++ break; ++ ++ case 53: ++#line 2078 "parser.y" ++ { ++ skip_balanced('{','}'); ++ (yyval.node) = 0; ++ Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n"); ++ ;} ++ break; ++ ++ case 54: ++#line 2084 "parser.y" ++ { ++ (yyval.node) = 0; ++ Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n"); ++ ;} ++ break; ++ ++ case 55: ++#line 2089 "parser.y" ++ { ++ (yyval.node) = 0; ++ Swig_warning(WARN_DEPRECATED_EXCEPT,cparse_file, cparse_line, "%%except is deprecated. Use %%exception instead.\n"); ++ ;} ++ break; ++ ++ case 56: ++#line 2096 "parser.y" ++ { ++ (yyval.node) = NewHash(); ++ Setattr((yyval.node),"value",(yyvsp[(1) - (4)].str)); ++ Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (4)].p),"type")); ++ ;} ++ break; ++ ++ case 57: ++#line 2103 "parser.y" ++ { ++ (yyval.node) = NewHash(); ++ Setattr((yyval.node),"value",(yyvsp[(1) - (1)].str)); ++ ;} ++ break; ++ ++ case 58: ++#line 2107 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 59: ++#line 2120 "parser.y" ++ { ++ Hash *p = (yyvsp[(5) - (7)].node); ++ (yyval.node) = new_node("fragment"); ++ Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (7)].node),"value")); ++ Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (7)].node),"type")); ++ Setattr((yyval.node),"section",Getattr(p,"name")); ++ Setattr((yyval.node),"kwargs",nextSibling(p)); ++ Setattr((yyval.node),"code",(yyvsp[(7) - (7)].str)); ++ ;} ++ break; ++ ++ case 60: ++#line 2129 "parser.y" ++ { ++ Hash *p = (yyvsp[(5) - (7)].node); ++ String *code; ++ skip_balanced('{','}'); ++ (yyval.node) = new_node("fragment"); ++ Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (7)].node),"value")); ++ Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (7)].node),"type")); ++ Setattr((yyval.node),"section",Getattr(p,"name")); ++ Setattr((yyval.node),"kwargs",nextSibling(p)); ++ Delitem(scanner_ccode,0); ++ Delitem(scanner_ccode,DOH_END); ++ code = Copy(scanner_ccode); ++ Setattr((yyval.node),"code",code); ++ Delete(code); ++ ;} ++ break; ++ ++ case 61: ++#line 2144 "parser.y" ++ { ++ (yyval.node) = new_node("fragment"); ++ Setattr((yyval.node),"value",Getattr((yyvsp[(3) - (5)].node),"value")); ++ Setattr((yyval.node),"type",Getattr((yyvsp[(3) - (5)].node),"type")); ++ Setattr((yyval.node),"emitonly","1"); ++ ;} ++ break; ++ ++ case 62: ++#line 2157 "parser.y" ++ { ++ (yyvsp[(1) - (4)].loc).filename = Copy(cparse_file); ++ (yyvsp[(1) - (4)].loc).line = cparse_line; ++ scanner_set_location((yyvsp[(3) - (4)].str),1); ++ if ((yyvsp[(2) - (4)].node)) { ++ String *maininput = Getattr((yyvsp[(2) - (4)].node), "maininput"); ++ if (maininput) ++ scanner_set_main_input_file(NewString(maininput)); ++ } ++ ;} ++ break; ++ ++ case 63: ++#line 2166 "parser.y" ++ { ++ String *mname = 0; ++ (yyval.node) = (yyvsp[(6) - (7)].node); ++ scanner_set_location((yyvsp[(1) - (7)].loc).filename,(yyvsp[(1) - (7)].loc).line+1); ++ if (strcmp((yyvsp[(1) - (7)].loc).type,"include") == 0) set_nodeType((yyval.node),"include"); ++ if (strcmp((yyvsp[(1) - (7)].loc).type,"import") == 0) { ++ mname = (yyvsp[(2) - (7)].node) ? Getattr((yyvsp[(2) - (7)].node),"module") : 0; ++ set_nodeType((yyval.node),"import"); ++ if (import_mode) --import_mode; ++ } ++ ++ Setattr((yyval.node),"name",(yyvsp[(3) - (7)].str)); ++ /* Search for the module (if any) */ ++ { ++ Node *n = firstChild((yyval.node)); ++ while (n) { ++ if (Strcmp(nodeType(n),"module") == 0) { ++ if (mname) { ++ Setattr(n,"name", mname); ++ mname = 0; ++ } ++ Setattr((yyval.node),"module",Getattr(n,"name")); ++ break; ++ } ++ n = nextSibling(n); ++ } ++ if (mname) { ++ /* There is no module node in the import ++ node, ie, you imported a .h file ++ directly. We are forced then to create ++ a new import node with a module node. ++ */ ++ Node *nint = new_node("import"); ++ Node *mnode = new_node("module"); ++ Setattr(mnode,"name", mname); ++ Setattr(mnode,"options",(yyvsp[(2) - (7)].node)); ++ appendChild(nint,mnode); ++ Delete(mnode); ++ appendChild(nint,firstChild((yyval.node))); ++ (yyval.node) = nint; ++ Setattr((yyval.node),"module",mname); ++ } ++ } ++ Setattr((yyval.node),"options",(yyvsp[(2) - (7)].node)); ++ ;} ++ break; ++ ++ case 64: ++#line 2213 "parser.y" ++ { (yyval.loc).type = "include"; ;} ++ break; ++ ++ case 65: ++#line 2214 "parser.y" ++ { (yyval.loc).type = "import"; ++import_mode;;} ++ break; ++ ++ case 66: ++#line 2221 "parser.y" ++ { ++ String *cpps; ++ if (Namespaceprefix) { ++ Swig_error(cparse_file, cparse_start_line, "%%inline directive inside a namespace is disallowed.\n"); ++ (yyval.node) = 0; ++ } else { ++ (yyval.node) = new_node("insert"); ++ Setattr((yyval.node),"code",(yyvsp[(2) - (2)].str)); ++ /* Need to run through the preprocessor */ ++ Seek((yyvsp[(2) - (2)].str),0,SEEK_SET); ++ Setline((yyvsp[(2) - (2)].str),cparse_start_line); ++ Setfile((yyvsp[(2) - (2)].str),cparse_file); ++ cpps = Preprocessor_parse((yyvsp[(2) - (2)].str)); ++ start_inline(Char(cpps), cparse_start_line); ++ Delete((yyvsp[(2) - (2)].str)); ++ Delete(cpps); ++ } ++ ++ ;} ++ break; ++ ++ case 67: ++#line 2240 "parser.y" ++ { ++ String *cpps; ++ int start_line = cparse_line; ++ skip_balanced('{','}'); ++ if (Namespaceprefix) { ++ Swig_error(cparse_file, cparse_start_line, "%%inline directive inside a namespace is disallowed.\n"); ++ ++ (yyval.node) = 0; ++ } else { ++ String *code; ++ (yyval.node) = new_node("insert"); ++ Delitem(scanner_ccode,0); ++ Delitem(scanner_ccode,DOH_END); ++ code = Copy(scanner_ccode); ++ Setattr((yyval.node),"code", code); ++ Delete(code); ++ cpps=Copy(scanner_ccode); ++ start_inline(Char(cpps), start_line); ++ Delete(cpps); ++ } ++ ;} ++ break; ++ ++ case 68: ++#line 2271 "parser.y" ++ { ++ (yyval.node) = new_node("insert"); ++ Setattr((yyval.node),"code",(yyvsp[(1) - (1)].str)); ++ ;} ++ break; ++ ++ case 69: ++#line 2275 "parser.y" ++ { ++ String *code = NewStringEmpty(); ++ (yyval.node) = new_node("insert"); ++ Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id)); ++ Setattr((yyval.node),"code",code); ++ if (Swig_insert_file((yyvsp[(5) - (5)].str),code) < 0) { ++ Swig_error(cparse_file, cparse_line, "Couldn't find '%s'.\n", (yyvsp[(5) - (5)].str)); ++ (yyval.node) = 0; ++ } ++ ;} ++ break; ++ ++ case 70: ++#line 2285 "parser.y" ++ { ++ (yyval.node) = new_node("insert"); ++ Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id)); ++ Setattr((yyval.node),"code",(yyvsp[(5) - (5)].str)); ++ ;} ++ break; ++ ++ case 71: ++#line 2290 "parser.y" ++ { ++ String *code; ++ skip_balanced('{','}'); ++ (yyval.node) = new_node("insert"); ++ Setattr((yyval.node),"section",(yyvsp[(3) - (5)].id)); ++ Delitem(scanner_ccode,0); ++ Delitem(scanner_ccode,DOH_END); ++ code = Copy(scanner_ccode); ++ Setattr((yyval.node),"code", code); ++ Delete(code); ++ ;} ++ break; ++ ++ case 72: ++#line 2308 "parser.y" ++ { ++ (yyval.node) = new_node("module"); ++ if ((yyvsp[(2) - (3)].node)) { ++ Setattr((yyval.node),"options",(yyvsp[(2) - (3)].node)); ++ if (Getattr((yyvsp[(2) - (3)].node),"directors")) { ++ Wrapper_director_mode_set(1); ++ if (!cparse_cplusplus) { ++ Swig_error(cparse_file, cparse_line, "Directors are not supported for C code and require the -c++ option\n"); ++ } ++ } ++ if (Getattr((yyvsp[(2) - (3)].node),"dirprot")) { ++ Wrapper_director_protected_mode_set(1); ++ } ++ if (Getattr((yyvsp[(2) - (3)].node),"allprotected")) { ++ Wrapper_all_protected_mode_set(1); ++ } ++ if (Getattr((yyvsp[(2) - (3)].node),"templatereduce")) { ++ template_reduce = 1; ++ } ++ if (Getattr((yyvsp[(2) - (3)].node),"notemplatereduce")) { ++ template_reduce = 0; ++ } ++ } ++ if (!ModuleName) ModuleName = NewString((yyvsp[(3) - (3)].id)); ++ if (!import_mode) { ++ /* first module included, we apply global ++ ModuleName, which can be modify by -module */ ++ String *mname = Copy(ModuleName); ++ Setattr((yyval.node),"name",mname); ++ Delete(mname); ++ } else { ++ /* import mode, we just pass the idstring */ ++ Setattr((yyval.node),"name",(yyvsp[(3) - (3)].id)); ++ } ++ if (!module_node) module_node = (yyval.node); ++ ;} ++ break; ++ ++ case 73: ++#line 2351 "parser.y" ++ { ++ Swig_warning(WARN_DEPRECATED_NAME,cparse_file,cparse_line, "%%name is deprecated. Use %%rename instead.\n"); ++ Delete(yyrename); ++ yyrename = NewString((yyvsp[(3) - (4)].id)); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 74: ++#line 2357 "parser.y" ++ { ++ Swig_warning(WARN_DEPRECATED_NAME,cparse_file,cparse_line, "%%name is deprecated. Use %%rename instead.\n"); ++ (yyval.node) = 0; ++ Swig_error(cparse_file,cparse_line,"Missing argument to %%name directive.\n"); ++ ;} ++ break; ++ ++ case 75: ++#line 2370 "parser.y" ++ { ++ (yyval.node) = new_node("native"); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (7)].id)); ++ Setattr((yyval.node),"wrap:name",(yyvsp[(6) - (7)].id)); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 76: ++#line 2376 "parser.y" ++ { ++ if (!SwigType_isfunction((yyvsp[(7) - (8)].decl).type)) { ++ Swig_error(cparse_file,cparse_line,"%%native declaration '%s' is not a function.\n", (yyvsp[(7) - (8)].decl).id); ++ (yyval.node) = 0; ++ } else { ++ Delete(SwigType_pop_function((yyvsp[(7) - (8)].decl).type)); ++ /* Need check for function here */ ++ SwigType_push((yyvsp[(6) - (8)].type),(yyvsp[(7) - (8)].decl).type); ++ (yyval.node) = new_node("native"); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (8)].id)); ++ Setattr((yyval.node),"wrap:name",(yyvsp[(7) - (8)].decl).id); ++ Setattr((yyval.node),"type",(yyvsp[(6) - (8)].type)); ++ Setattr((yyval.node),"parms",(yyvsp[(7) - (8)].decl).parms); ++ Setattr((yyval.node),"decl",(yyvsp[(7) - (8)].decl).type); ++ } ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 77: ++#line 2402 "parser.y" ++ { ++ (yyval.node) = new_node("pragma"); ++ Setattr((yyval.node),"lang",(yyvsp[(2) - (5)].id)); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (5)].id)); ++ Setattr((yyval.node),"value",(yyvsp[(5) - (5)].str)); ++ ;} ++ break; ++ ++ case 78: ++#line 2408 "parser.y" ++ { ++ (yyval.node) = new_node("pragma"); ++ Setattr((yyval.node),"lang",(yyvsp[(2) - (3)].id)); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (3)].id)); ++ ;} ++ break; ++ ++ case 79: ++#line 2415 "parser.y" ++ { (yyval.str) = (yyvsp[(1) - (1)].str); ;} ++ break; ++ ++ case 80: ++#line 2416 "parser.y" ++ { (yyval.str) = (yyvsp[(1) - (1)].str); ;} ++ break; ++ ++ case 81: ++#line 2419 "parser.y" ++ { (yyval.id) = (yyvsp[(2) - (3)].id); ;} ++ break; ++ ++ case 82: ++#line 2420 "parser.y" ++ { (yyval.id) = (char *) "swig"; ;} ++ break; ++ ++ case 83: ++#line 2427 "parser.y" ++ { ++ SwigType *t = (yyvsp[(2) - (4)].decl).type; ++ Hash *kws = NewHash(); ++ String *fixname; ++ fixname = feature_identifier_fix((yyvsp[(2) - (4)].decl).id); ++ Setattr(kws,"name",(yyvsp[(3) - (4)].id)); ++ if (!Len(t)) t = 0; ++ /* Special declarator check */ ++ if (t) { ++ if (SwigType_isfunction(t)) { ++ SwigType *decl = SwigType_pop_function(t); ++ if (SwigType_ispointer(t)) { ++ String *nname = NewStringf("*%s",fixname); ++ if ((yyvsp[(1) - (4)].intvalue)) { ++ Swig_name_rename_add(Namespaceprefix, nname,decl,kws,(yyvsp[(2) - (4)].decl).parms); ++ } else { ++ Swig_name_namewarn_add(Namespaceprefix,nname,decl,kws); ++ } ++ Delete(nname); ++ } else { ++ if ((yyvsp[(1) - (4)].intvalue)) { ++ Swig_name_rename_add(Namespaceprefix,(fixname),decl,kws,(yyvsp[(2) - (4)].decl).parms); ++ } else { ++ Swig_name_namewarn_add(Namespaceprefix,(fixname),decl,kws); ++ } ++ } ++ Delete(decl); ++ } else if (SwigType_ispointer(t)) { ++ String *nname = NewStringf("*%s",fixname); ++ if ((yyvsp[(1) - (4)].intvalue)) { ++ Swig_name_rename_add(Namespaceprefix,(nname),0,kws,(yyvsp[(2) - (4)].decl).parms); ++ } else { ++ Swig_name_namewarn_add(Namespaceprefix,(nname),0,kws); ++ } ++ Delete(nname); ++ } ++ } else { ++ if ((yyvsp[(1) - (4)].intvalue)) { ++ Swig_name_rename_add(Namespaceprefix,(fixname),0,kws,(yyvsp[(2) - (4)].decl).parms); ++ } else { ++ Swig_name_namewarn_add(Namespaceprefix,(fixname),0,kws); ++ } ++ } ++ (yyval.node) = 0; ++ scanner_clear_rename(); ++ ;} ++ break; ++ ++ case 84: ++#line 2473 "parser.y" ++ { ++ String *fixname; ++ Hash *kws = (yyvsp[(3) - (7)].node); ++ SwigType *t = (yyvsp[(5) - (7)].decl).type; ++ fixname = feature_identifier_fix((yyvsp[(5) - (7)].decl).id); ++ if (!Len(t)) t = 0; ++ /* Special declarator check */ ++ if (t) { ++ if ((yyvsp[(6) - (7)].dtype).qualifier) SwigType_push(t,(yyvsp[(6) - (7)].dtype).qualifier); ++ if (SwigType_isfunction(t)) { ++ SwigType *decl = SwigType_pop_function(t); ++ if (SwigType_ispointer(t)) { ++ String *nname = NewStringf("*%s",fixname); ++ if ((yyvsp[(1) - (7)].intvalue)) { ++ Swig_name_rename_add(Namespaceprefix, nname,decl,kws,(yyvsp[(5) - (7)].decl).parms); ++ } else { ++ Swig_name_namewarn_add(Namespaceprefix,nname,decl,kws); ++ } ++ Delete(nname); ++ } else { ++ if ((yyvsp[(1) - (7)].intvalue)) { ++ Swig_name_rename_add(Namespaceprefix,(fixname),decl,kws,(yyvsp[(5) - (7)].decl).parms); ++ } else { ++ Swig_name_namewarn_add(Namespaceprefix,(fixname),decl,kws); ++ } ++ } ++ Delete(decl); ++ } else if (SwigType_ispointer(t)) { ++ String *nname = NewStringf("*%s",fixname); ++ if ((yyvsp[(1) - (7)].intvalue)) { ++ Swig_name_rename_add(Namespaceprefix,(nname),0,kws,(yyvsp[(5) - (7)].decl).parms); ++ } else { ++ Swig_name_namewarn_add(Namespaceprefix,(nname),0,kws); ++ } ++ Delete(nname); ++ } ++ } else { ++ if ((yyvsp[(1) - (7)].intvalue)) { ++ Swig_name_rename_add(Namespaceprefix,(fixname),0,kws,(yyvsp[(5) - (7)].decl).parms); ++ } else { ++ Swig_name_namewarn_add(Namespaceprefix,(fixname),0,kws); ++ } ++ } ++ (yyval.node) = 0; ++ scanner_clear_rename(); ++ ;} ++ break; ++ ++ case 85: ++#line 2519 "parser.y" ++ { ++ if ((yyvsp[(1) - (6)].intvalue)) { ++ Swig_name_rename_add(Namespaceprefix,(yyvsp[(5) - (6)].str),0,(yyvsp[(3) - (6)].node),0); ++ } else { ++ Swig_name_namewarn_add(Namespaceprefix,(yyvsp[(5) - (6)].str),0,(yyvsp[(3) - (6)].node)); ++ } ++ (yyval.node) = 0; ++ scanner_clear_rename(); ++ ;} ++ break; ++ ++ case 86: ++#line 2530 "parser.y" ++ { ++ (yyval.intvalue) = 1; ++ ;} ++ break; ++ ++ case 87: ++#line 2533 "parser.y" ++ { ++ (yyval.intvalue) = 0; ++ ;} ++ break; ++ ++ case 88: ++#line 2560 "parser.y" ++ { ++ String *val = (yyvsp[(7) - (7)].str) ? NewString((yyvsp[(7) - (7)].str)) : NewString("1"); ++ new_feature((yyvsp[(3) - (7)].id), val, 0, (yyvsp[(5) - (7)].decl).id, (yyvsp[(5) - (7)].decl).type, (yyvsp[(5) - (7)].decl).parms, (yyvsp[(6) - (7)].dtype).qualifier); ++ (yyval.node) = 0; ++ scanner_clear_rename(); ++ ;} ++ break; ++ ++ case 89: ++#line 2566 "parser.y" ++ { ++ String *val = Len((yyvsp[(5) - (9)].str)) ? (yyvsp[(5) - (9)].str) : 0; ++ new_feature((yyvsp[(3) - (9)].id), val, 0, (yyvsp[(7) - (9)].decl).id, (yyvsp[(7) - (9)].decl).type, (yyvsp[(7) - (9)].decl).parms, (yyvsp[(8) - (9)].dtype).qualifier); ++ (yyval.node) = 0; ++ scanner_clear_rename(); ++ ;} ++ break; ++ ++ case 90: ++#line 2572 "parser.y" ++ { ++ String *val = (yyvsp[(8) - (8)].str) ? NewString((yyvsp[(8) - (8)].str)) : NewString("1"); ++ new_feature((yyvsp[(3) - (8)].id), val, (yyvsp[(4) - (8)].node), (yyvsp[(6) - (8)].decl).id, (yyvsp[(6) - (8)].decl).type, (yyvsp[(6) - (8)].decl).parms, (yyvsp[(7) - (8)].dtype).qualifier); ++ (yyval.node) = 0; ++ scanner_clear_rename(); ++ ;} ++ break; ++ ++ case 91: ++#line 2578 "parser.y" ++ { ++ String *val = Len((yyvsp[(5) - (10)].str)) ? (yyvsp[(5) - (10)].str) : 0; ++ new_feature((yyvsp[(3) - (10)].id), val, (yyvsp[(6) - (10)].node), (yyvsp[(8) - (10)].decl).id, (yyvsp[(8) - (10)].decl).type, (yyvsp[(8) - (10)].decl).parms, (yyvsp[(9) - (10)].dtype).qualifier); ++ (yyval.node) = 0; ++ scanner_clear_rename(); ++ ;} ++ break; ++ ++ case 92: ++#line 2586 "parser.y" ++ { ++ String *val = (yyvsp[(5) - (5)].str) ? NewString((yyvsp[(5) - (5)].str)) : NewString("1"); ++ new_feature((yyvsp[(3) - (5)].id), val, 0, 0, 0, 0, 0); ++ (yyval.node) = 0; ++ scanner_clear_rename(); ++ ;} ++ break; ++ ++ case 93: ++#line 2592 "parser.y" ++ { ++ String *val = Len((yyvsp[(5) - (7)].str)) ? (yyvsp[(5) - (7)].str) : 0; ++ new_feature((yyvsp[(3) - (7)].id), val, 0, 0, 0, 0, 0); ++ (yyval.node) = 0; ++ scanner_clear_rename(); ++ ;} ++ break; ++ ++ case 94: ++#line 2598 "parser.y" ++ { ++ String *val = (yyvsp[(6) - (6)].str) ? NewString((yyvsp[(6) - (6)].str)) : NewString("1"); ++ new_feature((yyvsp[(3) - (6)].id), val, (yyvsp[(4) - (6)].node), 0, 0, 0, 0); ++ (yyval.node) = 0; ++ scanner_clear_rename(); ++ ;} ++ break; ++ ++ case 95: ++#line 2604 "parser.y" ++ { ++ String *val = Len((yyvsp[(5) - (8)].str)) ? (yyvsp[(5) - (8)].str) : 0; ++ new_feature((yyvsp[(3) - (8)].id), val, (yyvsp[(6) - (8)].node), 0, 0, 0, 0); ++ (yyval.node) = 0; ++ scanner_clear_rename(); ++ ;} ++ break; ++ ++ case 96: ++#line 2612 "parser.y" ++ { (yyval.str) = (yyvsp[(1) - (1)].str); ;} ++ break; ++ ++ case 97: ++#line 2613 "parser.y" ++ { (yyval.str) = 0; ;} ++ break; ++ ++ case 98: ++#line 2614 "parser.y" ++ { (yyval.str) = (yyvsp[(3) - (5)].pl); ;} ++ break; ++ ++ case 99: ++#line 2617 "parser.y" ++ { ++ (yyval.node) = NewHash(); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (4)].id)); ++ Setattr((yyval.node),"value",(yyvsp[(4) - (4)].str)); ++ ;} ++ break; ++ ++ case 100: ++#line 2622 "parser.y" ++ { ++ (yyval.node) = NewHash(); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id)); ++ Setattr((yyval.node),"value",(yyvsp[(4) - (5)].str)); ++ set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node)); ++ ;} ++ break; ++ ++ case 101: ++#line 2632 "parser.y" ++ { ++ Parm *val; ++ String *name; ++ SwigType *t; ++ if (Namespaceprefix) name = NewStringf("%s::%s", Namespaceprefix, (yyvsp[(5) - (7)].decl).id); ++ else name = NewString((yyvsp[(5) - (7)].decl).id); ++ val = (yyvsp[(3) - (7)].pl); ++ if ((yyvsp[(5) - (7)].decl).parms) { ++ Setmeta(val,"parms",(yyvsp[(5) - (7)].decl).parms); ++ } ++ t = (yyvsp[(5) - (7)].decl).type; ++ if (!Len(t)) t = 0; ++ if (t) { ++ if ((yyvsp[(6) - (7)].dtype).qualifier) SwigType_push(t,(yyvsp[(6) - (7)].dtype).qualifier); ++ if (SwigType_isfunction(t)) { ++ SwigType *decl = SwigType_pop_function(t); ++ if (SwigType_ispointer(t)) { ++ String *nname = NewStringf("*%s",name); ++ Swig_feature_set(Swig_cparse_features(), nname, decl, "feature:varargs", val, 0); ++ Delete(nname); ++ } else { ++ Swig_feature_set(Swig_cparse_features(), name, decl, "feature:varargs", val, 0); ++ } ++ Delete(decl); ++ } else if (SwigType_ispointer(t)) { ++ String *nname = NewStringf("*%s",name); ++ Swig_feature_set(Swig_cparse_features(),nname,0,"feature:varargs",val, 0); ++ Delete(nname); ++ } ++ } else { ++ Swig_feature_set(Swig_cparse_features(),name,0,"feature:varargs",val, 0); ++ } ++ Delete(name); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 102: ++#line 2668 "parser.y" ++ { (yyval.pl) = (yyvsp[(1) - (1)].pl); ;} ++ break; ++ ++ case 103: ++#line 2669 "parser.y" ++ { ++ int i; ++ int n; ++ Parm *p; ++ n = atoi(Char((yyvsp[(1) - (3)].dtype).val)); ++ if (n <= 0) { ++ Swig_error(cparse_file, cparse_line,"Argument count in %%varargs must be positive.\n"); ++ (yyval.pl) = 0; ++ } else { ++ String *name = Getattr((yyvsp[(3) - (3)].p), "name"); ++ (yyval.pl) = Copy((yyvsp[(3) - (3)].p)); ++ if (name) ++ Setattr((yyval.pl), "name", NewStringf("%s%d", name, n)); ++ for (i = 1; i < n; i++) { ++ p = Copy((yyvsp[(3) - (3)].p)); ++ name = Getattr(p, "name"); ++ if (name) ++ Setattr(p, "name", NewStringf("%s%d", name, n-i)); ++ set_nextSibling(p,(yyval.pl)); ++ Delete((yyval.pl)); ++ (yyval.pl) = p; ++ } ++ } ++ ;} ++ break; ++ ++ case 104: ++#line 2704 "parser.y" ++ { ++ (yyval.node) = 0; ++ if ((yyvsp[(3) - (6)].tmap).method) { ++ String *code = 0; ++ (yyval.node) = new_node("typemap"); ++ Setattr((yyval.node),"method",(yyvsp[(3) - (6)].tmap).method); ++ if ((yyvsp[(3) - (6)].tmap).kwargs) { ++ ParmList *kw = (yyvsp[(3) - (6)].tmap).kwargs; ++ code = remove_block(kw, (yyvsp[(6) - (6)].str)); ++ Setattr((yyval.node),"kwargs", (yyvsp[(3) - (6)].tmap).kwargs); ++ } ++ code = code ? code : NewString((yyvsp[(6) - (6)].str)); ++ Setattr((yyval.node),"code", code); ++ Delete(code); ++ appendChild((yyval.node),(yyvsp[(5) - (6)].p)); ++ } ++ ;} ++ break; ++ ++ case 105: ++#line 2721 "parser.y" ++ { ++ (yyval.node) = 0; ++ if ((yyvsp[(3) - (6)].tmap).method) { ++ (yyval.node) = new_node("typemap"); ++ Setattr((yyval.node),"method",(yyvsp[(3) - (6)].tmap).method); ++ appendChild((yyval.node),(yyvsp[(5) - (6)].p)); ++ } ++ ;} ++ break; ++ ++ case 106: ++#line 2729 "parser.y" ++ { ++ (yyval.node) = 0; ++ if ((yyvsp[(3) - (8)].tmap).method) { ++ (yyval.node) = new_node("typemapcopy"); ++ Setattr((yyval.node),"method",(yyvsp[(3) - (8)].tmap).method); ++ Setattr((yyval.node),"pattern", Getattr((yyvsp[(7) - (8)].p),"pattern")); ++ appendChild((yyval.node),(yyvsp[(5) - (8)].p)); ++ } ++ ;} ++ break; ++ ++ case 107: ++#line 2742 "parser.y" ++ { ++ String *name = Getattr((yyvsp[(1) - (1)].node), "name"); ++ Hash *p = nextSibling((yyvsp[(1) - (1)].node)); ++ (yyval.tmap).method = name; ++ (yyval.tmap).kwargs = p; ++ if (Getattr((yyvsp[(1) - (1)].node), "value")) { ++ Swig_error(cparse_file, cparse_line, ++ "%%typemap method shouldn't have a value specified.\n"); ++ } ++ while (p) { ++ if (!Getattr(p, "value")) { ++ Swig_error(cparse_file, cparse_line, ++ "%%typemap attribute '%s' is missing its value. If this is specifying the target language, that's no longer supported: use #ifdef SWIG instead.\n", ++ Getattr(p, "name")); ++ /* Set to empty value to avoid segfaults later. */ ++ Setattr(p, "value", NewStringEmpty()); ++ } ++ p = nextSibling(p); ++ } ++ ;} ++ break; ++ ++ case 108: ++#line 2764 "parser.y" ++ { ++ (yyval.p) = (yyvsp[(1) - (2)].p); ++ set_nextSibling((yyval.p),(yyvsp[(2) - (2)].p)); ++ ;} ++ break; ++ ++ case 109: ++#line 2770 "parser.y" ++ { ++ (yyval.p) = (yyvsp[(2) - (3)].p); ++ set_nextSibling((yyval.p),(yyvsp[(3) - (3)].p)); ++ ;} ++ break; ++ ++ case 110: ++#line 2774 "parser.y" ++ { (yyval.p) = 0;;} ++ break; ++ ++ case 111: ++#line 2777 "parser.y" ++ { ++ Parm *parm; ++ SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type); ++ (yyval.p) = new_node("typemapitem"); ++ parm = NewParmWithoutFileLineInfo((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).id); ++ Setattr((yyval.p),"pattern",parm); ++ Setattr((yyval.p),"parms", (yyvsp[(2) - (2)].decl).parms); ++ Delete(parm); ++ /* $$ = NewParmWithoutFileLineInfo($1,$2.id); ++ Setattr($$,"parms",$2.parms); */ ++ ;} ++ break; ++ ++ case 112: ++#line 2788 "parser.y" ++ { ++ (yyval.p) = new_node("typemapitem"); ++ Setattr((yyval.p),"pattern",(yyvsp[(2) - (3)].pl)); ++ /* Setattr($$,"multitype",$2); */ ++ ;} ++ break; ++ ++ case 113: ++#line 2793 "parser.y" ++ { ++ (yyval.p) = new_node("typemapitem"); ++ Setattr((yyval.p),"pattern", (yyvsp[(2) - (6)].pl)); ++ /* Setattr($$,"multitype",$2); */ ++ Setattr((yyval.p),"parms",(yyvsp[(5) - (6)].pl)); ++ ;} ++ break; ++ ++ case 114: ++#line 2806 "parser.y" ++ { ++ (yyval.node) = new_node("types"); ++ Setattr((yyval.node),"parms",(yyvsp[(3) - (5)].pl)); ++ if ((yyvsp[(5) - (5)].str)) ++ Setattr((yyval.node),"convcode",NewString((yyvsp[(5) - (5)].str))); ++ ;} ++ break; ++ ++ case 115: ++#line 2818 "parser.y" ++ { ++ Parm *p, *tp; ++ Node *n; ++ Node *outer_class = currentOuterClass; ++ Symtab *tscope = 0; ++ int specialized = 0; ++ int variadic = 0; ++ ++ (yyval.node) = 0; ++ ++ tscope = Swig_symbol_current(); /* Get the current scope */ ++ ++ /* If the class name is qualified, we need to create or lookup namespace entries */ ++ (yyvsp[(5) - (9)].str) = resolve_create_node_scope((yyvsp[(5) - (9)].str), 0); ++ ++ if (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0) { ++ outer_class = nscope_inner; ++ } ++ ++ /* ++ We use the new namespace entry 'nscope' only to ++ emit the template node. The template parameters are ++ resolved in the current 'tscope'. ++ ++ This is closer to the C++ (typedef) behavior. ++ */ ++ n = Swig_cparse_template_locate((yyvsp[(5) - (9)].str),(yyvsp[(7) - (9)].p),tscope); ++ ++ /* Patch the argument types to respect namespaces */ ++ p = (yyvsp[(7) - (9)].p); ++ while (p) { ++ SwigType *value = Getattr(p,"value"); ++ if (!value) { ++ SwigType *ty = Getattr(p,"type"); ++ if (ty) { ++ SwigType *rty = 0; ++ int reduce = template_reduce; ++ if (reduce || !SwigType_ispointer(ty)) { ++ rty = Swig_symbol_typedef_reduce(ty,tscope); ++ if (!reduce) reduce = SwigType_ispointer(rty); ++ } ++ ty = reduce ? Swig_symbol_type_qualify(rty,tscope) : Swig_symbol_type_qualify(ty,tscope); ++ Setattr(p,"type",ty); ++ Delete(ty); ++ Delete(rty); ++ } ++ } else { ++ value = Swig_symbol_type_qualify(value,tscope); ++ Setattr(p,"value",value); ++ Delete(value); ++ } ++ ++ p = nextSibling(p); ++ } ++ ++ /* Look for the template */ ++ { ++ Node *nn = n; ++ Node *linklistend = 0; ++ Node *linkliststart = 0; ++ while (nn) { ++ Node *templnode = 0; ++ if (Strcmp(nodeType(nn),"template") == 0) { ++ int nnisclass = (Strcmp(Getattr(nn,"templatetype"),"class") == 0); /* if not a templated class it is a templated function */ ++ Parm *tparms = Getattr(nn,"templateparms"); ++ if (!tparms) { ++ specialized = 1; ++ } else if (Getattr(tparms,"variadic") && strncmp(Char(Getattr(tparms,"variadic")), "1", 1)==0) { ++ variadic = 1; ++ } ++ if (nnisclass && !variadic && !specialized && (ParmList_len((yyvsp[(7) - (9)].p)) > ParmList_len(tparms))) { ++ Swig_error(cparse_file, cparse_line, "Too many template parameters. Maximum of %d.\n", ParmList_len(tparms)); ++ } else if (nnisclass && !specialized && ((ParmList_len((yyvsp[(7) - (9)].p)) < (ParmList_numrequired(tparms) - (variadic?1:0))))) { /* Variadic parameter is optional */ ++ Swig_error(cparse_file, cparse_line, "Not enough template parameters specified. %d required.\n", (ParmList_numrequired(tparms)-(variadic?1:0)) ); ++ } else if (!nnisclass && ((ParmList_len((yyvsp[(7) - (9)].p)) != ParmList_len(tparms)))) { ++ /* must be an overloaded templated method - ignore it as it is overloaded with a different number of template parameters */ ++ nn = Getattr(nn,"sym:nextSibling"); /* repeat for overloaded templated functions */ ++ continue; ++ } else { ++ String *tname = Copy((yyvsp[(5) - (9)].str)); ++ int def_supplied = 0; ++ /* Expand the template */ ++ Node *templ = Swig_symbol_clookup((yyvsp[(5) - (9)].str),0); ++ Parm *targs = templ ? Getattr(templ,"templateparms") : 0; ++ ++ ParmList *temparms; ++ if (specialized) temparms = CopyParmList((yyvsp[(7) - (9)].p)); ++ else temparms = CopyParmList(tparms); ++ ++ /* Create typedef's and arguments */ ++ p = (yyvsp[(7) - (9)].p); ++ tp = temparms; ++ if (!p && ParmList_len(p) != ParmList_len(temparms)) { ++ /* we have no template parameters supplied in %template for a template that has default args*/ ++ p = tp; ++ def_supplied = 1; ++ } ++ ++ while (p) { ++ String *value = Getattr(p,"value"); ++ if (def_supplied) { ++ Setattr(p,"default","1"); ++ } ++ if (value) { ++ Setattr(tp,"value",value); ++ } else { ++ SwigType *ty = Getattr(p,"type"); ++ if (ty) { ++ Setattr(tp,"type",ty); ++ } ++ Delattr(tp,"value"); ++ } ++ /* fix default arg values */ ++ if (targs) { ++ Parm *pi = temparms; ++ Parm *ti = targs; ++ String *tv = Getattr(tp,"value"); ++ if (!tv) tv = Getattr(tp,"type"); ++ while(pi != tp && ti && pi) { ++ String *name = Getattr(ti,"name"); ++ String *value = Getattr(pi,"value"); ++ if (!value) value = Getattr(pi,"type"); ++ Replaceid(tv, name, value); ++ pi = nextSibling(pi); ++ ti = nextSibling(ti); ++ } ++ } ++ p = nextSibling(p); ++ tp = nextSibling(tp); ++ if (!p && tp) { ++ p = tp; ++ def_supplied = 1; ++ } else if (p && !tp) { /* Variadic template - tp < p */ ++ SWIG_WARN_NODE_BEGIN(nn); ++ Swig_warning(WARN_CPP11_VARIADIC_TEMPLATE,cparse_file, cparse_line,"Only the first variadic template argument is currently supported.\n"); ++ SWIG_WARN_NODE_END(nn); ++ break; ++ } ++ } ++ ++ templnode = copy_node(nn); ++ update_nested_classes(templnode); /* update classes nested within template */ ++ /* We need to set the node name based on name used to instantiate */ ++ Setattr(templnode,"name",tname); ++ Delete(tname); ++ if (!specialized) { ++ Delattr(templnode,"sym:typename"); ++ } else { ++ Setattr(templnode,"sym:typename","1"); ++ } ++ /* for now, nested %template is allowed only in the same scope as the template declaration */ ++ if ((yyvsp[(3) - (9)].id) && !(nnisclass && ((outer_class && (outer_class != Getattr(nn, "nested:outer"))) ++ ||(extendmode && current_class && (current_class != Getattr(nn, "nested:outer")))))) { ++ /* ++ Comment this out for 1.3.28. We need to ++ re-enable it later but first we need to ++ move %ignore from using %rename to use ++ %feature(ignore). ++ ++ String *symname = Swig_name_make(templnode,0,$3,0,0); ++ */ ++ String *symname = NewString((yyvsp[(3) - (9)].id)); ++ Swig_cparse_template_expand(templnode,symname,temparms,tscope); ++ Setattr(templnode,"sym:name",symname); ++ } else { ++ static int cnt = 0; ++ String *nname = NewStringf("__dummy_%d__", cnt++); ++ Swig_cparse_template_expand(templnode,nname,temparms,tscope); ++ Setattr(templnode,"sym:name",nname); ++ SetFlag(templnode,"hidden"); ++ Delete(nname); ++ Setattr(templnode,"feature:onlychildren", "typemap,typemapitem,typemapcopy,typedef,types,fragment,apply"); ++ if ((yyvsp[(3) - (9)].id)) { ++ Swig_warning(WARN_PARSE_NESTED_TEMPLATE, cparse_file, cparse_line, "Named nested template instantiations not supported. Processing as if no name was given to %%template().\n"); ++ } ++ } ++ Delattr(templnode,"templatetype"); ++ Setattr(templnode,"template",nn); ++ Setfile(templnode,cparse_file); ++ Setline(templnode,cparse_line); ++ Delete(temparms); ++ if (outer_class && nnisclass) { ++ SetFlag(templnode, "nested"); ++ Setattr(templnode, "nested:outer", outer_class); ++ } ++ add_symbols_copy(templnode); ++ ++ if (Strcmp(nodeType(templnode),"class") == 0) { ++ ++ /* Identify pure abstract methods */ ++ Setattr(templnode,"abstracts", pure_abstracts(firstChild(templnode))); ++ ++ /* Set up inheritance in symbol table */ ++ { ++ Symtab *csyms; ++ List *baselist = Getattr(templnode,"baselist"); ++ csyms = Swig_symbol_current(); ++ Swig_symbol_setscope(Getattr(templnode,"symtab")); ++ if (baselist) { ++ List *bases = Swig_make_inherit_list(Getattr(templnode,"name"),baselist, Namespaceprefix); ++ if (bases) { ++ Iterator s; ++ for (s = First(bases); s.item; s = Next(s)) { ++ Symtab *st = Getattr(s.item,"symtab"); ++ if (st) { ++ Setfile(st,Getfile(s.item)); ++ Setline(st,Getline(s.item)); ++ Swig_symbol_inherit(st); ++ } ++ } ++ Delete(bases); ++ } ++ } ++ Swig_symbol_setscope(csyms); ++ } ++ ++ /* Merge in %extend methods for this class. ++ This only merges methods within %extend for a template specialized class such as ++ template class K {}; %extend K { ... } ++ The copy_node() call above has already added in the generic %extend methods such as ++ template class K {}; %extend K { ... } */ ++ ++ /* !!! This may be broken. We may have to add the ++ %extend methods at the beginning of the class */ ++ { ++ String *stmp = 0; ++ String *clsname; ++ Node *am; ++ if (Namespaceprefix) { ++ clsname = stmp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name")); ++ } else { ++ clsname = Getattr(templnode,"name"); ++ } ++ am = Getattr(Swig_extend_hash(),clsname); ++ if (am) { ++ Symtab *st = Swig_symbol_current(); ++ Swig_symbol_setscope(Getattr(templnode,"symtab")); ++ /* Printf(stdout,"%s: %s %p %p\n", Getattr(templnode,"name"), clsname, Swig_symbol_current(), Getattr(templnode,"symtab")); */ ++ Swig_extend_merge(templnode,am); ++ Swig_symbol_setscope(st); ++ Swig_extend_append_previous(templnode,am); ++ Delattr(Swig_extend_hash(),clsname); ++ } ++ if (stmp) Delete(stmp); ++ } ++ ++ /* Add to classes hash */ ++ if (!classes) ++ classes = NewHash(); ++ ++ if (Namespaceprefix) { ++ String *temp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name")); ++ Setattr(classes,temp,templnode); ++ Delete(temp); ++ } else { ++ String *qs = Swig_symbol_qualifiedscopename(templnode); ++ Setattr(classes, qs,templnode); ++ Delete(qs); ++ } ++ } ++ } ++ ++ /* all the overloaded templated functions are added into a linked list */ ++ if (!linkliststart) ++ linkliststart = templnode; ++ if (nscope_inner) { ++ /* non-global namespace */ ++ if (templnode) { ++ appendChild(nscope_inner,templnode); ++ Delete(templnode); ++ if (nscope) (yyval.node) = nscope; ++ } ++ } else { ++ /* global namespace */ ++ if (!linklistend) { ++ (yyval.node) = templnode; ++ } else { ++ set_nextSibling(linklistend,templnode); ++ Delete(templnode); ++ } ++ linklistend = templnode; ++ } ++ } ++ nn = Getattr(nn,"sym:nextSibling"); /* repeat for overloaded templated functions. If a templated class there will never be a sibling. */ ++ } ++ update_defaultargs(linkliststart); ++ update_abstracts(linkliststart); ++ } ++ Swig_symbol_setscope(tscope); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ ;} ++ break; ++ ++ case 116: ++#line 3117 "parser.y" ++ { ++ Swig_warning(0,cparse_file, cparse_line,"%s\n", (yyvsp[(2) - (2)].str)); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 117: ++#line 3127 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ if ((yyval.node)) { ++ add_symbols((yyval.node)); ++ default_arguments((yyval.node)); ++ } ++ ;} ++ break; ++ ++ case 118: ++#line 3134 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 119: ++#line 3135 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 120: ++#line 3139 "parser.y" ++ { ++ if (Strcmp((yyvsp[(2) - (3)].str),"C") == 0) { ++ cparse_externc = 1; ++ } ++ ;} ++ break; ++ ++ case 121: ++#line 3143 "parser.y" ++ { ++ cparse_externc = 0; ++ if (Strcmp((yyvsp[(2) - (6)].str),"C") == 0) { ++ Node *n = firstChild((yyvsp[(5) - (6)].node)); ++ (yyval.node) = new_node("extern"); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (6)].str)); ++ appendChild((yyval.node),n); ++ while (n) { ++ String *s = Getattr(n, "storage"); ++ if (s) { ++ if (Strstr(s, "thread_local")) { ++ Insert(s,0,"externc "); ++ } else if (!Equal(s, "typedef")) { ++ Setattr(n,"storage","externc"); ++ } ++ } else { ++ Setattr(n,"storage","externc"); ++ } ++ n = nextSibling(n); ++ } ++ } else { ++ if (!Equal((yyvsp[(2) - (6)].str),"C++")) { ++ Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", (yyvsp[(2) - (6)].str)); ++ } ++ (yyval.node) = new_node("extern"); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (6)].str)); ++ appendChild((yyval.node),firstChild((yyvsp[(5) - (6)].node))); ++ } ++ ;} ++ break; ++ ++ case 122: ++#line 3172 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ SWIG_WARN_NODE_BEGIN((yyval.node)); ++ Swig_warning(WARN_CPP11_LAMBDA, cparse_file, cparse_line, "Lambda expressions and closures are not fully supported yet.\n"); ++ SWIG_WARN_NODE_END((yyval.node)); ++ ;} ++ break; ++ ++ case 123: ++#line 3178 "parser.y" ++ { ++ /* Convert using statement to a typedef statement */ ++ (yyval.node) = new_node("cdecl"); ++ Setattr((yyval.node),"type",(yyvsp[(4) - (6)].type)); ++ Setattr((yyval.node),"storage","typedef"); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (6)].str)); ++ Setattr((yyval.node),"decl",(yyvsp[(5) - (6)].decl).type); ++ SetFlag((yyval.node),"typealias"); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 124: ++#line 3188 "parser.y" ++ { ++ /* Convert alias template to a "template" typedef statement */ ++ (yyval.node) = new_node("template"); ++ Setattr((yyval.node),"type",(yyvsp[(8) - (10)].type)); ++ Setattr((yyval.node),"storage","typedef"); ++ Setattr((yyval.node),"name",(yyvsp[(6) - (10)].str)); ++ Setattr((yyval.node),"decl",(yyvsp[(9) - (10)].decl).type); ++ Setattr((yyval.node),"templateparms",(yyvsp[(3) - (10)].tparms)); ++ Setattr((yyval.node),"templatetype","cdecl"); ++ SetFlag((yyval.node),"aliastemplate"); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 125: ++#line 3200 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 126: ++#line 3209 "parser.y" ++ { ++ String *decl = (yyvsp[(3) - (6)].decl).type; ++ (yyval.node) = new_node("cdecl"); ++ if ((yyvsp[(4) - (6)].dtype).qualifier) ++ decl = add_qualifier_to_declarator((yyvsp[(3) - (6)].decl).type, (yyvsp[(4) - (6)].dtype).qualifier); ++ Setattr((yyval.node),"refqualifier",(yyvsp[(4) - (6)].dtype).refqualifier); ++ Setattr((yyval.node),"type",(yyvsp[(2) - (6)].type)); ++ Setattr((yyval.node),"storage",(yyvsp[(1) - (6)].id)); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (6)].decl).id); ++ Setattr((yyval.node),"decl",decl); ++ Setattr((yyval.node),"parms",(yyvsp[(3) - (6)].decl).parms); ++ Setattr((yyval.node),"value",(yyvsp[(5) - (6)].dtype).val); ++ Setattr((yyval.node),"throws",(yyvsp[(4) - (6)].dtype).throws); ++ Setattr((yyval.node),"throw",(yyvsp[(4) - (6)].dtype).throwf); ++ Setattr((yyval.node),"noexcept",(yyvsp[(4) - (6)].dtype).nexcept); ++ Setattr((yyval.node),"final",(yyvsp[(4) - (6)].dtype).final); ++ if ((yyvsp[(5) - (6)].dtype).val && (yyvsp[(5) - (6)].dtype).type) { ++ /* store initializer type as it might be different to the declared type */ ++ SwigType *valuetype = NewSwigType((yyvsp[(5) - (6)].dtype).type); ++ if (Len(valuetype) > 0) ++ Setattr((yyval.node),"valuetype",valuetype); ++ else ++ Delete(valuetype); ++ } ++ if (!(yyvsp[(6) - (6)].node)) { ++ if (Len(scanner_ccode)) { ++ String *code = Copy(scanner_ccode); ++ Setattr((yyval.node),"code",code); ++ Delete(code); ++ } ++ } else { ++ Node *n = (yyvsp[(6) - (6)].node); ++ /* Inherit attributes */ ++ while (n) { ++ String *type = Copy((yyvsp[(2) - (6)].type)); ++ Setattr(n,"type",type); ++ Setattr(n,"storage",(yyvsp[(1) - (6)].id)); ++ n = nextSibling(n); ++ Delete(type); ++ } ++ } ++ if ((yyvsp[(5) - (6)].dtype).bitfield) { ++ Setattr((yyval.node),"bitfield", (yyvsp[(5) - (6)].dtype).bitfield); ++ } ++ ++ if ((yyvsp[(3) - (6)].decl).id) { ++ /* Look for "::" declarations (ignored) */ ++ if (Strstr((yyvsp[(3) - (6)].decl).id, "::")) { ++ /* This is a special case. If the scope name of the declaration exactly ++ matches that of the declaration, then we will allow it. Otherwise, delete. */ ++ String *p = Swig_scopename_prefix((yyvsp[(3) - (6)].decl).id); ++ if (p) { ++ if ((Namespaceprefix && Strcmp(p, Namespaceprefix) == 0) || ++ (Classprefix && Strcmp(p, Classprefix) == 0)) { ++ String *lstr = Swig_scopename_last((yyvsp[(3) - (6)].decl).id); ++ Setattr((yyval.node), "name", lstr); ++ Delete(lstr); ++ set_nextSibling((yyval.node), (yyvsp[(6) - (6)].node)); ++ } else { ++ Delete((yyval.node)); ++ (yyval.node) = (yyvsp[(6) - (6)].node); ++ } ++ Delete(p); ++ } else { ++ Delete((yyval.node)); ++ (yyval.node) = (yyvsp[(6) - (6)].node); ++ } ++ } else { ++ set_nextSibling((yyval.node), (yyvsp[(6) - (6)].node)); ++ } ++ } else { ++ Swig_error(cparse_file, cparse_line, "Missing symbol name for global declaration\n"); ++ (yyval.node) = 0; ++ } ++ ++ if ((yyvsp[(4) - (6)].dtype).qualifier && (yyvsp[(1) - (6)].id) && Strstr((yyvsp[(1) - (6)].id), "static")) ++ Swig_error(cparse_file, cparse_line, "Static function %s cannot have a qualifier.\n", Swig_name_decl((yyval.node))); ++ ;} ++ break; ++ ++ case 127: ++#line 3289 "parser.y" ++ { ++ (yyval.node) = new_node("cdecl"); ++ if ((yyvsp[(4) - (9)].dtype).qualifier) SwigType_push((yyvsp[(3) - (9)].decl).type, (yyvsp[(4) - (9)].dtype).qualifier); ++ Setattr((yyval.node),"refqualifier",(yyvsp[(4) - (9)].dtype).refqualifier); ++ Setattr((yyval.node),"type",(yyvsp[(6) - (9)].node)); ++ Setattr((yyval.node),"storage",(yyvsp[(1) - (9)].id)); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (9)].decl).id); ++ Setattr((yyval.node),"decl",(yyvsp[(3) - (9)].decl).type); ++ Setattr((yyval.node),"parms",(yyvsp[(3) - (9)].decl).parms); ++ Setattr((yyval.node),"value",(yyvsp[(4) - (9)].dtype).val); ++ Setattr((yyval.node),"throws",(yyvsp[(4) - (9)].dtype).throws); ++ Setattr((yyval.node),"throw",(yyvsp[(4) - (9)].dtype).throwf); ++ Setattr((yyval.node),"noexcept",(yyvsp[(4) - (9)].dtype).nexcept); ++ Setattr((yyval.node),"final",(yyvsp[(4) - (9)].dtype).final); ++ if (!(yyvsp[(9) - (9)].node)) { ++ if (Len(scanner_ccode)) { ++ String *code = Copy(scanner_ccode); ++ Setattr((yyval.node),"code",code); ++ Delete(code); ++ } ++ } else { ++ Node *n = (yyvsp[(9) - (9)].node); ++ while (n) { ++ String *type = Copy((yyvsp[(6) - (9)].node)); ++ Setattr(n,"type",type); ++ Setattr(n,"storage",(yyvsp[(1) - (9)].id)); ++ n = nextSibling(n); ++ Delete(type); ++ } ++ } ++ if ((yyvsp[(4) - (9)].dtype).bitfield) { ++ Setattr((yyval.node),"bitfield", (yyvsp[(4) - (9)].dtype).bitfield); ++ } ++ ++ if (Strstr((yyvsp[(3) - (9)].decl).id,"::")) { ++ String *p = Swig_scopename_prefix((yyvsp[(3) - (9)].decl).id); ++ if (p) { ++ if ((Namespaceprefix && Strcmp(p, Namespaceprefix) == 0) || ++ (Classprefix && Strcmp(p, Classprefix) == 0)) { ++ String *lstr = Swig_scopename_last((yyvsp[(3) - (9)].decl).id); ++ Setattr((yyval.node),"name",lstr); ++ Delete(lstr); ++ set_nextSibling((yyval.node), (yyvsp[(9) - (9)].node)); ++ } else { ++ Delete((yyval.node)); ++ (yyval.node) = (yyvsp[(9) - (9)].node); ++ } ++ Delete(p); ++ } else { ++ Delete((yyval.node)); ++ (yyval.node) = (yyvsp[(9) - (9)].node); ++ } ++ } else { ++ set_nextSibling((yyval.node), (yyvsp[(9) - (9)].node)); ++ } ++ ++ if ((yyvsp[(4) - (9)].dtype).qualifier && (yyvsp[(1) - (9)].id) && Strstr((yyvsp[(1) - (9)].id), "static")) ++ Swig_error(cparse_file, cparse_line, "Static function %s cannot have a qualifier.\n", Swig_name_decl((yyval.node))); ++ ;} ++ break; ++ ++ case 128: ++#line 3352 "parser.y" ++ { ++ (yyval.node) = 0; ++ Clear(scanner_ccode); ++ ;} ++ break; ++ ++ case 129: ++#line 3356 "parser.y" ++ { ++ (yyval.node) = new_node("cdecl"); ++ if ((yyvsp[(3) - (5)].dtype).qualifier) SwigType_push((yyvsp[(2) - (5)].decl).type,(yyvsp[(3) - (5)].dtype).qualifier); ++ Setattr((yyval.node),"refqualifier",(yyvsp[(3) - (5)].dtype).refqualifier); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (5)].decl).id); ++ Setattr((yyval.node),"decl",(yyvsp[(2) - (5)].decl).type); ++ Setattr((yyval.node),"parms",(yyvsp[(2) - (5)].decl).parms); ++ Setattr((yyval.node),"value",(yyvsp[(4) - (5)].dtype).val); ++ Setattr((yyval.node),"throws",(yyvsp[(3) - (5)].dtype).throws); ++ Setattr((yyval.node),"throw",(yyvsp[(3) - (5)].dtype).throwf); ++ Setattr((yyval.node),"noexcept",(yyvsp[(3) - (5)].dtype).nexcept); ++ Setattr((yyval.node),"final",(yyvsp[(3) - (5)].dtype).final); ++ if ((yyvsp[(4) - (5)].dtype).bitfield) { ++ Setattr((yyval.node),"bitfield", (yyvsp[(4) - (5)].dtype).bitfield); ++ } ++ if (!(yyvsp[(5) - (5)].node)) { ++ if (Len(scanner_ccode)) { ++ String *code = Copy(scanner_ccode); ++ Setattr((yyval.node),"code",code); ++ Delete(code); ++ } ++ } else { ++ set_nextSibling((yyval.node), (yyvsp[(5) - (5)].node)); ++ } ++ ;} ++ break; ++ ++ case 130: ++#line 3381 "parser.y" ++ { ++ skip_balanced('{','}'); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 131: ++#line 3385 "parser.y" ++ { ++ (yyval.node) = 0; ++ if (yychar == RPAREN) { ++ Swig_error(cparse_file, cparse_line, "Unexpected closing parenthesis (')').\n"); ++ } else { ++ Swig_error(cparse_file, cparse_line, "Syntax error - possibly a missing semicolon (';').\n"); ++ } ++ Exit(EXIT_FAILURE); ++ ;} ++ break; ++ ++ case 132: ++#line 3396 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ++ ;} ++ break; ++ ++ case 133: ++#line 3401 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 134: ++#line 3402 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 135: ++#line 3403 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 136: ++#line 3407 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 137: ++#line 3408 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].str); ;} ++ break; ++ ++ case 138: ++#line 3409 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (2)].str); ++ SwigType_add_reference((yyval.node)); ++ ;} ++ break; ++ ++ case 139: ++#line 3413 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 140: ++#line 3424 "parser.y" ++ { ++ (yyval.node) = new_node("lambda"); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (12)].str)); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 141: ++#line 3429 "parser.y" ++ { ++ (yyval.node) = new_node("lambda"); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (14)].str)); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 142: ++#line 3434 "parser.y" ++ { ++ (yyval.node) = new_node("lambda"); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (8)].str)); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 143: ++#line 3441 "parser.y" ++ { ++ skip_balanced('[',']'); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 144: ++#line 3447 "parser.y" ++ { ++ skip_balanced('<','>'); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 145: ++#line 3451 "parser.y" ++ { (yyval.node) = 0; ;} ++ break; ++ ++ case 146: ++#line 3454 "parser.y" ++ { ++ skip_balanced('{','}'); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 147: ++#line 3459 "parser.y" ++ { ++ (yyval.pl) = 0; ++ ;} ++ break; ++ ++ case 148: ++#line 3462 "parser.y" ++ { ++ skip_balanced('(',')'); ++ ;} ++ break; ++ ++ case 149: ++#line 3464 "parser.y" ++ { ++ (yyval.pl) = 0; ++ ;} ++ break; ++ ++ case 150: ++#line 3475 "parser.y" ++ { ++ (yyval.node) = (char *)"enum"; ++ ;} ++ break; ++ ++ case 151: ++#line 3478 "parser.y" ++ { ++ (yyval.node) = (char *)"enum class"; ++ ;} ++ break; ++ ++ case 152: ++#line 3481 "parser.y" ++ { ++ (yyval.node) = (char *)"enum struct"; ++ ;} ++ break; ++ ++ case 153: ++#line 3490 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(2) - (2)].type); ++ ;} ++ break; ++ ++ case 154: ++#line 3493 "parser.y" ++ { (yyval.node) = 0; ;} ++ break; ++ ++ case 155: ++#line 3500 "parser.y" ++ { ++ SwigType *ty = 0; ++ int scopedenum = (yyvsp[(3) - (5)].id) && !Equal((yyvsp[(2) - (5)].node), "enum"); ++ (yyval.node) = new_node("enumforward"); ++ ty = NewStringf("enum %s", (yyvsp[(3) - (5)].id)); ++ Setattr((yyval.node),"enumkey",(yyvsp[(2) - (5)].node)); ++ if (scopedenum) ++ SetFlag((yyval.node), "scopedenum"); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (5)].id)); ++ Setattr((yyval.node),"inherit",(yyvsp[(4) - (5)].node)); ++ Setattr((yyval.node),"type",ty); ++ Setattr((yyval.node),"sym:weak", "1"); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 156: ++#line 3522 "parser.y" ++ { ++ SwigType *ty = 0; ++ int scopedenum = (yyvsp[(3) - (8)].id) && !Equal((yyvsp[(2) - (8)].node), "enum"); ++ (yyval.node) = new_node("enum"); ++ ty = NewStringf("enum %s", (yyvsp[(3) - (8)].id)); ++ Setattr((yyval.node),"enumkey",(yyvsp[(2) - (8)].node)); ++ if (scopedenum) ++ SetFlag((yyval.node), "scopedenum"); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (8)].id)); ++ Setattr((yyval.node),"inherit",(yyvsp[(4) - (8)].node)); ++ Setattr((yyval.node),"type",ty); ++ appendChild((yyval.node),(yyvsp[(6) - (8)].node)); ++ add_symbols((yyval.node)); /* Add to tag space */ ++ ++ if (scopedenum) { ++ Swig_symbol_newscope(); ++ Swig_symbol_setscopename((yyvsp[(3) - (8)].id)); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ } ++ ++ add_symbols((yyvsp[(6) - (8)].node)); /* Add enum values to appropriate enum or enum class scope */ ++ ++ if (scopedenum) { ++ Setattr((yyval.node),"symtab", Swig_symbol_popscope()); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ } ++ ;} ++ break; ++ ++ case 157: ++#line 3551 "parser.y" ++ { ++ Node *n; ++ SwigType *ty = 0; ++ String *unnamed = 0; ++ int unnamedinstance = 0; ++ int scopedenum = (yyvsp[(3) - (11)].id) && !Equal((yyvsp[(2) - (11)].node), "enum"); ++ ++ (yyval.node) = new_node("enum"); ++ Setattr((yyval.node),"enumkey",(yyvsp[(2) - (11)].node)); ++ if (scopedenum) ++ SetFlag((yyval.node), "scopedenum"); ++ Setattr((yyval.node),"inherit",(yyvsp[(4) - (11)].node)); ++ if ((yyvsp[(3) - (11)].id)) { ++ Setattr((yyval.node),"name",(yyvsp[(3) - (11)].id)); ++ ty = NewStringf("enum %s", (yyvsp[(3) - (11)].id)); ++ } else if ((yyvsp[(8) - (11)].decl).id) { ++ unnamed = make_unnamed(); ++ ty = NewStringf("enum %s", unnamed); ++ Setattr((yyval.node),"unnamed",unnamed); ++ /* name is not set for unnamed enum instances, e.g. enum { foo } Instance; */ ++ if ((yyvsp[(1) - (11)].id) && Cmp((yyvsp[(1) - (11)].id),"typedef") == 0) { ++ Setattr((yyval.node),"name",(yyvsp[(8) - (11)].decl).id); ++ } else { ++ unnamedinstance = 1; ++ } ++ Setattr((yyval.node),"storage",(yyvsp[(1) - (11)].id)); ++ } ++ if ((yyvsp[(8) - (11)].decl).id && Cmp((yyvsp[(1) - (11)].id),"typedef") == 0) { ++ Setattr((yyval.node),"tdname",(yyvsp[(8) - (11)].decl).id); ++ Setattr((yyval.node),"allows_typedef","1"); ++ } ++ appendChild((yyval.node),(yyvsp[(6) - (11)].node)); ++ n = new_node("cdecl"); ++ Setattr(n,"type",ty); ++ Setattr(n,"name",(yyvsp[(8) - (11)].decl).id); ++ Setattr(n,"storage",(yyvsp[(1) - (11)].id)); ++ Setattr(n,"decl",(yyvsp[(8) - (11)].decl).type); ++ Setattr(n,"parms",(yyvsp[(8) - (11)].decl).parms); ++ Setattr(n,"unnamed",unnamed); ++ ++ if (unnamedinstance) { ++ SwigType *cty = NewString("enum "); ++ Setattr((yyval.node),"type",cty); ++ SetFlag((yyval.node),"unnamedinstance"); ++ SetFlag(n,"unnamedinstance"); ++ Delete(cty); ++ } ++ if ((yyvsp[(11) - (11)].node)) { ++ Node *p = (yyvsp[(11) - (11)].node); ++ set_nextSibling(n,p); ++ while (p) { ++ SwigType *cty = Copy(ty); ++ Setattr(p,"type",cty); ++ Setattr(p,"unnamed",unnamed); ++ Setattr(p,"storage",(yyvsp[(1) - (11)].id)); ++ Delete(cty); ++ p = nextSibling(p); ++ } ++ } else { ++ if (Len(scanner_ccode)) { ++ String *code = Copy(scanner_ccode); ++ Setattr(n,"code",code); ++ Delete(code); ++ } ++ } ++ ++ /* Ensure that typedef enum ABC {foo} XYZ; uses XYZ for sym:name, like structs. ++ * Note that class_rename/yyrename are bit of a mess so used this simple approach to change the name. */ ++ if ((yyvsp[(8) - (11)].decl).id && (yyvsp[(3) - (11)].id) && Cmp((yyvsp[(1) - (11)].id),"typedef") == 0) { ++ String *name = NewString((yyvsp[(8) - (11)].decl).id); ++ Setattr((yyval.node), "parser:makename", name); ++ Delete(name); ++ } ++ ++ add_symbols((yyval.node)); /* Add enum to tag space */ ++ set_nextSibling((yyval.node),n); ++ Delete(n); ++ ++ if (scopedenum) { ++ Swig_symbol_newscope(); ++ Swig_symbol_setscopename((yyvsp[(3) - (11)].id)); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ } ++ ++ add_symbols((yyvsp[(6) - (11)].node)); /* Add enum values to appropriate enum or enum class scope */ ++ ++ if (scopedenum) { ++ Setattr((yyval.node),"symtab", Swig_symbol_popscope()); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ } ++ ++ add_symbols(n); ++ Delete(unnamed); ++ ;} ++ break; ++ ++ case 158: ++#line 3649 "parser.y" ++ { ++ /* This is a sick hack. If the ctor_end has parameters, ++ and the parms parameter only has 1 parameter, this ++ could be a declaration of the form: ++ ++ type (id)(parms) ++ ++ Otherwise it's an error. */ ++ int err = 0; ++ (yyval.node) = 0; ++ ++ if ((ParmList_len((yyvsp[(4) - (6)].pl)) == 1) && (!Swig_scopename_check((yyvsp[(2) - (6)].type)))) { ++ SwigType *ty = Getattr((yyvsp[(4) - (6)].pl),"type"); ++ String *name = Getattr((yyvsp[(4) - (6)].pl),"name"); ++ err = 1; ++ if (!name) { ++ (yyval.node) = new_node("cdecl"); ++ Setattr((yyval.node),"type",(yyvsp[(2) - (6)].type)); ++ Setattr((yyval.node),"storage",(yyvsp[(1) - (6)].id)); ++ Setattr((yyval.node),"name",ty); ++ ++ if ((yyvsp[(6) - (6)].decl).have_parms) { ++ SwigType *decl = NewStringEmpty(); ++ SwigType_add_function(decl,(yyvsp[(6) - (6)].decl).parms); ++ Setattr((yyval.node),"decl",decl); ++ Setattr((yyval.node),"parms",(yyvsp[(6) - (6)].decl).parms); ++ if (Len(scanner_ccode)) { ++ String *code = Copy(scanner_ccode); ++ Setattr((yyval.node),"code",code); ++ Delete(code); ++ } ++ } ++ if ((yyvsp[(6) - (6)].decl).defarg) { ++ Setattr((yyval.node),"value",(yyvsp[(6) - (6)].decl).defarg); ++ } ++ Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].decl).throws); ++ Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].decl).throwf); ++ Setattr((yyval.node),"noexcept",(yyvsp[(6) - (6)].decl).nexcept); ++ Setattr((yyval.node),"final",(yyvsp[(6) - (6)].decl).final); ++ err = 0; ++ } ++ } ++ if (err) { ++ Swig_error(cparse_file,cparse_line,"Syntax error in input(2).\n"); ++ Exit(EXIT_FAILURE); ++ } ++ ;} ++ break; ++ ++ case 159: ++#line 3702 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 160: ++#line 3703 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 161: ++#line 3704 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 162: ++#line 3705 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 163: ++#line 3706 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 164: ++#line 3707 "parser.y" ++ { (yyval.node) = 0; ;} ++ break; ++ ++ case 165: ++#line 3716 "parser.y" ++ { ++ String *prefix; ++ List *bases = 0; ++ Node *scope = 0; ++ String *code; ++ (yyval.node) = new_node("class"); ++ Setline((yyval.node),cparse_start_line); ++ Setattr((yyval.node),"kind",(yyvsp[(2) - (6)].id)); ++ if ((yyvsp[(5) - (6)].bases)) { ++ Setattr((yyval.node),"baselist", Getattr((yyvsp[(5) - (6)].bases),"public")); ++ Setattr((yyval.node),"protectedbaselist", Getattr((yyvsp[(5) - (6)].bases),"protected")); ++ Setattr((yyval.node),"privatebaselist", Getattr((yyvsp[(5) - (6)].bases),"private")); ++ } ++ Setattr((yyval.node),"allows_typedef","1"); ++ ++ /* preserve the current scope */ ++ Setattr((yyval.node),"prev_symtab",Swig_symbol_current()); ++ ++ /* If the class name is qualified. We need to create or lookup namespace/scope entries */ ++ scope = resolve_create_node_scope((yyvsp[(3) - (6)].str), 1); ++ /* save nscope_inner to the class - it may be overwritten in nested classes*/ ++ Setattr((yyval.node), "nested:innerscope", nscope_inner); ++ Setattr((yyval.node), "nested:nscope", nscope); ++ Setfile(scope,cparse_file); ++ Setline(scope,cparse_line); ++ (yyvsp[(3) - (6)].str) = scope; ++ Setattr((yyval.node),"name",(yyvsp[(3) - (6)].str)); ++ ++ if (currentOuterClass) { ++ SetFlag((yyval.node), "nested"); ++ Setattr((yyval.node), "nested:outer", currentOuterClass); ++ set_access_mode((yyval.node)); ++ } ++ Swig_features_get(Swig_cparse_features(), Namespaceprefix, Getattr((yyval.node), "name"), 0, (yyval.node)); ++ /* save yyrename to the class attribute, to be used later in add_symbols()*/ ++ Setattr((yyval.node), "class_rename", make_name((yyval.node), (yyvsp[(3) - (6)].str), 0)); ++ Setattr((yyval.node), "Classprefix", (yyvsp[(3) - (6)].str)); ++ Classprefix = NewString((yyvsp[(3) - (6)].str)); ++ /* Deal with inheritance */ ++ if ((yyvsp[(5) - (6)].bases)) ++ bases = Swig_make_inherit_list((yyvsp[(3) - (6)].str),Getattr((yyvsp[(5) - (6)].bases),"public"),Namespaceprefix); ++ prefix = SwigType_istemplate_templateprefix((yyvsp[(3) - (6)].str)); ++ if (prefix) { ++ String *fbase, *tbase; ++ if (Namespaceprefix) { ++ fbase = NewStringf("%s::%s", Namespaceprefix,(yyvsp[(3) - (6)].str)); ++ tbase = NewStringf("%s::%s", Namespaceprefix, prefix); ++ } else { ++ fbase = Copy((yyvsp[(3) - (6)].str)); ++ tbase = Copy(prefix); ++ } ++ Swig_name_inherit(tbase,fbase); ++ Delete(fbase); ++ Delete(tbase); ++ } ++ if (strcmp((yyvsp[(2) - (6)].id),"class") == 0) { ++ cplus_mode = CPLUS_PRIVATE; ++ } else { ++ cplus_mode = CPLUS_PUBLIC; ++ } ++ if (!cparse_cplusplus) { ++ set_scope_to_global(); ++ } ++ Swig_symbol_newscope(); ++ Swig_symbol_setscopename((yyvsp[(3) - (6)].str)); ++ Swig_inherit_base_symbols(bases); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ cparse_start_line = cparse_line; ++ ++ /* If there are active template parameters, we need to make sure they are ++ placed in the class symbol table so we can catch shadows */ ++ ++ if (template_parameters) { ++ Parm *tp = template_parameters; ++ while(tp) { ++ String *tpname = Copy(Getattr(tp,"name")); ++ Node *tn = new_node("templateparm"); ++ Setattr(tn,"name",tpname); ++ Swig_symbol_cadd(tpname,tn); ++ tp = nextSibling(tp); ++ Delete(tpname); ++ } ++ } ++ Delete(prefix); ++ inclass = 1; ++ currentOuterClass = (yyval.node); ++ if (cparse_cplusplusout) { ++ /* save the structure declaration to declare it in global scope for C++ to see */ ++ code = get_raw_text_balanced('{', '}'); ++ Setattr((yyval.node), "code", code); ++ Delete(code); ++ } ++ ;} ++ break; ++ ++ case 166: ++#line 3809 "parser.y" ++ { ++ Node *p; ++ SwigType *ty; ++ Symtab *cscope; ++ Node *am = 0; ++ String *scpname = 0; ++ (void) (yyvsp[(6) - (10)].node); ++ (yyval.node) = currentOuterClass; ++ currentOuterClass = Getattr((yyval.node), "nested:outer"); ++ nscope_inner = Getattr((yyval.node), "nested:innerscope"); ++ nscope = Getattr((yyval.node), "nested:nscope"); ++ Delattr((yyval.node), "nested:innerscope"); ++ Delattr((yyval.node), "nested:nscope"); ++ if (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0) { /* actual parent class for this class */ ++ Node* forward_declaration = Swig_symbol_clookup_no_inherit(Getattr((yyval.node),"name"), Getattr(nscope_inner, "symtab")); ++ if (forward_declaration) { ++ Setattr((yyval.node), "access", Getattr(forward_declaration, "access")); ++ } ++ Setattr((yyval.node), "nested:outer", nscope_inner); ++ SetFlag((yyval.node), "nested"); ++ } ++ if (!currentOuterClass) ++ inclass = 0; ++ cscope = Getattr((yyval.node), "prev_symtab"); ++ Delattr((yyval.node), "prev_symtab"); ++ ++ /* Check for pure-abstract class */ ++ Setattr((yyval.node),"abstracts", pure_abstracts((yyvsp[(8) - (10)].node))); ++ ++ /* This bit of code merges in a previously defined %extend directive (if any) */ ++ { ++ String *clsname = Swig_symbol_qualifiedscopename(0); ++ am = Getattr(Swig_extend_hash(), clsname); ++ if (am) { ++ Swig_extend_merge((yyval.node), am); ++ Delattr(Swig_extend_hash(), clsname); ++ } ++ Delete(clsname); ++ } ++ if (!classes) classes = NewHash(); ++ scpname = Swig_symbol_qualifiedscopename(0); ++ Setattr(classes, scpname, (yyval.node)); ++ ++ appendChild((yyval.node), (yyvsp[(8) - (10)].node)); ++ ++ if (am) ++ Swig_extend_append_previous((yyval.node), am); ++ ++ p = (yyvsp[(10) - (10)].node); ++ if (p && !nscope_inner) { ++ if (!cparse_cplusplus && currentOuterClass) ++ appendChild(currentOuterClass, p); ++ else ++ appendSibling((yyval.node), p); ++ } ++ ++ if (nscope_inner) { ++ ty = NewString(scpname); /* if the class is declared out of scope, let the declarator use fully qualified type*/ ++ } else if (cparse_cplusplus && !cparse_externc) { ++ ty = NewString((yyvsp[(3) - (10)].str)); ++ } else { ++ ty = NewStringf("%s %s", (yyvsp[(2) - (10)].id), (yyvsp[(3) - (10)].str)); ++ } ++ while (p) { ++ Setattr(p, "storage", (yyvsp[(1) - (10)].id)); ++ Setattr(p, "type" ,ty); ++ if (!cparse_cplusplus && currentOuterClass && (!Getattr(currentOuterClass, "name"))) { ++ SetFlag(p, "hasconsttype"); ++ SetFlag(p, "feature:immutable"); ++ } ++ p = nextSibling(p); ++ } ++ if ((yyvsp[(10) - (10)].node) && Cmp((yyvsp[(1) - (10)].id),"typedef") == 0) ++ add_typedef_name((yyval.node), (yyvsp[(10) - (10)].node), (yyvsp[(3) - (10)].str), cscope, scpname); ++ Delete(scpname); ++ ++ if (cplus_mode != CPLUS_PUBLIC) { ++ /* we 'open' the class at the end, to allow %template ++ to add new members */ ++ Node *pa = new_node("access"); ++ Setattr(pa, "kind", "public"); ++ cplus_mode = CPLUS_PUBLIC; ++ appendChild((yyval.node), pa); ++ Delete(pa); ++ } ++ if (currentOuterClass) ++ restore_access_mode((yyval.node)); ++ Setattr((yyval.node), "symtab", Swig_symbol_popscope()); ++ Classprefix = Getattr((yyval.node), "Classprefix"); ++ Delattr((yyval.node), "Classprefix"); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ if (cplus_mode == CPLUS_PRIVATE) { ++ (yyval.node) = 0; /* skip private nested classes */ ++ } else if (cparse_cplusplus && currentOuterClass && ignore_nested_classes && !GetFlag((yyval.node), "feature:flatnested")) { ++ (yyval.node) = nested_forward_declaration((yyvsp[(1) - (10)].id), (yyvsp[(2) - (10)].id), (yyvsp[(3) - (10)].str), Copy((yyvsp[(3) - (10)].str)), (yyvsp[(10) - (10)].node)); ++ } else if (nscope_inner) { ++ /* this is tricky */ ++ /* we add the declaration in the original namespace */ ++ if (Strcmp(nodeType(nscope_inner), "class") == 0 && cparse_cplusplus && ignore_nested_classes && !GetFlag((yyval.node), "feature:flatnested")) ++ (yyval.node) = nested_forward_declaration((yyvsp[(1) - (10)].id), (yyvsp[(2) - (10)].id), (yyvsp[(3) - (10)].str), Copy((yyvsp[(3) - (10)].str)), (yyvsp[(10) - (10)].node)); ++ appendChild(nscope_inner, (yyval.node)); ++ Swig_symbol_setscope(Getattr(nscope_inner, "symtab")); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ yyrename = Copy(Getattr((yyval.node), "class_rename")); ++ add_symbols((yyval.node)); ++ Delattr((yyval.node), "class_rename"); ++ /* but the variable definition in the current scope */ ++ Swig_symbol_setscope(cscope); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ add_symbols((yyvsp[(10) - (10)].node)); ++ if (nscope) { ++ (yyval.node) = nscope; /* here we return recreated namespace tower instead of the class itself */ ++ if ((yyvsp[(10) - (10)].node)) { ++ appendSibling((yyval.node), (yyvsp[(10) - (10)].node)); ++ } ++ } else if (!SwigType_istemplate(ty) && template_parameters == 0) { /* for template we need the class itself */ ++ (yyval.node) = (yyvsp[(10) - (10)].node); ++ } ++ } else { ++ Delete(yyrename); ++ yyrename = 0; ++ if (!cparse_cplusplus && currentOuterClass) { /* nested C structs go into global scope*/ ++ Node *outer = currentOuterClass; ++ while (Getattr(outer, "nested:outer")) ++ outer = Getattr(outer, "nested:outer"); ++ appendSibling(outer, (yyval.node)); ++ Swig_symbol_setscope(cscope); /* declaration goes in the parent scope */ ++ add_symbols((yyvsp[(10) - (10)].node)); ++ set_scope_to_global(); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ yyrename = Copy(Getattr((yyval.node), "class_rename")); ++ add_symbols((yyval.node)); ++ if (!cparse_cplusplusout) ++ Delattr((yyval.node), "nested:outer"); ++ Delattr((yyval.node), "class_rename"); ++ (yyval.node) = 0; ++ } else { ++ yyrename = Copy(Getattr((yyval.node), "class_rename")); ++ add_symbols((yyval.node)); ++ add_symbols((yyvsp[(10) - (10)].node)); ++ Delattr((yyval.node), "class_rename"); ++ } ++ } ++ Delete(ty); ++ Swig_symbol_setscope(cscope); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ Classprefix = currentOuterClass ? Getattr(currentOuterClass, "Classprefix") : 0; ++ ;} ++ break; ++ ++ case 167: ++#line 3965 "parser.y" ++ { ++ String *unnamed; ++ String *code; ++ unnamed = make_unnamed(); ++ (yyval.node) = new_node("class"); ++ Setline((yyval.node),cparse_start_line); ++ Setattr((yyval.node),"kind",(yyvsp[(2) - (4)].id)); ++ if ((yyvsp[(3) - (4)].bases)) { ++ Setattr((yyval.node),"baselist", Getattr((yyvsp[(3) - (4)].bases),"public")); ++ Setattr((yyval.node),"protectedbaselist", Getattr((yyvsp[(3) - (4)].bases),"protected")); ++ Setattr((yyval.node),"privatebaselist", Getattr((yyvsp[(3) - (4)].bases),"private")); ++ } ++ Setattr((yyval.node),"storage",(yyvsp[(1) - (4)].id)); ++ Setattr((yyval.node),"unnamed",unnamed); ++ Setattr((yyval.node),"allows_typedef","1"); ++ if (currentOuterClass) { ++ SetFlag((yyval.node), "nested"); ++ Setattr((yyval.node), "nested:outer", currentOuterClass); ++ set_access_mode((yyval.node)); ++ } ++ Swig_features_get(Swig_cparse_features(), Namespaceprefix, 0, 0, (yyval.node)); ++ /* save yyrename to the class attribute, to be used later in add_symbols()*/ ++ Setattr((yyval.node), "class_rename", make_name((yyval.node),0,0)); ++ if (strcmp((yyvsp[(2) - (4)].id),"class") == 0) { ++ cplus_mode = CPLUS_PRIVATE; ++ } else { ++ cplus_mode = CPLUS_PUBLIC; ++ } ++ Swig_symbol_newscope(); ++ cparse_start_line = cparse_line; ++ currentOuterClass = (yyval.node); ++ inclass = 1; ++ Classprefix = 0; ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ /* save the structure declaration to make a typedef for it later*/ ++ code = get_raw_text_balanced('{', '}'); ++ Setattr((yyval.node), "code", code); ++ Delete(code); ++ ;} ++ break; ++ ++ case 168: ++#line 4004 "parser.y" ++ { ++ String *unnamed; ++ List *bases = 0; ++ String *name = 0; ++ Node *n; ++ Classprefix = 0; ++ (void)(yyvsp[(5) - (8)].node); ++ (yyval.node) = currentOuterClass; ++ currentOuterClass = Getattr((yyval.node), "nested:outer"); ++ if (!currentOuterClass) ++ inclass = 0; ++ else ++ restore_access_mode((yyval.node)); ++ unnamed = Getattr((yyval.node),"unnamed"); ++ /* Check for pure-abstract class */ ++ Setattr((yyval.node),"abstracts", pure_abstracts((yyvsp[(6) - (8)].node))); ++ n = (yyvsp[(8) - (8)].node); ++ if (cparse_cplusplus && currentOuterClass && ignore_nested_classes && !GetFlag((yyval.node), "feature:flatnested")) { ++ String *name = n ? Copy(Getattr(n, "name")) : 0; ++ (yyval.node) = nested_forward_declaration((yyvsp[(1) - (8)].id), (yyvsp[(2) - (8)].id), 0, name, n); ++ Swig_symbol_popscope(); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ } else if (n) { ++ appendSibling((yyval.node),n); ++ /* If a proper typedef name was given, we'll use it to set the scope name */ ++ name = try_to_find_a_name_for_unnamed_structure((yyvsp[(1) - (8)].id), n); ++ if (name) { ++ String *scpname = 0; ++ SwigType *ty; ++ Setattr((yyval.node),"tdname",name); ++ Setattr((yyval.node),"name",name); ++ Swig_symbol_setscopename(name); ++ if ((yyvsp[(3) - (8)].bases)) ++ bases = Swig_make_inherit_list(name,Getattr((yyvsp[(3) - (8)].bases),"public"),Namespaceprefix); ++ Swig_inherit_base_symbols(bases); ++ ++ /* If a proper name was given, we use that as the typedef, not unnamed */ ++ Clear(unnamed); ++ Append(unnamed, name); ++ if (cparse_cplusplus && !cparse_externc) { ++ ty = NewString(name); ++ } else { ++ ty = NewStringf("%s %s", (yyvsp[(2) - (8)].id),name); ++ } ++ while (n) { ++ Setattr(n,"storage",(yyvsp[(1) - (8)].id)); ++ Setattr(n, "type", ty); ++ if (!cparse_cplusplus && currentOuterClass && (!Getattr(currentOuterClass, "name"))) { ++ SetFlag(n,"hasconsttype"); ++ SetFlag(n,"feature:immutable"); ++ } ++ n = nextSibling(n); ++ } ++ n = (yyvsp[(8) - (8)].node); ++ ++ /* Check for previous extensions */ ++ { ++ String *clsname = Swig_symbol_qualifiedscopename(0); ++ Node *am = Getattr(Swig_extend_hash(),clsname); ++ if (am) { ++ /* Merge the extension into the symbol table */ ++ Swig_extend_merge((yyval.node),am); ++ Swig_extend_append_previous((yyval.node),am); ++ Delattr(Swig_extend_hash(),clsname); ++ } ++ Delete(clsname); ++ } ++ if (!classes) classes = NewHash(); ++ scpname = Swig_symbol_qualifiedscopename(0); ++ Setattr(classes,scpname,(yyval.node)); ++ Delete(scpname); ++ } else { /* no suitable name was found for a struct */ ++ Setattr((yyval.node), "nested:unnamed", Getattr(n, "name")); /* save the name of the first declarator for later use in name generation*/ ++ while (n) { /* attach unnamed struct to the declarators, so that they would receive proper type later*/ ++ Setattr(n, "nested:unnamedtype", (yyval.node)); ++ Setattr(n, "storage", (yyvsp[(1) - (8)].id)); ++ n = nextSibling(n); ++ } ++ n = (yyvsp[(8) - (8)].node); ++ Swig_symbol_setscopename(""); ++ } ++ appendChild((yyval.node),(yyvsp[(6) - (8)].node)); ++ /* Pop the scope */ ++ Setattr((yyval.node),"symtab",Swig_symbol_popscope()); ++ if (name) { ++ Delete(yyrename); ++ yyrename = Copy(Getattr((yyval.node), "class_rename")); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ add_symbols((yyval.node)); ++ add_symbols(n); ++ Delattr((yyval.node), "class_rename"); ++ }else if (cparse_cplusplus) ++ (yyval.node) = 0; /* ignore unnamed structs for C++ */ ++ Delete(unnamed); ++ } else { /* unnamed struct w/o declarator*/ ++ Swig_symbol_popscope(); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ add_symbols((yyvsp[(6) - (8)].node)); ++ Delete((yyval.node)); ++ (yyval.node) = (yyvsp[(6) - (8)].node); /* pass member list to outer class/namespace (instead of self)*/ ++ } ++ Classprefix = currentOuterClass ? Getattr(currentOuterClass, "Classprefix") : 0; ++ ;} ++ break; ++ ++ case 169: ++#line 4112 "parser.y" ++ { (yyval.node) = 0; ;} ++ break; ++ ++ case 170: ++#line 4113 "parser.y" ++ { ++ (yyval.node) = new_node("cdecl"); ++ Setattr((yyval.node),"name",(yyvsp[(1) - (4)].decl).id); ++ Setattr((yyval.node),"decl",(yyvsp[(1) - (4)].decl).type); ++ Setattr((yyval.node),"parms",(yyvsp[(1) - (4)].decl).parms); ++ set_nextSibling((yyval.node), (yyvsp[(4) - (4)].node)); ++ ;} ++ break; ++ ++ case 171: ++#line 4125 "parser.y" ++ { ++ if ((yyvsp[(1) - (4)].id) && (Strcmp((yyvsp[(1) - (4)].id),"friend") == 0)) { ++ /* Ignore */ ++ (yyval.node) = 0; ++ } else { ++ (yyval.node) = new_node("classforward"); ++ Setattr((yyval.node),"kind",(yyvsp[(2) - (4)].id)); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (4)].str)); ++ Setattr((yyval.node),"sym:weak", "1"); ++ add_symbols((yyval.node)); ++ } ++ ;} ++ break; ++ ++ case 172: ++#line 4143 "parser.y" ++ { ++ if (currentOuterClass) ++ Setattr(currentOuterClass, "template_parameters", template_parameters); ++ template_parameters = (yyvsp[(3) - (4)].tparms); ++ parsing_template_declaration = 1; ++ ;} ++ break; ++ ++ case 173: ++#line 4148 "parser.y" ++ { ++ String *tname = 0; ++ int error = 0; ++ ++ /* check if we get a namespace node with a class declaration, and retrieve the class */ ++ Symtab *cscope = Swig_symbol_current(); ++ Symtab *sti = 0; ++ Node *ntop = (yyvsp[(6) - (6)].node); ++ Node *ni = ntop; ++ SwigType *ntype = ni ? nodeType(ni) : 0; ++ while (ni && Strcmp(ntype,"namespace") == 0) { ++ sti = Getattr(ni,"symtab"); ++ ni = firstChild(ni); ++ ntype = nodeType(ni); ++ } ++ if (sti) { ++ Swig_symbol_setscope(sti); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ (yyvsp[(6) - (6)].node) = ni; ++ } ++ ++ (yyval.node) = (yyvsp[(6) - (6)].node); ++ if ((yyval.node)) tname = Getattr((yyval.node),"name"); ++ ++ /* Check if the class is a template specialization */ ++ if (((yyval.node)) && (Strchr(tname,'<')) && (!is_operator(tname))) { ++ /* If a specialization. Check if defined. */ ++ Node *tempn = 0; ++ { ++ String *tbase = SwigType_templateprefix(tname); ++ tempn = Swig_symbol_clookup_local(tbase,0); ++ if (!tempn || (Strcmp(nodeType(tempn),"template") != 0)) { ++ SWIG_WARN_NODE_BEGIN(tempn); ++ Swig_warning(WARN_PARSE_TEMPLATE_SP_UNDEF, Getfile((yyval.node)),Getline((yyval.node)),"Specialization of non-template '%s'.\n", tbase); ++ SWIG_WARN_NODE_END(tempn); ++ tempn = 0; ++ error = 1; ++ } ++ Delete(tbase); ++ } ++ Setattr((yyval.node),"specialization","1"); ++ Setattr((yyval.node),"templatetype",nodeType((yyval.node))); ++ set_nodeType((yyval.node),"template"); ++ /* Template partial specialization */ ++ if (tempn && ((yyvsp[(3) - (6)].tparms)) && ((yyvsp[(6) - (6)].node))) { ++ List *tlist; ++ String *targs = SwigType_templateargs(tname); ++ tlist = SwigType_parmlist(targs); ++ /* Printf(stdout,"targs = '%s' %s\n", targs, tlist); */ ++ if (!Getattr((yyval.node),"sym:weak")) { ++ Setattr((yyval.node),"sym:typename","1"); ++ } ++ ++ if (Len(tlist) != ParmList_len(Getattr(tempn,"templateparms"))) { ++ Swig_error(Getfile((yyval.node)),Getline((yyval.node)),"Inconsistent argument count in template partial specialization. %d %d\n", Len(tlist), ParmList_len(Getattr(tempn,"templateparms"))); ++ ++ } else { ++ ++ /* This code builds the argument list for the partial template ++ specialization. This is a little hairy, but the idea is as ++ follows: ++ ++ $3 contains a list of arguments supplied for the template. ++ For example template. ++ ++ tlist is a list of the specialization arguments--which may be ++ different. For example class. ++ ++ tp is a copy of the arguments in the original template definition. ++ ++ The patching algorithm walks through the list of supplied ++ arguments ($3), finds the position in the specialization arguments ++ (tlist), and then patches the name in the argument list of the ++ original template. ++ */ ++ ++ { ++ String *pn; ++ Parm *p, *p1; ++ int i, nargs; ++ Parm *tp = CopyParmList(Getattr(tempn,"templateparms")); ++ nargs = Len(tlist); ++ p = (yyvsp[(3) - (6)].tparms); ++ while (p) { ++ for (i = 0; i < nargs; i++){ ++ pn = Getattr(p,"name"); ++ if (Strcmp(pn,SwigType_base(Getitem(tlist,i))) == 0) { ++ int j; ++ Parm *p1 = tp; ++ for (j = 0; j < i; j++) { ++ p1 = nextSibling(p1); ++ } ++ Setattr(p1,"name",pn); ++ Setattr(p1,"partialarg","1"); ++ } ++ } ++ p = nextSibling(p); ++ } ++ p1 = tp; ++ i = 0; ++ while (p1) { ++ if (!Getattr(p1,"partialarg")) { ++ Delattr(p1,"name"); ++ Setattr(p1,"type", Getitem(tlist,i)); ++ } ++ i++; ++ p1 = nextSibling(p1); ++ } ++ Setattr((yyval.node),"templateparms",tp); ++ Delete(tp); ++ } ++ #if 0 ++ /* Patch the parameter list */ ++ if (tempn) { ++ Parm *p,*p1; ++ ParmList *tp = CopyParmList(Getattr(tempn,"templateparms")); ++ p = (yyvsp[(3) - (6)].tparms); ++ p1 = tp; ++ while (p && p1) { ++ String *pn = Getattr(p,"name"); ++ Printf(stdout,"pn = '%s'\n", pn); ++ if (pn) Setattr(p1,"name",pn); ++ else Delattr(p1,"name"); ++ pn = Getattr(p,"type"); ++ if (pn) Setattr(p1,"type",pn); ++ p = nextSibling(p); ++ p1 = nextSibling(p1); ++ } ++ Setattr((yyval.node),"templateparms",tp); ++ Delete(tp); ++ } else { ++ Setattr((yyval.node),"templateparms",(yyvsp[(3) - (6)].tparms)); ++ } ++ #endif ++ Delattr((yyval.node),"specialization"); ++ Setattr((yyval.node),"partialspecialization","1"); ++ /* Create a specialized name for matching */ ++ { ++ Parm *p = (yyvsp[(3) - (6)].tparms); ++ String *fname = NewString(Getattr((yyval.node),"name")); ++ String *ffname = 0; ++ ParmList *partialparms = 0; ++ ++ char tmp[32]; ++ int i, ilen; ++ while (p) { ++ String *n = Getattr(p,"name"); ++ if (!n) { ++ p = nextSibling(p); ++ continue; ++ } ++ ilen = Len(tlist); ++ for (i = 0; i < ilen; i++) { ++ if (Strstr(Getitem(tlist,i),n)) { ++ sprintf(tmp,"$%d",i+1); ++ Replaceid(fname,n,tmp); ++ } ++ } ++ p = nextSibling(p); ++ } ++ /* Patch argument names with typedef */ ++ { ++ Iterator tt; ++ Parm *parm_current = 0; ++ List *tparms = SwigType_parmlist(fname); ++ ffname = SwigType_templateprefix(fname); ++ Append(ffname,"<("); ++ for (tt = First(tparms); tt.item; ) { ++ SwigType *rtt = Swig_symbol_typedef_reduce(tt.item,0); ++ SwigType *ttr = Swig_symbol_type_qualify(rtt,0); ++ ++ Parm *newp = NewParmWithoutFileLineInfo(ttr, 0); ++ if (partialparms) ++ set_nextSibling(parm_current, newp); ++ else ++ partialparms = newp; ++ parm_current = newp; ++ ++ Append(ffname,ttr); ++ tt = Next(tt); ++ if (tt.item) Putc(',',ffname); ++ Delete(rtt); ++ Delete(ttr); ++ } ++ Delete(tparms); ++ Append(ffname,")>"); ++ } ++ { ++ Node *new_partial = NewHash(); ++ String *partials = Getattr(tempn,"partials"); ++ if (!partials) { ++ partials = NewList(); ++ Setattr(tempn,"partials",partials); ++ Delete(partials); ++ } ++ /* Printf(stdout,"partial: fname = '%s', '%s'\n", fname, Swig_symbol_typedef_reduce(fname,0)); */ ++ Setattr(new_partial, "partialparms", partialparms); ++ Setattr(new_partial, "templcsymname", ffname); ++ Append(partials, new_partial); ++ } ++ Setattr((yyval.node),"partialargs",ffname); ++ Swig_symbol_cadd(ffname,(yyval.node)); ++ } ++ } ++ Delete(tlist); ++ Delete(targs); ++ } else { ++ /* An explicit template specialization */ ++ /* add default args from primary (unspecialized) template */ ++ String *ty = Swig_symbol_template_deftype(tname,0); ++ String *fname = Swig_symbol_type_qualify(ty,0); ++ Swig_symbol_cadd(fname,(yyval.node)); ++ Delete(ty); ++ Delete(fname); ++ } ++ } else if ((yyval.node)) { ++ Setattr((yyval.node),"templatetype",nodeType((yyvsp[(6) - (6)].node))); ++ set_nodeType((yyval.node),"template"); ++ Setattr((yyval.node),"templateparms", (yyvsp[(3) - (6)].tparms)); ++ if (!Getattr((yyval.node),"sym:weak")) { ++ Setattr((yyval.node),"sym:typename","1"); ++ } ++ add_symbols((yyval.node)); ++ default_arguments((yyval.node)); ++ /* We also place a fully parameterized version in the symbol table */ ++ { ++ Parm *p; ++ String *fname = NewStringf("%s<(", Getattr((yyval.node),"name")); ++ p = (yyvsp[(3) - (6)].tparms); ++ while (p) { ++ String *n = Getattr(p,"name"); ++ if (!n) n = Getattr(p,"type"); ++ Append(fname,n); ++ p = nextSibling(p); ++ if (p) Putc(',',fname); ++ } ++ Append(fname,")>"); ++ Swig_symbol_cadd(fname,(yyval.node)); ++ } ++ } ++ (yyval.node) = ntop; ++ Swig_symbol_setscope(cscope); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ if (error || (nscope_inner && Strcmp(nodeType(nscope_inner), "class") == 0)) { ++ (yyval.node) = 0; ++ } ++ if (currentOuterClass) ++ template_parameters = Getattr(currentOuterClass, "template_parameters"); ++ else ++ template_parameters = 0; ++ parsing_template_declaration = 0; ++ ;} ++ break; ++ ++ case 174: ++#line 4404 "parser.y" ++ { ++ Swig_warning(WARN_PARSE_EXPLICIT_TEMPLATE, cparse_file, cparse_line, "Explicit template instantiation ignored.\n"); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 175: ++#line 4410 "parser.y" ++ { ++ Swig_warning(WARN_PARSE_EXPLICIT_TEMPLATE, cparse_file, cparse_line, "Explicit template instantiation ignored.\n"); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 176: ++#line 4416 "parser.y" ++ { ++ Swig_warning(WARN_PARSE_EXTERN_TEMPLATE, cparse_file, cparse_line, "Extern template ignored.\n"); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 177: ++#line 4422 "parser.y" ++ { ++ Swig_warning(WARN_PARSE_EXTERN_TEMPLATE, cparse_file, cparse_line, "Extern template ignored.\n"); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 178: ++#line 4428 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 179: ++#line 4431 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 180: ++#line 4434 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 181: ++#line 4437 "parser.y" ++ { ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 182: ++#line 4440 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 183: ++#line 4443 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 184: ++#line 4448 "parser.y" ++ { ++ /* Rip out the parameter names */ ++ Parm *p = (yyvsp[(1) - (1)].pl); ++ (yyval.tparms) = (yyvsp[(1) - (1)].pl); ++ ++ while (p) { ++ String *name = Getattr(p,"name"); ++ if (!name) { ++ /* Hmmm. Maybe it's a 'class T' parameter */ ++ char *type = Char(Getattr(p,"type")); ++ /* Template template parameter */ ++ if (strncmp(type,"template ",16) == 0) { ++ type += 16; ++ } ++ if ((strncmp(type,"class ",6) == 0) || (strncmp(type,"typename ", 9) == 0)) { ++ char *t = strchr(type,' '); ++ Setattr(p,"name", t+1); ++ } else ++ /* Variadic template args */ ++ if ((strncmp(type,"class... ",9) == 0) || (strncmp(type,"typename... ", 12) == 0)) { ++ char *t = strchr(type,' '); ++ Setattr(p,"name", t+1); ++ Setattr(p,"variadic", "1"); ++ } else { ++ /* ++ Swig_error(cparse_file, cparse_line, "Missing template parameter name\n"); ++ $$.rparms = 0; ++ $$.parms = 0; ++ break; */ ++ } ++ } ++ p = nextSibling(p); ++ } ++ ;} ++ break; ++ ++ case 185: ++#line 4484 "parser.y" ++ { ++ set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].pl)); ++ (yyval.pl) = (yyvsp[(1) - (2)].p); ++ ;} ++ break; ++ ++ case 186: ++#line 4488 "parser.y" ++ { (yyval.pl) = 0; ;} ++ break; ++ ++ case 187: ++#line 4491 "parser.y" ++ { ++ (yyval.p) = NewParmWithoutFileLineInfo(NewString((yyvsp[(1) - (2)].id)), 0); ++ Setattr((yyval.p), "value", (yyvsp[(2) - (2)].dtype).rawval ? (yyvsp[(2) - (2)].dtype).rawval : (yyvsp[(2) - (2)].dtype).val); ++ ;} ++ break; ++ ++ case 188: ++#line 4495 "parser.y" ++ { ++ (yyval.p) = (yyvsp[(1) - (1)].p); ++ ;} ++ break; ++ ++ case 189: ++#line 4500 "parser.y" ++ { ++ set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].pl)); ++ (yyval.pl) = (yyvsp[(2) - (3)].p); ++ ;} ++ break; ++ ++ case 190: ++#line 4504 "parser.y" ++ { (yyval.pl) = 0; ;} ++ break; ++ ++ case 191: ++#line 4509 "parser.y" ++ { ++ String *uname = Swig_symbol_type_qualify((yyvsp[(2) - (3)].str),0); ++ String *name = Swig_scopename_last((yyvsp[(2) - (3)].str)); ++ (yyval.node) = new_node("using"); ++ Setattr((yyval.node),"uname",uname); ++ Setattr((yyval.node),"name", name); ++ Delete(uname); ++ Delete(name); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 192: ++#line 4519 "parser.y" ++ { ++ Node *n = Swig_symbol_clookup((yyvsp[(3) - (4)].str),0); ++ if (!n) { ++ Swig_error(cparse_file, cparse_line, "Nothing known about namespace '%s'\n", (yyvsp[(3) - (4)].str)); ++ (yyval.node) = 0; ++ } else { ++ ++ while (Strcmp(nodeType(n),"using") == 0) { ++ n = Getattr(n,"node"); ++ } ++ if (n) { ++ if (Strcmp(nodeType(n),"namespace") == 0) { ++ Symtab *current = Swig_symbol_current(); ++ Symtab *symtab = Getattr(n,"symtab"); ++ (yyval.node) = new_node("using"); ++ Setattr((yyval.node),"node",n); ++ Setattr((yyval.node),"namespace", (yyvsp[(3) - (4)].str)); ++ if (current != symtab) { ++ Swig_symbol_inherit(symtab); ++ } ++ } else { ++ Swig_error(cparse_file, cparse_line, "'%s' is not a namespace.\n", (yyvsp[(3) - (4)].str)); ++ (yyval.node) = 0; ++ } ++ } else { ++ (yyval.node) = 0; ++ } ++ } ++ ;} ++ break; ++ ++ case 193: ++#line 4550 "parser.y" ++ { ++ Hash *h; ++ Node *parent_ns = 0; ++ List *scopes = Swig_scopename_tolist((yyvsp[(2) - (3)].str)); ++ int ilen = Len(scopes); ++ int i; ++ ++/* ++Printf(stdout, "==== Namespace %s creation...\n", $2); ++*/ ++ (yyval.node) = 0; ++ for (i = 0; i < ilen; i++) { ++ Node *ns = new_node("namespace"); ++ Symtab *current_symtab = Swig_symbol_current(); ++ String *scopename = Getitem(scopes, i); ++ Setattr(ns, "name", scopename); ++ (yyval.node) = ns; ++ if (parent_ns) ++ appendChild(parent_ns, ns); ++ parent_ns = ns; ++ h = Swig_symbol_clookup(scopename, 0); ++ if (h && (current_symtab == Getattr(h, "sym:symtab")) && (Strcmp(nodeType(h), "namespace") == 0)) { ++/* ++Printf(stdout, " Scope %s [found C++17 style]\n", scopename); ++*/ ++ if (Getattr(h, "alias")) { ++ h = Getattr(h, "namespace"); ++ Swig_warning(WARN_PARSE_NAMESPACE_ALIAS, cparse_file, cparse_line, "Namespace alias '%s' not allowed here. Assuming '%s'\n", ++ scopename, Getattr(h, "name")); ++ scopename = Getattr(h, "name"); ++ } ++ Swig_symbol_setscope(Getattr(h, "symtab")); ++ } else { ++/* ++Printf(stdout, " Scope %s [creating single scope C++17 style]\n", scopename); ++*/ ++ h = Swig_symbol_newscope(); ++ Swig_symbol_setscopename(scopename); ++ } ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ } ++ Delete(scopes); ++ ;} ++ break; ++ ++ case 194: ++#line 4593 "parser.y" ++ { ++ Node *n = (yyvsp[(4) - (6)].node); ++ Node *top_ns = 0; ++ do { ++ Setattr(n, "symtab", Swig_symbol_popscope()); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ add_symbols(n); ++ top_ns = n; ++ n = parentNode(n); ++ } while(n); ++ appendChild((yyvsp[(4) - (6)].node), firstChild((yyvsp[(5) - (6)].node))); ++ Delete((yyvsp[(5) - (6)].node)); ++ (yyval.node) = top_ns; ++ ;} ++ break; ++ ++ case 195: ++#line 4608 "parser.y" ++ { ++ Hash *h; ++ (yyvsp[(1) - (2)].node) = Swig_symbol_current(); ++ h = Swig_symbol_clookup(" ",0); ++ if (h && (Strcmp(nodeType(h),"namespace") == 0)) { ++ Swig_symbol_setscope(Getattr(h,"symtab")); ++ } else { ++ Swig_symbol_newscope(); ++ /* we don't use "__unnamed__", but a long 'empty' name */ ++ Swig_symbol_setscopename(" "); ++ } ++ Namespaceprefix = 0; ++ ;} ++ break; ++ ++ case 196: ++#line 4620 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(4) - (5)].node); ++ set_nodeType((yyval.node),"namespace"); ++ Setattr((yyval.node),"unnamed","1"); ++ Setattr((yyval.node),"symtab", Swig_symbol_popscope()); ++ Swig_symbol_setscope((yyvsp[(1) - (5)].node)); ++ Delete(Namespaceprefix); ++ Namespaceprefix = Swig_symbol_qualifiedscopename(0); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 197: ++#line 4630 "parser.y" ++ { ++ /* Namespace alias */ ++ Node *n; ++ (yyval.node) = new_node("namespace"); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (5)].id)); ++ Setattr((yyval.node),"alias",(yyvsp[(4) - (5)].str)); ++ n = Swig_symbol_clookup((yyvsp[(4) - (5)].str),0); ++ if (!n) { ++ Swig_error(cparse_file, cparse_line, "Unknown namespace '%s'\n", (yyvsp[(4) - (5)].str)); ++ (yyval.node) = 0; ++ } else { ++ if (Strcmp(nodeType(n),"namespace") != 0) { ++ Swig_error(cparse_file, cparse_line, "'%s' is not a namespace\n",(yyvsp[(4) - (5)].str)); ++ (yyval.node) = 0; ++ } else { ++ while (Getattr(n,"alias")) { ++ n = Getattr(n,"namespace"); ++ } ++ Setattr((yyval.node),"namespace",n); ++ add_symbols((yyval.node)); ++ /* Set up a scope alias */ ++ Swig_symbol_alias((yyvsp[(2) - (5)].id),Getattr(n,"symtab")); ++ } ++ } ++ ;} ++ break; ++ ++ case 198: ++#line 4657 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (2)].node); ++ /* Insert cpp_member (including any siblings) to the front of the cpp_members linked list */ ++ if ((yyval.node)) { ++ Node *p = (yyval.node); ++ Node *pp =0; ++ while (p) { ++ pp = p; ++ p = nextSibling(p); ++ } ++ set_nextSibling(pp,(yyvsp[(2) - (2)].node)); ++ if ((yyvsp[(2) - (2)].node)) ++ set_previousSibling((yyvsp[(2) - (2)].node), pp); ++ } else { ++ (yyval.node) = (yyvsp[(2) - (2)].node); ++ } ++ ;} ++ break; ++ ++ case 199: ++#line 4674 "parser.y" ++ { ++ extendmode = 1; ++ if (cplus_mode != CPLUS_PUBLIC) { ++ Swig_error(cparse_file,cparse_line,"%%extend can only be used in a public section\n"); ++ } ++ ;} ++ break; ++ ++ case 200: ++#line 4679 "parser.y" ++ { ++ extendmode = 0; ++ ;} ++ break; ++ ++ case 201: ++#line 4681 "parser.y" ++ { ++ (yyval.node) = new_node("extend"); ++ mark_nodes_as_extend((yyvsp[(4) - (7)].node)); ++ appendChild((yyval.node),(yyvsp[(4) - (7)].node)); ++ set_nextSibling((yyval.node),(yyvsp[(7) - (7)].node)); ++ ;} ++ break; ++ ++ case 202: ++#line 4687 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 203: ++#line 4688 "parser.y" ++ { (yyval.node) = 0;;} ++ break; ++ ++ case 204: ++#line 4689 "parser.y" ++ { ++ Swig_error(cparse_file,cparse_line,"Syntax error in input(3).\n"); ++ Exit(EXIT_FAILURE); ++ ;} ++ break; ++ ++ case 205: ++#line 4692 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(3) - (3)].node); ++ ;} ++ break; ++ ++ case 206: ++#line 4703 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 207: ++#line 4704 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ if (extendmode && current_class) { ++ String *symname; ++ symname= make_name((yyval.node),Getattr((yyval.node),"name"), Getattr((yyval.node),"decl")); ++ if (Strcmp(symname,Getattr((yyval.node),"name")) == 0) { ++ /* No renaming operation. Set name to class name */ ++ Delete(yyrename); ++ yyrename = NewString(Getattr(current_class,"sym:name")); ++ } else { ++ Delete(yyrename); ++ yyrename = symname; ++ } ++ } ++ add_symbols((yyval.node)); ++ default_arguments((yyval.node)); ++ ;} ++ break; ++ ++ case 208: ++#line 4721 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 209: ++#line 4722 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 210: ++#line 4723 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 211: ++#line 4724 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 212: ++#line 4725 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 213: ++#line 4726 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 214: ++#line 4727 "parser.y" ++ { (yyval.node) = 0; ;} ++ break; ++ ++ case 215: ++#line 4728 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 216: ++#line 4729 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 217: ++#line 4730 "parser.y" ++ { (yyval.node) = 0; ;} ++ break; ++ ++ case 218: ++#line 4731 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 219: ++#line 4732 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 220: ++#line 4733 "parser.y" ++ { (yyval.node) = 0; ;} ++ break; ++ ++ case 221: ++#line 4734 "parser.y" ++ {(yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 222: ++#line 4735 "parser.y" ++ {(yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 223: ++#line 4736 "parser.y" ++ { (yyval.node) = 0; ;} ++ break; ++ ++ case 224: ++#line 4738 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 225: ++#line 4741 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(2) - (2)].node); ++ set_comment((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].str)); ++ ;} ++ break; ++ ++ case 226: ++#line 4745 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (2)].node); ++ set_comment((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 227: ++#line 4757 "parser.y" ++ { ++ if (inclass || extendmode) { ++ SwigType *decl = NewStringEmpty(); ++ (yyval.node) = new_node("constructor"); ++ Setattr((yyval.node),"storage",(yyvsp[(1) - (6)].id)); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (6)].type)); ++ Setattr((yyval.node),"parms",(yyvsp[(4) - (6)].pl)); ++ SwigType_add_function(decl,(yyvsp[(4) - (6)].pl)); ++ Setattr((yyval.node),"decl",decl); ++ Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].decl).throws); ++ Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].decl).throwf); ++ Setattr((yyval.node),"noexcept",(yyvsp[(6) - (6)].decl).nexcept); ++ Setattr((yyval.node),"final",(yyvsp[(6) - (6)].decl).final); ++ if (Len(scanner_ccode)) { ++ String *code = Copy(scanner_ccode); ++ Setattr((yyval.node),"code",code); ++ Delete(code); ++ } ++ SetFlag((yyval.node),"feature:new"); ++ if ((yyvsp[(6) - (6)].decl).defarg) ++ Setattr((yyval.node),"value",(yyvsp[(6) - (6)].decl).defarg); ++ } else { ++ (yyval.node) = 0; ++ } ++ ;} ++ break; ++ ++ case 228: ++#line 4786 "parser.y" ++ { ++ String *name = NewStringf("%s",(yyvsp[(2) - (6)].str)); ++ if (*(Char(name)) != '~') Insert(name,0,"~"); ++ (yyval.node) = new_node("destructor"); ++ Setattr((yyval.node),"name",name); ++ Delete(name); ++ if (Len(scanner_ccode)) { ++ String *code = Copy(scanner_ccode); ++ Setattr((yyval.node),"code",code); ++ Delete(code); ++ } ++ { ++ String *decl = NewStringEmpty(); ++ SwigType_add_function(decl,(yyvsp[(4) - (6)].pl)); ++ Setattr((yyval.node),"decl",decl); ++ Delete(decl); ++ } ++ Setattr((yyval.node),"throws",(yyvsp[(6) - (6)].dtype).throws); ++ Setattr((yyval.node),"throw",(yyvsp[(6) - (6)].dtype).throwf); ++ Setattr((yyval.node),"noexcept",(yyvsp[(6) - (6)].dtype).nexcept); ++ Setattr((yyval.node),"final",(yyvsp[(6) - (6)].dtype).final); ++ if ((yyvsp[(6) - (6)].dtype).val) ++ Setattr((yyval.node),"value",(yyvsp[(6) - (6)].dtype).val); ++ if ((yyvsp[(6) - (6)].dtype).qualifier) ++ Swig_error(cparse_file, cparse_line, "Destructor %s %s cannot have a qualifier.\n", Swig_name_decl((yyval.node)), SwigType_str((yyvsp[(6) - (6)].dtype).qualifier, 0)); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 229: ++#line 4816 "parser.y" ++ { ++ String *name; ++ (yyval.node) = new_node("destructor"); ++ Setattr((yyval.node),"storage","virtual"); ++ name = NewStringf("%s",(yyvsp[(3) - (7)].str)); ++ if (*(Char(name)) != '~') Insert(name,0,"~"); ++ Setattr((yyval.node),"name",name); ++ Delete(name); ++ Setattr((yyval.node),"throws",(yyvsp[(7) - (7)].dtype).throws); ++ Setattr((yyval.node),"throw",(yyvsp[(7) - (7)].dtype).throwf); ++ Setattr((yyval.node),"noexcept",(yyvsp[(7) - (7)].dtype).nexcept); ++ Setattr((yyval.node),"final",(yyvsp[(7) - (7)].dtype).final); ++ if ((yyvsp[(7) - (7)].dtype).val) ++ Setattr((yyval.node),"value",(yyvsp[(7) - (7)].dtype).val); ++ if (Len(scanner_ccode)) { ++ String *code = Copy(scanner_ccode); ++ Setattr((yyval.node),"code",code); ++ Delete(code); ++ } ++ { ++ String *decl = NewStringEmpty(); ++ SwigType_add_function(decl,(yyvsp[(5) - (7)].pl)); ++ Setattr((yyval.node),"decl",decl); ++ Delete(decl); ++ } ++ if ((yyvsp[(7) - (7)].dtype).qualifier) ++ Swig_error(cparse_file, cparse_line, "Destructor %s %s cannot have a qualifier.\n", Swig_name_decl((yyval.node)), SwigType_str((yyvsp[(7) - (7)].dtype).qualifier, 0)); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 230: ++#line 4849 "parser.y" ++ { ++ (yyval.node) = new_node("cdecl"); ++ Setattr((yyval.node),"type",(yyvsp[(3) - (8)].type)); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (8)].str)); ++ Setattr((yyval.node),"storage",(yyvsp[(1) - (8)].id)); ++ ++ SwigType_add_function((yyvsp[(4) - (8)].type),(yyvsp[(6) - (8)].pl)); ++ if ((yyvsp[(8) - (8)].dtype).qualifier) { ++ SwigType_push((yyvsp[(4) - (8)].type),(yyvsp[(8) - (8)].dtype).qualifier); ++ } ++ if ((yyvsp[(8) - (8)].dtype).val) { ++ Setattr((yyval.node),"value",(yyvsp[(8) - (8)].dtype).val); ++ } ++ Setattr((yyval.node),"refqualifier",(yyvsp[(8) - (8)].dtype).refqualifier); ++ Setattr((yyval.node),"decl",(yyvsp[(4) - (8)].type)); ++ Setattr((yyval.node),"parms",(yyvsp[(6) - (8)].pl)); ++ Setattr((yyval.node),"conversion_operator","1"); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 231: ++#line 4868 "parser.y" ++ { ++ SwigType *decl; ++ (yyval.node) = new_node("cdecl"); ++ Setattr((yyval.node),"type",(yyvsp[(3) - (8)].type)); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (8)].str)); ++ Setattr((yyval.node),"storage",(yyvsp[(1) - (8)].id)); ++ decl = NewStringEmpty(); ++ SwigType_add_reference(decl); ++ SwigType_add_function(decl,(yyvsp[(6) - (8)].pl)); ++ if ((yyvsp[(8) - (8)].dtype).qualifier) { ++ SwigType_push(decl,(yyvsp[(8) - (8)].dtype).qualifier); ++ } ++ if ((yyvsp[(8) - (8)].dtype).val) { ++ Setattr((yyval.node),"value",(yyvsp[(8) - (8)].dtype).val); ++ } ++ Setattr((yyval.node),"refqualifier",(yyvsp[(8) - (8)].dtype).refqualifier); ++ Setattr((yyval.node),"decl",decl); ++ Setattr((yyval.node),"parms",(yyvsp[(6) - (8)].pl)); ++ Setattr((yyval.node),"conversion_operator","1"); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 232: ++#line 4889 "parser.y" ++ { ++ SwigType *decl; ++ (yyval.node) = new_node("cdecl"); ++ Setattr((yyval.node),"type",(yyvsp[(3) - (8)].type)); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (8)].str)); ++ Setattr((yyval.node),"storage",(yyvsp[(1) - (8)].id)); ++ decl = NewStringEmpty(); ++ SwigType_add_rvalue_reference(decl); ++ SwigType_add_function(decl,(yyvsp[(6) - (8)].pl)); ++ if ((yyvsp[(8) - (8)].dtype).qualifier) { ++ SwigType_push(decl,(yyvsp[(8) - (8)].dtype).qualifier); ++ } ++ if ((yyvsp[(8) - (8)].dtype).val) { ++ Setattr((yyval.node),"value",(yyvsp[(8) - (8)].dtype).val); ++ } ++ Setattr((yyval.node),"refqualifier",(yyvsp[(8) - (8)].dtype).refqualifier); ++ Setattr((yyval.node),"decl",decl); ++ Setattr((yyval.node),"parms",(yyvsp[(6) - (8)].pl)); ++ Setattr((yyval.node),"conversion_operator","1"); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 233: ++#line 4911 "parser.y" ++ { ++ SwigType *decl; ++ (yyval.node) = new_node("cdecl"); ++ Setattr((yyval.node),"type",(yyvsp[(3) - (9)].type)); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (9)].str)); ++ Setattr((yyval.node),"storage",(yyvsp[(1) - (9)].id)); ++ decl = NewStringEmpty(); ++ SwigType_add_pointer(decl); ++ SwigType_add_reference(decl); ++ SwigType_add_function(decl,(yyvsp[(7) - (9)].pl)); ++ if ((yyvsp[(9) - (9)].dtype).qualifier) { ++ SwigType_push(decl,(yyvsp[(9) - (9)].dtype).qualifier); ++ } ++ if ((yyvsp[(9) - (9)].dtype).val) { ++ Setattr((yyval.node),"value",(yyvsp[(9) - (9)].dtype).val); ++ } ++ Setattr((yyval.node),"refqualifier",(yyvsp[(9) - (9)].dtype).refqualifier); ++ Setattr((yyval.node),"decl",decl); ++ Setattr((yyval.node),"parms",(yyvsp[(7) - (9)].pl)); ++ Setattr((yyval.node),"conversion_operator","1"); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 234: ++#line 4934 "parser.y" ++ { ++ String *t = NewStringEmpty(); ++ (yyval.node) = new_node("cdecl"); ++ Setattr((yyval.node),"type",(yyvsp[(3) - (7)].type)); ++ Setattr((yyval.node),"name",(yyvsp[(2) - (7)].str)); ++ Setattr((yyval.node),"storage",(yyvsp[(1) - (7)].id)); ++ SwigType_add_function(t,(yyvsp[(5) - (7)].pl)); ++ if ((yyvsp[(7) - (7)].dtype).qualifier) { ++ SwigType_push(t,(yyvsp[(7) - (7)].dtype).qualifier); ++ } ++ if ((yyvsp[(7) - (7)].dtype).val) { ++ Setattr((yyval.node),"value",(yyvsp[(7) - (7)].dtype).val); ++ } ++ Setattr((yyval.node),"refqualifier",(yyvsp[(7) - (7)].dtype).refqualifier); ++ Setattr((yyval.node),"decl",t); ++ Setattr((yyval.node),"parms",(yyvsp[(5) - (7)].pl)); ++ Setattr((yyval.node),"conversion_operator","1"); ++ add_symbols((yyval.node)); ++ ;} ++ break; ++ ++ case 235: ++#line 4957 "parser.y" ++ { ++ skip_balanced('{','}'); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 236: ++#line 4965 "parser.y" ++ { ++ skip_balanced('(',')'); ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 237: ++#line 4972 "parser.y" ++ { ++ (yyval.node) = new_node("access"); ++ Setattr((yyval.node),"kind","public"); ++ cplus_mode = CPLUS_PUBLIC; ++ ;} ++ break; ++ ++ case 238: ++#line 4979 "parser.y" ++ { ++ (yyval.node) = new_node("access"); ++ Setattr((yyval.node),"kind","private"); ++ cplus_mode = CPLUS_PRIVATE; ++ ;} ++ break; ++ ++ case 239: ++#line 4987 "parser.y" ++ { ++ (yyval.node) = new_node("access"); ++ Setattr((yyval.node),"kind","protected"); ++ cplus_mode = CPLUS_PROTECTED; ++ ;} ++ break; ++ ++ case 240: ++#line 4995 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 241: ++#line 4998 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 242: ++#line 5002 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 243: ++#line 5005 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 244: ++#line 5006 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 245: ++#line 5007 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 246: ++#line 5008 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 247: ++#line 5009 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 248: ++#line 5010 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 249: ++#line 5011 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 250: ++#line 5012 "parser.y" ++ { (yyval.node) = (yyvsp[(1) - (1)].node); ;} ++ break; ++ ++ case 251: ++#line 5015 "parser.y" ++ { ++ Clear(scanner_ccode); ++ (yyval.dtype).val = 0; ++ (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier; ++ (yyval.dtype).refqualifier = (yyvsp[(1) - (2)].dtype).refqualifier; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws; ++ (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf; ++ (yyval.dtype).nexcept = (yyvsp[(1) - (2)].dtype).nexcept; ++ (yyval.dtype).final = (yyvsp[(1) - (2)].dtype).final; ++ ;} ++ break; ++ ++ case 252: ++#line 5026 "parser.y" ++ { ++ Clear(scanner_ccode); ++ (yyval.dtype).val = (yyvsp[(3) - (4)].dtype).val; ++ (yyval.dtype).qualifier = (yyvsp[(1) - (4)].dtype).qualifier; ++ (yyval.dtype).refqualifier = (yyvsp[(1) - (4)].dtype).refqualifier; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = (yyvsp[(1) - (4)].dtype).throws; ++ (yyval.dtype).throwf = (yyvsp[(1) - (4)].dtype).throwf; ++ (yyval.dtype).nexcept = (yyvsp[(1) - (4)].dtype).nexcept; ++ (yyval.dtype).final = (yyvsp[(1) - (4)].dtype).final; ++ ;} ++ break; ++ ++ case 253: ++#line 5037 "parser.y" ++ { ++ skip_balanced('{','}'); ++ (yyval.dtype).val = 0; ++ (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier; ++ (yyval.dtype).refqualifier = (yyvsp[(1) - (2)].dtype).refqualifier; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws; ++ (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf; ++ (yyval.dtype).nexcept = (yyvsp[(1) - (2)].dtype).nexcept; ++ (yyval.dtype).final = (yyvsp[(1) - (2)].dtype).final; ++ ;} ++ break; ++ ++ case 254: ++#line 5050 "parser.y" ++ { ++ Clear(scanner_ccode); ++ (yyval.dtype).val = 0; ++ (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier; ++ (yyval.dtype).refqualifier = (yyvsp[(1) - (2)].dtype).refqualifier; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws; ++ (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf; ++ (yyval.dtype).nexcept = (yyvsp[(1) - (2)].dtype).nexcept; ++ (yyval.dtype).final = (yyvsp[(1) - (2)].dtype).final; ++ ;} ++ break; ++ ++ case 255: ++#line 5061 "parser.y" ++ { ++ Clear(scanner_ccode); ++ (yyval.dtype).val = (yyvsp[(3) - (4)].dtype).val; ++ (yyval.dtype).qualifier = (yyvsp[(1) - (4)].dtype).qualifier; ++ (yyval.dtype).refqualifier = (yyvsp[(1) - (4)].dtype).refqualifier; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = (yyvsp[(1) - (4)].dtype).throws; ++ (yyval.dtype).throwf = (yyvsp[(1) - (4)].dtype).throwf; ++ (yyval.dtype).nexcept = (yyvsp[(1) - (4)].dtype).nexcept; ++ (yyval.dtype).final = (yyvsp[(1) - (4)].dtype).final; ++ ;} ++ break; ++ ++ case 256: ++#line 5072 "parser.y" ++ { ++ skip_balanced('{','}'); ++ (yyval.dtype).val = 0; ++ (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier; ++ (yyval.dtype).refqualifier = (yyvsp[(1) - (2)].dtype).refqualifier; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = (yyvsp[(1) - (2)].dtype).throws; ++ (yyval.dtype).throwf = (yyvsp[(1) - (2)].dtype).throwf; ++ (yyval.dtype).nexcept = (yyvsp[(1) - (2)].dtype).nexcept; ++ (yyval.dtype).final = (yyvsp[(1) - (2)].dtype).final; ++ ;} ++ break; ++ ++ case 257: ++#line 5086 "parser.y" ++ { ;} ++ break; ++ ++ case 258: ++#line 5089 "parser.y" ++ { (yyval.type) = (yyvsp[(1) - (1)].type); ++ /* Printf(stdout,"primitive = '%s'\n", $$);*/ ++ ;} ++ break; ++ ++ case 259: ++#line 5092 "parser.y" ++ { (yyval.type) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 260: ++#line 5093 "parser.y" ++ { (yyval.type) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 261: ++#line 5097 "parser.y" ++ { (yyval.type) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 262: ++#line 5099 "parser.y" ++ { ++ (yyval.type) = (yyvsp[(1) - (1)].str); ++ ;} ++ break; ++ ++ case 263: ++#line 5107 "parser.y" ++ { ++ if (Strcmp((yyvsp[(2) - (2)].str),"C") == 0) { ++ (yyval.id) = "externc"; ++ } else if (Strcmp((yyvsp[(2) - (2)].str),"C++") == 0) { ++ (yyval.id) = "extern"; ++ } else { ++ Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", (yyvsp[(2) - (2)].str)); ++ (yyval.id) = 0; ++ } ++ ;} ++ break; ++ ++ case 264: ++#line 5119 "parser.y" ++ { (yyval.id) = "extern"; ;} ++ break; ++ ++ case 265: ++#line 5120 "parser.y" ++ { (yyval.id) = (yyvsp[(1) - (1)].id); ;} ++ break; ++ ++ case 266: ++#line 5121 "parser.y" ++ { ++ if (Equal((yyvsp[(1) - (2)].id), "extern")) { ++ (yyval.id) = "extern thread_local"; ++ } else { ++ (yyval.id) = "externc thread_local"; ++ } ++ ;} ++ break; ++ ++ case 267: ++#line 5128 "parser.y" ++ { (yyval.id) = "typedef"; ;} ++ break; ++ ++ case 268: ++#line 5129 "parser.y" ++ { (yyval.id) = "static"; ;} ++ break; ++ ++ case 269: ++#line 5130 "parser.y" ++ { (yyval.id) = "typedef"; ;} ++ break; ++ ++ case 270: ++#line 5131 "parser.y" ++ { (yyval.id) = "virtual"; ;} ++ break; ++ ++ case 271: ++#line 5132 "parser.y" ++ { (yyval.id) = "friend"; ;} ++ break; ++ ++ case 272: ++#line 5133 "parser.y" ++ { (yyval.id) = "explicit"; ;} ++ break; ++ ++ case 273: ++#line 5134 "parser.y" ++ { (yyval.id) = "constexpr"; ;} ++ break; ++ ++ case 274: ++#line 5135 "parser.y" ++ { (yyval.id) = "explicit constexpr"; ;} ++ break; ++ ++ case 275: ++#line 5136 "parser.y" ++ { (yyval.id) = "explicit constexpr"; ;} ++ break; ++ ++ case 276: ++#line 5137 "parser.y" ++ { (yyval.id) = "static constexpr"; ;} ++ break; ++ ++ case 277: ++#line 5138 "parser.y" ++ { (yyval.id) = "static constexpr"; ;} ++ break; ++ ++ case 278: ++#line 5139 "parser.y" ++ { (yyval.id) = "thread_local"; ;} ++ break; ++ ++ case 279: ++#line 5140 "parser.y" ++ { (yyval.id) = "static thread_local"; ;} ++ break; ++ ++ case 280: ++#line 5141 "parser.y" ++ { (yyval.id) = "static thread_local"; ;} ++ break; ++ ++ case 281: ++#line 5142 "parser.y" ++ { (yyval.id) = "extern thread_local"; ;} ++ break; ++ ++ case 282: ++#line 5143 "parser.y" ++ { (yyval.id) = "extern thread_local"; ;} ++ break; ++ ++ case 283: ++#line 5144 "parser.y" ++ { (yyval.id) = 0; ;} ++ break; ++ ++ case 284: ++#line 5151 "parser.y" ++ { ++ Parm *p; ++ (yyval.pl) = (yyvsp[(1) - (1)].pl); ++ p = (yyvsp[(1) - (1)].pl); ++ while (p) { ++ Replace(Getattr(p,"type"),"typename ", "", DOH_REPLACE_ANY); ++ p = nextSibling(p); ++ } ++ ;} ++ break; ++ ++ case 285: ++#line 5162 "parser.y" ++ { ++ set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].pl)); ++ (yyval.pl) = (yyvsp[(1) - (2)].p); ++ ;} ++ break; ++ ++ case 286: ++#line 5166 "parser.y" ++ { ++ (yyval.pl) = 0; ++ previousNode = currentNode; ++ currentNode=0; ++ ;} ++ break; ++ ++ case 287: ++#line 5173 "parser.y" ++ { ++ set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].pl)); ++ (yyval.pl) = (yyvsp[(2) - (3)].p); ++ ;} ++ break; ++ ++ case 288: ++#line 5177 "parser.y" ++ { ++ set_comment(previousNode, (yyvsp[(2) - (4)].str)); ++ set_nextSibling((yyvsp[(3) - (4)].p), (yyvsp[(4) - (4)].pl)); ++ (yyval.pl) = (yyvsp[(3) - (4)].p); ++ ;} ++ break; ++ ++ case 289: ++#line 5182 "parser.y" ++ { (yyval.pl) = 0; ;} ++ break; ++ ++ case 290: ++#line 5186 "parser.y" ++ { ++ SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type); ++ (yyval.p) = NewParmWithoutFileLineInfo((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).id); ++ previousNode = currentNode; ++ currentNode = (yyval.p); ++ Setfile((yyval.p),cparse_file); ++ Setline((yyval.p),cparse_line); ++ if ((yyvsp[(2) - (2)].decl).defarg) { ++ Setattr((yyval.p),"value",(yyvsp[(2) - (2)].decl).defarg); ++ } ++ ;} ++ break; ++ ++ case 291: ++#line 5198 "parser.y" ++ { ++ (yyval.p) = NewParmWithoutFileLineInfo(NewStringf("template %s %s", (yyvsp[(5) - (7)].id),(yyvsp[(6) - (7)].str)), 0); ++ previousNode = currentNode; ++ currentNode = (yyval.p); ++ Setfile((yyval.p),cparse_file); ++ Setline((yyval.p),cparse_line); ++ if ((yyvsp[(7) - (7)].dtype).val) { ++ Setattr((yyval.p),"value",(yyvsp[(7) - (7)].dtype).val); ++ } ++ ;} ++ break; ++ ++ case 292: ++#line 5208 "parser.y" ++ { ++ SwigType *t = NewString("v(...)"); ++ (yyval.p) = NewParmWithoutFileLineInfo(t, 0); ++ previousNode = currentNode; ++ currentNode = (yyval.p); ++ Setfile((yyval.p),cparse_file); ++ Setline((yyval.p),cparse_line); ++ ;} ++ break; ++ ++ case 293: ++#line 5218 "parser.y" ++ { ++ (yyval.p) = (yyvsp[(1) - (1)].p); ++ ;} ++ break; ++ ++ case 294: ++#line 5221 "parser.y" ++ { ++ (yyval.p) = (yyvsp[(2) - (2)].p); ++ set_comment((yyvsp[(2) - (2)].p), (yyvsp[(1) - (2)].str)); ++ ;} ++ break; ++ ++ case 295: ++#line 5225 "parser.y" ++ { ++ (yyval.p) = (yyvsp[(1) - (2)].p); ++ set_comment((yyvsp[(1) - (2)].p), (yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 296: ++#line 5231 "parser.y" ++ { ++ Parm *p; ++ (yyval.p) = (yyvsp[(1) - (1)].p); ++ p = (yyvsp[(1) - (1)].p); ++ while (p) { ++ if (Getattr(p,"type")) { ++ Replace(Getattr(p,"type"),"typename ", "", DOH_REPLACE_ANY); ++ } ++ p = nextSibling(p); ++ } ++ ;} ++ break; ++ ++ case 297: ++#line 5244 "parser.y" ++ { ++ set_nextSibling((yyvsp[(1) - (2)].p),(yyvsp[(2) - (2)].p)); ++ (yyval.p) = (yyvsp[(1) - (2)].p); ++ ;} ++ break; ++ ++ case 298: ++#line 5248 "parser.y" ++ { (yyval.p) = 0; ;} ++ break; ++ ++ case 299: ++#line 5251 "parser.y" ++ { ++ set_nextSibling((yyvsp[(2) - (3)].p),(yyvsp[(3) - (3)].p)); ++ (yyval.p) = (yyvsp[(2) - (3)].p); ++ ;} ++ break; ++ ++ case 300: ++#line 5255 "parser.y" ++ { (yyval.p) = 0; ;} ++ break; ++ ++ case 301: ++#line 5259 "parser.y" ++ { ++ (yyval.p) = (yyvsp[(1) - (1)].p); ++ { ++ /* We need to make a possible adjustment for integer parameters. */ ++ SwigType *type; ++ Node *n = 0; ++ ++ while (!n) { ++ type = Getattr((yyvsp[(1) - (1)].p),"type"); ++ n = Swig_symbol_clookup(type,0); /* See if we can find a node that matches the typename */ ++ if ((n) && (Strcmp(nodeType(n),"cdecl") == 0)) { ++ SwigType *decl = Getattr(n,"decl"); ++ if (!SwigType_isfunction(decl)) { ++ String *value = Getattr(n,"value"); ++ if (value) { ++ String *v = Copy(value); ++ Setattr((yyvsp[(1) - (1)].p),"type",v); ++ Delete(v); ++ n = 0; ++ } ++ } ++ } else { ++ break; ++ } ++ } ++ } ++ ++ ;} ++ break; ++ ++ case 302: ++#line 5287 "parser.y" ++ { ++ (yyval.p) = NewParmWithoutFileLineInfo(0,0); ++ Setfile((yyval.p),cparse_file); ++ Setline((yyval.p),cparse_line); ++ Setattr((yyval.p),"value",(yyvsp[(1) - (1)].dtype).val); ++ ;} ++ break; ++ ++ case 303: ++#line 5295 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (2)].dtype); ++ Printf((yyval.dtype).val, "%s", (yyvsp[(2) - (2)].dtype).val); ++ ;} ++ break; ++ ++ case 304: ++#line 5299 "parser.y" ++ { (yyval.dtype).val = NewStringEmpty(); ;} ++ break; ++ ++ case 305: ++#line 5302 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf(",%s%s", (yyvsp[(2) - (3)].dtype).val, (yyvsp[(3) - (3)].dtype).val); ++ (yyval.dtype).type = 0; ++ ;} ++ break; ++ ++ case 306: ++#line 5306 "parser.y" ++ { (yyval.dtype).val = NewStringEmpty(); ;} ++ break; ++ ++ case 307: ++#line 5309 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(2) - (2)].dtype); ++ if ((yyvsp[(2) - (2)].dtype).type == T_ERROR) { ++ Swig_warning(WARN_PARSE_BAD_DEFAULT,cparse_file, cparse_line, "Can't set default argument (ignored)\n"); ++ (yyval.dtype).val = 0; ++ (yyval.dtype).rawval = 0; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ } ++ ;} ++ break; ++ ++ case 308: ++#line 5322 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(2) - (5)].dtype); ++ if ((yyvsp[(2) - (5)].dtype).type == T_ERROR) { ++ Swig_warning(WARN_PARSE_BAD_DEFAULT,cparse_file, cparse_line, "Can't set default argument (ignored)\n"); ++ (yyval.dtype) = (yyvsp[(2) - (5)].dtype); ++ (yyval.dtype).val = 0; ++ (yyval.dtype).rawval = 0; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ } else { ++ (yyval.dtype).val = NewStringf("%s[%s]",(yyvsp[(2) - (5)].dtype).val,(yyvsp[(4) - (5)].dtype).val); ++ } ++ ;} ++ break; ++ ++ case 309: ++#line 5338 "parser.y" ++ { ++ skip_balanced('{','}'); ++ (yyval.dtype).val = NewString(scanner_ccode); ++ (yyval.dtype).rawval = 0; ++ (yyval.dtype).type = T_INT; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ ;} ++ break; ++ ++ case 310: ++#line 5349 "parser.y" ++ { ++ (yyval.dtype).val = 0; ++ (yyval.dtype).rawval = 0; ++ (yyval.dtype).type = 0; ++ (yyval.dtype).bitfield = (yyvsp[(2) - (2)].dtype).val; ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ ;} ++ break; ++ ++ case 311: ++#line 5359 "parser.y" ++ { ++ (yyval.dtype).val = 0; ++ (yyval.dtype).rawval = 0; ++ (yyval.dtype).type = T_INT; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ ;} ++ break; ++ ++ case 312: ++#line 5371 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(1) - (2)].decl); ++ (yyval.decl).defarg = (yyvsp[(2) - (2)].dtype).rawval ? (yyvsp[(2) - (2)].dtype).rawval : (yyvsp[(2) - (2)].dtype).val; ++ ;} ++ break; ++ ++ case 313: ++#line 5375 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(1) - (2)].decl); ++ (yyval.decl).defarg = (yyvsp[(2) - (2)].dtype).rawval ? (yyvsp[(2) - (2)].dtype).rawval : (yyvsp[(2) - (2)].dtype).val; ++ ;} ++ break; ++ ++ case 314: ++#line 5379 "parser.y" ++ { ++ (yyval.decl).type = 0; ++ (yyval.decl).id = 0; ++ (yyval.decl).defarg = (yyvsp[(1) - (1)].dtype).rawval ? (yyvsp[(1) - (1)].dtype).rawval : (yyvsp[(1) - (1)].dtype).val; ++ ;} ++ break; ++ ++ case 315: ++#line 5386 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (5)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_function(t,(yyvsp[(3) - (5)].pl)); ++ if ((yyvsp[(5) - (5)].dtype).qualifier) ++ SwigType_push(t, (yyvsp[(5) - (5)].dtype).qualifier); ++ if (!(yyval.decl).have_parms) { ++ (yyval.decl).parms = (yyvsp[(3) - (5)].pl); ++ (yyval.decl).have_parms = 1; ++ } ++ if (!(yyval.decl).type) { ++ (yyval.decl).type = t; ++ } else { ++ SwigType_push(t, (yyval.decl).type); ++ Delete((yyval.decl).type); ++ (yyval.decl).type = t; ++ } ++ (yyval.decl).defarg = 0; ++ ;} ++ break; ++ ++ case 316: ++#line 5408 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(1) - (1)].decl); ++ if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) { ++ Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type)); ++ } else if (SwigType_isarray((yyvsp[(1) - (1)].decl).type)) { ++ SwigType *ta = SwigType_pop_arrays((yyvsp[(1) - (1)].decl).type); ++ if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) { ++ Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type)); ++ } else { ++ (yyval.decl).parms = 0; ++ } ++ SwigType_push((yyvsp[(1) - (1)].decl).type,ta); ++ Delete(ta); ++ } else { ++ (yyval.decl).parms = 0; ++ } ++ ;} ++ break; ++ ++ case 317: ++#line 5425 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(1) - (1)].decl); ++ if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) { ++ Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type)); ++ } else if (SwigType_isarray((yyvsp[(1) - (1)].decl).type)) { ++ SwigType *ta = SwigType_pop_arrays((yyvsp[(1) - (1)].decl).type); ++ if (SwigType_isfunction((yyvsp[(1) - (1)].decl).type)) { ++ Delete(SwigType_pop_function((yyvsp[(1) - (1)].decl).type)); ++ } else { ++ (yyval.decl).parms = 0; ++ } ++ SwigType_push((yyvsp[(1) - (1)].decl).type,ta); ++ Delete(ta); ++ } else { ++ (yyval.decl).parms = 0; ++ } ++ ;} ++ break; ++ ++ case 318: ++#line 5444 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (5)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_function(t, (yyvsp[(3) - (5)].pl)); ++ if ((yyvsp[(5) - (5)].dtype).qualifier) ++ SwigType_push(t, (yyvsp[(5) - (5)].dtype).qualifier); ++ if (!(yyval.decl).have_parms) { ++ (yyval.decl).parms = (yyvsp[(3) - (5)].pl); ++ (yyval.decl).have_parms = 1; ++ } ++ if (!(yyval.decl).type) { ++ (yyval.decl).type = t; ++ } else { ++ SwigType_push(t, (yyval.decl).type); ++ Delete((yyval.decl).type); ++ (yyval.decl).type = t; ++ } ++ ;} ++ break; ++ ++ case 319: ++#line 5463 "parser.y" ++ { ++ (yyval.decl).type = 0; ++ (yyval.decl).id = 0; ++ (yyval.decl).parms = 0; ++ ;} ++ break; ++ ++ case 320: ++#line 5470 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(2) - (2)].decl); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (2)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (2)].type); ++ ;} ++ break; ++ ++ case 321: ++#line 5478 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(3) - (3)].decl); ++ SwigType_add_reference((yyvsp[(1) - (3)].type)); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (3)].type); ++ ;} ++ break; ++ ++ case 322: ++#line 5487 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(3) - (3)].decl); ++ SwigType_add_rvalue_reference((yyvsp[(1) - (3)].type)); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (3)].type); ++ ;} ++ break; ++ ++ case 323: ++#line 5496 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(1) - (1)].decl); ++ if (!(yyval.decl).type) (yyval.decl).type = NewStringEmpty(); ++ ;} ++ break; ++ ++ case 324: ++#line 5500 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(2) - (2)].decl); ++ (yyval.decl).type = NewStringEmpty(); ++ SwigType_add_reference((yyval.decl).type); ++ if ((yyvsp[(2) - (2)].decl).type) { ++ SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type); ++ Delete((yyvsp[(2) - (2)].decl).type); ++ } ++ ;} ++ break; ++ ++ case 325: ++#line 5509 "parser.y" ++ { ++ /* Introduced in C++11, move operator && */ ++ /* Adds one S/R conflict */ ++ (yyval.decl) = (yyvsp[(2) - (2)].decl); ++ (yyval.decl).type = NewStringEmpty(); ++ SwigType_add_rvalue_reference((yyval.decl).type); ++ if ((yyvsp[(2) - (2)].decl).type) { ++ SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type); ++ Delete((yyvsp[(2) - (2)].decl).type); ++ } ++ ;} ++ break; ++ ++ case 326: ++#line 5520 "parser.y" ++ { ++ SwigType *t = NewStringEmpty(); ++ ++ (yyval.decl) = (yyvsp[(3) - (3)].decl); ++ SwigType_add_memberpointer(t,(yyvsp[(1) - (3)].str)); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 327: ++#line 5531 "parser.y" ++ { ++ SwigType *t = NewStringEmpty(); ++ (yyval.decl) = (yyvsp[(4) - (4)].decl); ++ SwigType_add_memberpointer(t,(yyvsp[(2) - (4)].str)); ++ SwigType_push((yyvsp[(1) - (4)].type),t); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (4)].type); ++ Delete(t); ++ ;} ++ break; ++ ++ case 328: ++#line 5543 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(5) - (5)].decl); ++ SwigType_add_memberpointer((yyvsp[(1) - (5)].type),(yyvsp[(2) - (5)].str)); ++ SwigType_add_reference((yyvsp[(1) - (5)].type)); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (5)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (5)].type); ++ ;} ++ break; ++ ++ case 329: ++#line 5553 "parser.y" ++ { ++ SwigType *t = NewStringEmpty(); ++ (yyval.decl) = (yyvsp[(4) - (4)].decl); ++ SwigType_add_memberpointer(t,(yyvsp[(1) - (4)].str)); ++ SwigType_add_reference(t); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 330: ++#line 5567 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(3) - (3)].decl); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (3)].type); ++ ;} ++ break; ++ ++ case 331: ++#line 5575 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(4) - (4)].decl); ++ SwigType_add_reference((yyvsp[(1) - (4)].type)); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (4)].type); ++ ;} ++ break; ++ ++ case 332: ++#line 5584 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(4) - (4)].decl); ++ SwigType_add_rvalue_reference((yyvsp[(1) - (4)].type)); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (4)].type); ++ ;} ++ break; ++ ++ case 333: ++#line 5593 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(2) - (2)].decl); ++ if (!(yyval.decl).type) (yyval.decl).type = NewStringEmpty(); ++ ;} ++ break; ++ ++ case 334: ++#line 5597 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(3) - (3)].decl); ++ (yyval.decl).type = NewStringEmpty(); ++ SwigType_add_reference((yyval.decl).type); ++ if ((yyvsp[(3) - (3)].decl).type) { ++ SwigType_push((yyval.decl).type,(yyvsp[(3) - (3)].decl).type); ++ Delete((yyvsp[(3) - (3)].decl).type); ++ } ++ ;} ++ break; ++ ++ case 335: ++#line 5606 "parser.y" ++ { ++ /* Introduced in C++11, move operator && */ ++ /* Adds one S/R conflict */ ++ (yyval.decl) = (yyvsp[(3) - (3)].decl); ++ (yyval.decl).type = NewStringEmpty(); ++ SwigType_add_rvalue_reference((yyval.decl).type); ++ if ((yyvsp[(3) - (3)].decl).type) { ++ SwigType_push((yyval.decl).type,(yyvsp[(3) - (3)].decl).type); ++ Delete((yyvsp[(3) - (3)].decl).type); ++ } ++ ;} ++ break; ++ ++ case 336: ++#line 5617 "parser.y" ++ { ++ SwigType *t = NewStringEmpty(); ++ ++ (yyval.decl) = (yyvsp[(4) - (4)].decl); ++ SwigType_add_memberpointer(t,(yyvsp[(1) - (4)].str)); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 337: ++#line 5628 "parser.y" ++ { ++ SwigType *t = NewStringEmpty(); ++ (yyval.decl) = (yyvsp[(5) - (5)].decl); ++ SwigType_add_memberpointer(t,(yyvsp[(2) - (5)].str)); ++ SwigType_push((yyvsp[(1) - (5)].type),t); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (5)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (5)].type); ++ Delete(t); ++ ;} ++ break; ++ ++ case 338: ++#line 5640 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(6) - (6)].decl); ++ SwigType_add_memberpointer((yyvsp[(1) - (6)].type),(yyvsp[(2) - (6)].str)); ++ SwigType_add_reference((yyvsp[(1) - (6)].type)); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (6)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (6)].type); ++ ;} ++ break; ++ ++ case 339: ++#line 5650 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(6) - (6)].decl); ++ SwigType_add_memberpointer((yyvsp[(1) - (6)].type),(yyvsp[(2) - (6)].str)); ++ SwigType_add_rvalue_reference((yyvsp[(1) - (6)].type)); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (6)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (6)].type); ++ ;} ++ break; ++ ++ case 340: ++#line 5660 "parser.y" ++ { ++ SwigType *t = NewStringEmpty(); ++ (yyval.decl) = (yyvsp[(5) - (5)].decl); ++ SwigType_add_memberpointer(t,(yyvsp[(1) - (5)].str)); ++ SwigType_add_reference(t); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 341: ++#line 5671 "parser.y" ++ { ++ SwigType *t = NewStringEmpty(); ++ (yyval.decl) = (yyvsp[(5) - (5)].decl); ++ SwigType_add_memberpointer(t,(yyvsp[(1) - (5)].str)); ++ SwigType_add_rvalue_reference(t); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 342: ++#line 5684 "parser.y" ++ { ++ /* Note: This is non-standard C. Template declarator is allowed to follow an identifier */ ++ (yyval.decl).id = Char((yyvsp[(1) - (1)].str)); ++ (yyval.decl).type = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ ;} ++ break; ++ ++ case 343: ++#line 5691 "parser.y" ++ { ++ (yyval.decl).id = Char(NewStringf("~%s",(yyvsp[(2) - (2)].str))); ++ (yyval.decl).type = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ ;} ++ break; ++ ++ case 344: ++#line 5699 "parser.y" ++ { ++ (yyval.decl).id = Char((yyvsp[(2) - (3)].str)); ++ (yyval.decl).type = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ ;} ++ break; ++ ++ case 345: ++#line 5715 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(3) - (4)].decl); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(2) - (4)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(2) - (4)].type); ++ ;} ++ break; ++ ++ case 346: ++#line 5723 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(4) - (5)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_memberpointer(t,(yyvsp[(2) - (5)].str)); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 347: ++#line 5734 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (3)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_array(t,""); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 348: ++#line 5745 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (4)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 349: ++#line 5756 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (4)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_function(t,(yyvsp[(3) - (4)].pl)); ++ if (!(yyval.decl).have_parms) { ++ (yyval.decl).parms = (yyvsp[(3) - (4)].pl); ++ (yyval.decl).have_parms = 1; ++ } ++ if (!(yyval.decl).type) { ++ (yyval.decl).type = t; ++ } else { ++ SwigType_push(t, (yyval.decl).type); ++ Delete((yyval.decl).type); ++ (yyval.decl).type = t; ++ } ++ ;} ++ break; ++ ++ case 350: ++#line 5775 "parser.y" ++ { ++ /* Note: This is non-standard C. Template declarator is allowed to follow an identifier */ ++ (yyval.decl).id = Char((yyvsp[(1) - (1)].str)); ++ (yyval.decl).type = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ ;} ++ break; ++ ++ case 351: ++#line 5783 "parser.y" ++ { ++ (yyval.decl).id = Char(NewStringf("~%s",(yyvsp[(2) - (2)].str))); ++ (yyval.decl).type = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ ;} ++ break; ++ ++ case 352: ++#line 5800 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(3) - (4)].decl); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(2) - (4)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(2) - (4)].type); ++ ;} ++ break; ++ ++ case 353: ++#line 5808 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(3) - (4)].decl); ++ if (!(yyval.decl).type) { ++ (yyval.decl).type = NewStringEmpty(); ++ } ++ SwigType_add_reference((yyval.decl).type); ++ ;} ++ break; ++ ++ case 354: ++#line 5815 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(3) - (4)].decl); ++ if (!(yyval.decl).type) { ++ (yyval.decl).type = NewStringEmpty(); ++ } ++ SwigType_add_rvalue_reference((yyval.decl).type); ++ ;} ++ break; ++ ++ case 355: ++#line 5822 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(4) - (5)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_memberpointer(t,(yyvsp[(2) - (5)].str)); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 356: ++#line 5833 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(5) - (6)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_memberpointer(t, (yyvsp[(2) - (6)].str)); ++ SwigType_push(t, (yyvsp[(4) - (6)].str)); ++ if ((yyval.decl).type) { ++ SwigType_push(t, (yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 357: ++#line 5845 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(4) - (5)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_memberpointer(t, (yyvsp[(2) - (5)].str)); ++ if ((yyval.decl).type) { ++ SwigType_push(t, (yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 358: ++#line 5856 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(5) - (6)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_memberpointer(t, (yyvsp[(2) - (6)].str)); ++ SwigType_push(t, (yyvsp[(4) - (6)].str)); ++ if ((yyval.decl).type) { ++ SwigType_push(t, (yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 359: ++#line 5868 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (3)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_array(t,""); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 360: ++#line 5879 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (4)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 361: ++#line 5890 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (4)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_function(t,(yyvsp[(3) - (4)].pl)); ++ if (!(yyval.decl).have_parms) { ++ (yyval.decl).parms = (yyvsp[(3) - (4)].pl); ++ (yyval.decl).have_parms = 1; ++ } ++ if (!(yyval.decl).type) { ++ (yyval.decl).type = t; ++ } else { ++ SwigType_push(t, (yyval.decl).type); ++ Delete((yyval.decl).type); ++ (yyval.decl).type = t; ++ } ++ ;} ++ break; ++ ++ case 362: ++#line 5910 "parser.y" ++ { ++ SwigType *t; ++ Append((yyvsp[(1) - (5)].str), " "); /* intervening space is mandatory */ ++ Append((yyvsp[(1) - (5)].str), Char((yyvsp[(2) - (5)].id))); ++ (yyval.decl).id = Char((yyvsp[(1) - (5)].str)); ++ t = NewStringEmpty(); ++ SwigType_add_function(t,(yyvsp[(4) - (5)].pl)); ++ if (!(yyval.decl).have_parms) { ++ (yyval.decl).parms = (yyvsp[(4) - (5)].pl); ++ (yyval.decl).have_parms = 1; ++ } ++ if (!(yyval.decl).type) { ++ (yyval.decl).type = t; ++ } else { ++ SwigType_push(t, (yyval.decl).type); ++ Delete((yyval.decl).type); ++ (yyval.decl).type = t; ++ } ++ ;} ++ break; ++ ++ case 363: ++#line 5931 "parser.y" ++ { ++ (yyval.decl).type = (yyvsp[(1) - (1)].type); ++ (yyval.decl).id = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ ;} ++ break; ++ ++ case 364: ++#line 5937 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(2) - (2)].decl); ++ SwigType_push((yyvsp[(1) - (2)].type),(yyvsp[(2) - (2)].decl).type); ++ (yyval.decl).type = (yyvsp[(1) - (2)].type); ++ Delete((yyvsp[(2) - (2)].decl).type); ++ ;} ++ break; ++ ++ case 365: ++#line 5943 "parser.y" ++ { ++ (yyval.decl).type = (yyvsp[(1) - (2)].type); ++ SwigType_add_reference((yyval.decl).type); ++ (yyval.decl).id = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ ;} ++ break; ++ ++ case 366: ++#line 5950 "parser.y" ++ { ++ (yyval.decl).type = (yyvsp[(1) - (2)].type); ++ SwigType_add_rvalue_reference((yyval.decl).type); ++ (yyval.decl).id = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ ;} ++ break; ++ ++ case 367: ++#line 5957 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(3) - (3)].decl); ++ SwigType_add_reference((yyvsp[(1) - (3)].type)); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (3)].type); ++ ;} ++ break; ++ ++ case 368: ++#line 5966 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(3) - (3)].decl); ++ SwigType_add_rvalue_reference((yyvsp[(1) - (3)].type)); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (3)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (3)].type); ++ ;} ++ break; ++ ++ case 369: ++#line 5975 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(1) - (1)].decl); ++ ;} ++ break; ++ ++ case 370: ++#line 5978 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(2) - (2)].decl); ++ (yyval.decl).type = NewStringEmpty(); ++ SwigType_add_reference((yyval.decl).type); ++ if ((yyvsp[(2) - (2)].decl).type) { ++ SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type); ++ Delete((yyvsp[(2) - (2)].decl).type); ++ } ++ ;} ++ break; ++ ++ case 371: ++#line 5987 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(2) - (2)].decl); ++ (yyval.decl).type = NewStringEmpty(); ++ SwigType_add_rvalue_reference((yyval.decl).type); ++ if ((yyvsp[(2) - (2)].decl).type) { ++ SwigType_push((yyval.decl).type,(yyvsp[(2) - (2)].decl).type); ++ Delete((yyvsp[(2) - (2)].decl).type); ++ } ++ ;} ++ break; ++ ++ case 372: ++#line 5996 "parser.y" ++ { ++ (yyval.decl).id = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ (yyval.decl).type = NewStringEmpty(); ++ SwigType_add_reference((yyval.decl).type); ++ ;} ++ break; ++ ++ case 373: ++#line 6003 "parser.y" ++ { ++ (yyval.decl).id = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ (yyval.decl).type = NewStringEmpty(); ++ SwigType_add_rvalue_reference((yyval.decl).type); ++ ;} ++ break; ++ ++ case 374: ++#line 6010 "parser.y" ++ { ++ (yyval.decl).type = NewStringEmpty(); ++ SwigType_add_memberpointer((yyval.decl).type,(yyvsp[(1) - (2)].str)); ++ (yyval.decl).id = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ ;} ++ break; ++ ++ case 375: ++#line 6017 "parser.y" ++ { ++ (yyval.decl).type = NewStringEmpty(); ++ SwigType_add_memberpointer((yyval.decl).type, (yyvsp[(1) - (3)].str)); ++ SwigType_push((yyval.decl).type, (yyvsp[(3) - (3)].str)); ++ (yyval.decl).id = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ ;} ++ break; ++ ++ case 376: ++#line 6025 "parser.y" ++ { ++ SwigType *t = NewStringEmpty(); ++ (yyval.decl).type = (yyvsp[(1) - (3)].type); ++ (yyval.decl).id = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ SwigType_add_memberpointer(t,(yyvsp[(2) - (3)].str)); ++ SwigType_push((yyval.decl).type,t); ++ Delete(t); ++ ;} ++ break; ++ ++ case 377: ++#line 6035 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(4) - (4)].decl); ++ SwigType_add_memberpointer((yyvsp[(1) - (4)].type),(yyvsp[(2) - (4)].str)); ++ if ((yyval.decl).type) { ++ SwigType_push((yyvsp[(1) - (4)].type),(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = (yyvsp[(1) - (4)].type); ++ ;} ++ break; ++ ++ case 378: ++#line 6046 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (3)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_array(t,""); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 379: ++#line 6057 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (4)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_array(t,(yyvsp[(3) - (4)].dtype).val); ++ if ((yyval.decl).type) { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ } ++ (yyval.decl).type = t; ++ ;} ++ break; ++ ++ case 380: ++#line 6068 "parser.y" ++ { ++ (yyval.decl).type = NewStringEmpty(); ++ (yyval.decl).id = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ SwigType_add_array((yyval.decl).type,""); ++ ;} ++ break; ++ ++ case 381: ++#line 6075 "parser.y" ++ { ++ (yyval.decl).type = NewStringEmpty(); ++ (yyval.decl).id = 0; ++ (yyval.decl).parms = 0; ++ (yyval.decl).have_parms = 0; ++ SwigType_add_array((yyval.decl).type,(yyvsp[(2) - (3)].dtype).val); ++ ;} ++ break; ++ ++ case 382: ++#line 6082 "parser.y" ++ { ++ (yyval.decl) = (yyvsp[(2) - (3)].decl); ++ ;} ++ break; ++ ++ case 383: ++#line 6085 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (4)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_function(t,(yyvsp[(3) - (4)].pl)); ++ if (!(yyval.decl).type) { ++ (yyval.decl).type = t; ++ } else { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ (yyval.decl).type = t; ++ } ++ if (!(yyval.decl).have_parms) { ++ (yyval.decl).parms = (yyvsp[(3) - (4)].pl); ++ (yyval.decl).have_parms = 1; ++ } ++ ;} ++ break; ++ ++ case 384: ++#line 6102 "parser.y" ++ { ++ SwigType *t; ++ (yyval.decl) = (yyvsp[(1) - (5)].decl); ++ t = NewStringEmpty(); ++ SwigType_add_function(t,(yyvsp[(3) - (5)].pl)); ++ SwigType_push(t, (yyvsp[(5) - (5)].dtype).qualifier); ++ if (!(yyval.decl).type) { ++ (yyval.decl).type = t; ++ } else { ++ SwigType_push(t,(yyval.decl).type); ++ Delete((yyval.decl).type); ++ (yyval.decl).type = t; ++ } ++ if (!(yyval.decl).have_parms) { ++ (yyval.decl).parms = (yyvsp[(3) - (5)].pl); ++ (yyval.decl).have_parms = 1; ++ } ++ ;} ++ break; ++ ++ case 385: ++#line 6120 "parser.y" ++ { ++ (yyval.decl).type = NewStringEmpty(); ++ SwigType_add_function((yyval.decl).type,(yyvsp[(2) - (3)].pl)); ++ (yyval.decl).parms = (yyvsp[(2) - (3)].pl); ++ (yyval.decl).have_parms = 1; ++ (yyval.decl).id = 0; ++ ;} ++ break; ++ ++ case 386: ++#line 6130 "parser.y" ++ { ++ (yyval.type) = NewStringEmpty(); ++ SwigType_add_pointer((yyval.type)); ++ SwigType_push((yyval.type),(yyvsp[(2) - (3)].str)); ++ SwigType_push((yyval.type),(yyvsp[(3) - (3)].type)); ++ Delete((yyvsp[(3) - (3)].type)); ++ ;} ++ break; ++ ++ case 387: ++#line 6137 "parser.y" ++ { ++ (yyval.type) = NewStringEmpty(); ++ SwigType_add_pointer((yyval.type)); ++ SwigType_push((yyval.type),(yyvsp[(2) - (2)].type)); ++ Delete((yyvsp[(2) - (2)].type)); ++ ;} ++ break; ++ ++ case 388: ++#line 6143 "parser.y" ++ { ++ (yyval.type) = NewStringEmpty(); ++ SwigType_add_pointer((yyval.type)); ++ SwigType_push((yyval.type),(yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 389: ++#line 6148 "parser.y" ++ { ++ (yyval.type) = NewStringEmpty(); ++ SwigType_add_pointer((yyval.type)); ++ ;} ++ break; ++ ++ case 390: ++#line 6155 "parser.y" ++ { ++ (yyval.dtype).qualifier = (yyvsp[(1) - (1)].str); ++ (yyval.dtype).refqualifier = 0; ++ ;} ++ break; ++ ++ case 391: ++#line 6159 "parser.y" ++ { ++ (yyval.dtype).qualifier = (yyvsp[(1) - (2)].str); ++ (yyval.dtype).refqualifier = (yyvsp[(2) - (2)].str); ++ SwigType_push((yyval.dtype).qualifier, (yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 392: ++#line 6164 "parser.y" ++ { ++ (yyval.dtype).qualifier = NewStringEmpty(); ++ (yyval.dtype).refqualifier = (yyvsp[(1) - (1)].str); ++ SwigType_push((yyval.dtype).qualifier, (yyvsp[(1) - (1)].str)); ++ ;} ++ break; ++ ++ case 393: ++#line 6171 "parser.y" ++ { ++ (yyval.str) = NewStringEmpty(); ++ SwigType_add_reference((yyval.str)); ++ ;} ++ break; ++ ++ case 394: ++#line 6175 "parser.y" ++ { ++ (yyval.str) = NewStringEmpty(); ++ SwigType_add_rvalue_reference((yyval.str)); ++ ;} ++ break; ++ ++ case 395: ++#line 6181 "parser.y" ++ { ++ (yyval.str) = NewStringEmpty(); ++ if ((yyvsp[(1) - (1)].id)) SwigType_add_qualifier((yyval.str),(yyvsp[(1) - (1)].id)); ++ ;} ++ break; ++ ++ case 396: ++#line 6185 "parser.y" ++ { ++ (yyval.str) = (yyvsp[(2) - (2)].str); ++ if ((yyvsp[(1) - (2)].id)) SwigType_add_qualifier((yyval.str),(yyvsp[(1) - (2)].id)); ++ ;} ++ break; ++ ++ case 397: ++#line 6191 "parser.y" ++ { (yyval.id) = "const"; ;} ++ break; ++ ++ case 398: ++#line 6192 "parser.y" ++ { (yyval.id) = "volatile"; ;} ++ break; ++ ++ case 399: ++#line 6193 "parser.y" ++ { (yyval.id) = 0; ;} ++ break; ++ ++ case 400: ++#line 6199 "parser.y" ++ { ++ (yyval.type) = (yyvsp[(1) - (1)].type); ++ Replace((yyval.type),"typename ","", DOH_REPLACE_ANY); ++ ;} ++ break; ++ ++ case 401: ++#line 6205 "parser.y" ++ { ++ (yyval.type) = (yyvsp[(2) - (2)].type); ++ SwigType_push((yyval.type),(yyvsp[(1) - (2)].str)); ++ ;} ++ break; ++ ++ case 402: ++#line 6209 "parser.y" ++ { (yyval.type) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 403: ++#line 6210 "parser.y" ++ { ++ (yyval.type) = (yyvsp[(1) - (2)].type); ++ SwigType_push((yyval.type),(yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 404: ++#line 6214 "parser.y" ++ { ++ (yyval.type) = (yyvsp[(2) - (3)].type); ++ SwigType_push((yyval.type),(yyvsp[(3) - (3)].str)); ++ SwigType_push((yyval.type),(yyvsp[(1) - (3)].str)); ++ ;} ++ break; ++ ++ case 405: ++#line 6221 "parser.y" ++ { (yyval.type) = (yyvsp[(1) - (1)].type); ++ /* Printf(stdout,"primitive = '%s'\n", $$);*/ ++ ;} ++ break; ++ ++ case 406: ++#line 6224 "parser.y" ++ { (yyval.type) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 407: ++#line 6225 "parser.y" ++ { (yyval.type) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 408: ++#line 6229 "parser.y" ++ { (yyval.type) = NewStringf("enum %s", (yyvsp[(2) - (2)].str)); ;} ++ break; ++ ++ case 409: ++#line 6230 "parser.y" ++ { (yyval.type) = (yyvsp[(1) - (1)].type); ;} ++ break; ++ ++ case 410: ++#line 6232 "parser.y" ++ { ++ (yyval.type) = (yyvsp[(1) - (1)].str); ++ ;} ++ break; ++ ++ case 411: ++#line 6235 "parser.y" ++ { ++ (yyval.type) = NewStringf("%s %s", (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 412: ++#line 6238 "parser.y" ++ { ++ (yyval.type) = (yyvsp[(1) - (1)].type); ++ ;} ++ break; ++ ++ case 413: ++#line 6243 "parser.y" ++ { ++ Node *n = Swig_symbol_clookup((yyvsp[(3) - (4)].str),0); ++ if (!n) { ++ Swig_error(cparse_file, cparse_line, "Identifier %s not defined.\n", (yyvsp[(3) - (4)].str)); ++ (yyval.type) = (yyvsp[(3) - (4)].str); ++ } else { ++ (yyval.type) = Getattr(n, "type"); ++ } ++ ;} ++ break; ++ ++ case 414: ++#line 6254 "parser.y" ++ { ++ if (!(yyvsp[(1) - (1)].ptype).type) (yyvsp[(1) - (1)].ptype).type = NewString("int"); ++ if ((yyvsp[(1) - (1)].ptype).us) { ++ (yyval.type) = NewStringf("%s %s", (yyvsp[(1) - (1)].ptype).us, (yyvsp[(1) - (1)].ptype).type); ++ Delete((yyvsp[(1) - (1)].ptype).us); ++ Delete((yyvsp[(1) - (1)].ptype).type); ++ } else { ++ (yyval.type) = (yyvsp[(1) - (1)].ptype).type; ++ } ++ if (Cmp((yyval.type),"signed int") == 0) { ++ Delete((yyval.type)); ++ (yyval.type) = NewString("int"); ++ } else if (Cmp((yyval.type),"signed long") == 0) { ++ Delete((yyval.type)); ++ (yyval.type) = NewString("long"); ++ } else if (Cmp((yyval.type),"signed short") == 0) { ++ Delete((yyval.type)); ++ (yyval.type) = NewString("short"); ++ } else if (Cmp((yyval.type),"signed long long") == 0) { ++ Delete((yyval.type)); ++ (yyval.type) = NewString("long long"); ++ } ++ ;} ++ break; ++ ++ case 415: ++#line 6279 "parser.y" ++ { ++ (yyval.ptype) = (yyvsp[(1) - (1)].ptype); ++ ;} ++ break; ++ ++ case 416: ++#line 6282 "parser.y" ++ { ++ if ((yyvsp[(1) - (2)].ptype).us && (yyvsp[(2) - (2)].ptype).us) { ++ Swig_error(cparse_file, cparse_line, "Extra %s specifier.\n", (yyvsp[(2) - (2)].ptype).us); ++ } ++ (yyval.ptype) = (yyvsp[(2) - (2)].ptype); ++ if ((yyvsp[(1) - (2)].ptype).us) (yyval.ptype).us = (yyvsp[(1) - (2)].ptype).us; ++ if ((yyvsp[(1) - (2)].ptype).type) { ++ if (!(yyvsp[(2) - (2)].ptype).type) (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type; ++ else { ++ int err = 0; ++ if ((Cmp((yyvsp[(1) - (2)].ptype).type,"long") == 0)) { ++ if ((Cmp((yyvsp[(2) - (2)].ptype).type,"long") == 0) || (Strncmp((yyvsp[(2) - (2)].ptype).type,"double",6) == 0)) { ++ (yyval.ptype).type = NewStringf("long %s", (yyvsp[(2) - (2)].ptype).type); ++ } else if (Cmp((yyvsp[(2) - (2)].ptype).type,"int") == 0) { ++ (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type; ++ } else { ++ err = 1; ++ } ++ } else if ((Cmp((yyvsp[(1) - (2)].ptype).type,"short")) == 0) { ++ if (Cmp((yyvsp[(2) - (2)].ptype).type,"int") == 0) { ++ (yyval.ptype).type = (yyvsp[(1) - (2)].ptype).type; ++ } else { ++ err = 1; ++ } ++ } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"int") == 0) { ++ (yyval.ptype).type = (yyvsp[(2) - (2)].ptype).type; ++ } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"double") == 0) { ++ if (Cmp((yyvsp[(2) - (2)].ptype).type,"long") == 0) { ++ (yyval.ptype).type = NewString("long double"); ++ } else if (Cmp((yyvsp[(2) - (2)].ptype).type,"_Complex") == 0) { ++ (yyval.ptype).type = NewString("double _Complex"); ++ } else { ++ err = 1; ++ } ++ } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"float") == 0) { ++ if (Cmp((yyvsp[(2) - (2)].ptype).type,"_Complex") == 0) { ++ (yyval.ptype).type = NewString("float _Complex"); ++ } else { ++ err = 1; ++ } ++ } else if (Cmp((yyvsp[(1) - (2)].ptype).type,"_Complex") == 0) { ++ (yyval.ptype).type = NewStringf("%s _Complex", (yyvsp[(2) - (2)].ptype).type); ++ } else { ++ err = 1; ++ } ++ if (err) { ++ Swig_error(cparse_file, cparse_line, "Extra %s specifier.\n", (yyvsp[(1) - (2)].ptype).type); ++ } ++ } ++ } ++ ;} ++ break; ++ ++ case 417: ++#line 6336 "parser.y" ++ { ++ (yyval.ptype).type = NewString("int"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 418: ++#line 6340 "parser.y" ++ { ++ (yyval.ptype).type = NewString("short"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 419: ++#line 6344 "parser.y" ++ { ++ (yyval.ptype).type = NewString("long"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 420: ++#line 6348 "parser.y" ++ { ++ (yyval.ptype).type = NewString("char"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 421: ++#line 6352 "parser.y" ++ { ++ (yyval.ptype).type = NewString("wchar_t"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 422: ++#line 6356 "parser.y" ++ { ++ (yyval.ptype).type = NewString("float"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 423: ++#line 6360 "parser.y" ++ { ++ (yyval.ptype).type = NewString("double"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 424: ++#line 6364 "parser.y" ++ { ++ (yyval.ptype).us = NewString("signed"); ++ (yyval.ptype).type = 0; ++ ;} ++ break; ++ ++ case 425: ++#line 6368 "parser.y" ++ { ++ (yyval.ptype).us = NewString("unsigned"); ++ (yyval.ptype).type = 0; ++ ;} ++ break; ++ ++ case 426: ++#line 6372 "parser.y" ++ { ++ (yyval.ptype).type = NewString("_Complex"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 427: ++#line 6376 "parser.y" ++ { ++ (yyval.ptype).type = NewString("__int8"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 428: ++#line 6380 "parser.y" ++ { ++ (yyval.ptype).type = NewString("__int16"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 429: ++#line 6384 "parser.y" ++ { ++ (yyval.ptype).type = NewString("__int32"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 430: ++#line 6388 "parser.y" ++ { ++ (yyval.ptype).type = NewString("__int64"); ++ (yyval.ptype).us = 0; ++ ;} ++ break; ++ ++ case 431: ++#line 6394 "parser.y" ++ { /* scanner_check_typedef(); */ ;} ++ break; ++ ++ case 432: ++#line 6394 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(2) - (2)].dtype); ++ if ((yyval.dtype).type == T_STRING) { ++ (yyval.dtype).rawval = NewStringf("\"%(escape)s\"",(yyval.dtype).val); ++ } else if ((yyval.dtype).type != T_CHAR && (yyval.dtype).type != T_WSTRING && (yyval.dtype).type != T_WCHAR) { ++ (yyval.dtype).rawval = NewStringf("%s", (yyval.dtype).val); ++ } ++ (yyval.dtype).qualifier = 0; ++ (yyval.dtype).refqualifier = 0; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ scanner_ignore_typedef(); ++ ;} ++ break; ++ ++ case 433: ++#line 6410 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ++ ;} ++ break; ++ ++ case 434: ++#line 6415 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ++ ;} ++ break; ++ ++ case 435: ++#line 6418 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ++ ;} ++ break; ++ ++ case 436: ++#line 6424 "parser.y" ++ { ++ (yyval.dtype).val = NewString("delete"); ++ (yyval.dtype).rawval = 0; ++ (yyval.dtype).type = T_STRING; ++ (yyval.dtype).qualifier = 0; ++ (yyval.dtype).refqualifier = 0; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ ;} ++ break; ++ ++ case 437: ++#line 6439 "parser.y" ++ { ++ (yyval.dtype).val = NewString("default"); ++ (yyval.dtype).rawval = 0; ++ (yyval.dtype).type = T_STRING; ++ (yyval.dtype).qualifier = 0; ++ (yyval.dtype).refqualifier = 0; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ ;} ++ break; ++ ++ case 438: ++#line 6455 "parser.y" ++ { (yyval.id) = (yyvsp[(1) - (1)].id); ;} ++ break; ++ ++ case 439: ++#line 6456 "parser.y" ++ { (yyval.id) = (char *) 0;;} ++ break; ++ ++ case 444: ++#line 6475 "parser.y" ++ { ++ Setattr((yyvsp[(1) - (1)].node),"_last",(yyvsp[(1) - (1)].node)); ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 445: ++#line 6479 "parser.y" ++ { ++ Setattr((yyvsp[(1) - (2)].node),"_last",(yyvsp[(1) - (2)].node)); ++ set_comment((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].str)); ++ (yyval.node) = (yyvsp[(1) - (2)].node); ++ ;} ++ break; ++ ++ case 446: ++#line 6484 "parser.y" ++ { ++ if ((yyvsp[(3) - (3)].node)) { ++ set_nextSibling((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); ++ Setattr((yyvsp[(1) - (3)].node),"_last",Getattr((yyvsp[(3) - (3)].node),"_last")); ++ Setattr((yyvsp[(3) - (3)].node),"_last",NULL); ++ } else { ++ Setattr((yyvsp[(1) - (3)].node),"_last",(yyvsp[(1) - (3)].node)); ++ } ++ (yyval.node) = (yyvsp[(1) - (3)].node); ++ ;} ++ break; ++ ++ case 447: ++#line 6494 "parser.y" ++ { ++ if ((yyvsp[(4) - (4)].node)) { ++ set_nextSibling((yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); ++ Setattr((yyvsp[(1) - (4)].node),"_last",Getattr((yyvsp[(4) - (4)].node),"_last")); ++ Setattr((yyvsp[(4) - (4)].node),"_last",NULL); ++ } else { ++ Setattr((yyvsp[(1) - (4)].node),"_last",(yyvsp[(1) - (4)].node)); ++ } ++ set_comment((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].str)); ++ (yyval.node) = (yyvsp[(1) - (4)].node); ++ ;} ++ break; ++ ++ case 448: ++#line 6505 "parser.y" ++ { ++ (yyval.node) = 0; ++ ;} ++ break; ++ ++ case 449: ++#line 6510 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(2) - (3)].node); ++ ;} ++ break; ++ ++ case 450: ++#line 6515 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(1) - (1)].node); ++ ;} ++ break; ++ ++ case 451: ++#line 6518 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(2) - (2)].node); ++ set_comment((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].str)); ++ ;} ++ break; ++ ++ case 452: ++#line 6524 "parser.y" ++ { ++ SwigType *type = NewSwigType(T_INT); ++ (yyval.node) = new_node("enumitem"); ++ Setattr((yyval.node),"name",(yyvsp[(1) - (1)].id)); ++ Setattr((yyval.node),"type",type); ++ SetFlag((yyval.node),"feature:immutable"); ++ Delete(type); ++ ;} ++ break; ++ ++ case 453: ++#line 6532 "parser.y" ++ { ++ SwigType *type = NewSwigType((yyvsp[(3) - (3)].dtype).type == T_BOOL ? T_BOOL : ((yyvsp[(3) - (3)].dtype).type == T_CHAR ? T_CHAR : T_INT)); ++ (yyval.node) = new_node("enumitem"); ++ Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id)); ++ Setattr((yyval.node),"type",type); ++ SetFlag((yyval.node),"feature:immutable"); ++ Setattr((yyval.node),"enumvalue", (yyvsp[(3) - (3)].dtype).val); ++ Setattr((yyval.node),"value",(yyvsp[(1) - (3)].id)); ++ Delete(type); ++ ;} ++ break; ++ ++ case 454: ++#line 6544 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ++ if (((yyval.dtype).type != T_INT) && ((yyval.dtype).type != T_UINT) && ++ ((yyval.dtype).type != T_LONG) && ((yyval.dtype).type != T_ULONG) && ++ ((yyval.dtype).type != T_LONGLONG) && ((yyval.dtype).type != T_ULONGLONG) && ++ ((yyval.dtype).type != T_SHORT) && ((yyval.dtype).type != T_USHORT) && ++ ((yyval.dtype).type != T_SCHAR) && ((yyval.dtype).type != T_UCHAR) && ++ ((yyval.dtype).type != T_CHAR) && ((yyval.dtype).type != T_BOOL)) { ++ Swig_error(cparse_file,cparse_line,"Type error. Expecting an integral type\n"); ++ } ++ ;} ++ break; ++ ++ case 455: ++#line 6559 "parser.y" ++ { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;} ++ break; ++ ++ case 456: ++#line 6560 "parser.y" ++ { ++ Node *n; ++ (yyval.dtype).val = (yyvsp[(1) - (1)].type); ++ (yyval.dtype).type = T_INT; ++ /* Check if value is in scope */ ++ n = Swig_symbol_clookup((yyvsp[(1) - (1)].type),0); ++ if (n) { ++ /* A band-aid for enum values used in expressions. */ ++ if (Strcmp(nodeType(n),"enumitem") == 0) { ++ String *q = Swig_symbol_qualified(n); ++ if (q) { ++ (yyval.dtype).val = NewStringf("%s::%s", q, Getattr(n,"name")); ++ Delete(q); ++ } ++ } ++ } ++ ;} ++ break; ++ ++ case 457: ++#line 6580 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s->%s", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id)); ++ (yyval.dtype).type = 0; ++ ;} ++ break; ++ ++ case 458: ++#line 6584 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s->%s(%s)", (yyvsp[(1) - (6)].id), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].dtype).val); ++ (yyval.dtype).type = 0; ++ ;} ++ break; ++ ++ case 459: ++#line 6588 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (3)].dtype); ++ Printf((yyval.dtype).val, "->%s", (yyvsp[(3) - (3)].id)); ++ ;} ++ break; ++ ++ case 460: ++#line 6592 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (6)].dtype); ++ Printf((yyval.dtype).val, "->%s(%s)", (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].dtype).val); ++ ;} ++ break; ++ ++ case 461: ++#line 6596 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s.%s", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id)); ++ (yyval.dtype).type = 0; ++ ;} ++ break; ++ ++ case 462: ++#line 6600 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s.%s(%s)", (yyvsp[(1) - (6)].id), (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].dtype).val); ++ (yyval.dtype).type = 0; ++ ;} ++ break; ++ ++ case 463: ++#line 6604 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (3)].dtype); ++ Printf((yyval.dtype).val, ".%s", (yyvsp[(3) - (3)].id)); ++ ;} ++ break; ++ ++ case 464: ++#line 6608 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (6)].dtype); ++ Printf((yyval.dtype).val, ".%s(%s)", (yyvsp[(3) - (6)].id), (yyvsp[(5) - (6)].dtype).val); ++ ;} ++ break; ++ ++ case 465: ++#line 6615 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ++ ;} ++ break; ++ ++ case 466: ++#line 6618 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ++ ;} ++ break; ++ ++ case 467: ++#line 6621 "parser.y" ++ { ++ (yyval.dtype).val = (yyvsp[(1) - (1)].str); ++ (yyval.dtype).type = T_STRING; ++ ;} ++ break; ++ ++ case 468: ++#line 6625 "parser.y" ++ { ++ SwigType_push((yyvsp[(3) - (5)].type),(yyvsp[(4) - (5)].decl).type); ++ (yyval.dtype).val = NewStringf("sizeof(%s)",SwigType_str((yyvsp[(3) - (5)].type),0)); ++ (yyval.dtype).type = T_ULONG; ++ ;} ++ break; ++ ++ case 469: ++#line 6630 "parser.y" ++ { ++ SwigType_push((yyvsp[(4) - (6)].type),(yyvsp[(5) - (6)].decl).type); ++ (yyval.dtype).val = NewStringf("sizeof...(%s)",SwigType_str((yyvsp[(4) - (6)].type),0)); ++ (yyval.dtype).type = T_ULONG; ++ ;} ++ break; ++ ++ case 470: ++#line 6642 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("sizeof(%s)", (yyvsp[(3) - (4)].dtype).val); ++ (yyval.dtype).type = T_ULONG; ++ ;} ++ break; ++ ++ case 471: ++#line 6650 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("sizeof(%s)", (yyvsp[(2) - (2)].dtype).val); ++ (yyval.dtype).type = T_ULONG; ++ ;} ++ break; ++ ++ case 472: ++#line 6654 "parser.y" ++ { ++ (yyval.dtype).val = (yyvsp[(1) - (1)].str); ++ (yyval.dtype).rawval = NewStringf("L\"%s\"", (yyval.dtype).val); ++ (yyval.dtype).type = T_WSTRING; ++ ;} ++ break; ++ ++ case 473: ++#line 6659 "parser.y" ++ { ++ (yyval.dtype).val = NewString((yyvsp[(1) - (1)].str)); ++ if (Len((yyval.dtype).val)) { ++ (yyval.dtype).rawval = NewStringf("'%(escape)s'", (yyval.dtype).val); ++ } else { ++ (yyval.dtype).rawval = NewString("'\\0'"); ++ } ++ (yyval.dtype).type = T_CHAR; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ ;} ++ break; ++ ++ case 474: ++#line 6673 "parser.y" ++ { ++ (yyval.dtype).val = NewString((yyvsp[(1) - (1)].str)); ++ if (Len((yyval.dtype).val)) { ++ (yyval.dtype).rawval = NewStringf("L\'%s\'", (yyval.dtype).val); ++ } else { ++ (yyval.dtype).rawval = NewString("L'\\0'"); ++ } ++ (yyval.dtype).type = T_WCHAR; ++ (yyval.dtype).bitfield = 0; ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ ;} ++ break; ++ ++ case 475: ++#line 6690 "parser.y" ++ { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;} ++ break; ++ ++ case 476: ++#line 6691 "parser.y" ++ { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;} ++ break; ++ ++ case 477: ++#line 6694 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("(%s)",(yyvsp[(2) - (3)].dtype).val); ++ if ((yyvsp[(2) - (3)].dtype).rawval) { ++ (yyval.dtype).rawval = NewStringf("(%s)",(yyvsp[(2) - (3)].dtype).rawval); ++ } ++ (yyval.dtype).type = (yyvsp[(2) - (3)].dtype).type; ++ ;} ++ break; ++ ++ case 478: ++#line 6704 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(4) - (4)].dtype); ++ if ((yyvsp[(4) - (4)].dtype).type != T_STRING) { ++ switch ((yyvsp[(2) - (4)].dtype).type) { ++ case T_FLOAT: ++ case T_DOUBLE: ++ case T_LONGDOUBLE: ++ case T_FLTCPLX: ++ case T_DBLCPLX: ++ (yyval.dtype).val = NewStringf("(%s)%s", (yyvsp[(2) - (4)].dtype).val, (yyvsp[(4) - (4)].dtype).val); /* SwigType_str and decimal points don't mix! */ ++ break; ++ default: ++ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (4)].dtype).val,0), (yyvsp[(4) - (4)].dtype).val); ++ break; ++ } ++ } ++ (yyval.dtype).type = promote((yyvsp[(2) - (4)].dtype).type, (yyvsp[(4) - (4)].dtype).type); ++ ;} ++ break; ++ ++ case 479: ++#line 6722 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(5) - (5)].dtype); ++ if ((yyvsp[(5) - (5)].dtype).type != T_STRING) { ++ SwigType_push((yyvsp[(2) - (5)].dtype).val,(yyvsp[(3) - (5)].type)); ++ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (5)].dtype).val,0), (yyvsp[(5) - (5)].dtype).val); ++ } ++ ;} ++ break; ++ ++ case 480: ++#line 6729 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(5) - (5)].dtype); ++ if ((yyvsp[(5) - (5)].dtype).type != T_STRING) { ++ SwigType_add_reference((yyvsp[(2) - (5)].dtype).val); ++ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (5)].dtype).val,0), (yyvsp[(5) - (5)].dtype).val); ++ } ++ ;} ++ break; ++ ++ case 481: ++#line 6736 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(5) - (5)].dtype); ++ if ((yyvsp[(5) - (5)].dtype).type != T_STRING) { ++ SwigType_add_rvalue_reference((yyvsp[(2) - (5)].dtype).val); ++ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (5)].dtype).val,0), (yyvsp[(5) - (5)].dtype).val); ++ } ++ ;} ++ break; ++ ++ case 482: ++#line 6743 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(6) - (6)].dtype); ++ if ((yyvsp[(6) - (6)].dtype).type != T_STRING) { ++ SwigType_push((yyvsp[(2) - (6)].dtype).val,(yyvsp[(3) - (6)].type)); ++ SwigType_add_reference((yyvsp[(2) - (6)].dtype).val); ++ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (6)].dtype).val,0), (yyvsp[(6) - (6)].dtype).val); ++ } ++ ;} ++ break; ++ ++ case 483: ++#line 6751 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(6) - (6)].dtype); ++ if ((yyvsp[(6) - (6)].dtype).type != T_STRING) { ++ SwigType_push((yyvsp[(2) - (6)].dtype).val,(yyvsp[(3) - (6)].type)); ++ SwigType_add_rvalue_reference((yyvsp[(2) - (6)].dtype).val); ++ (yyval.dtype).val = NewStringf("(%s) %s", SwigType_str((yyvsp[(2) - (6)].dtype).val,0), (yyvsp[(6) - (6)].dtype).val); ++ } ++ ;} ++ break; ++ ++ case 484: ++#line 6759 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(2) - (2)].dtype); ++ (yyval.dtype).val = NewStringf("&%s",(yyvsp[(2) - (2)].dtype).val); ++ ;} ++ break; ++ ++ case 485: ++#line 6763 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(2) - (2)].dtype); ++ (yyval.dtype).val = NewStringf("*%s",(yyvsp[(2) - (2)].dtype).val); ++ ;} ++ break; ++ ++ case 486: ++#line 6769 "parser.y" ++ { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;} ++ break; ++ ++ case 487: ++#line 6770 "parser.y" ++ { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;} ++ break; ++ ++ case 488: ++#line 6771 "parser.y" ++ { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;} ++ break; ++ ++ case 489: ++#line 6772 "parser.y" ++ { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;} ++ break; ++ ++ case 490: ++#line 6773 "parser.y" ++ { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;} ++ break; ++ ++ case 491: ++#line 6774 "parser.y" ++ { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;} ++ break; ++ ++ case 492: ++#line 6775 "parser.y" ++ { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;} ++ break; ++ ++ case 493: ++#line 6776 "parser.y" ++ { (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ;} ++ break; ++ ++ case 494: ++#line 6779 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s+%s", COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); ++ ;} ++ break; ++ ++ case 495: ++#line 6783 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s-%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); ++ ;} ++ break; ++ ++ case 496: ++#line 6787 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s*%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); ++ ;} ++ break; ++ ++ case 497: ++#line 6791 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s/%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); ++ ;} ++ break; ++ ++ case 498: ++#line 6795 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s%%%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); ++ ;} ++ break; ++ ++ case 499: ++#line 6799 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s&%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); ++ ;} ++ break; ++ ++ case 500: ++#line 6803 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s|%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); ++ ;} ++ break; ++ ++ case 501: ++#line 6807 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s^%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = promote((yyvsp[(1) - (3)].dtype).type,(yyvsp[(3) - (3)].dtype).type); ++ ;} ++ break; ++ ++ case 502: ++#line 6811 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s << %s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = promote_type((yyvsp[(1) - (3)].dtype).type); ++ ;} ++ break; ++ ++ case 503: ++#line 6815 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s >> %s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = promote_type((yyvsp[(1) - (3)].dtype).type); ++ ;} ++ break; ++ ++ case 504: ++#line 6819 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s&&%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT; ++ ;} ++ break; ++ ++ case 505: ++#line 6823 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s||%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT; ++ ;} ++ break; ++ ++ case 506: ++#line 6827 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s==%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT; ++ ;} ++ break; ++ ++ case 507: ++#line 6831 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s!=%s",COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)),COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT; ++ ;} ++ break; ++ ++ case 508: ++#line 6839 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s > %s", COMPOUND_EXPR_VAL((yyvsp[(2) - (5)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(4) - (5)].dtype))); ++ (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT; ++ ;} ++ break; ++ ++ case 509: ++#line 6849 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s < %s", COMPOUND_EXPR_VAL((yyvsp[(2) - (5)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(4) - (5)].dtype))); ++ (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT; ++ ;} ++ break; ++ ++ case 510: ++#line 6853 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s >= %s", COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT; ++ ;} ++ break; ++ ++ case 511: ++#line 6857 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s <= %s", COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ (yyval.dtype).type = cparse_cplusplus ? T_BOOL : T_INT; ++ ;} ++ break; ++ ++ case 512: ++#line 6861 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s <=> %s", COMPOUND_EXPR_VAL((yyvsp[(1) - (3)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(3) - (3)].dtype))); ++ /* Really `<=>` returns one of `std::strong_ordering`, ++ * `std::partial_ordering` or `std::weak_ordering`, but we ++ * fake it by treating the return value as `int`. The main ++ * thing to do with the return value in this context is to ++ * compare it with 0, for which `int` does the job. */ ++ (yyval.dtype).type = T_INT; ++ ;} ++ break; ++ ++ case 513: ++#line 6870 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("%s?%s:%s", COMPOUND_EXPR_VAL((yyvsp[(1) - (5)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(3) - (5)].dtype)), COMPOUND_EXPR_VAL((yyvsp[(5) - (5)].dtype))); ++ /* This may not be exactly right, but is probably good enough ++ * for the purposes of parsing constant expressions. */ ++ (yyval.dtype).type = promote((yyvsp[(3) - (5)].dtype).type, (yyvsp[(5) - (5)].dtype).type); ++ ;} ++ break; ++ ++ case 514: ++#line 6876 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("-%s",(yyvsp[(2) - (2)].dtype).val); ++ (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type; ++ ;} ++ break; ++ ++ case 515: ++#line 6880 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("+%s",(yyvsp[(2) - (2)].dtype).val); ++ (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type; ++ ;} ++ break; ++ ++ case 516: ++#line 6884 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("~%s",(yyvsp[(2) - (2)].dtype).val); ++ (yyval.dtype).type = (yyvsp[(2) - (2)].dtype).type; ++ ;} ++ break; ++ ++ case 517: ++#line 6888 "parser.y" ++ { ++ (yyval.dtype).val = NewStringf("!%s",COMPOUND_EXPR_VAL((yyvsp[(2) - (2)].dtype))); ++ (yyval.dtype).type = T_INT; ++ ;} ++ break; ++ ++ case 518: ++#line 6892 "parser.y" ++ { ++ String *qty; ++ skip_balanced('(',')'); ++ qty = Swig_symbol_type_qualify((yyvsp[(1) - (2)].type),0); ++ if (SwigType_istemplate(qty)) { ++ String *nstr = SwigType_namestr(qty); ++ Delete(qty); ++ qty = nstr; ++ } ++ (yyval.dtype).val = NewStringf("%s%s",qty,scanner_ccode); ++ Clear(scanner_ccode); ++ (yyval.dtype).type = T_INT; ++ Delete(qty); ++ ;} ++ break; ++ ++ case 519: ++#line 6908 "parser.y" ++ { ++ (yyval.str) = NewString("..."); ++ ;} ++ break; ++ ++ case 520: ++#line 6911 "parser.y" ++ { ++ (yyval.str) = 0; ++ ;} ++ break; ++ ++ case 521: ++#line 6916 "parser.y" ++ { ++ (yyval.bases) = (yyvsp[(1) - (1)].bases); ++ ;} ++ break; ++ ++ case 522: ++#line 6921 "parser.y" ++ { inherit_list = 1; ;} ++ break; ++ ++ case 523: ++#line 6921 "parser.y" ++ { (yyval.bases) = (yyvsp[(3) - (3)].bases); inherit_list = 0; ;} ++ break; ++ ++ case 524: ++#line 6922 "parser.y" ++ { (yyval.bases) = 0; ;} ++ break; ++ ++ case 525: ++#line 6925 "parser.y" ++ { ++ Hash *list = NewHash(); ++ Node *base = (yyvsp[(1) - (1)].node); ++ Node *name = Getattr(base,"name"); ++ List *lpublic = NewList(); ++ List *lprotected = NewList(); ++ List *lprivate = NewList(); ++ Setattr(list,"public",lpublic); ++ Setattr(list,"protected",lprotected); ++ Setattr(list,"private",lprivate); ++ Delete(lpublic); ++ Delete(lprotected); ++ Delete(lprivate); ++ Append(Getattr(list,Getattr(base,"access")),name); ++ (yyval.bases) = list; ++ ;} ++ break; ++ ++ case 526: ++#line 6942 "parser.y" ++ { ++ Hash *list = (yyvsp[(1) - (3)].bases); ++ Node *base = (yyvsp[(3) - (3)].node); ++ Node *name = Getattr(base,"name"); ++ Append(Getattr(list,Getattr(base,"access")),name); ++ (yyval.bases) = list; ++ ;} ++ break; ++ ++ case 527: ++#line 6951 "parser.y" ++ { ++ (yyval.intvalue) = cparse_line; ++ ;} ++ break; ++ ++ case 528: ++#line 6953 "parser.y" ++ { ++ (yyval.node) = NewHash(); ++ Setfile((yyval.node),cparse_file); ++ Setline((yyval.node),(yyvsp[(2) - (4)].intvalue)); ++ Setattr((yyval.node),"name",(yyvsp[(3) - (4)].str)); ++ Setfile((yyvsp[(3) - (4)].str),cparse_file); ++ Setline((yyvsp[(3) - (4)].str),(yyvsp[(2) - (4)].intvalue)); ++ if (last_cpptype && (Strcmp(last_cpptype,"struct") != 0)) { ++ Setattr((yyval.node),"access","private"); ++ Swig_warning(WARN_PARSE_NO_ACCESS, Getfile((yyval.node)), Getline((yyval.node)), "No access specifier given for base class '%s' (ignored).\n", SwigType_namestr((yyvsp[(3) - (4)].str))); ++ } else { ++ Setattr((yyval.node),"access","public"); ++ } ++ if ((yyvsp[(4) - (4)].str)) ++ SetFlag((yyval.node), "variadic"); ++ ;} ++ break; ++ ++ case 529: ++#line 6969 "parser.y" ++ { ++ (yyval.intvalue) = cparse_line; ++ ;} ++ break; ++ ++ case 530: ++#line 6971 "parser.y" ++ { ++ (yyval.node) = NewHash(); ++ Setfile((yyval.node),cparse_file); ++ Setline((yyval.node),(yyvsp[(3) - (6)].intvalue)); ++ Setattr((yyval.node),"name",(yyvsp[(5) - (6)].str)); ++ Setfile((yyvsp[(5) - (6)].str),cparse_file); ++ Setline((yyvsp[(5) - (6)].str),(yyvsp[(3) - (6)].intvalue)); ++ Setattr((yyval.node),"access",(yyvsp[(2) - (6)].id)); ++ if (Strcmp((yyvsp[(2) - (6)].id),"public") != 0) { ++ Swig_warning(WARN_PARSE_PRIVATE_INHERIT, Getfile((yyval.node)), Getline((yyval.node)), "%s inheritance from base '%s' (ignored).\n", (yyvsp[(2) - (6)].id), SwigType_namestr((yyvsp[(5) - (6)].str))); ++ } ++ if ((yyvsp[(6) - (6)].str)) ++ SetFlag((yyval.node), "variadic"); ++ ;} ++ break; ++ ++ case 531: ++#line 6987 "parser.y" ++ { (yyval.id) = (char*)"public"; ;} ++ break; ++ ++ case 532: ++#line 6988 "parser.y" ++ { (yyval.id) = (char*)"private"; ;} ++ break; ++ ++ case 533: ++#line 6989 "parser.y" ++ { (yyval.id) = (char*)"protected"; ;} ++ break; ++ ++ case 534: ++#line 6992 "parser.y" ++ { ++ (yyval.id) = (char*)"class"; ++ if (!inherit_list) last_cpptype = (yyval.id); ++ ;} ++ break; ++ ++ case 535: ++#line 6996 "parser.y" ++ { ++ (yyval.id) = (char *)"typename"; ++ if (!inherit_list) last_cpptype = (yyval.id); ++ ;} ++ break; ++ ++ case 536: ++#line 7000 "parser.y" ++ { ++ (yyval.id) = (char *)"class..."; ++ if (!inherit_list) last_cpptype = (yyval.id); ++ ;} ++ break; ++ ++ case 537: ++#line 7004 "parser.y" ++ { ++ (yyval.id) = (char *)"typename..."; ++ if (!inherit_list) last_cpptype = (yyval.id); ++ ;} ++ break; ++ ++ case 538: ++#line 7010 "parser.y" ++ { ++ (yyval.id) = (yyvsp[(1) - (1)].id); ++ ;} ++ break; ++ ++ case 539: ++#line 7013 "parser.y" ++ { ++ (yyval.id) = (char*)"struct"; ++ if (!inherit_list) last_cpptype = (yyval.id); ++ ;} ++ break; ++ ++ case 540: ++#line 7017 "parser.y" ++ { ++ (yyval.id) = (char*)"union"; ++ if (!inherit_list) last_cpptype = (yyval.id); ++ ;} ++ break; ++ ++ case 541: ++#line 7023 "parser.y" ++ { ++ (yyval.id) = (char*)"class"; ++ if (!inherit_list) last_cpptype = (yyval.id); ++ ;} ++ break; ++ ++ case 542: ++#line 7027 "parser.y" ++ { ++ (yyval.id) = (char*)"struct"; ++ if (!inherit_list) last_cpptype = (yyval.id); ++ ;} ++ break; ++ ++ case 543: ++#line 7031 "parser.y" ++ { ++ (yyval.id) = (char*)"union"; ++ if (!inherit_list) last_cpptype = (yyval.id); ++ ;} ++ break; ++ ++ case 544: ++#line 7037 "parser.y" ++ { ++ (yyval.id) = (yyvsp[(1) - (1)].id); ++ ;} ++ break; ++ ++ case 545: ++#line 7040 "parser.y" ++ { ++ (yyval.id) = 0; ++ ;} ++ break; ++ ++ case 548: ++#line 7049 "parser.y" ++ { ++ (yyval.str) = 0; ++ ;} ++ break; ++ ++ case 549: ++#line 7052 "parser.y" ++ { ++ (yyval.str) = NewString("1"); ++ ;} ++ break; ++ ++ case 550: ++#line 7055 "parser.y" ++ { ++ (yyval.str) = NewString("1"); ++ ;} ++ break; ++ ++ case 551: ++#line 7058 "parser.y" ++ { ++ (yyval.str) = NewString("1"); ++ ;} ++ break; ++ ++ case 552: ++#line 7063 "parser.y" ++ { ++ (yyval.str) = (yyvsp[(1) - (1)].str); ++ ;} ++ break; ++ ++ case 553: ++#line 7066 "parser.y" ++ { ++ (yyval.str) = 0; ++ ;} ++ break; ++ ++ case 554: ++#line 7071 "parser.y" ++ { ++ (yyval.str) = NewString("1"); ++ ;} ++ break; ++ ++ case 555: ++#line 7074 "parser.y" ++ { ++ (yyval.str) = 0; ++ ;} ++ break; ++ ++ case 556: ++#line 7079 "parser.y" ++ { ++ (yyval.dtype).throws = (yyvsp[(3) - (4)].pl); ++ (yyval.dtype).throwf = NewString("1"); ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ ;} ++ break; ++ ++ case 557: ++#line 7085 "parser.y" ++ { ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = NewString("true"); ++ (yyval.dtype).final = 0; ++ ;} ++ break; ++ ++ case 558: ++#line 7091 "parser.y" ++ { ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = (yyvsp[(1) - (1)].str); ++ ;} ++ break; ++ ++ case 559: ++#line 7097 "parser.y" ++ { ++ (yyval.dtype).throws = (yyvsp[(3) - (5)].pl); ++ (yyval.dtype).throwf = NewString("1"); ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = (yyvsp[(5) - (5)].str); ++ ;} ++ break; ++ ++ case 560: ++#line 7103 "parser.y" ++ { ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = NewString("true"); ++ (yyval.dtype).final = (yyvsp[(2) - (2)].str); ++ ;} ++ break; ++ ++ case 561: ++#line 7109 "parser.y" ++ { ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = (yyvsp[(3) - (4)].dtype).val; ++ (yyval.dtype).final = 0; ++ ;} ++ break; ++ ++ case 562: ++#line 7117 "parser.y" ++ { ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ (yyval.dtype).qualifier = (yyvsp[(1) - (1)].dtype).qualifier; ++ (yyval.dtype).refqualifier = (yyvsp[(1) - (1)].dtype).refqualifier; ++ ;} ++ break; ++ ++ case 563: ++#line 7125 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ++ (yyval.dtype).qualifier = 0; ++ (yyval.dtype).refqualifier = 0; ++ ;} ++ break; ++ ++ case 564: ++#line 7130 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(2) - (2)].dtype); ++ (yyval.dtype).qualifier = (yyvsp[(1) - (2)].dtype).qualifier; ++ (yyval.dtype).refqualifier = (yyvsp[(1) - (2)].dtype).refqualifier; ++ ;} ++ break; ++ ++ case 565: ++#line 7137 "parser.y" ++ { ++ (yyval.dtype) = (yyvsp[(1) - (1)].dtype); ++ ;} ++ break; ++ ++ case 566: ++#line 7140 "parser.y" ++ { ++ (yyval.dtype).throws = 0; ++ (yyval.dtype).throwf = 0; ++ (yyval.dtype).nexcept = 0; ++ (yyval.dtype).final = 0; ++ (yyval.dtype).qualifier = 0; ++ (yyval.dtype).refqualifier = 0; ++ ;} ++ break; ++ ++ case 567: ++#line 7150 "parser.y" ++ { ++ Clear(scanner_ccode); ++ (yyval.decl).have_parms = 0; ++ (yyval.decl).defarg = 0; ++ (yyval.decl).throws = (yyvsp[(1) - (3)].dtype).throws; ++ (yyval.decl).throwf = (yyvsp[(1) - (3)].dtype).throwf; ++ (yyval.decl).nexcept = (yyvsp[(1) - (3)].dtype).nexcept; ++ (yyval.decl).final = (yyvsp[(1) - (3)].dtype).final; ++ if ((yyvsp[(1) - (3)].dtype).qualifier) ++ Swig_error(cparse_file, cparse_line, "Constructor cannot have a qualifier.\n"); ++ ;} ++ break; ++ ++ case 568: ++#line 7161 "parser.y" ++ { ++ skip_balanced('{','}'); ++ (yyval.decl).have_parms = 0; ++ (yyval.decl).defarg = 0; ++ (yyval.decl).throws = (yyvsp[(1) - (3)].dtype).throws; ++ (yyval.decl).throwf = (yyvsp[(1) - (3)].dtype).throwf; ++ (yyval.decl).nexcept = (yyvsp[(1) - (3)].dtype).nexcept; ++ (yyval.decl).final = (yyvsp[(1) - (3)].dtype).final; ++ if ((yyvsp[(1) - (3)].dtype).qualifier) ++ Swig_error(cparse_file, cparse_line, "Constructor cannot have a qualifier.\n"); ++ ;} ++ break; ++ ++ case 569: ++#line 7172 "parser.y" ++ { ++ Clear(scanner_ccode); ++ (yyval.decl).parms = (yyvsp[(2) - (4)].pl); ++ (yyval.decl).have_parms = 1; ++ (yyval.decl).defarg = 0; ++ (yyval.decl).throws = 0; ++ (yyval.decl).throwf = 0; ++ (yyval.decl).nexcept = 0; ++ (yyval.decl).final = 0; ++ ;} ++ break; ++ ++ case 570: ++#line 7182 "parser.y" ++ { ++ skip_balanced('{','}'); ++ (yyval.decl).parms = (yyvsp[(2) - (4)].pl); ++ (yyval.decl).have_parms = 1; ++ (yyval.decl).defarg = 0; ++ (yyval.decl).throws = 0; ++ (yyval.decl).throwf = 0; ++ (yyval.decl).nexcept = 0; ++ (yyval.decl).final = 0; ++ ;} ++ break; ++ ++ case 571: ++#line 7192 "parser.y" ++ { ++ (yyval.decl).have_parms = 0; ++ (yyval.decl).defarg = (yyvsp[(2) - (3)].dtype).val; ++ (yyval.decl).throws = 0; ++ (yyval.decl).throwf = 0; ++ (yyval.decl).nexcept = 0; ++ (yyval.decl).final = 0; ++ ;} ++ break; ++ ++ case 572: ++#line 7200 "parser.y" ++ { ++ (yyval.decl).have_parms = 0; ++ (yyval.decl).defarg = (yyvsp[(3) - (4)].dtype).val; ++ (yyval.decl).throws = (yyvsp[(1) - (4)].dtype).throws; ++ (yyval.decl).throwf = (yyvsp[(1) - (4)].dtype).throwf; ++ (yyval.decl).nexcept = (yyvsp[(1) - (4)].dtype).nexcept; ++ (yyval.decl).final = (yyvsp[(1) - (4)].dtype).final; ++ if ((yyvsp[(1) - (4)].dtype).qualifier) ++ Swig_error(cparse_file, cparse_line, "Constructor cannot have a qualifier.\n"); ++ ;} ++ break; ++ ++ case 579: ++#line 7222 "parser.y" ++ { ++ skip_balanced('(',')'); ++ Clear(scanner_ccode); ++ ;} ++ break; ++ ++ case 580: ++#line 7234 "parser.y" ++ { ++ skip_balanced('{','}'); ++ Clear(scanner_ccode); ++ ;} ++ break; ++ ++ case 581: ++#line 7240 "parser.y" ++ { ++ String *s = NewStringEmpty(); ++ SwigType_add_template(s,(yyvsp[(2) - (3)].p)); ++ (yyval.id) = Char(s); ++ scanner_last_id(1); ++ ;} ++ break; ++ ++ case 582: ++#line 7249 "parser.y" ++ { (yyval.id) = (yyvsp[(1) - (1)].id); ;} ++ break; ++ ++ case 583: ++#line 7250 "parser.y" ++ { (yyval.id) = Swig_copy_string("override"); ;} ++ break; ++ ++ case 584: ++#line 7251 "parser.y" ++ { (yyval.id) = Swig_copy_string("final"); ;} ++ break; ++ ++ case 585: ++#line 7254 "parser.y" ++ { (yyval.id) = (yyvsp[(1) - (1)].id); ;} ++ break; ++ ++ case 586: ++#line 7255 "parser.y" ++ { (yyval.id) = Char((yyvsp[(1) - (1)].dtype).val); ;} ++ break; ++ ++ case 587: ++#line 7256 "parser.y" ++ { (yyval.id) = Char((yyvsp[(1) - (1)].str)); ;} ++ break; ++ ++ case 588: ++#line 7259 "parser.y" ++ { (yyval.id) = (yyvsp[(1) - (1)].id); ;} ++ break; ++ ++ case 589: ++#line 7260 "parser.y" ++ { (yyval.id) = 0; ;} ++ break; ++ ++ case 590: ++#line 7263 "parser.y" ++ { ++ (yyval.str) = 0; ++ if (!(yyval.str)) (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].str),(yyvsp[(2) - (2)].str)); ++ Delete((yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 591: ++#line 7268 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s%s",(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].str)); ++ Delete((yyvsp[(4) - (4)].str)); ++ ;} ++ break; ++ ++ case 592: ++#line 7272 "parser.y" ++ { ++ (yyval.str) = NewString((yyvsp[(1) - (1)].str)); ++ ;} ++ break; ++ ++ case 593: ++#line 7275 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str)); ++ ;} ++ break; ++ ++ case 594: ++#line 7278 "parser.y" ++ { ++ (yyval.str) = NewStringf("%s", (yyvsp[(1) - (1)].str)); ++ ;} ++ break; ++ ++ case 595: ++#line 7281 "parser.y" ++ { ++ (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].id)); ++ ;} ++ break; ++ ++ case 596: ++#line 7284 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str)); ++ ;} ++ break; ++ ++ case 597: ++#line 7289 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s%s",(yyvsp[(2) - (3)].str),(yyvsp[(3) - (3)].str)); ++ Delete((yyvsp[(3) - (3)].str)); ++ ;} ++ break; ++ ++ case 598: ++#line 7293 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 599: ++#line 7296 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 600: ++#line 7303 "parser.y" ++ { ++ (yyval.str) = NewStringf("::~%s",(yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 601: ++#line 7309 "parser.y" ++ { ++ (yyval.str) = NewStringf("%s", (yyvsp[(1) - (1)].id)); ++ ;} ++ break; ++ ++ case 602: ++#line 7312 "parser.y" ++ { ++ (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].id), (yyvsp[(2) - (2)].id)); ++ ;} ++ break; ++ ++ case 603: ++#line 7317 "parser.y" ++ { ++ (yyval.str) = (yyvsp[(1) - (1)].str); ++ ;} ++ break; ++ ++ case 604: ++#line 7320 "parser.y" ++ { ++ (yyval.str) = NewStringf("%s%s", (yyvsp[(2) - (3)].id), (yyvsp[(3) - (3)].id)); ++ ;} ++ break; ++ ++ case 605: ++#line 7326 "parser.y" ++ { ++ (yyval.str) = 0; ++ if (!(yyval.str)) (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].id),(yyvsp[(2) - (2)].str)); ++ Delete((yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 606: ++#line 7331 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s%s",(yyvsp[(3) - (4)].id),(yyvsp[(4) - (4)].str)); ++ Delete((yyvsp[(4) - (4)].str)); ++ ;} ++ break; ++ ++ case 607: ++#line 7335 "parser.y" ++ { ++ (yyval.str) = NewString((yyvsp[(1) - (1)].id)); ++ ;} ++ break; ++ ++ case 608: ++#line 7338 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].id)); ++ ;} ++ break; ++ ++ case 609: ++#line 7341 "parser.y" ++ { ++ (yyval.str) = NewString((yyvsp[(1) - (1)].str)); ++ ;} ++ break; ++ ++ case 610: ++#line 7344 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s",(yyvsp[(3) - (3)].str)); ++ ;} ++ break; ++ ++ case 611: ++#line 7349 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s%s",(yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].str)); ++ Delete((yyvsp[(3) - (3)].str)); ++ ;} ++ break; ++ ++ case 612: ++#line 7353 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].id)); ++ ;} ++ break; ++ ++ case 613: ++#line 7356 "parser.y" ++ { ++ (yyval.str) = NewStringf("::%s",(yyvsp[(2) - (2)].str)); ++ ;} ++ break; ++ ++ case 614: ++#line 7359 "parser.y" ++ { ++ (yyval.str) = NewStringf("::~%s",(yyvsp[(2) - (2)].id)); ++ ;} ++ break; ++ ++ case 615: ++#line 7365 "parser.y" ++ { ++ (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].id)); ++ ;} ++ break; ++ ++ case 616: ++#line 7368 "parser.y" ++ { (yyval.str) = NewString((yyvsp[(1) - (1)].id));;} ++ break; ++ ++ case 617: ++#line 7371 "parser.y" ++ { ++ (yyval.str) = NewStringf("%s%s", (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].id)); ++ ;} ++ break; ++ ++ case 618: ++#line 7379 "parser.y" ++ { (yyval.str) = NewString((yyvsp[(1) - (1)].id));;} ++ break; ++ ++ case 619: ++#line 7382 "parser.y" ++ { ++ (yyval.str) = (yyvsp[(1) - (1)].str); ++ ;} ++ break; ++ ++ case 620: ++#line 7385 "parser.y" ++ { ++ skip_balanced('{','}'); ++ (yyval.str) = NewString(scanner_ccode); ++ ;} ++ break; ++ ++ case 621: ++#line 7389 "parser.y" ++ { ++ (yyval.str) = (yyvsp[(1) - (1)].str); ++ ;} ++ break; ++ ++ case 622: ++#line 7394 "parser.y" ++ { ++ Hash *n; ++ (yyval.node) = NewHash(); ++ n = (yyvsp[(2) - (3)].node); ++ while(n) { ++ String *name, *value; ++ name = Getattr(n,"name"); ++ value = Getattr(n,"value"); ++ if (!value) value = (String *) "1"; ++ Setattr((yyval.node),name, value); ++ n = nextSibling(n); ++ } ++ ;} ++ break; ++ ++ case 623: ++#line 7407 "parser.y" ++ { (yyval.node) = 0; ;} ++ break; ++ ++ case 624: ++#line 7411 "parser.y" ++ { ++ (yyval.node) = NewHash(); ++ Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id)); ++ Setattr((yyval.node),"value",(yyvsp[(3) - (3)].str)); ++ ;} ++ break; ++ ++ case 625: ++#line 7416 "parser.y" ++ { ++ (yyval.node) = NewHash(); ++ Setattr((yyval.node),"name",(yyvsp[(1) - (5)].id)); ++ Setattr((yyval.node),"value",(yyvsp[(3) - (5)].str)); ++ set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node)); ++ ;} ++ break; ++ ++ case 626: ++#line 7422 "parser.y" ++ { ++ (yyval.node) = NewHash(); ++ Setattr((yyval.node),"name",(yyvsp[(1) - (1)].id)); ++ ;} ++ break; ++ ++ case 627: ++#line 7426 "parser.y" ++ { ++ (yyval.node) = NewHash(); ++ Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id)); ++ set_nextSibling((yyval.node),(yyvsp[(3) - (3)].node)); ++ ;} ++ break; ++ ++ case 628: ++#line 7431 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(3) - (3)].node); ++ Setattr((yyval.node),"name",(yyvsp[(1) - (3)].id)); ++ ;} ++ break; ++ ++ case 629: ++#line 7435 "parser.y" ++ { ++ (yyval.node) = (yyvsp[(3) - (5)].node); ++ Setattr((yyval.node),"name",(yyvsp[(1) - (5)].id)); ++ set_nextSibling((yyval.node),(yyvsp[(5) - (5)].node)); ++ ;} ++ break; ++ ++ case 630: ++#line 7442 "parser.y" ++ { ++ (yyval.str) = (yyvsp[(1) - (1)].str); ++ ;} ++ break; ++ ++ case 631: ++#line 7445 "parser.y" ++ { ++ (yyval.str) = Char((yyvsp[(1) - (1)].dtype).val); ++ ;} ++ break; ++ ++ ++/* Line 1267 of yacc.c. */ ++#line 12845 "parser.c" ++ default: break; ++ } ++ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); ++ ++ YYPOPSTACK (yylen); ++ yylen = 0; ++ 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 ++ yyerror (YY_("syntax error")); ++#else ++ { ++ YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); ++ if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) ++ { ++ YYSIZE_T yyalloc = 2 * yysize; ++ if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) ++ yyalloc = YYSTACK_ALLOC_MAXIMUM; ++ if (yymsg != yymsgbuf) ++ YYSTACK_FREE (yymsg); ++ yymsg = (char *) YYSTACK_ALLOC (yyalloc); ++ if (yymsg) ++ yymsg_alloc = yyalloc; ++ else ++ { ++ yymsg = yymsgbuf; ++ yymsg_alloc = sizeof yymsgbuf; ++ } ++ } ++ ++ if (0 < yysize && yysize <= yymsg_alloc) ++ { ++ (void) yysyntax_error (yymsg, yystate, yychar); ++ yyerror (yymsg); ++ } ++ else ++ { ++ yyerror (YY_("syntax error")); ++ if (yysize != 0) ++ goto yyexhaustedlab; ++ } ++ } ++#endif ++ } ++ ++ ++ ++ if (yyerrstatus == 3) ++ { ++ /* If just tried and failed to reuse look-ahead token after an ++ error, discard it. */ ++ ++ if (yychar <= YYEOF) ++ { ++ /* Return failure if at end of input. */ ++ if (yychar == YYEOF) ++ YYABORT; ++ } ++ 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: ++ ++ /* Pacify compilers like GCC when the user code never invokes ++ YYERROR and the label yyerrorlab therefore never appears in user ++ code. */ ++ if (/*CONSTCOND*/ 0) ++ goto yyerrorlab; ++ ++ /* Do not reclaim the symbols of the rule which action triggered ++ this YYERROR. */ ++ YYPOPSTACK (yylen); ++ yylen = 0; ++ YY_STACK_PRINT (yyss, yyssp); ++ 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 (1); ++ 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: ++ yyresult = 1; ++ goto yyreturn; ++ ++#ifndef yyoverflow ++/*-------------------------------------------------. ++| yyexhaustedlab -- memory exhaustion comes here. | ++`-------------------------------------------------*/ ++yyexhaustedlab: ++ yyerror (YY_("memory exhausted")); ++ yyresult = 2; ++ /* Fall through. */ ++#endif ++ ++yyreturn: ++ if (yychar != YYEOF && yychar != YYEMPTY) ++ yydestruct ("Cleanup: discarding lookahead", ++ yytoken, &yylval); ++ /* Do not reclaim the symbols of the rule which action triggered ++ this YYABORT or YYACCEPT. */ ++ YYPOPSTACK (yylen); ++ YY_STACK_PRINT (yyss, yyssp); ++ while (yyssp != yyss) ++ { ++ yydestruct ("Cleanup: popping", ++ yystos[*yyssp], yyvsp); ++ YYPOPSTACK (1); ++ } ++#ifndef yyoverflow ++ if (yyss != yyssa) ++ YYSTACK_FREE (yyss); ++#endif ++#if YYERROR_VERBOSE ++ if (yymsg != yymsgbuf) ++ YYSTACK_FREE (yymsg); ++#endif ++ /* Make sure YYID is used. */ ++ return YYID (yyresult); ++} ++ ++ ++#line 7452 "parser.y" ++ ++ ++SwigType *Swig_cparse_type(String *s) { ++ String *ns; ++ ns = NewStringf("%s;",s); ++ Seek(ns,0,SEEK_SET); ++ scanner_file(ns); ++ top = 0; ++ scanner_next_token(PARSETYPE); ++ yyparse(); ++ /* Printf(stdout,"typeparse: '%s' ---> '%s'\n", s, top); */ ++ return top; ++} ++ ++ ++Parm *Swig_cparse_parm(String *s) { ++ String *ns; ++ ns = NewStringf("%s;",s); ++ Seek(ns,0,SEEK_SET); ++ scanner_file(ns); ++ top = 0; ++ scanner_next_token(PARSEPARM); ++ yyparse(); ++ /* Printf(stdout,"typeparse: '%s' ---> '%s'\n", s, top); */ ++ Delete(ns); ++ return top; ++} ++ ++ ++ParmList *Swig_cparse_parms(String *s, Node *file_line_node) { ++ String *ns; ++ char *cs = Char(s); ++ if (cs && cs[0] != '(') { ++ ns = NewStringf("(%s);",s); ++ } else { ++ ns = NewStringf("%s;",s); ++ } ++ Setfile(ns, Getfile(file_line_node)); ++ Setline(ns, Getline(file_line_node)); ++ Seek(ns,0,SEEK_SET); ++ scanner_file(ns); ++ top = 0; ++ scanner_next_token(PARSEPARMS); ++ yyparse(); ++ /* Printf(stdout,"typeparse: '%s' ---> '%s'\n", s, top); */ ++ return top; ++} ++ ++ +diff --git a/Source/CParse/parser.h b/Source/CParse/parser.h +new file mode 100644 +index 000000000..6e1da8516 +--- /dev/null ++++ b/Source/CParse/parser.h +@@ -0,0 +1,394 @@ ++/* A Bison parser, made by GNU Bison 2.3. */ ++ ++/* Skeleton interface for Bison's Yacc-like parsers in C ++ ++ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 ++ 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., 51 Franklin Street, Fifth Floor, ++ Boston, MA 02110-1301, USA. */ ++ ++/* As a special exception, you may create a larger work that contains ++ part or all of the Bison parser skeleton and distribute that work ++ under terms of your choice, so long as that work isn't itself a ++ parser generator using the skeleton or a modified version thereof ++ as a parser skeleton. Alternatively, if you modify or redistribute ++ the parser skeleton itself, you may (at your option) remove this ++ special exception, which will cause the skeleton and the resulting ++ Bison output files to be licensed under the GNU General Public ++ License without this special exception. ++ ++ This special exception was added by the Free Software Foundation in ++ version 2.2 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 { ++ END = 0, ++ ID = 258, ++ HBLOCK = 259, ++ POUND = 260, ++ STRING = 261, ++ WSTRING = 262, ++ INCLUDE = 263, ++ IMPORT = 264, ++ INSERT = 265, ++ CHARCONST = 266, ++ WCHARCONST = 267, ++ NUM_INT = 268, ++ NUM_FLOAT = 269, ++ NUM_UNSIGNED = 270, ++ NUM_LONG = 271, ++ NUM_ULONG = 272, ++ NUM_LONGLONG = 273, ++ NUM_ULONGLONG = 274, ++ NUM_BOOL = 275, ++ TYPEDEF = 276, ++ TYPE_INT = 277, ++ TYPE_UNSIGNED = 278, ++ TYPE_SHORT = 279, ++ TYPE_LONG = 280, ++ TYPE_FLOAT = 281, ++ TYPE_DOUBLE = 282, ++ TYPE_CHAR = 283, ++ TYPE_WCHAR = 284, ++ TYPE_VOID = 285, ++ TYPE_SIGNED = 286, ++ TYPE_BOOL = 287, ++ TYPE_COMPLEX = 288, ++ TYPE_TYPEDEF = 289, ++ TYPE_RAW = 290, ++ TYPE_NON_ISO_INT8 = 291, ++ TYPE_NON_ISO_INT16 = 292, ++ TYPE_NON_ISO_INT32 = 293, ++ TYPE_NON_ISO_INT64 = 294, ++ LPAREN = 295, ++ RPAREN = 296, ++ COMMA = 297, ++ SEMI = 298, ++ EXTERN = 299, ++ INIT = 300, ++ LBRACE = 301, ++ RBRACE = 302, ++ PERIOD = 303, ++ ELLIPSIS = 304, ++ CONST_QUAL = 305, ++ VOLATILE = 306, ++ REGISTER = 307, ++ STRUCT = 308, ++ UNION = 309, ++ EQUAL = 310, ++ SIZEOF = 311, ++ MODULE = 312, ++ LBRACKET = 313, ++ RBRACKET = 314, ++ BEGINFILE = 315, ++ ENDOFFILE = 316, ++ ILLEGAL = 317, ++ CONSTANT = 318, ++ NAME = 319, ++ RENAME = 320, ++ NAMEWARN = 321, ++ EXTEND = 322, ++ PRAGMA = 323, ++ FEATURE = 324, ++ VARARGS = 325, ++ ENUM = 326, ++ CLASS = 327, ++ TYPENAME = 328, ++ PRIVATE = 329, ++ PUBLIC = 330, ++ PROTECTED = 331, ++ COLON = 332, ++ STATIC = 333, ++ VIRTUAL = 334, ++ FRIEND = 335, ++ THROW = 336, ++ CATCH = 337, ++ EXPLICIT = 338, ++ STATIC_ASSERT = 339, ++ CONSTEXPR = 340, ++ THREAD_LOCAL = 341, ++ DECLTYPE = 342, ++ AUTO = 343, ++ NOEXCEPT = 344, ++ OVERRIDE = 345, ++ FINAL = 346, ++ USING = 347, ++ NAMESPACE = 348, ++ NATIVE = 349, ++ INLINE = 350, ++ TYPEMAP = 351, ++ EXCEPT = 352, ++ ECHO = 353, ++ APPLY = 354, ++ CLEAR = 355, ++ SWIGTEMPLATE = 356, ++ FRAGMENT = 357, ++ WARN = 358, ++ LESSTHAN = 359, ++ GREATERTHAN = 360, ++ DELETE_KW = 361, ++ DEFAULT = 362, ++ LESSTHANOREQUALTO = 363, ++ GREATERTHANOREQUALTO = 364, ++ EQUALTO = 365, ++ NOTEQUALTO = 366, ++ LESSEQUALGREATER = 367, ++ ARROW = 368, ++ QUESTIONMARK = 369, ++ TYPES = 370, ++ PARMS = 371, ++ NONID = 372, ++ DSTAR = 373, ++ DCNOT = 374, ++ TEMPLATE = 375, ++ OPERATOR = 376, ++ CONVERSIONOPERATOR = 377, ++ PARSETYPE = 378, ++ PARSEPARM = 379, ++ PARSEPARMS = 380, ++ DOXYGENSTRING = 381, ++ DOXYGENPOSTSTRING = 382, ++ CAST = 383, ++ LOR = 384, ++ LAND = 385, ++ OR = 386, ++ XOR = 387, ++ AND = 388, ++ RSHIFT = 389, ++ LSHIFT = 390, ++ MINUS = 391, ++ PLUS = 392, ++ MODULO = 393, ++ SLASH = 394, ++ STAR = 395, ++ LNOT = 396, ++ NOT = 397, ++ UMINUS = 398, ++ DCOLON = 399 ++ }; ++#endif ++/* Tokens. */ ++#define END 0 ++#define ID 258 ++#define HBLOCK 259 ++#define POUND 260 ++#define STRING 261 ++#define WSTRING 262 ++#define INCLUDE 263 ++#define IMPORT 264 ++#define INSERT 265 ++#define CHARCONST 266 ++#define WCHARCONST 267 ++#define NUM_INT 268 ++#define NUM_FLOAT 269 ++#define NUM_UNSIGNED 270 ++#define NUM_LONG 271 ++#define NUM_ULONG 272 ++#define NUM_LONGLONG 273 ++#define NUM_ULONGLONG 274 ++#define NUM_BOOL 275 ++#define TYPEDEF 276 ++#define TYPE_INT 277 ++#define TYPE_UNSIGNED 278 ++#define TYPE_SHORT 279 ++#define TYPE_LONG 280 ++#define TYPE_FLOAT 281 ++#define TYPE_DOUBLE 282 ++#define TYPE_CHAR 283 ++#define TYPE_WCHAR 284 ++#define TYPE_VOID 285 ++#define TYPE_SIGNED 286 ++#define TYPE_BOOL 287 ++#define TYPE_COMPLEX 288 ++#define TYPE_TYPEDEF 289 ++#define TYPE_RAW 290 ++#define TYPE_NON_ISO_INT8 291 ++#define TYPE_NON_ISO_INT16 292 ++#define TYPE_NON_ISO_INT32 293 ++#define TYPE_NON_ISO_INT64 294 ++#define LPAREN 295 ++#define RPAREN 296 ++#define COMMA 297 ++#define SEMI 298 ++#define EXTERN 299 ++#define INIT 300 ++#define LBRACE 301 ++#define RBRACE 302 ++#define PERIOD 303 ++#define ELLIPSIS 304 ++#define CONST_QUAL 305 ++#define VOLATILE 306 ++#define REGISTER 307 ++#define STRUCT 308 ++#define UNION 309 ++#define EQUAL 310 ++#define SIZEOF 311 ++#define MODULE 312 ++#define LBRACKET 313 ++#define RBRACKET 314 ++#define BEGINFILE 315 ++#define ENDOFFILE 316 ++#define ILLEGAL 317 ++#define CONSTANT 318 ++#define NAME 319 ++#define RENAME 320 ++#define NAMEWARN 321 ++#define EXTEND 322 ++#define PRAGMA 323 ++#define FEATURE 324 ++#define VARARGS 325 ++#define ENUM 326 ++#define CLASS 327 ++#define TYPENAME 328 ++#define PRIVATE 329 ++#define PUBLIC 330 ++#define PROTECTED 331 ++#define COLON 332 ++#define STATIC 333 ++#define VIRTUAL 334 ++#define FRIEND 335 ++#define THROW 336 ++#define CATCH 337 ++#define EXPLICIT 338 ++#define STATIC_ASSERT 339 ++#define CONSTEXPR 340 ++#define THREAD_LOCAL 341 ++#define DECLTYPE 342 ++#define AUTO 343 ++#define NOEXCEPT 344 ++#define OVERRIDE 345 ++#define FINAL 346 ++#define USING 347 ++#define NAMESPACE 348 ++#define NATIVE 349 ++#define INLINE 350 ++#define TYPEMAP 351 ++#define EXCEPT 352 ++#define ECHO 353 ++#define APPLY 354 ++#define CLEAR 355 ++#define SWIGTEMPLATE 356 ++#define FRAGMENT 357 ++#define WARN 358 ++#define LESSTHAN 359 ++#define GREATERTHAN 360 ++#define DELETE_KW 361 ++#define DEFAULT 362 ++#define LESSTHANOREQUALTO 363 ++#define GREATERTHANOREQUALTO 364 ++#define EQUALTO 365 ++#define NOTEQUALTO 366 ++#define LESSEQUALGREATER 367 ++#define ARROW 368 ++#define QUESTIONMARK 369 ++#define TYPES 370 ++#define PARMS 371 ++#define NONID 372 ++#define DSTAR 373 ++#define DCNOT 374 ++#define TEMPLATE 375 ++#define OPERATOR 376 ++#define CONVERSIONOPERATOR 377 ++#define PARSETYPE 378 ++#define PARSEPARM 379 ++#define PARSEPARMS 380 ++#define DOXYGENSTRING 381 ++#define DOXYGENPOSTSTRING 382 ++#define CAST 383 ++#define LOR 384 ++#define LAND 385 ++#define OR 386 ++#define XOR 387 ++#define AND 388 ++#define RSHIFT 389 ++#define LSHIFT 390 ++#define MINUS 391 ++#define PLUS 392 ++#define MODULO 393 ++#define SLASH 394 ++#define STAR 395 ++#define LNOT 396 ++#define NOT 397 ++#define UMINUS 398 ++#define DCOLON 399 ++ ++ ++ ++ ++#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED ++typedef union YYSTYPE ++#line 1554 "parser.y" ++{ ++ const char *id; ++ List *bases; ++ struct Define { ++ String *val; ++ String *rawval; ++ int type; ++ String *qualifier; ++ String *refqualifier; ++ String *bitfield; ++ Parm *throws; ++ String *throwf; ++ String *nexcept; ++ String *final; ++ } dtype; ++ struct { ++ const char *type; ++ String *filename; ++ int line; ++ } loc; ++ struct { ++ char *id; ++ SwigType *type; ++ String *defarg; ++ ParmList *parms; ++ short have_parms; ++ ParmList *throws; ++ String *throwf; ++ String *nexcept; ++ String *final; ++ } decl; ++ Parm *tparms; ++ struct { ++ String *method; ++ Hash *kwargs; ++ } tmap; ++ struct { ++ String *type; ++ String *us; ++ } ptype; ++ SwigType *type; ++ String *str; ++ Parm *p; ++ ParmList *pl; ++ int intvalue; ++ Node *node; ++} ++/* Line 1529 of yacc.c. */ ++#line 387 "parser.h" ++ YYSTYPE; ++# define yystype YYSTYPE /* obsolescent; will be withdrawn */ ++# define YYSTYPE_IS_DECLARED 1 ++# define YYSTYPE_IS_TRIVIAL 1 ++#endif ++ ++extern YYSTYPE yylval; ++ diff --git a/bazel/swig_java.bzl b/bazel/swig_java.bzl index 4a04929aa7..c30c683b0a 100644 --- a/bazel/swig_java.bzl +++ b/bazel/swig_java.bzl @@ -51,8 +51,6 @@ def _java_wrap_cc_impl(ctx): java_files_dir = ctx.actions.declare_directory("java_files") swig_args = ctx.actions.args() - swig_args.add_all([java_files_dir], expand_directories = False) - swig_args.add("swig") swig_args.add("-c++") swig_args.add("-java") swig_args.add("-package", ctx.attr.package) @@ -72,7 +70,7 @@ def _java_wrap_cc_impl(ctx): ctx.actions.run( outputs = generated_c_files + [java_files_dir], inputs = depset([src] + ctx.files.swig_includes, transitive = header_sets), - executable = ctx.executable._mkdir_wrapper, + executable = ctx.executable._swig, arguments = [swig_args], mnemonic = "SwigCompile", ) @@ -120,8 +118,8 @@ It's expected that the `swig` binary exists in the host's path. default = Label("@bazel_tools//tools/jdk:current_java_runtime"), providers = [java_common.JavaRuntimeInfo], ), - "_mkdir_wrapper": attr.label( - default = Label("//bazel:mkdir_wrapper"), + "_swig": attr.label( + default = Label("//bazel:run_swig"), executable = True, cfg = "exec", ),