##############################################################################
.PHONY:: all all.opt byte opt top clean distclean configure opt-compil
.PHONY:: $(MAKESUBDIRS:%=%.all) $(MAKESUBDIRS:%=%.opt) subdirs.all subdirs.opt
-.PHONY:: all-opt all-byte byte-only opt-only
+.PHONY:: all-opt all-byte byte-only opt-only pure-byte
.PHONY:: copy-stubs install-stubs install install-man install-python install-common
+# below follow the main make targets when ocamlbuild is not enabled
+ifneq ($(FEATURE_OCAMLBUILD),yes)
+
# All make targets that are expected to be an entry point have a dependency on
# 'Makefile.config' to ensure that if Makefile.config is not present, an error
# message is printed first before any other actions are executed.
$(MAKE) opt-only
$(MAKE) preinstall
-# aliases for "byte" and "opt-compil"
-opt opt-only: Makefile.config opt-compil
-byte-only: Makefile.config byte
-
byte: Makefile.config version.ml
@$(MAKE) .depend
@$(MAKE) subdirs.all
top: $(EXEC).top
+# the .cmi file of coccilib
+ocaml/coccilib/coccilib.cmi: ocaml/coccilib.cmi
+ cp ocaml/coccilib.cmi ocaml/coccilib/coccilib.cmi
+
+# ocamlbuild version of the main make targets
+else
+
+all: Makefile.config
+ $(MAKE) $(TARGET_ALL)
+
+world: Makefile.config myocamlbuild.ml version.ml prepare-bundles
+ @echo "building both versions of spatch"
+ $(MAKE) byte
+ $(MAKE) opt-compil
+ @$(MAKE) coccilib-cmi
+ $(MAKE) preinstall
+ $(MAKE) docs
+ @echo ""
+ @echo -e "\tcoccinelle can now be installed via 'make install'"
+
+# note: the 'all-dev' target excludes the documentation and is less noisy
+all-dev: Makefile.config myocamlbuild.ml version.ml prepare-bundles
+ $(MAKE) byte
+ @$(MAKE) coccilib-cmi
+ @$(MAKE) preinstall
+
+all-release: Makefile.config myocamlbuild.ml version.ml prepare-bundles
+ @echo building $(TARGET_SPATCH)
+ $(MAKE) $(TARGET_SPATCH)
+ @$(MAKE) coccilib-cmi
+ $(MAKE) preinstall
+ $(MAKE) docs
+ @echo ""
+ @echo -e "\tcoccinelle can now be installed via 'make install'"
+
+all.opt: Makefile.config myocamlbuild.ml version.ml prepare-bundles
+ $(MAKE) opt-only
+ @$(MAKE) coccilib-cmi
+ $(MAKE) preinstall
+
+byte: Makefile.config myocamlbuild.ml version.ml prepare-bundles
+ $(OCAMLBUILD) -j 0 main.byte
+ cp _build/main.byte $(EXEC)
+
+pure-byte: Makefile.config myocamlbuild.ml version.ml prepare-bundles
+ $(OCAMLBUILD) -j 0 -tag nocustom main.byte
+ cp _build/main.byte $(EXEC)
+
+opt-compil: Makefile.config myocamlbuild.ml version.ml prepare-bundles
+ $(OCAMLBUILD) -j 0 main.native
+ cp _build/main.native $(EXEC).opt
+
+# the .cmi file of coccilib
+_build/ocaml/coccilib.cmi:
+ $(OCAMLBUILD) -j 0 ocaml/coccilib.cmi
+ocaml/coccilib/coccilib.cmi: _build/ocaml/coccilib.cmi
+ cp _build/ocaml/coccilib.cmi ocaml/coccilib/coccilib.cmi
+
+# end of main build target distinction on ocamlbuild
+endif
+
+# aliases for "byte" and "opt-compil"
+opt opt-only: Makefile.config opt-compil
+byte-only: Makefile.config byte
+
+
+# ensures that coccilib.cmi gets build
+.PHONY:: coccilib-cmi
+coccilib-cmi: ocaml/coccilib/coccilib.cmi
+distclean::
+ rm -f ocaml/coccilib/coccilib.cmi
+
+
subdirs.all:
@+for D in $(MAKESUBDIRS); do $(MAKE) $$D.all || exit 1 ; done
$(MAKESUBDIRS:%=%.opt):
@$(MAKE) -C $(@:%.opt=%) all.opt
+# This make target prepares the bundled software for building.
+# Note that running 'make' in these subdirectories will
+# automatically prepare the bundled software.
+.PHONY:: prepare-bundles
+prepare-bundles: $(MAKELIBS:%=%/.prepare)
+
+$(MAKELIBS:%=%/.prepare):
+ echo $@
+ @$(MAKE) -C $(@:%.prepare=%) .prepare
+
#dependencies:
# commons:
# globals:
clean distclean::
rm -f $(TARGET) $(TARGET).opt $(TARGET).top
+clean::
+ @if test -n "${OCAMLBUILD}" -d _build; then \
+ $(OCAMLBUILD) -clean; fi
+
+# distclean can run without ocamlbuild configured.
+distclean::
+ -@if test -d _build; then \
+ ocamlbuild -clean; fi
+ rm -rf _build _log
+
.PHONY:: tools configure
configure:
@echo "Makefile.config needs to be (re)build. Run ./configure $(CONFIGURE_FLAGS) to generate it."
@false
+# as above, also for the ocamlbuild plugin
+myocamlbuild.ml: myocamlbuild.ml.in configure.ac
+
tools: $(LIBS) $(LNKLIBS)
$(MAKE) -C tools
# may need the stubs, see 'copy-stubs'.
purebytecode:
rm -f spatch.opt spatch
+ifneq ($(FEATURE_OCAMLBUILD),yes)
$(MAKE) BYTECODE_EXTRA="" byte-only
+else
+ @$(MAKE) pure-byte
+endif
sed -i '1 s,^#!.*$$,#!/usr/bin/ocamlrun,g' spatch
# copies the stubs libraries (if any) to the root directory
+ifneq ($(FEATURE_OCAMLBUILD),yes)
copy-stubs:
@if test -f ./bundles/pycaml/dllpycaml_stubs.so; then \
cp -fv ./bundles/pycaml/dllpycaml_stubs.so .; fi
@if test -f ./bundles/pcre/dllpcre_stubs.so; then \
cp -fv ./bundles/pcre/dllpcre_stubs.so .; fi
+else
+copy-stubs:
+ @if test -f _build/bundles/pycaml/dllpycaml_stubs.so; then \
+ cp -fv _build/bundles/pycaml/dllpycaml_stubs.so .; fi
+ @if test -f _build/bundles/pcre/dllpcre_stubs.so; then \
+ cp -fv _build/bundles/pcre/dllpcre_stubs.so .; fi
+endif
##############################################################################
# Build version information
##############################################################################
.PHONY:: docs
+ifneq ($(FEATURE_OCAMLBUILD),yes)
docs:
+else
+docs: prepare-bundles
+endif
@$(MAKE) -C docs || (echo "warning: ignored the failed construction of the manual" 1>&2)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
@if test "x$(FEATURE_OCAML)" = x1; then \
if test -f ./parsing_c/ast_c.cmo -o -f ./parsing_c/ast_c.cmx; then \
$(MAKE) -C ocaml doc; \
else echo "note: to obtain coccilib documenation, it is required to build 'spatch' first so that ./parsing_c/ast_c.cm* gets build."; \
fi fi
+else
+ @if test "x$(FEATURE_OCAML)" = x1; then \
+ $(MAKE) -C ocaml doc; fi
+endif
@echo "finished building manuals"
clean:: Makefile.config
##############################################################################
preinstall: docs/spatch.1 scripts/spatch scripts/spatch.opt scripts/spatch.byte
- @echo "generated the wrapper scripts for spatch (the frontends)"
docs/spatch.1: Makefile.config
$(MAKE) -C docs spatch.1
# don't remove DESTDIR, it can be set by package build system like ebuild
# for staged installation.
-install-common:
+install-common: ocaml/coccilib/coccilib.cmi
$(MKDIR_P) $(DESTDIR)$(BINDIR)
$(MKDIR_P) $(DESTDIR)$(LIBDIR)
$(MKDIR_P) $(DESTDIR)$(SHAREDIR)/ocaml
- $(MKDIR_P) $(DESTDIR)$(SHAREDIR)/commons
- $(MKDIR_P) $(DESTDIR)$(SHAREDIR)/globals
- $(MKDIR_P) $(DESTDIR)$(SHAREDIR)/parsing_c
+# $(MKDIR_P) $(DESTDIR)$(SHAREDIR)/commons
+# $(MKDIR_P) $(DESTDIR)$(SHAREDIR)/globals
+# $(MKDIR_P) $(DESTDIR)$(SHAREDIR)/parsing_c
$(INSTALL_DATA) standard.h $(DESTDIR)$(SHAREDIR)
$(INSTALL_DATA) standard.iso $(DESTDIR)$(SHAREDIR)
- $(INSTALL_DATA) ocaml/coccilib.cmi $(DESTDIR)$(SHAREDIR)/ocaml/
- $(INSTALL_DATA) parsing_c/*.cmi $(DESTDIR)$(SHAREDIR)/parsing_c/
- $(INSTALL_DATA) commons/*.cmi $(DESTDIR)$(SHAREDIR)/commons/
- $(INSTALL_DATA) globals/iteration.cmi $(DESTDIR)$(SHAREDIR)/globals/
+ $(INSTALL_DATA) ocaml/coccilib/coccilib.cmi $(DESTDIR)$(SHAREDIR)/ocaml/
+# $(INSTALL_DATA) parsing_c/*.cmi $(DESTDIR)$(SHAREDIR)/parsing_c/
+# $(INSTALL_DATA) commons/*.cmi $(DESTDIR)$(SHAREDIR)/commons/
+# $(INSTALL_DATA) globals/iteration.cmi $(DESTDIR)$(SHAREDIR)/globals/
install-man:
@echo "Installing manuals in: ${DESTDIR}${MANDIR}"
set -e; for i in $(CLEANSUBDIRS); do $(MAKE) -C $$i $@; done
rm -f test.ml
rm -f TAGS *.native *.byte *.d.native *.p.byte
- rm -rf _build _log
- rm -f tests/SCORE_actual.sexp tests/SCORE_best_of_both.sexp
+ if test -z "${KEEP_GENERATED}"; then \
+ rm -f tests/SCORE_actual.sexp tests/SCORE_best_of_both.sexp; fi
find . -name ".#*1.*" | xargs rm -f
rm -f $(EXEC) $(EXEC).opt $(EXEC).top
+ rm -f setup/Makefile
# using 'touch' to prevent infinite recursion with 'make depend'
.PHONY:: depend
rm -rf autom4te.cache
rm -f config.status
rm -f config.log
- rm -f version.ml
+ if test -z "${KEEP_GENERATED}"; then \
+ rm -f version.ml; fi
rm -f globals/config.ml
rm -f globals/regexp.ml python/pycocci.ml ocaml/prepare_ocamlcocci.ml
rm -f scripts/spatch.sh
ifneq ($(MAKECMDGOALS),all)
ifneq ($(MAKECMDGOALS),.depend)
ifneq ($(MAKECMDGOALS),depend)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
endif
endif
endif
+endif
include Makefile.common
# This file is not the actual Makefile, as we do not use Automake for
# our project. The purpose of this file is to instruct autoreconf
# to include the setup directory.
+#
+# Note: ./configure generates the Makefile from Makefile.in, but
+# not from this Makefile.am.
ACLOCAL_AMFLAGS = -I setup --install
%.cmo: %.cmx
@echo "skipped building $@ in optimizing mode: $< will be build instead."
endif
+
+
+# If this variable is set, then 'make distclean' should not remove certain
+# generated files like the generated parsers, and documentation.
+export KEEP_GENERATED
# note that variables are exported and thus cannot be used in
# definitions of other variables. Use $(EXTRA_OCAML_FLAGS) for that.
-# Todo: since these definitions are not in Makefile.config.in, the
+# Todo: since these definitions are now in Makefile.config.in, the
# defaults can be removed from each individual Makefile in the
# subdirectories.
export OCAMLCFLAGS?=$(EXTRA_OCAML_FLAGS)
FEATURE_PYTHON=@FEATURE_PYTHON@
FEATURE_OCAML=@FEATURE_OCAML@
NO_OCAMLFIND=@SUBSTITUTED_OCAMLFIND@
+FEATURE_OCAMLBUILD=@FEATURE_OCAMLBUILD@
# Include paths
PCREDIR=@PATH_pcre@
GIT=git
endif
+# the release process rewrites the Makefile.config, so we need
+# to save important configure flags.
+remember_ocamlbuild:=$(FEATURE_OCAMLBUILD)
+
+ifeq ($(remember_ocamlbuild),yes)
+ extra_configure_flags := --enable-ocamlbuild
+else
+ extra_configure_flags :=
+endif
+
# Procedure to do first time:
fix-expected:
@echo "going to generate: tests/SCORE_expected_orig.sexp"
$(MAKE) distclean
- ./configure --enable-release --disable-python
+ ./configure --enable-release --disable-python $(extra_configure_flags)
$(MAKE) opt-only
yes | ./spatch.opt -testall --iso-file ./standard.iso --macro-file-builtins ./standard.h
cp tests/SCORE_actual.sexp tests/SCORE_expected_orig.sexp
@echo "\tThe coccinelle SVN repository must be in $(WEBBASE)\n"
package-src:
- $(MAKE) distclean KEEP_CONFIG=1 # Clean project (keep the config for the make actions)
+ ./configure --enable-release --disable-python --disable-pcre-syntax $(extra_configure_flags)
$(MAKE) srctar
$(MAKE) coccicheck
# on those libraries.
package-nopython:
$(MAKE) distclean
- ./configure --enable-release --disable-python --disable-pcre-syntax --disable-menhirLib --disable-sexplib --disable-extlib --disable-pycaml
+ ./configure --enable-release --disable-python --disable-pcre-syntax --disable-menhirLib --disable-pycaml $(extra_configure_flags)
$(MAKE) bintar
$(MAKE) bytecodetar
# on those libraries.
package-python:
$(MAKE) distclean
- ./configure --enable-release --enable-python --disable-pcre-syntax --disable-menhirLib --disable-sexplib --disable-extlib --disable-pycaml
+ ./configure --enable-release --enable-python --disable-pcre-syntax --disable-menhirLib --disable-pycaml $(extra_configure_flags)
$(MAKE) bintar-python
$(MAKE) bytecodetar-python
# update: make docs generates pdf but also some ugly .log files, so
# make clean is there to remove them while not removing the pdf
# (only distclean remove the pdfs).
-#
-# Prerequisite: a distclean with preservation of Makefile.config
srctar: Makefile.config
$(MAKE) docs
- $(MAKE) clean
+ $(MAKE) -C parsing_cocci parser_cocci_menhir.ml
+ $(MAKE) -C parsing_cocci parser_cocci_menhir.mli
+ $(MAKE) distclean KEEP_GENERATED=1 KEEP_CONFIG=1
if test -f "$(TMP)/$(PACKAGE)/"; then rm -f "$(TMP)/$(PACKAGE)/"; fi # remove it if it is a symlink
$(MKDIR_P) "$(TMP)/$(PACKAGE)/"
cp -rfa ./* "$(TMP)/$(PACKAGE)/"
- cd $(TMP)/$(PACKAGE); $(MAKE) -C parsing_cocci parser_cocci_menhir.ml
rm -f $(TMP)/$(PACKAGE)/Makefile.config
cd $(TMP); tar cvfz $(PACKAGE).tgz --exclude-vcs $(EXCL) $(PACKAGE)
rm -rf $(TMP)/$(PACKAGE)
# Note: configure first
dist:
$(MAKE) licensify
- $(MAKE) distclean KEEP_CONFIG=1
$(MAKE) docs
$(MAKE) -C parsing_cocci parser_cocci_menhir.ml
- $(MAKE) clean
+ $(MAKE) distclean KEEP_CONFIG=1 KEEP_GENERATED=1
tar cvfz $(PACKAGE).tar.gz --transform="s,^,$(PACKAGE)/,S" --exclude=$(PACKAGE).tar.gz --exclude-backups --exclude-vcs *
--- /dev/null
+# Compile all .ml files against some base libraries
+# (defined in the plugin as unix,str,nums and bigarray)
+<**/*.ml>: use_base
+
+#
+# Cocci sources and directories
+#
+
+<commons>: include
+<commons/ocamlextra>: include
+<commons/ocollection>: include
+
+<globals>: include
+<globals/regexp_pcre.ml>: use_pcre
+
+<parsing_cocci>: include
+<parsing_cocci/parser_cocci_menhir.ml>: use_menhirLib, nowarn20
+
+<parsing_c>: include
+<ctl>: include
+<engine>: include
+<popl09>: include
+<extra>: include
+
+<ocaml>: include
+<ocaml/coccilib.ml{,i}>: use_pcre
+
+<python>: include
+<python/yes_pycocci.ml>: thread, use_pycaml
+
+# some users have a symlink 'result' pointing to the outcome
+# of the build, which causes troubles with the hygiene check.
+<result>: -traverse
+
+
+#
+# Subdirectories
+#
+
+<engine/engine.{cma,cmxa}>: use_pcre
+<globals/globals.{cma,cmxa}>: use_pcre
+<ocaml/ocaml.{cma,cmxa}>: use_pcre
+<parsing_c/parsing_c.{cma,cmxa}>: use_pcre
+<parsing_cocci/parsing_cocci.{cma,cmxa}>: use_pcre, use_menhirLib
+<popl09/popl09.{cma,cmxa}>: use_pcre
+<python/python.{cma,cmxa}>: use_pcre, use_pycaml
+
+
+#
+# Bundled packages
+#
+
+# apriori remove the traverse tag from the bundle
+# directories to prevent them from being included.
+# The traverse tag will be added by the plugin for
+# the bundles that are included.
+<bundles/*>: -traverse
+
+<bundles/pcre/pcre.{cma,cmxa}>: use_pcre
+<bundles/pycaml/pycaml.{cma,cmxa}>: thread, use_pycaml
+
+# Interaction between the bundles and the plugin.
+<bundles/pcre/libpcre_stubs.a>: use_pcre
+<bundles/pcre/*/lib/pcre_stubs.c>: use_pcre
+<bundles/pycaml/libpycaml_stubs.a>: use_pycaml
+<bundles/pycaml/*/pycaml_stubs.c>: pp_pycaml, use_pycaml
+<bundles/pycaml/*/pycaml.ml>: pp_pycaml
+<bundles/menhirLib/*/src/*.cmx>: for-pack(MenhirLib)
+
+
+#
+# Hygiene
+#
+
+# Some lexers and parsers are precompiled in the
+# source distribution to make some preprocessors
+# optional
+
+<parsing_c/parser_c.mly>: not_hygienic
+<parsing_c/lexer_c.mll>: not_hygienic
+<parsing_cocci/lexer_cli.mll>: not_hygienic
+<parsing_cocci/lexer_script.mll>: not_hygienic
+<parsing_cocci/lexer_cocci.mll>: not_hygienic
+<parsing_cocci/parser_cocci_menhir.mly>: not_hygienic
+<parsing_cocci/parser_cocci_menhir.ml{,i}>: precious
+<ocaml/coccilib/coccilib.cmi>: not_hygienic
+
+
+#
+# Applications
+# Main is the entry point of spatch.
+#
+
+# library dependencies of spatch.
+<main.{byte,native}>: thread, use_base, use_menhirLib, use_pcre, use_pycaml
+
+# some test tools in the subdirectories
+<parsing_cocci/main.{byte,native}>: use_base, use_pcre
+<ctl/test_ctl.{byte,native}>: use_base
+
+
+# Build tools/all.otarget for all tools, or
+# tools/all.opt.otarget for all tools with the native compiler.
+
+<tools/gitgrep.{byte,native}>: use_base
+<tools/gitsort.{byte,native}>: use_base
+<tools/process_isoprofile.{byte,native}>: use_base
+<tools/alloc_free.{byte,native}>: use_base
+<tools/bridge.{byte,native}>: use_base
+<tools/spp.{byte,native}>: use_base
+<tools/splitpatch.{byte,native}>: use_base
+<tools/extract_c_and_res.{byte,native}>: use_base
+<tools/cstripenv.{byte,native}>: use_base, use_pcre
+<tools/distributed/cleanup.{byte,native}>: use_base
+
+
+#
+# Documentation
+#
+
+<ocaml/man.docdir/index.html>: gen_man, use_menhirLib, use_pcre, use_pycaml
+<ocaml/html.docdir/index.html>: gen_html, use_menhirLib, use_pcre, use_pycaml
@$(MAKE) all-opt-build
all-opt-build: $(EXTMARKER) extLib.cmxa META
+# prepares the source bundle for building.
+.prepare: $(EXTMARKER)
+ touch .prepare
+
clean:
rm -f .depend META extLib.cm[ioxa] extLib.[ao] \
$(EXTLIB)/*.cm[ioxa] extLib.cmxa \
distclean: clean
rm -rf $(EXTLIB)
+ rm -f .prepare
depend: $(EXTMARKER)
@$(MAKE) all-opt-build
all-opt-build: .depend menhirLib.cmxa META
+# prepares the source bundle for building.
+.prepare: $(MENHIRMARKER)
+ touch .prepare
+
clean:
rm -f menhirLib.cma menhirLib.cmxa META \
$(MENHIRLIB)/*.cm[ioxa] \
$(MENHIRLIB)/*.o \
+ $(MENHIRLIB)/*.annot \
$(MENHIRLIB)/engineTypes.mli $(MENHIRLIB)/tableFormat.mli \
menhirLib.cm[ioxa] menhirLib.[oa] \
.depend
distclean: clean
rm -rf $(MENHIRDIR)
+ rm -f .prepare
$(MENHIRMARKER): $(MENHIRDIR).tar.gz
$(TAR) xfvz $<
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
ifneq ($(MAKECMDGOALS),depend-build)
-include .depend
+ifneq ($(FEATURE_OCAMLBUILD),yes)
+-include .depend
+endif
endif
endif
endif
--- /dev/null
+# Includes the sources of the
+# bundles' source directory if
+# this directory is included.
+
+<menhir-20120123/src>: include
+++ /dev/null
-François Pottier <Francois.Pottier@inria.fr>
-Yann Régis-Gianas <Yann.Regis-Gianas@pps.jussieu.fr>
+++ /dev/null
-2012/01/23:
-
-Fixed a bug whereby a %nonassoc declaration was not respected. This
-declaration requests that a shift/reduce conflict be reduced in favor of
-neither shifting nor reducing, that is, a syntax error must occur. However,
-due to an unforeseen interaction with the "default reduction" mechanism, this
-declaration was sometimes ignored and reduction would take place.
-
-2012/01/09:
-Changes in the (undocumented) Coq back-end so as to match the ESOP 2012
-paper.
-
-2011/10/19:
-The Makefile now tests whether Unix or Windows is used (the test is performed
-by evaluating Sys.os_type under ocaml) and changes a couple settings accordingly:
-- the executable file name is either menhir or menhir.exe
-- the object file suffix is either .o or .obj
-
-2011/10/19:
-Added --strict, which causes many warnings about the grammar and about the
-automaton to be considered errors.
-
-2011/10/19:
-The # annotations that are inserted in the generated .ml file now retain their
-full path. (That is, we no longer use [Filename.basename].) This implies that
-the # annotations depend on how menhir is invoked -- e.g. "menhir
-foo/bar.mly" and "cd foo && menhir bar.mly" will produce different
-results. Nevertheless, this seems reasonable and useful (e.g. in conjunction
-with ocamlbuild and a hierarchy of files). Thanks to Daniel Weil.
-
-2011/10/06:
-With the -lg 1 switch, Menhir now indicates whether the grammar is SLR(1).
-
-2011/05/24:
-Removed the lock in ocamldep.wrapper. It is the responsibility of the user
-to avoid interferences with other processes (or other instances of the script)
-that create and/or remove files.
-
-2011/04/28:
-The (internal) computation of the automaton's invariant was broken and has
-been fixed. Surprisingly, this does not seem to affect the generated code,
-(which was correct,) so no observable bug is fixed. Hopefully no bug is
-introduced!
-
-2011/04/07:
-The grammar description files (.mly) are now read in up front and stored in
-memory while they are parsed. This allows us to avoid the use of pos_in and
-seek_in, which do not work correctly when CRLF conversion is being performed.
-
-2011/04/05:
-Fixed a bug in the type inference module (for parameterized non-terminals)
-which would cause an infinite loop.
-
-2011/01/24:
-Fixed a bug that would cause an assertion failure in the generated parser
-in some situations where the input stream was incorrect and the grammar
-involved the error token. The fix might cause grammars that use the error
-token to behave differently (hopefully more accurately) as of now.
-
-2009/06/18:
-Makefile changes: build and install only the bytecode version of menhirLib
-when TARGET=byte is set.
-
-2009/02/06:
-Fixed ocamldep.wrapper to avoid quoting the name of the ocaml command.
-This is hoped to fix a compilation problem under MinGW.
-
-2009/02/04:
-A Makefile fix to avoid a problem under Windows/Cygwin.
-Renamed the ocaml-check-version script so as to avoid a warning.
-
-2008/09/05:
-Ocaml summer project: added --interpret, --table, and --suggest-*.
-
-2008/08/06:
-Fixed a problem that would cause the code inliner to abort when a semantic
-value and a non-terminal symbol happened to have the same name.
-
-2008/08/06:
-Removed code sharing.
-
-2008/06/20:
-Removed an incorrect assertion that caused failures (lr1.ml, line 134).
-
-2007/12/05:
-Disabled code sharing by default, as it is currently broken. (See Yann's
-message; assertion failure at runtime.)
-
-2007/12/01:
-Added an optimization to share code among states that have identical
-outgoing transition tables.
-
-2007/08/30:
-Small Makefile change: create an executable file for check-ocaml-version in
-order to work around the absence of dynamic loading on some platforms.
-
-2007/05/20:
-Made a fundamental change in the construction of the LR(1) automaton
-in order to eliminate a bug that could lead to spurious conflicts --
-thanks to Ketti for submitting a bug report.
-
-2007/05/18:
-Added --follow-construction to help understand the construction of the
-LR(1) automaton (very verbose).
-
-2007/05/11:
-Code generation: more explicit qualifications with Pervasives so as
-to avoid capture when the user redefines some of the built-in operators,
-such as (+).
-Added a new demo (calc-param) that shows how to use %parameter.
-
-2007/03/22:
-Makefile improvements (check for PREFIX; bootstrap in bytecode now
-also available). Slight changes to OMakefile.shared.
-
-2007/02/15:
-Portability fix in Makefile and Makefile.shared (avoided "which").
-
-2006/12/15:
-Portability fix in Makefile.shared (replaced "&>" with "2>&1 >").
-
-2006/06/23:
-Made a slight restriction to Pager's criterion so as to never introduce
-fake conflict tokens (see Lr0.compatible). This might help make conflict
-explanations more accurate in the future.
-
-2006/06/16:
-Fixed bug that would cause positions to become invalid after %inlining.
-
-2006/06/15:
-Fixed --depend to be more lenient when analyzing ocamldep's output.
-Added --raw-depend which transmits ocamldep's output unchanged (for
-use in conjunction with omake).
-
-2006/06/12:
-Fixed bug that would cause --only-preprocess to print %token declarations
-also for pseudo-tokens.
-Fixed bug that caused some precedence declarations to be incorrectly
-reported as useless.
-Improved things so that useless pseudo-tokens now also cause warnings.
-Fixed bug that would cause %type directives for terminal symbols to
-be incorrectly accepted.
-Fixed bug that would occur when a semantic action containing $i keywords
-was %inlined.
-
-2006/05/05:
-Fixed problem that caused some end-of-stream conflicts not to be reported.
-Fixed Pager's compatibility criterion to avoid creating end-of-stream conflicts.
-
-2006/04/21:
-Fixed problem that allowed generating incorrect but apparently well-typed
-Objective Caml code when a semantic action was ill-typed and --infer was
-omitted.
-
-2006/03/29:
-Improved conflict reports by factoring out maximal common derivation contexts.
-
-2006/03/28:
-Fixed bug that could arise when explaining a conflict in a non-LALR(1) grammar.
-
-2006/03/27:
-Changed count of reduce/reduce conflicts to allow a comparison with ocamlyacc's diagnostics.
-When refusing to resolve a conflict, report all diagnostics before dying.
-
-2006/03/18:
-Added display of FOLLOW sets when using --log-grammar 2.
-Added --graph option.
-Fixed behavior of --depend option.
-
-2006/01/06:
-Removed reversed lists from the standard library.
-
+++ /dev/null
-REQUIREMENTS
-
-You need Objective Caml 3.09 or later and GNU make.
-
-HOW TO INSTALL
-
-If you wish to install via ocamlfind, make sure that ocamlfind is in
-your PATH. (Remember that prefixing a command with sudo affects its
-PATH.)
-
-Run the following command:
-
- make PREFIX=/usr/local install
-
-If your machine does not have the native code Objective Caml compiler
-(ocamlopt), but does have the bytecode compiler (ocamlc), then instead
-of the above command, use:
-
- make PREFIX=/usr/local TARGET=byte all install
-
-The value of the PREFIX variable can be changed to control where
-the software, the standard library, and the documentation should
-be stored. These files are copied to the following places:
-
- $PREFIX/bin/
- $PREFIX/share/menhir/
- $PREFIX/doc/menhir/
-
-The support library, MenhirLib, is either installed via ocamlfind, if
-available, or placed within $PREFIX/share/menhir. Menhir's --suggest
-options help determine where and how it was installed.
-
-The documentation includes a reference manual and a number of demos.
-
+++ /dev/null
-In the following, "the Library" refers to the following files:
-
- src/standard.mly
- src/infiniteArray.{ml,mli}
- src/packedIntArray.{ml,mli}
- src/rowDisplacement.{ml,mli}
- src/engineTypes.ml
- src/engine.{ml,mli}
- src/tableFormat.ml
- src/tableInterpreter.{ml,mli}
- src/convert.{ml,mli}
-
-while "the Generator" refers to all other files in this archive.
-
-The Generator is distributed under the terms of the Q Public License
-version 1.0 with a change to choice of law (included below).
-
-The Library is distributed under the terms of the GNU Library General
-Public License version 2 (included below).
-
-As a special exception to the Q Public Licence, you may develop
-application programs, reusable components and other software items
-that link with the original or modified versions of the Generator
-and are not made available to the general public, without any of the
-additional requirements listed in clause 6c of the Q Public licence.
-
-As a special exception to the GNU Library General Public License, you
-may link, statically or dynamically, a "work that uses the Library"
-with a publicly distributed version of the Library to produce an
-executable file containing portions of the Library, and distribute
-that executable file under terms of your choice, without any of the
-additional requirements listed in clause 6 of the GNU Library General
-Public License. By "a publicly distributed version of the Library",
-we mean either the unmodified Library as distributed by INRIA, or a
-modified version of the Library that is distributed under the
-conditions defined in clause 3 of the GNU Library General Public
-License. This exception does not however invalidate any other reasons
-why the executable file might be covered by the GNU Library General
-Public License.
-
-----------------------------------------------------------------------
-
- THE Q PUBLIC LICENSE version 1.0
-
- Copyright (C) 1999 Troll Tech AS, Norway.
- Everyone is permitted to copy and
- distribute this license document.
-
-The intent of this license is to establish freedom to share and change
-the software regulated by this license under the open source model.
-
-This license applies to any software containing a notice placed by the
-copyright holder saying that it may be distributed under the terms of
-the Q Public License version 1.0. Such software is herein referred to
-as the Software. This license covers modification and distribution of
-the Software, use of third-party application programs based on the
-Software, and development of free software which uses the Software.
-
- Granted Rights
-
-1. You are granted the non-exclusive rights set forth in this license
-provided you agree to and comply with any and all conditions in this
-license. Whole or partial distribution of the Software, or software
-items that link with the Software, in any form signifies acceptance of
-this license.
-
-2. You may copy and distribute the Software in unmodified form
-provided that the entire package, including - but not restricted to -
-copyright, trademark notices and disclaimers, as released by the
-initial developer of the Software, is distributed.
-
-3. You may make modifications to the Software and distribute your
-modifications, in a form that is separate from the Software, such as
-patches. The following restrictions apply to modifications:
-
- a. Modifications must not alter or remove any copyright notices
- in the Software.
-
- b. When modifications to the Software are released under this
- license, a non-exclusive royalty-free right is granted to the
- initial developer of the Software to distribute your
- modification in future versions of the Software provided such
- versions remain available under these terms in addition to any
- other license(s) of the initial developer.
-
-4. You may distribute machine-executable forms of the Software or
-machine-executable forms of modified versions of the Software,
-provided that you meet these restrictions:
-
- a. You must include this license document in the distribution.
-
- b. You must ensure that all recipients of the machine-executable
- forms are also able to receive the complete machine-readable
- source code to the distributed Software, including all
- modifications, without any charge beyond the costs of data
- transfer, and place prominent notices in the distribution
- explaining this.
-
- c. You must ensure that all modifications included in the
- machine-executable forms are available under the terms of this
- license.
-
-5. You may use the original or modified versions of the Software to
-compile, link and run application programs legally developed by you or
-by others.
-
-6. You may develop application programs, reusable components and other
-software items that link with the original or modified versions of the
-Software. These items, when distributed, are subject to the following
-requirements:
-
- a. You must ensure that all recipients of machine-executable
- forms of these items are also able to receive and use the
- complete machine-readable source code to the items without any
- charge beyond the costs of data transfer.
-
- b. You must explicitly license all recipients of your items to
- use and re-distribute original and modified versions of the
- items in both machine-executable and source code forms. The
- recipients must be able to do so without any charges whatsoever,
- and they must be able to re-distribute to anyone they choose.
-
- c. If the items are not available to the general public, and the
- initial developer of the Software requests a copy of the items,
- then you must supply one.
-
- Limitations of Liability
-
-In no event shall the initial developers or copyright holders be
-liable for any damages whatsoever, including - but not restricted to -
-lost revenue or profits or other direct, indirect, special, incidental
-or consequential damages, even if they have been advised of the
-possibility of such damages, except to the extent invariable law, if
-any, provides otherwise.
-
- No Warranty
-
-The Software and this license document are provided AS IS with NO
-WARRANTY OF ANY KIND, INCLUDING THE WARRANTY OF DESIGN,
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-
- Choice of Law
-
-This license is governed by the Laws of France.
-
-----------------------------------------------------------------------
-
- GNU LIBRARY GENERAL PUBLIC LICENSE
- Version 2, June 1991
-
- Copyright (C) 1991 Free Software Foundation, Inc.
- 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the library GPL. It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
-
- Preamble
-
- The licenses for most software are designed to take away your
-freedom to share and change it. By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
- This license, the Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it. You can use it for
-your libraries, too.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
- To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if
-you distribute copies of the library, or if you modify it.
-
- For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you. You must make sure that they, too, receive or can get the source
-code. If you link a program with the library, you must provide
-complete object files to the recipients so that they can relink them
-with the library, after making changes to the library and recompiling
-it. And you must show them these terms so they know their rights.
-
- Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
- Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library. If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-\f
- Finally, any free program is threatened constantly by software
-patents. We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software. To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
- Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs. This
-license, the GNU Library General Public License, applies to certain
-designated libraries. This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
- The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it. Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program. However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
- Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries. We
-concluded that weaker conditions might promote sharing better.
-
- However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves. This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them. (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.) The hope is that this
-will lead to faster development of free libraries.
-
- The precise terms and conditions for copying, distribution and
-modification follow. Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library". The
-former contains code derived from the library, while the latter only
-works together with the library.
-
- Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-\f
- GNU LIBRARY GENERAL PUBLIC LICENSE
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-General Public License (also called "this License"). Each licensee is
-addressed as "you".
-
- A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
- The "Library", below, refers to any such software library or work
-which has been distributed under these terms. A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language. (Hereinafter, translation is
-included without limitation in the term "modification".)
-
- "Source code" for a work means the preferred form of the work for
-making modifications to it. For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
- Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope. The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it). Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
- 1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
- You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-\f
- 2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
- a) The modified work must itself be a software library.
-
- b) You must cause the files modified to carry prominent notices
- stating that you changed the files and the date of any change.
-
- c) You must cause the whole of the work to be licensed at no
- charge to all third parties under the terms of this License.
-
- d) If a facility in the modified Library refers to a function or a
- table of data to be supplied by an application program that uses
- the facility, other than as an argument passed when the facility
- is invoked, then you must make a good faith effort to ensure that,
- in the event an application does not supply such function or
- table, the facility still operates, and performs whatever part of
- its purpose remains meaningful.
-
- (For example, a function in a library to compute square roots has
- a purpose that is entirely well-defined independent of the
- application. Therefore, Subsection 2d requires that any
- application-supplied function or table used by this function must
- be optional: if the application does not supply it, the square
- root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole. If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works. But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
- 3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library. To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License. (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.) Do not make any other change in
-these notices.
-\f
- Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
- This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
- 4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
- If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
- 5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library". Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
- However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library". The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
- When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library. The
-threshold for this to be true is not precisely defined by law.
-
- If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work. (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
- Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-\f
- 6. As an exception to the Sections above, you may also compile or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
- You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License. You must supply a copy of this License. If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License. Also, you must do one
-of these things:
-
- a) Accompany the work with the complete corresponding
- machine-readable source code for the Library including whatever
- changes were used in the work (which must be distributed under
- Sections 1 and 2 above); and, if the work is an executable linked
- with the Library, with the complete machine-readable "work that
- uses the Library", as object code and/or source code, so that the
- user can modify the Library and then relink to produce a modified
- executable containing the modified Library. (It is understood
- that the user who changes the contents of definitions files in the
- Library will not necessarily be able to recompile the application
- to use the modified definitions.)
-
- b) Accompany the work with a written offer, valid for at
- least three years, to give the same user the materials
- specified in Subsection 6a, above, for a charge no more
- than the cost of performing this distribution.
-
- c) If distribution of the work is made by offering access to copy
- from a designated place, offer equivalent access to copy the above
- specified materials from the same place.
-
- d) Verify that the user has already received a copy of these
- materials or that you have already sent this user a copy.
-
- For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it. However, as a special exception,
-the source code distributed need not include anything that is normally
-distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
- It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system. Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-\f
- 7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
- a) Accompany the combined library with a copy of the same work
- based on the Library, uncombined with any other library
- facilities. This must be distributed under the terms of the
- Sections above.
-
- b) Give prominent notice with the combined library of the fact
- that part of it is a work based on the Library, and explaining
- where to find the accompanying uncombined form of the same work.
-
- 8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License. Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License. However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
- 9. You are not required to accept this License, since you have not
-signed it. However, nothing else grants you permission to modify or
-distribute the Library or its derivative works. These actions are
-prohibited by law if you do not accept this License. Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
- 10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions. You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-\f
- 11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all. For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices. Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
- 12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded. In such case, this License incorporates the limitation as if
-written in the body of this License.
-
- 13. The Free Software Foundation may publish revised and/or new
-versions of the Library General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation. If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-\f
- 14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission. For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this. Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
- NO WARRANTY
-
- 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
- END OF TERMS AND CONDITIONS
-\f
- Appendix: How to Apply These Terms to Your New Libraries
-
- If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change. You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
- To apply these terms, attach the following notices to the library. It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
- <one line to give the library's name and a brief idea of what it does.>
- Copyright (C) <year> <name of author>
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Library General Public
- License as published by the Free Software Foundation; either
- version 2 of the License, or (at your option) any later version.
-
- This library is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- Library General Public License for more details.
-
- You should have received a copy of the GNU Library General Public
- License along with this library; if not, write to the Free
- Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
- MA 02111-1307, USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary. Here is a sample; alter the names:
-
- Yoyodyne, Inc., hereby disclaims all copyright interest in the
- library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
- <signature of Ty Coon>, 1 April 1990
- Ty Coon, President of Vice
-
-That's all there is to it!
+++ /dev/null
-# This is the main Makefile that is shipped as part of the source package.
-# Keep in mind that the hierarchy that is shipped is not identical to the
-# hierarchy within the svn repository: some sub-directories are not shipped;
-# the documentation is pre-built.
-
-# The hierarchy that is shipped includes:
-# demos
-# menhir.1
-# manual.pdf
-# src
-# Makefile (this one)
-
-# ----------------------------------------------------------------------------
-
-# By default, we attempt to use ocamlfind (if present in the PATH), but it it
-# is possible to prevent that externally by setting USE_OCAMLFIND to false.
-
-ifndef USE_OCAMLFIND
- USE_OCAMLFIND = ocamlfind ocamlc -v >/dev/null 2>&1
-endif
-
-# ----------------------------------------------------------------------------
-
-# A few settings differ on Windows versus Unix.
-
-include Makefile.arch
-
-# ----------------------------------------------------------------------------
-# Installation paths.
-
-# TEMPORARY GODIVA and Linux do not agree on the standard paths...
-
-ifndef PREFIX
- $(error Please define PREFIX)
-endif
-
-bindir := ${PREFIX}/bin
-docdir := ${PREFIX}/share/doc/menhir
-libdir := ${PREFIX}/share/menhir
-mandir := ${PREFIX}/share/man/man1
-MANS := menhir.1
-DOCS := manual.pdf demos
-MLYLIB := src/standard.mly
-
-# -------------------------------------------------------------------------
-
-# Building menhirLib.
-
-ifeq ($(TARGET),byte)
-MENHIRLIB := menhirLib.cmi menhirLib.cmo
-else
-MENHIRLIB := menhirLib.cmi menhirLib.cmo menhirLib.cmx menhirLib.$(OBJ)
-endif
-
-# ----------------------------------------------------------------------------
-# Compilation.
-
-# Installation time settings are recorded within src/installation.ml.
-# This file is recreated every time so as to avoid becoming stale.
-
-.PHONY: all install uninstall
-
-all:
- rm -f src/installation.ml
- echo "let libdir = \"${libdir}\"" > src/installation.ml
- if $(USE_OCAMLFIND) ; then \
- echo "let ocamlfind = true" >> src/installation.ml ; \
- else \
- echo "let ocamlfind = false" >> src/installation.ml ; \
- fi
- $(MAKE) $(MFLAGS) -C src -f Makefile
- $(MAKE) $(MFLAGS) -C src -f Makefile $(MENHIRLIB)
-
-# ----------------------------------------------------------------------------
-# Installation.
-
-install: all
- mkdir -p $(bindir)
- mkdir -p $(libdir)
- mkdir -p $(docdir)
- mkdir -p $(mandir)
- install src/$(MENHIREXE) $(bindir)
- install -m 644 $(MLYLIB) $(libdir)
- cp -r $(DOCS) $(docdir)
- cp -r $(MANS) $(mandir)
- @cd src && if $(USE_OCAMLFIND) ; then \
- echo Installing MenhirLib via ocamlfind. ; \
- ocamlfind install menhirLib META $(MENHIRLIB) ; \
- else \
- echo Installing MenhirLib manually. ; \
- install -m 644 $(MENHIRLIB) $(libdir) ; \
- fi
-
-uninstall:
- rm -rf $(bindir)/$(MENHIREXE)
- rm -rf $(libdir)
- rm -rf $(docdir)
- rm -rf $(mandir)/$(MANS)
- @if $(USE_OCAMLFIND) ; then \
- echo Un-installing MenhirLib via ocamlfind. ; \
- ocamlfind remove menhirLib ; \
- fi
+++ /dev/null
-# If ocaml reports that Sys.os_type is Unix, we assume Unix, otherwise
-# we assume Windows.
-
-ifeq "$(shell rm -f ./o.ml && echo print_endline Sys.os_type > ./o.ml && ocaml ./o.ml && rm -f ./o.ml)" "Unix"
-MENHIREXE := menhir
-OBJ := o
-else
-MENHIREXE := menhir.exe
-OBJ := obj
-endif
+++ /dev/null
-DEMOS := calc calc-two calc-param
-
-.PHONY: all clean
-
-all:
- @for i in $(DEMOS) ; do \
- $(MAKE) -C $$i ; \
- done
-
-clean:
- /bin/rm -f *~ .*~ *.omc
- @for i in $(DEMOS) ; do \
- $(MAKE) -C $$i clean ; \
- done
+++ /dev/null
-# This auxiliary Makefile is meant to be included by a client Makefile in
-# addition to Makefile.shared. It is optional. It implements the common case
-# where every .mly file in the current directory is to be viewed as a
-# mono-module grammar specification.
-
-$(foreach module,$(wildcard *.mly),$(eval $(call menhir_monomodule,$(patsubst %.mly,%,$(module)),)))
-
+++ /dev/null
-# This Makefile is shared between all demos. It is our suggestion
-# of a canonical Makefile for projects that use Objective Caml,
-# ocamllex, and menhir. It requires a recent version of GNU make
-# (older versions do not correctly implement $(eval)).
-
-# ----------------------------------------------------------------
-
-# This Makefile is meant to be included within a host Makefile
-# that defines the following variables:
-#
-# GENERATED : a list of the source (.ml and .mli) files
-# that should be generated by invoking ocamllex
-# or menhir
-#
-# MODULES : a list of the modules (without extension)
-# that should be linked into the executable
-# program. Order is significant.
-#
-# EXECUTABLE : the base name of the executables that should
-# be produced. Suffixes $(BSUFFIX) and $(OSUFFIX)
-# will be added to distinguish the bytecode and
-# native code versions.
-
-# ----------------------------------------------------------------
-
-# The host Makefile can also override the following settings:
-
-# Menhir.
-
-ifndef MENHIR
- MENHIR := menhir
-endif
-
-# Parser generation flags.
-ifndef PGFLAGS
- PGFLAGS := --infer -v
-endif
-
-# Include directives for compilation and for linking.
-
-ifndef INCLUDE
- INCLUDE :=
-endif
-
-# Bytecode compilation flags.
-
-ifndef BFLAGS
- BFLAGS :=
-endif
-
-# Native code compilation flags.
-ifndef OFLAGS
- OFLAGS :=
-endif
-
-# Menhir-suggested compilation flags.
-ifndef SUGG_FLAGS
- SUGG_FLAGS := $(shell $(MENHIR) $(PGFLAGS) --suggest-comp-flags 2>/dev/null)
-endif
-
-# Bytecode link-time flags.
-ifndef BLNKFLAGS
- BLNKFLAGS :=
-endif
-
-# Menhir-suggested bytecode link-time flags.
-ifndef SUGG_BLNKFLAGS
- SUGG_BLNKFLAGS := $(shell $(MENHIR) $(PGFLAGS) --suggest-link-flags-byte 2>/dev/null)
-endif
-
-# Native code link-time flags.
-ifndef OLNKFLAGS
- OLNKFLAGS :=
-endif
-
-# Menhir-suggested native code link-time flags.
-ifndef SUGG_OLNKFLAGS
- SUGG_OLNKFLAGS := $(shell $(MENHIR) $(PGFLAGS) --suggest-link-flags-opt 2>/dev/null)
-endif
-
-# Suffix appended to the name of the bytecode executable.
-ifndef BSUFFIX
- BSUFFIX := .byte
-endif
-
-# Suffix appended to the name of the native code executable.
-ifndef OSUFFIX
- OSUFFIX :=
-endif
-
-# Access paths.
-
-ifndef OCAML
- OCAML := ocaml
-endif
-
-ifndef OCAMLC
- OCAMLC := $(shell if ocamlfind ocamlc -v >/dev/null 2>&1 ; \
- then echo ocamlfind ocamlc ; \
- elif ocamlc.opt -v >/dev/null 2>&1 ; \
- then echo ocamlc.opt ; \
- else echo ocamlc ; fi)
-endif
-
-ifndef OCAMLOPT
- OCAMLOPT := $(shell if ocamlfind ocamlopt -v >/dev/null 2>&1 ; \
- then echo ocamlfind ocamlopt ; \
- elif ocamlopt.opt -v >/dev/null 2>&1 ; \
- then echo ocamlopt.opt ; \
- else echo ocamlopt ; fi)
-endif
-
-ifndef OCAMLDEP
- OCAMLDEP := $(shell if ocamlfind ocamldep -version >/dev/null 2>&1 ; \
- then echo ocamlfind ocamldep ; \
- elif ocamldep.opt -version >/dev/null 2>&1 ; \
- then echo ocamldep.opt ; \
- else echo ocamldep ; fi)
-endif
-
-ifndef OCAMLDEPWRAPPER
- OCAMLDEPWRAPPER:= ./ocamldep.wrapper
-endif
-
-ifndef OCAMLLEX
- OCAMLLEX := ocamllex
-endif
-
-# A list of targets that do not require dependency analysis.
-# This variable should be set by the host before including
-# this Makefile.
-COLD += clean
-
-# ----------------------------------------------------------------
-
-# Do not destroy the generated source files.
-
-.SECONDARY: $(GENERATED)
-
-# ----------------------------------------------------------------
-
-# Linking.
-
-$(EXECUTABLE)$(OSUFFIX): $(MODULES:=.cmx)
- $(OCAMLOPT) -o $@ $(INCLUDE) $(OLNKFLAGS) $(SUGG_FLAGS) $(SUGG_OLNKFLAGS) $^
-
-$(EXECUTABLE)$(BSUFFIX): $(MODULES:=.cmo)
- $(OCAMLC) -o $@ $(INCLUDE) $(BLNKFLAGS) $(SUGG_FLAGS) $(SUGG_BLNKFLAGS) $^
-
-# ----------------------------------------------------------------
-
-# Compiling.
-
-# We make the .ml and .mli files generated by ocamllex and menhir
-# unwritable, so as to prevent them from being edited by mistake.
-
-%.cmi: %.mli %.mli.d
- $(OCAMLC) $(INCLUDE) $(BFLAGS) $(SUGG_FLAGS) -c $<
-
-%.cmo: %.ml %.ml.d
- $(OCAMLC) $(INCLUDE) $(BFLAGS) $(SUGG_FLAGS) -c $<
-
-%.cmx %.o: %.ml %.ml.d
- $(OCAMLOPT) $(INCLUDE) $(OFLAGS) $(SUGG_FLAGS) -c $<
-
-%.ml: %.mll
- @if [ -f $@ ] ; then /bin/chmod +w $@ ; fi
- $(OCAMLLEX) $<
- @/bin/chmod -w $@
-
-# ----------------------------------------------------------------
-
-# Computing dependencies.
-
-# We associate a tiny Makefile, whose name ends in .d, with every
-# source file; it contains dependency information only. For an .ml or
-# .mli file, we create an .ml.d or .mli.d file by invoking ocamldep.
-# For an .mll file, we create an .ml.d file by invoking ocamllex first
-# (this is implicit), then ocamldep.
-
-# When it finds a reference to module M, ocamldep checks whether the
-# files m.ml and m.mli exist before deciding which dependency to
-# report. If m.ml and m.mli are generated from m.mll or m.mly, then
-# there is a potential problem: because ocamldep is invoked before
-# these files are created, it cannot see them. The standard solution
-# until now was to invoke ocamllex and ocamlyacc first to create all
-# generated files, and run ocamldep next. This approach does not work
-# with menhir when the --infer switch is on: menhir cannot be invoked
-# first because it needs type information found in .cmi (or .cmo or
-# .cmx) files. Our solution is to wrap ocamldep in a script that
-# creates fake generated files m.ml and m.mli to let ocamldep know that
-# these files are supposed to exist. This is somewhat tricky, but appears
-# to work.
-
-%.ml.d: %.ml
- $(OCAML) $(OCAMLDEPWRAPPER) $(GENERATED) - $(OCAMLDEP) $< > $@
-
-%.mli.d: %.mli
- $(OCAML) $(OCAMLDEPWRAPPER) $(GENERATED) - $(OCAMLDEP) $< > $@
-
-# All .d files are included within the present Makefile, so it they
-# do not exist, they are created first, and the dependencies that
-# they contain are then taken into account.
-
-# A .SECONDARY directive is used to ensure that the auxiliary
-# Makefiles are never removed. Otherwise, make could create
-# one, remove one, create one, remove one, ... (We have observed
-# this.)
-
-ifeq ($(findstring $(MAKECMDGOALS),$(COLD)),)
- ifneq ($(strip $(wildcard *.mli)),)
- .SECONDARY: $(patsubst %.mli,%.mli.d,$(wildcard *.mli))
- -include $(patsubst %.mli,%.mli.d,$(wildcard *.mli))
- endif
- ifneq ($(strip $(wildcard *.ml)),)
- .SECONDARY: $(patsubst %.ml,%.ml.d,$(wildcard *.ml))
- -include $(patsubst %.ml,%.ml.d,$(wildcard *.ml))
- endif
- ifneq ($(strip $(wildcard *.mll)),)
- .SECONDARY: $(patsubst %.mll,%.ml.d,$(wildcard *.mll))
- -include $(patsubst %.mll,%.ml.d,$(wildcard *.mll))
- endif
-endif
-
-
-# ----------------------------------------------------------------
-
-# Support for menhir projects.
-
-# The macro menhir_multimodule defines support for multi-module grammar
-# specifications, that is, for producing parsers out of multiple
-# source files. The parameter $(1) is the name of the parser that
-# should be produced; the parameter $(2) is the list of .mly source
-# files; the parameter $(3) contains extra options to be passed to
-# menhir.
-
-# The dependency file is named $(1).d and created by invoking menhir
-# --depend.
-
-define menhir_multimodule
-$(1).ml $(1).mli: $(2) $(1).d
- @if [ -f $(1).ml ] ; then /bin/chmod +w $(1).ml ; fi
- @if [ -f $(1).mli ] ; then /bin/chmod +w $(1).mli ; fi
- $(MENHIR) --ocamlc "$(OCAMLC)" $(PGFLAGS) --base $(1) $(3) $(2)
- @/bin/chmod -w $(1).ml $(1).mli
-
-$(1).d: $(2)
- @if [ -f $(1).ml ] ; then /bin/chmod +w $(1).ml ; fi
- @if [ -f $(1).mli ] ; then /bin/chmod +w $(1).mli ; fi
- $(OCAML) $(OCAMLDEPWRAPPER) $(GENERATED) - \
- $(MENHIR) --ocamldep "$(OCAMLDEP)" --depend --base $(1) $(3) $(2) > $$@
-
-ifeq ($$(findstring $$(MAKECMDGOALS),$$(COLD)),)
-.SECONDARY: $(1).d
--include $(1).d
-endif
-endef
-
-# The macro menhir_monomodule defines support for a mono-module grammar
-# specification. The parameter $(1) is the name of the parser that
-# should be produced; the source file is $(1).mly. The parameter $(2)
-# contains extra options to be passed to menhir.
-
-define menhir_monomodule
-$(eval $(call menhir_multimodule,$(1),$(1).mly,$(2)))
-endef
-
-# Neither of the two macros above is invoked by default, as it is not
-# known here which is appropriate. It is up to the client to invoke
-# these macros with suitable parameters. The auxiliary Makefile.auto
-# implements the common case where every .mly file is a mono-module
-# grammar.
-
-# ----------------------------------------------------------------
-
-.PHONY: clean
-
-clean::
- /bin/rm -f $(EXECUTABLE)$(BSUFFIX) $(EXECUTABLE)$(OSUFFIX) $(GENERATED)
- /bin/rm -f *.cmi *.cmx *.cmo *.o *~ .*~ *.automaton *.conflicts *.annot
- /bin/rm -f *.d
-
+++ /dev/null
-# This OMakefile is designed for projects that use Objective Caml,
-# ocamllex, menhir, and alphaCaml.
-
-# This OMakefile is meant to be included within a host OMakefile
-# that defines the following variables:
-#
-# GENERATED : a list of the source (.ml and .mli) files
-# that are generated (by invoking ocamllex
-# or menhir)
-#
-# MODULES : a list of the modules (without extension)
-# that should be linked into the executable
-# program. Order is significant.
-#
-# EXECUTABLE : the base name of the executables that should
-# be produced. Suffixes $(BSUFFIX) and $(OSUFFIX)
-# will be added to distinguish the bytecode and
-# native code versions.
-
-# -------------------------------------------------------------------------
-
-# The host OMakefile can override the following default settings.
-
-# Menhir.
-
-if $(not $(defined MENHIR))
- MENHIR = menhir
- export
-
-# Parser generation flags.
-
-if $(not $(defined MENHIR_FLAGS))
- MENHIR_FLAGS = --infer -v
- export
-
-# Include directives for compilation and for linking.
-
-if $(not $(defined PREFIXED_OCAMLINCLUDES))
- PREFIXED_OCAMLINCLUDES =
- export
-
-# Bytecode compilation flags.
-
-if $(not $(defined BFLAGS))
- BFLAGS = -dtypes -g
- export
-
-# Native code compilation flags.
-
-if $(not $(defined OFLAGS))
- OFLAGS = -dtypes
- export
-
-# Menhir-suggested compilation flags.
-if $(not $(defined SUGG_FLAGS))
- SUGG_FLAGS = $(shell $(MENHIR) $(MENHIR_FLAGS) --suggest-comp-flags 2>/dev/null)
- export
-
-# Bytecode link-time flags.
-
-if $(not $(defined BLNKFLAGS))
- BLNKFLAGS = -g
- export
-
-# Menhir-suggested bytecode link-time flags.
-if $(not $(defined SUGG_BLNKFLAGS))
- SUGG_BLNKFLAGS = $(shell $(MENHIR) $(MENHIR_FLAGS) --suggest-link-flags-byte 2>/dev/null)
- export
-
-# Native code link-time flags.
-
-if $(not $(defined OLNKFLAGS))
- OLNKFLAGS =
- export
-
-# Menhir-suggested native code link-time flags.
-if $(not $(defined SUGG_OLNKFLAGS))
- SUGG_OLNKFLAGS = $(shell $(MENHIR) $(MENHIR_FLAGS) --suggest-link-flags-opt 2>/dev/null)
- export
-
-# Lexer generation flags.
-
-if $(not $(defined LGFLAGS))
- LGFLAGS =
- export
-
-# Suffix appended to the name of the bytecode executable.
-
-if $(not $(defined BSUFFIX))
- BSUFFIX = .byte
- export
-
-# Suffix appended to the name of the native code executable.
-
-if $(not $(defined OSUFFIX))
- OSUFFIX =
- export
-
-# Access paths for the tools.
-
-if $(not $(defined OCAML))
- OCAML = ocaml
- export
-
-if $(not $(defined OCAMLC))
- if $(which ocamlfind)
- OCAMLC = ocamlfind ocamlc
- export
- elseif $(which ocamlc.opt)
- OCAMLC = ocamlc.opt
- export
- else
- OCAMLC = ocamlc
- export
- export
-
-if $(not $(defined OCAMLOPT))
- if $(which ocamlfind)
- OCAMLOPT = ocamlfind ocamlopt
- export
- elseif $(which ocamlopt.opt)
- OCAMLOPT = ocamlopt.opt
- export
- else
- OCAMLOPT = ocamlopt
- export
- export
-
-if $(not $(defined OCAMLDEP))
- if $(which ocamlfind)
- OCAMLDEP = ocamlfind ocamldep
- export
- elseif $(which ocamldep.opt)
- OCAMLDEP = ocamldep.opt
- export
- else
- OCAMLDEP = ocamldep
- export
- export
-
-if $(not $(defined OCAMLDEPWRAPPER))
- OCAMLDEPWRAPPER = ./ocamldep.wrapper
- export
-
-if $(not $(defined OCAMLLEX))
- OCAMLLEX = ocamllex
- export
-
-if $(not $(defined ALPHACAML))
- ALPHACAML = alphaCaml
- export
-
-# ----------------------------------------------------------------
-
-# Define an ocamldep wrapper that creates fake generated files so that
-# ocamldep can see that these files exist (or are supposed to exist).
-# This is required to work around ocamldep's brokenness.
-
-WrapScanner(command) =
- $(OCAML) $(OCAMLDEPWRAPPER) $(GENERATED) - $(command)
-
-# ----------------------------------------------------------------
-
-# Dependencies.
-
-.SCANNER: %.cmi: %.mli
- WrapScanner($(OCAMLDEP) $<)
-
-.SCANNER: %.cmx %.cmo %.o: %.ml
- WrapScanner($(OCAMLDEP) $<)
-
-# ----------------------------------------------------------------
-
-# Compilation.
-
-%.cmi: %.mli
- $(OCAMLC) $(PREFIXED_OCAMLINCLUDES) $(BFLAGS) $(SUGG_FLAGS) -c $<
-
-%.cmo: %.ml
- $(OCAMLC) $(PREFIXED_OCAMLINCLUDES) $(BFLAGS) $(SUGG_FLAGS) -c $<
-
-%.cmx %.o: %.ml
- $(OCAMLOPT) $(PREFIXED_OCAMLINCLUDES) $(OFLAGS) $(SUGG_FLAGS) -c $<
-
-%.ml: %.mll
- $(OCAMLLEX) $(LGFLAGS) $<
-
-%.ml %.mli: %.mla
- $(ALPHACAML) $<
-
-# ----------------------------------------------------------------
-
-# Linking.
-
-$(EXECUTABLE)$(OSUFFIX): $(addsuffix .cmx, $(MODULES))
- $(OCAMLOPT) -o $@ $(PREFIXED_OCAMLINCLUDES) $(OLNKFLAGS) $(SUGG_FLAGS) $(SUGG_OLNKFLAGS) $+
-
-$(EXECUTABLE)$(BSUFFIX): $(addsuffix .cmo, $(MODULES))
- $(OCAMLC) -o $@ $(PREFIXED_OCAMLINCLUDES) $(BLNKFLAGS) $(SUGG_FLAGS) $(SUGG_BLNKFLAGS) $+
-
-# ----------------------------------------------------------------
-
-# Menhir: multiple file projects.
-
-MenhirMulti(target, sources, options) =
- TARGETS = $(file $(target).ml $(target).mli)
- SOURCES = $(file $(sources))
- $(TARGETS): $(SOURCES)
- $(MENHIR) --ocamlc "$(OCAMLC) $(PREFIXED_OCAMLINCLUDES) $(BFLAGS)" $(MENHIR_FLAGS) --base $(target) $(options) $(SOURCES)
- .SCANNER: $(TARGETS): $(SOURCES)
- WrapScanner($(MENHIR) --ocamldep "$(OCAMLDEP)" --depend --base $(target) $(options) $(SOURCES))
-
-# Menhir: single file projects.
-
-MenhirMono(target, options) =
- MenhirMulti($(target), $(target).mly, $(options))
-
-# Menhir: automatic single file projects.
-# This causes every .mly file to be viewed as a single file project.
-
-MenhirAuto() =
- foreach (target, $(glob *.mly))
- MenhirMono($(removesuffix $(target)), $(EMPTY))
-
-# ----------------------------------------------------------------
-
-.PHONY: clean
-
-clean:
- /bin/rm -f $(EXECUTABLE)$(BSUFFIX) $(EXECUTABLE)$(OSUFFIX) $(GENERATED)
- /bin/rm -f *.cmi *.cmx *.cmo *.o *~ .*~ *.automaton *.conflicts *.annot
+++ /dev/null
-# Add --table on the next line to use Menhir's table-based back-end.
-PGFLAGS := --infer
-GENERATED := parser.ml parser.mli lexer.ml tokens.ml tokens.mli
-MODULES := parser lexer calc
-EXECUTABLE := calc
-OCAMLDEPWRAPPER := ../ocamldep.wrapper
-include ../Makefile.shared
-$(eval $(call menhir_monomodule,tokens,--only-tokens))
-$(eval $(call menhir_multimodule,parser,tokens.mly parser.mly,--external-tokens Tokens))
+++ /dev/null
-GENERATED = parser.ml parser.mli lexer.ml
-MODULES = parser lexer calc
-EXECUTABLE = calc
-OCAMLDEPWRAPPER = ../ocamldep.wrapper
-include ../OMakefile.shared
-MenhirAuto()
-.DEFAULT: $(EXECUTABLE)$(OSUFFIX)
+++ /dev/null
-#
-# Load the standard configuration.
-#
-open build/Common
-
-#
-# The command-line variables are defined *after* the
-# standard configuration has been loaded.
-#
-DefineCommandVars()
-
-#
-# Include the OMakefile in this directory.
-#
-.SUBDIRS: .
+++ /dev/null
-In this variant of the calc demo, the parser's semantic actions are
-parameterized over a structure, called [Semantics], which defines how numbers
-should be interpreted. The parser is later instantiated with floating-point
-numbers, so the calculator actually performs floating-point evaluation -- but
-the grammar specification is independent of this detail.
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* Let's do floating-point evaluation, for a change. *)
-
-module FloatSemantics = struct
-
- type number =
- float
-
- let inject =
- float_of_int
-
- let ( + ) = ( +. )
- let ( - ) = ( -. )
- let ( * ) = ( *. )
- let ( / ) = ( /. )
- let (~- ) = (~-. )
-
-end
-
-(* Let us now specialize our parameterized parser. *)
-
-module FloatParser =
- Parser.Make(FloatSemantics)
-
-(* The rest is as usual. *)
-
-let () =
- let stdinbuf = Lexing.from_channel stdin in
- while true do
- (* Read line by line. *)
- let linebuf = Lexing.from_string (Lexer.line stdinbuf) in
- try
- (* Run the parser on a single line of input. *)
- Printf.printf "%.1f\n%!" (FloatParser.main Lexer.token linebuf)
- with
- | Lexer.Error msg ->
- Printf.fprintf stderr "%s%!" msg
- | FloatParser.Error ->
- Printf.fprintf stderr "At offset %d: syntax error.\n%!" (Lexing.lexeme_start linebuf)
- done
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-{
- open Tokens
-
- exception Error of string
-
-}
-
-rule line = parse
-| ([^'\n']* '\n') as line
- { line }
-| eof
- { exit 0 }
-
-and token = parse
-| [' ' '\t']
- { token lexbuf }
-| '\n'
- { EOL }
-| ['0'-'9']+ as i
- { INT (int_of_string i) }
-| '+'
- { PLUS }
-| '-'
- { MINUS }
-| '*'
- { TIMES }
-| '/'
- { DIV }
-| '('
- { LPAREN }
-| ')'
- { RPAREN }
-| eof
- { exit 0 }
-| _
- { raise (Error (Printf.sprintf "At offset %d: unexpected character.\n" (Lexing.lexeme_start lexbuf))) }
-
+++ /dev/null
-/**************************************************************************/
-/* */
-/* Menhir */
-/* */
-/* François Pottier, INRIA Rocquencourt */
-/* Yann Régis-Gianas, PPS, Université Paris Diderot */
-/* */
-/* Copyright 2005-2008 Institut National de Recherche en Informatique */
-/* et en Automatique. All rights reserved. This file is distributed */
-/* under the terms of the Q Public License version 1.0, with the change */
-/* described in file LICENSE. */
-/* */
-/**************************************************************************/
-
-(* These are the functions that we need in order to write our semantic
- actions. *)
-
-%parameter<Semantics : sig
- type number
- val inject: int -> number
- val ( + ): number -> number -> number
- val ( - ): number -> number -> number
- val ( * ): number -> number -> number
- val ( / ): number -> number -> number
- val ( ~-): number -> number
-end>
-
-(* The parser no longer returns an integer; instead, it returns an
- abstract number. *)
-
-%start <Semantics.number> main
-
-(* Let us open the [Semantics] module, so as to make all of its
- operations available in the semantic actions. *)
-
-%{
-
- open Semantics
-
-%}
-
-%%
-
-main:
-| e = expr EOL
- { e }
-
-expr:
-| i = INT
- { inject i }
-| LPAREN e = expr RPAREN
- { e }
-| e1 = expr PLUS e2 = expr
- { e1 + e2 }
-| e1 = expr MINUS e2 = expr
- { e1 - e2 }
-| e1 = expr TIMES e2 = expr
- { e1 * e2 }
-| e1 = expr DIV e2 = expr
- { e1 / e2 }
-| MINUS e = expr %prec UMINUS
- { - e }
-
+++ /dev/null
-/**************************************************************************/
-/* */
-/* Menhir */
-/* */
-/* François Pottier, INRIA Rocquencourt */
-/* Yann Régis-Gianas, PPS, Université Paris Diderot */
-/* */
-/* Copyright 2005-2008 Institut National de Recherche en Informatique */
-/* et en Automatique. All rights reserved. This file is distributed */
-/* under the terms of the Q Public License version 1.0, with the change */
-/* described in file LICENSE. */
-/* */
-/**************************************************************************/
-
-(* We want the tokens to be independent of the [Semantics] parameter,
- so we declare them here, in a separate file, as opposed to within
- [parser.mly]. *)
-
-%token <int> INT
-%token PLUS MINUS TIMES DIV
-%token LPAREN RPAREN
-%token EOL
-
-%left PLUS MINUS /* lowest precedence */
-%left TIMES DIV /* medium precedence */
-%nonassoc UMINUS /* highest precedence */
-
-%%
-
+++ /dev/null
-# Add --table on the next line to use Menhir's table-based back-end.
-PGFLAGS := --infer
-GENERATED := tokens.ml tokens.mli algebraic.ml algebraic.mli reverse.ml reverse.mli lexer.ml
-MODULES := algebraic reverse lexer calc
-EXECUTABLE := calc
-OCAMLDEPWRAPPER := ../ocamldep.wrapper
-include ../Makefile.shared
-$(eval $(call menhir_monomodule,tokens,--only-tokens))
-$(eval $(call menhir_multimodule,algebraic,tokens.mly algebraic.mly common.mly,--external-tokens Tokens))
-$(eval $(call menhir_multimodule,reverse,tokens.mly reverse.mly common.mly,--external-tokens Tokens))
+++ /dev/null
-GENERATED = tokens.ml tokens.mli algebraic.ml algebraic.mli reverse.ml reverse.mli lexer.ml
-MODULES = algebraic reverse lexer calc
-EXECUTABLE = calc
-OCAMLDEPWRAPPER = ../ocamldep.wrapper
-include ../OMakefile.shared
-MenhirMono(tokens,--only-tokens)
-MenhirMulti(algebraic,tokens.mly algebraic.mly,--external-tokens Tokens)
-MenhirMulti(reverse,tokens.mly reverse.mly,--external-tokens Tokens)
-.DEFAULT: $(EXECUTABLE)$(OSUFFIX)
+++ /dev/null
-#
-# Load the standard configuration.
-#
-open build/Common
-
-#
-# The command-line variables are defined *after* the
-# standard configuration has been loaded.
-#
-DefineCommandVars()
-
-#
-# Include the OMakefile in this directory.
-#
-.SUBDIRS: .
+++ /dev/null
-This tiny program reads arithmetic expressions from the standard input
-channel. Each expression is expected to be complete when the current line
-ends. Its value is then displayed on the standard output channel.
-
-In this version, there is a single lexer, but there are two parsers, one for
-expressions in algebraic (that is, infix) notation, one for expressions in
-reverse Polish (that is, postfix) notation. One of the two parsers is selected
-at runtime via a command line switch.
-
-This demo illustrates how to build two parsers that share a single set of
-tokens (see tokens.mly) and that share some productions (see common.mly).
-
+++ /dev/null
-/**************************************************************************/
-/* */
-/* Menhir */
-/* */
-/* François Pottier, INRIA Rocquencourt */
-/* Yann Régis-Gianas, PPS, Université Paris Diderot */
-/* */
-/* Copyright 2005-2008 Institut National de Recherche en Informatique */
-/* et en Automatique. All rights reserved. This file is distributed */
-/* under the terms of the Q Public License version 1.0, with the change */
-/* described in file LICENSE. */
-/* */
-/**************************************************************************/
-
-(* This partial grammar specification defines the syntax of expressions
- in algebraic notation. *)
-
-%left PLUS MINUS /* lowest precedence */
-%left TIMES DIV /* medium precedence */
-%nonassoc UMINUS /* highest precedence */
-
-%%
-
-%public expr:
-| i = INT
- { i }
-| LPAREN e = expr RPAREN
- { e }
-| e1 = expr PLUS e2 = expr
- { e1 + e2 }
-| e1 = expr MINUS e2 = expr
- { e1 - e2 }
-| e1 = expr TIMES e2 = expr
- { e1 * e2 }
-| e1 = expr DIV e2 = expr
- { e1 / e2 }
-| MINUS e = expr %prec UMINUS
- { - e }
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-let algebraic =
- ref true
-
-let () =
- Arg.parse [
- "--algebraic", Arg.Set algebraic, " Use algebraic (that is, infix) notation";
- "--reverse", Arg.Clear algebraic, " Use reverse Polish (that is, postfix) notation";
- ] (fun _ -> ()) (Printf.sprintf "Usage: %s <options>" Sys.argv.(0))
-
-let main =
- if !algebraic then
- Algebraic.main
- else
- Reverse.main
-
-let () =
- let stdinbuf = Lexing.from_channel stdin in
- while true do
- (* Read line by line. *)
- let linebuf = Lexing.from_string (Lexer.line stdinbuf) in
- try
- (* Run the parser on a single line of input. *)
- Printf.printf "%d\n%!" (main Lexer.token linebuf)
- with
- | Lexer.Error msg ->
- Printf.fprintf stderr "%s%!" msg
- | Algebraic.Error
- | Reverse.Error ->
- Printf.fprintf stderr "At offset %d: syntax error.\n%!" (Lexing.lexeme_start linebuf)
- done
+++ /dev/null
-/**************************************************************************/
-/* */
-/* Menhir */
-/* */
-/* François Pottier, INRIA Rocquencourt */
-/* Yann Régis-Gianas, PPS, Université Paris Diderot */
-/* */
-/* Copyright 2005-2008 Institut National de Recherche en Informatique */
-/* et en Automatique. All rights reserved. This file is distributed */
-/* under the terms of the Q Public License version 1.0, with the change */
-/* described in file LICENSE. */
-/* */
-/**************************************************************************/
-
-(* This partial grammar specification defines the grammar's entry
- point to be an expression, followed with an end-of-line token. *)
-
-%start <int> main
-
-%%
-
-main:
-| e = expr EOL
- { e }
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-{
- open Tokens
-
- exception Error of string
-
-}
-
-rule line = parse
-| ([^'\n']* '\n') as line
- { line }
-| eof
- { exit 0 }
-
-and token = parse
-| [' ' '\t']
- { token lexbuf }
-| '\n'
- { EOL }
-| ['0'-'9']+ as i
- { INT (int_of_string i) }
-| '+'
- { PLUS }
-| '-'
- { MINUS }
-| '*'
- { TIMES }
-| '/'
- { DIV }
-| '('
- { LPAREN }
-| ')'
- { RPAREN }
-| eof
- { exit 0 }
-| _
- { raise (Error (Printf.sprintf "At offset %d: unexpected character.\n" (Lexing.lexeme_start lexbuf))) }
-
+++ /dev/null
-/**************************************************************************/
-/* */
-/* Menhir */
-/* */
-/* François Pottier, INRIA Rocquencourt */
-/* Yann Régis-Gianas, PPS, Université Paris Diderot */
-/* */
-/* Copyright 2005-2008 Institut National de Recherche en Informatique */
-/* et en Automatique. All rights reserved. This file is distributed */
-/* under the terms of the Q Public License version 1.0, with the change */
-/* described in file LICENSE. */
-/* */
-/**************************************************************************/
-
-(* This partial grammar specification defines the syntax of
- expressions in reverse Polish notation. Parentheses are
- meaningless, and unary minus is not supported (some other symbol
- than MINUS would be required in order to avoid an ambiguity). *)
-
-%%
-
-%public expr:
-| i = INT
- { i }
-| e1 = expr e2 = expr PLUS
- { e1 + e2 }
-| e1 = expr e2 = expr MINUS
- { e1 - e2 }
-| e1 = expr e2 = expr TIMES
- { e1 * e2 }
-| e1 = expr e2 = expr DIV
- { e1 / e2 }
-
+++ /dev/null
-/**************************************************************************/
-/* */
-/* Menhir */
-/* */
-/* François Pottier, INRIA Rocquencourt */
-/* Yann Régis-Gianas, PPS, Université Paris Diderot */
-/* */
-/* Copyright 2005-2008 Institut National de Recherche en Informatique */
-/* et en Automatique. All rights reserved. This file is distributed */
-/* under the terms of the Q Public License version 1.0, with the change */
-/* described in file LICENSE. */
-/* */
-/**************************************************************************/
-
-(* This partial grammar specification defines the set of tokens. *)
-
-%token <int> INT
-%token PLUS MINUS TIMES DIV
-%token LPAREN RPAREN
-%token EOL
-
-%%
-
+++ /dev/null
-*** omake: the project was last locked by madiran:5845.
+++ /dev/null
-# Add --table on the next line to use Menhir's table-based back-end.
-PGFLAGS := --infer
-GENERATED := parser.ml parser.mli lexer.ml
-MODULES := parser lexer calc
-EXECUTABLE := calc
-OCAMLDEPWRAPPER := ../ocamldep.wrapper
-include ../Makefile.shared
-include ../Makefile.auto
+++ /dev/null
-GENERATED = parser.ml parser.mli lexer.ml
-MODULES = parser lexer calc
-EXECUTABLE = calc
-OCAMLDEPWRAPPER = ../ocamldep.wrapper
-include ../OMakefile.shared
-MenhirAuto()
-.DEFAULT: $(EXECUTABLE)$(OSUFFIX)
+++ /dev/null
-#
-# Load the standard configuration.
-#
-open build/Common
-
-#
-# The command-line variables are defined *after* the
-# standard configuration has been loaded.
-#
-DefineCommandVars()
-
-#
-# Include the OMakefile in this directory.
-#
-.SUBDIRS: .
+++ /dev/null
-This tiny program reads arithmetic expressions from the standard input
-channel. Each expression is expected to be complete when the current line
-ends. Its value is then displayed on the standard output channel. This
-code is adapted from ocamlyacc's documentation.
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-let () =
- let stdinbuf = Lexing.from_channel stdin in
- while true do
- (* Read line by line. *)
- let linebuf = Lexing.from_string (Lexer.line stdinbuf) in
- try
- (* Run the parser on a single line of input. *)
- Printf.printf "%d\n%!" (Parser.main Lexer.token linebuf)
- with
- | Lexer.Error msg ->
- Printf.fprintf stderr "%s%!" msg
- | Parser.Error ->
- Printf.fprintf stderr "At offset %d: syntax error.\n%!" (Lexing.lexeme_start linebuf)
- done
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-{
- open Parser
-
- exception Error of string
-
-}
-
-rule line = parse
-| ([^'\n']* '\n') as line
- { line }
-| eof
- { exit 0 }
-
-and token = parse
-| [' ' '\t']
- { token lexbuf }
-| '\n'
- { EOL }
-| ['0'-'9']+ as i
- { INT (int_of_string i) }
-| '+'
- { PLUS }
-| '-'
- { MINUS }
-| '*'
- { TIMES }
-| '/'
- { DIV }
-| '('
- { LPAREN }
-| ')'
- { RPAREN }
-| eof
- { exit 0 }
-| _
- { raise (Error (Printf.sprintf "At offset %d: unexpected character.\n" (Lexing.lexeme_start lexbuf))) }
-
+++ /dev/null
-/**************************************************************************/
-/* */
-/* Menhir */
-/* */
-/* François Pottier, INRIA Rocquencourt */
-/* Yann Régis-Gianas, PPS, Université Paris Diderot */
-/* */
-/* Copyright 2005-2008 Institut National de Recherche en Informatique */
-/* et en Automatique. All rights reserved. This file is distributed */
-/* under the terms of the Q Public License version 1.0, with the change */
-/* described in file LICENSE. */
-/* */
-/**************************************************************************/
-
-%token <int> INT
-%token PLUS MINUS TIMES DIV
-%token LPAREN RPAREN
-%token EOL
-
-%left PLUS MINUS /* lowest precedence */
-%left TIMES DIV /* medium precedence */
-%nonassoc UMINUS /* highest precedence */
-
-%start <int> main
-
-%%
-
-main:
-| e = expr EOL
- { e }
-
-expr:
-| i = INT
- { i }
-| LPAREN e = expr RPAREN
- { e }
-| e1 = expr PLUS e2 = expr
- { e1 + e2 }
-| e1 = expr MINUS e2 = expr
- { e1 - e2 }
-| e1 = expr TIMES e2 = expr
- { e1 * e2 }
-| e1 = expr DIV e2 = expr
- { e1 / e2 }
-| MINUS e = expr %prec UMINUS
- { - e }
-
+++ /dev/null
-#!/usr/bin/env ocaml
-
-(* ocamldep.wrapper <filename> ... <filename> - <ocamldep command>
- runs the <ocamldep command> in an environment where all of the
- <filenames> listed appear to exist. The files are created, if
- required, before the command is run, and destroyed afterwards. *)
-
-(* An earlier version of this script acquired a lock, so as to prevent
- multiple instances of this script from interfering with one another.
- However, this did not prevent interference between this script and
- some other process (e.g., the ocaml compiler) which creates files.
- So, the lock has been removed. My suggestion is to never use this
- script in a concurrent setting. If you wish to use parallel make,
- then you might be able to use a two-level Makefile approach: first,
- compute all dependencies in a sequential manner; then, construct all
- targets in a parallel manner. *)
-
-#load "unix.cma"
-open Printf
-
-(* Parse the command line. The arguments that precede "-" are understood
- as file names and stored in the list [xs]. The arguments that follow
- "-" are understood as a command and stored in [command]. *)
-
-let xs =
- ref []
-
-let command =
- ref ""
-
-let verbose =
- ref false
-
-let rec loop accumulating i =
- if i = Array.length Sys.argv then
- ()
- else if accumulating then
- (* [accumulating] is [true] as long as we have not found the "-" marker *)
- match Sys.argv.(i) with
- | "-v" ->
- verbose := true;
- loop true (i+1)
- | "-" ->
- (* We have found the marker. The next parameter should be the name of
- the raw [ocamldep] command. Copy it to the command (unquoted --
- apparently some shells do not permit quoting a command name). *)
- let i = i + 1 in
- assert (i < Array.length Sys.argv);
- command := Sys.argv.(i);
- (* Stop accumulating file names. Copy the remaining arguments into
- the command. *)
- loop false (i+1)
- | _ ->
- (* Continue accumulating file names in [xs]. *)
- xs := Sys.argv.(i) :: !xs;
- loop true (i+1)
- else begin
- (* After we have found the "-" marker, the remaining arguments are
- copied (quoted) into the command. *)
- command := sprintf "%s %s" !command (Filename.quote Sys.argv.(i));
- loop false (i+1)
- end
-
-let () =
- loop true 1
-
-(* Create the required files if they don't exist, run the command,
- then destroy any files that we have created. *)
-
-let rec loop = function
- | [] ->
- if !verbose then
- fprintf stderr "ocamldep.wrapper: running %s\n" !command;
- Sys.command !command
- | x :: xs ->
- if Sys.file_exists x then
- loop xs
- else begin
- if !verbose then
- fprintf stderr "ocamldep.wrapper: creating fake %s\n" x;
- let c = open_out x in
- close_out c;
- let exitcode = loop xs in
- if Sys.file_exists x then begin
- try
- if !verbose then
- fprintf stderr "ocamldep.wrapper: removing fake %s..." x;
- Sys.remove x;
- if !verbose then
- fprintf stderr " ok\n"
- with Sys_error _ ->
- if !verbose then
- fprintf stderr " failed\n"
- end;
- exitcode
- end
-
-let () =
- exit (loop !xs)
+++ /dev/null
-.\" Hey, EMACS: -*- nroff -*-
-.TH MENHIR 1 "April 19, 2006"
-.\" Please adjust this date whenever revising the manpage.
-.\"
-.\" Some roff macros, for reference:
-.\" .nh disable hyphenation
-.\" .hy enable hyphenation
-.\" .ad l left justify
-.\" .ad b justify to both left and right margins
-.\" .nf disable filling
-.\" .fi enable filling
-.\" .br insert line break
-.\" .sp <n> insert n+1 empty lines
-.\" for manpage-specific macros, see man(7)
-
-
-.SH NAME
-menhir \- parser generator for OCaml
-
-
-.SH SYNOPSIS
-.B menhir
-.RI [ options ] " files"
-.SH DESCRIPTION
-.B menhir
-is a LR(1) parser generator for the Objective Caml programming language. That is, Menhir compiles LR(1) grammar specifications down to Objective Caml code. It is mostly compatible with
-.BR ocamlyacc (1).
-
-
-.SH OPTIONS
-.TP
-.B \-h, \-\-help
-Show summary of options.
-.TP
-.BI \-b,\ \-\-base\ basename
-Specifies a base name for the output file(s).
-.TP
-.B \-\-comment
-Include comments in the generated code.
-.TP
-.B \-\-depend
-Invoke ocamldep and display dependencies.
-.TP
-.B \-\-dump
-Describe the automaton in
-.IR basename .automaton.
-.TP
-.B \-\-error\-recovery
-Attempt recovery by discarding tokens after errors.
-.TP
-.B \-\-explain
-Explain conflicts in
-.IR basename .conflicts.
-.TP
-.BI \-\-external\-tokens\ module
-Import token type definition from
-.IR module .
-.TP
-.B \-\-graph
-Write grammar's dependency graph to
-.IR basename .dot.
-.TP
-.B \-\-infer
-Invoke ocamlc for ahead of time type inference.
-.TP
-.B \-\-interpret
-Interpret the sentences provided on stdin.
-.TP
-.B \-\-interpret\-show\-cst
-Show a concrete syntax tree upon acceptance.
-.TP
-.BI \-la,\ \-\-log\-automaton\ level
-Log information about the automaton.
-.TP
-.BI \-lc,\ \-\-log\-code\ level
-Log information about the generated code.
-.TP
-.BI \-lg,\ \-\-log\-grammar\ level
-Log information about the grammar.
-.TP
-.B \-\-no\-inline
-Ignore the %inline keyword.
-.TP
-.B \-\-no\-stdlib
-Do not load the standard library.
-.TP
-.BI \-\-ocamlc\ command
-Specifies how ocamlc should be invoked.
-.TP
-.BI \-\-ocamldep\ command
-Specifies how ocamldep should be invoked.
-.TP
-.B \-\-only\-preprocess
-Print a simplified grammar and exit.
-.TP
-.B \-\-only\-tokens
-Generate token type definition only, no code.
-.TP
-.B \-\-raw\-depend
-Invoke ocamldep and echo its raw output.
-.TP
-.BI \-\-stdlib\ directory
-Specify where the standard library lies.
-.TP
-.B \-\-suggest\-comp\-flags
-Suggest compilation flags for ocaml{c,opt}.
-.TP
-.B \-\-suggest\-link\-flags-byte
-Suggest link flags for ocamlc.
-.TP
-.B \-\-suggest\-link\-flags-opt
-Suggest link flags for ocamlopt.
-.TP
-.B \-t, \-\-table
-Use the table-based back-end.
-.TP
-.B \-\-timings
-Display internal timings.
-.TP
-.B \-\-trace
-Include tracing instructions in the generated code.
-.TP
-.B \-\-version
-Show version number and exit.
-.TP
-.B \-v
-Synonymous with
-.BR \-\-dump\ \-\-explain .
-
-
-.SH SEE ALSO
-.BR ocaml (1).
-
-
-.SH AUTHOR
-.B menhir
-was written by François Pottier and Yann Régis-Gianas.
-.PP
-This manual page was written by Samuel Mimram <smimram@debian.org>,
-for the Debian project (but may be used by others).
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* -------------------------------------------------------------------------- *)
-
-(* Maps. *)
-
-(* We require imperative maps, that is, maps that can be updated in place.
- An implementation of persistent maps, such as the one offered by ocaml's
- standard library, can easily be turned into an implementation of imperative
- maps, so this is a weak requirement. *)
-
-module type IMPERATIVE_MAPS = sig
- type key
- type 'data t
- val create: unit -> 'data t
- val clear: 'data t -> unit
- val add: key -> 'data -> 'data t -> unit
- val find: key -> 'data t -> 'data
- val iter: (key -> 'data -> unit) -> 'data t -> unit
-end
-
-(* -------------------------------------------------------------------------- *)
-
-(* Properties. *)
-
-(* Properties must form a partial order, equipped with a least element, and
- must satisfy the ascending chain condition: every monotone sequence
- eventually stabilizes. *)
-
-(* [is_maximal] determines whether a property [p] is maximal with respect to
- the partial order. Only a conservative check is required: in any event, it
- is permitted for [is_maximal p] to return [false]. If [is_maximal p]
- returns [true], then [p] must have no upper bound other than itself. In
- particular, if properties form a lattice, then [p] must be the top
- element. This feature, not described in the paper, enables a couple of
- minor optimizations. *)
-
-module type PROPERTY = sig
- type property
- val bottom: property
- val equal: property -> property -> bool
- val is_maximal: property -> bool
-end
-
-(* -------------------------------------------------------------------------- *)
-
-(* The dynamic dependency graph. *)
-
-(* An edge from [node1] to [node2] means that [node1] depends on [node2], or
- (equivalently) that [node1] observes [node2]. Then, an update of the
- current property at [node2] causes a signal to be sent to [node1]. A node
- can observe itself. *)
-
-(* This module could be placed in a separate file, but is included here in
- order to make [Fix] self-contained. *)
-
-module Graph : sig
-
- (* This module provides a data structure for maintaining and modifying
- a directed graph. Each node is allowed to carry a piece of client
- data. There are functions for creating a new node, looking up a
- node's data, looking up a node's predecessors, and setting or
- clearing a node's successors (all at once). *)
- type 'data node
-
- (* [create data] creates a new node, with no incident edges, with
- client information [data]. Time complexity: constant. *)
- val create: 'data -> 'data node
-
- (* [data node] returns the client information associated with
- the node [node]. Time complexity: constant. *)
- val data: 'data node -> 'data
-
- (* [predecessors node] returns a list of [node]'s predecessors.
- Amortized time complexity: linear in the length of the output
- list. *)
- val predecessors: 'data node -> 'data node list
-
- (* [set_successors src dsts] creates an edge from the node [src] to
- each of the nodes in the list [dsts]. Duplicate elements in the
- list [dsts] are removed, so that no duplicate edges are created. It
- is assumed that [src] initially has no successors. Time complexity:
- linear in the length of the input list. *)
- val set_successors: 'data node -> 'data node list -> unit
-
- (* [clear_successors node] removes all of [node]'s outgoing edges.
- Time complexity: linear in the number of edges that are removed. *)
- val clear_successors: 'data node -> unit
-
- (* That's it. *)
-end
-= struct
-
- (* Using doubly-linked adjacency lists, one could implement [predecessors]
- in worst-case linear time with respect to the length of the output list,
- [set_successors] in worst-case linear time with respect to the length of
- the input list, and [clear_successors] in worst-case linear time with
- respect to the number of edges that are removed. We use a simpler
- implementation, based on singly-linked adjacency lists, with deferred
- removal of edges. It achieves the same complexity bounds, except
- [predecessors] only offers an amortized complexity bound. This is good
- enough for our purposes, and, in practice, is more efficient by a
- constant factor. This simplification was suggested by Arthur
- Charguéraud. *)
-
- type 'data node = {
-
- (* The client information associated with this node. *)
-
- data: 'data;
-
- (* This node's incoming and outgoing edges. *)
-
- mutable outgoing: 'data edge list;
- mutable incoming: 'data edge list;
-
- (* A transient mark, always set to [false], except when checking
- against duplicate elements in a successor list. *)
-
- mutable marked: bool;
-
- }
-
- and 'data edge = {
-
- (* This edge's nodes. Edges are symmetric: source and destination
- are not distinguished. Thus, an edge appears both in the outgoing
- edge list of its source node and in the incoming edge list of its
- destination node. This allows edges to be easily marked as
- destroyed. *)
-
- node1: 'data node;
- node2: 'data node;
-
- (* Edges that are destroyed are marked as such, but are not
- immediately removed from the adjacency lists. *)
-
- mutable destroyed: bool;
-
- }
-
- let create (data : 'data) : 'data node = {
- data = data;
- outgoing = [];
- incoming = [];
- marked = false;
- }
-
- let data (node : 'data node) : 'data =
- node.data
-
- (* [follow src edge] returns the node that is connected to [src]
- by [edge]. Time complexity: constant. *)
-
- let follow src edge =
- if edge.node1 == src then
- edge.node2
- else begin
- assert (edge.node2 == src);
- edge.node1
- end
-
- (* The [predecessors] function removes edges that have been marked
- destroyed. The cost of removing these has already been paid for,
- so the amortized time complexity of [predecessors] is linear in
- the length of the output list. *)
-
- let predecessors (node : 'data node) : 'data node list =
- let predecessors = List.filter (fun edge -> not edge.destroyed) node.incoming in
- node.incoming <- predecessors;
- List.map (follow node) predecessors
-
- (* [link src dst] creates a new edge from [src] to [dst], together
- with its reverse edge. Time complexity: constant. *)
-
- let link (src : 'data node) (dst : 'data node) : unit =
- let edge = {
- node1 = src;
- node2 = dst;
- destroyed = false;
- } in
- src.outgoing <- edge :: src.outgoing;
- dst.incoming <- edge :: dst.incoming
-
- let set_successors (src : 'data node) (dsts : 'data node list) : unit =
- assert (src.outgoing = []);
- let rec loop = function
- | [] ->
- ()
- | dst :: dsts ->
- if dst.marked then
- loop dsts (* skip duplicate elements *)
- else begin
- dst.marked <- true;
- link src dst;
- loop dsts;
- dst.marked <- false
- end
- in
- loop dsts
-
- let clear_successors (node : 'data node) : unit =
- List.iter (fun edge ->
- assert (not edge.destroyed);
- edge.destroyed <- true;
- ) node.outgoing;
- node.outgoing <- []
-
-end
-
-(* -------------------------------------------------------------------------- *)
-
-(* The code is parametric in an implementation of maps over variables and in
- an implementation of properties. *)
-
-module Make
- (M : IMPERATIVE_MAPS)
- (P : PROPERTY)
-= struct
-
-type variable =
- M.key
-
-type property =
- P.property
-
-type valuation =
- variable -> property
-
-type rhs =
- valuation -> property
-
-type equations =
- variable -> rhs
-
-(* -------------------------------------------------------------------------- *)
-
-(* Data. *)
-
-(* Each node in the dependency graph carries information about a fixed
- variable [v]. *)
-
-type node =
- data Graph.node
-
-and data = {
-
- (* This is the result of the application of [rhs] to the variable [v]. It
- must be stored in order to guarantee that this application is performed
- at most once. *)
- rhs: rhs;
-
- (* This is the current property at [v]. It evolves monotonically with
- time. *)
- mutable property: property;
-
- (* That's it! *)
-}
-
-(* [property node] returns the current property at [node]. *)
-
-let property node =
- (Graph.data node).property
-
-(* -------------------------------------------------------------------------- *)
-
-(* Many definitions must be made within the body of the function [lfp].
- For greater syntactic convenience, we place them in a local module. *)
-
-let lfp (eqs : equations) : valuation =
- let module LFP = struct
-
-(* -------------------------------------------------------------------------- *)
-
-(* The workset. *)
-
-(* When the algorithm is inactive, the workset is empty. *)
-
-(* Our workset is based on a Queue, but it could just as well be based on a
- Stack. A textual replacement is possible. It could also be based on a
- priority queue, provided a sensible way of assigning priorities could
- be found. *)
-
-module Workset : sig
-
- (* [insert node] inserts [node] into the workset. [node] must have no
- successors. *)
- val insert: node -> unit
-
- (* [repeat f] repeatedly applies [f] to a node extracted out of the
- workset, until the workset becomes empty. [f] is allowed to use
- [insert]. *)
- val repeat: (node -> unit) -> unit
-
- (* That's it! *)
-end
-= struct
-
- (* Initialize the workset. *)
-
- let workset =
- Queue.create()
-
- let insert node =
- Queue.push node workset
-
- let repeat f =
- while not (Queue.is_empty workset) do
- f (Queue.pop workset)
- done
-
-end
-
-(* -------------------------------------------------------------------------- *)
-
-(* Signals. *)
-
-(* A node in the workset has no successors. (It can have predecessors.) In
- other words, a predecessor (an observer) of some node is never in the
- workset. Furthermore, a node never appears twice in the workset. *)
-
-(* When a variable broadcasts a signal, all of its predecessors (observers)
- receive the signal. Any variable that receives the signal loses all of its
- successors (that is, it ceases to observe anything) and is inserted into
- the workset. This preserves the above invariant. *)
-
-let signal subject =
- List.iter (fun observer ->
- Graph.clear_successors observer;
- Workset.insert observer
- ) (Graph.predecessors subject)
- (* At this point, [subject] has no predecessors. This plays no role in
- the correctness proof, though. *)
-
-(* -------------------------------------------------------------------------- *)
-
-(* Tables. *)
-
-(* The permanent table maps variables that have reached a fixed point
- to properties. It persists forever. *)
-
-let permanent : property M.t =
- M.create()
-
-(* The transient table maps variables that have not yet reached a
- fixed point to nodes. (A node contains not only a property, but
- also a memoized right-hand side, and carries edges.) At the
- beginning of a run, it is empty. It fills up during a run. At the
- end of a run, it is copied into the permanent table and cleared. *)
-
-let transient : node M.t =
- M.create()
-
-(* [freeze()] copies the transient table into the permanent table, and
- empties the transient table. This allows all nodes to be reclaimed
- by the garbage collector. *)
-
-let freeze () =
- M.iter (fun v node ->
- M.add v (property node) permanent
- ) transient;
- M.clear transient
-
-(* -------------------------------------------------------------------------- *)
-
-(* Workset processing. *)
-
-
-(* [solve node] re-evaluates the right-hand side at [node]. If this leads to
- a change, then the current property is updated, and [node] emits a signal
- towards its observers. *)
-
-(* When [solve node] is invoked, [node] has no subjects. Indeed, when [solve]
- is invoked by [node_for], [node] is newly created; when [solve] is invoked by
- [Workset.repeat], [node] has just been extracted out of the workset, and a
- node in the workset has no subjects. *)
-
-(* [node] must not be in the workset. *)
-
-(* In short, when [solve node] is invoked, [node] is neither awake nor asleep.
- When [solve node] finishes, [node] is either awake or asleep again. (Chances
- are, it is asleep, unless it is its own observer; then, it is awakened by the
- final call to [signal node].) *)
-
-let rec solve (node : node) : unit =
-
- (* Retrieve the data record carried by this node. *)
- let data = Graph.data node in
-
- (* Prepare to compute an updated value at this node. This is done by
- invoking the client's right-hand side function. *)
-
- (* The flag [alive] is used to prevent the client from invoking [request]
- after this interaction phase is over. In theory, this dynamic check seems
- required in order to argue that [request] behaves like a pure function.
- In practice, this check is not very useful: only a bizarre client would
- store a [request] function and invoke it after it has become stale. *)
- let alive = ref true
- and subjects = ref [] in
-
- (* We supply the client with [request], a function that provides access to
- the current valuation, and dynamically records dependencies. This yields
- a set of dependencies that is correct by construction. *)
- let request (v : variable) : property =
- assert !alive;
- try
- M.find v permanent
- with Not_found ->
- let subject = node_for v in
- let p = property subject in
- if not (P.is_maximal p) then
- subjects := subject :: !subjects;
- p
- in
-
- (* Give control to the client. *)
- let new_property = data.rhs request in
-
- (* From now on, prevent any invocation of this instance of [request]
- the client. *)
- alive := false;
-
- (* At this point, [node] has no subjects, as noted above. Thus, the
- precondition of [set_successors] is met. We can install [data.subjects]
- as the new set of subjects for this node. *)
-
- (* If we have gathered no subjects in the list [data.subjects], then
- this node must have stabilized. If [new_property] is maximal,
- then this node must have stabilized. *)
-
- (* If this node has stabilized, then it need not observe any more, so the
- call to [set_successors] is skipped. In practice, this seems to be a
- minor optimization. In the particular case where every node stabilizes at
- the very first call to [rhs], this means that no edges are ever
- built. This particular case is unlikely, as it means that we are just
- doing memoization, not a true fixed point computation. *)
-
- (* One could go further and note that, if this node has stabilized, then it
- could immediately be taken out of the transient table and copied into the
- permanent table. This would have the beneficial effect of allowing the
- detection of further nodes that have stabilized. Furthermore, it would
- enforce the property that no node in the transient table has a maximal
- value, hence the call to [is_maximal] above would become useless. *)
-
- if not (!subjects = [] || P.is_maximal new_property) then
- Graph.set_successors node !subjects;
-
- (* If the updated value differs from the previous value, record
- the updated value and send a signal to all observers of [node]. *)
- if not (P.equal data.property new_property) then begin
- data.property <- new_property;
- signal node
- end
- (* Note that equality of the two values does not imply that this node has
- stabilized forever. *)
-
-(* -------------------------------------------------------------------------- *)
-
-(* [node_for v] returns the graph node associated with the variable [v]. It is
- assumed that [v] does not appear in the permanent table. If [v] appears in
- the transient table, the associated node is returned. Otherwise, [v] is a
- newly discovered variable: a new node is created on the fly, and the
- transient table is grown. The new node can either be inserted into the
- workset (it is then awake) or handled immediately via a recursive call to
- [solve] (it is then asleep, unless it observes itself). *)
-
-(* The recursive call to [solve node] can be replaced, if desired, by a call
- to [Workset.insert node]. Using a recursive call to [solve] permits eager
- top-down discovery of new nodes. This can save a constant factor, because
- it allows new nodes to move directly from [bottom] to a good first
- approximation, without sending any signals, since [node] has no observers
- when [solve node] is invoked. In fact, if the dependency graph is acyclic,
- the algorithm discovers nodes top-down, performs computation on the way
- back up, and runs without ever inserting a node into the workset!
- Unfortunately, this causes the stack to grow as deep as the longest path in
- the dependency graph, which can blow up the stack. *)
-
-and node_for (v : variable) : node =
- try
- M.find v transient
- with Not_found ->
- let node = Graph.create { rhs = eqs v; property = P.bottom } in
- (* Adding this node to the transient table prior to calling [solve]
- recursively is mandatory, otherwise [solve] might loop, creating
- an infinite number of nodes for the same variable. *)
- M.add v node transient;
- solve node; (* or: Workset.insert node *)
- node
-
-(* -------------------------------------------------------------------------- *)
-
-(* Invocations of [get] trigger the fixed point computation. *)
-
-(* The flag [inactive] prevents reentrant calls by the client. *)
-
-let inactive =
- ref true
-
-let get (v : variable) : property =
- try
- M.find v permanent
- with Not_found ->
- assert !inactive;
- inactive := false;
- let node = node_for v in
- Workset.repeat solve;
- freeze();
- inactive := true;
- property node
-
-(* -------------------------------------------------------------------------- *)
-
-(* Close the local module [LFP]. *)
-
-end
-in LFP.get
-
-end
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This code is described in the paper ``Lazy Least Fixed Points in ML''. *)
-
-(* -------------------------------------------------------------------------- *)
-
-(* Maps. *)
-
-(* We require imperative maps, that is, maps that can be updated in place.
- An implementation of persistent maps, such as the one offered by ocaml's
- standard library, can easily be turned into an implementation of imperative
- maps, so this is a weak requirement. *)
-
-module type IMPERATIVE_MAPS = sig
- type key
- type 'data t
- val create: unit -> 'data t
- val clear: 'data t -> unit
- val add: key -> 'data -> 'data t -> unit
- val find: key -> 'data t -> 'data
- val iter: (key -> 'data -> unit) -> 'data t -> unit
-end
-
-(* -------------------------------------------------------------------------- *)
-
-(* Properties. *)
-
-(* Properties must form a partial order, equipped with a least element, and
- must satisfy the ascending chain condition: every monotone sequence
- eventually stabilizes. *)
-
-(* [is_maximal] determines whether a property [p] is maximal with respect to
- the partial order. Only a conservative check is required: in any event, it
- is permitted for [is_maximal p] to return [false]. If [is_maximal p]
- returns [true], then [p] must have no upper bound other than itself. In
- particular, if properties form a lattice, then [p] must be the top
- element. This feature, not described in the paper, enables a couple of
- minor optimizations. *)
-
-module type PROPERTY = sig
- type property
- val bottom: property
- val equal: property -> property -> bool
- val is_maximal: property -> bool
-end
-
-(* -------------------------------------------------------------------------- *)
-
-(* The code is parametric in an implementation of maps over variables and in
- an implementation of properties. *)
-
-module Make
- (M : IMPERATIVE_MAPS)
- (P : PROPERTY)
- : sig
- type variable = M.key
- type property = P.property
-
- (* A valuation is a mapping of variables to properties. *)
- type valuation = variable -> property
-
- (* A right-hand side, when supplied with a valuation that gives
- meaning to its free variables, evaluates to a property. More
- precisely, a right-hand side is a monotone function of
- valuations to properties. *)
- type rhs = valuation -> property
-
- (* A system of equations is a mapping of variables to right-hand
- sides. *)
- type equations = variable -> rhs
-
- (* [lfp eqs] produces the least solution of the system of monotone
- equations [eqs]. *)
-
- (* It is guaranteed that, for each variable [v], the application [eqs v] is
- performed at most once (whereas the right-hand side produced by this
- application is, in general, evaluated multiple times). This guarantee can
- be used to perform costly pre-computation, or memory allocation, when [eqs]
- is applied to its first argument. *)
-
- (* When [lfp] is applied to a system of equations [eqs], it performs no
- actual computation. It produces a valuation, [get], which represents
- the least solution of the system of equations. The actual fixed point
- computation takes place, on demand, when [get] is applied. *)
- val lfp: equations -> valuation
- end
-
\ No newline at end of file
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* Abstract syntax of the language used for code production. *)
-
-type program = {
-
- (* The structure of programs is pretty ad hoc: the following components
- must be printed in this order -- so there is no way for a module
- definition to follow a recursive value definition, for instance.
- This is tolerable for the time being, but may have to change in the
- future. *)
-
- (* Functor parameters. *)
- paramdefs: Stretch.t list;
-
- (* Raw Objective Caml prologue. *)
- prologue: Stretch.t list;
-
- (* Exception definitions. *)
- excdefs: excdef list;
-
- (* Algebraic data type definitions (mutually recursive). *)
- typedefs: typedef list;
-
- (* Value definitions (not mutually recursive). *)
- nonrecvaldefs: valdef list;
-
- (* Module definitions. *)
- moduledefs: moduledef list;
-
- (* Function definitions (mutually recursive). *)
- valdefs: valdef list;
-
- (* Raw Objective Caml postlogue. *)
- postlogue: string list;
-
- }
-
-and interface = {
-
- (* Functor parameters. *)
- paramdecls: Stretch.t list;
-
- (* Exception definitions. *)
- excdecls: excdef list;
-
- (* Algebraic data type declarations (mutually recursive). *)
- typedecls: typedef list;
-
- (* Value declarations. *)
- valdecls: (string * typescheme) list
-
- }
-
-and excdef = {
-
- (* Name of the exception. *)
- excname: string;
-
- (* Optional equality. *)
- exceq: string option;
-
- }
-
-and typedef = {
-
- (* Name of the algebraic data type. *)
- typename: string;
-
- (* Type parameters. This is a list of type variable names,
- without the leading quote, which will be added by the
- pretty-printer. *)
- typeparams: string list;
-
- (* Data constructors. *)
- typerhs: typedefrhs;
-
- (* Constraint. *)
- typeconstraint: (typ * typ) option
-
- }
-
-and typedefrhs =
- | TDefRecord of fielddef list
- | TDefSum of datadef list
- | TAbbrev of typ
-
-and fielddef = {
-
- (* Whether the field is mutable. *)
- modifiable: bool;
-
- (* Name of the field. *)
- fieldname: string;
-
- (* Type of the field. *)
- fieldtype: typescheme
-
- }
-
-and datadef = {
-
- (* Name of the data constructor. *)
- dataname: string;
-
- (* Types of the value parameters. *)
- datavalparams: typ list;
-
- (* Instantiated type parameters, if this is a GADT --
- [None] if this is an ordinary ADT. *)
- datatypeparams: typ list option;
-
- }
-
-and typ =
-
- (* Textual Objective Caml type. *)
- | TypTextual of Stretch.ocamltype
-
- (* Type variable, without its leading quote. *)
- | TypVar of string
-
- (* Application of an algebraic data type constructor. *)
- | TypApp of string * typ list
-
- (* Anonymous tuple. *)
- | TypTuple of typ list
-
- (* Arrow type. *)
- | TypArrow of typ * typ
-
-and typescheme = {
-
- (* Universal quantifiers, without leading quotes. *)
- quantifiers: string list;
-
- (* Body. *)
- body: typ;
-
- }
-
-and valdef = {
-
- (* Whether the value is public. Public values cannot be
- suppressed by the inliner. They serve as seeds for the
- dead code analysis. *)
-
- valpublic: bool;
-
- (* Definition's left-hand side. *)
- valpat: pattern;
-
- (* Value to which it is bound. *)
- valval: expr
-
- }
-
-and expr =
-
- (* Variable. *)
- | EVar of string
-
- (* Function. *)
- | EFun of pattern list * expr
-
- (* Function call. *)
- | EApp of expr * expr list
-
- (* Local definitions. This is a nested sequence of [let]
- definitions. *)
- | ELet of (pattern * expr) list * expr
-
- (* Case analysis. *)
- | EMatch of expr * branch list
- | EIfThen of expr * expr
- | EIfThenElse of expr * expr * expr
-
- (* Raising exceptions. *)
- | ERaise of expr
-
- (* Exception analysis. *)
- | ETry of expr * branch list
-
- (* Data construction. Tuples of length 1 are considered nonexistent,
- that is, [ETuple [e]] is considered the same expression as [e]. *)
-
- | EUnit
- | EIntConst of int
- | EStringConst of string
- | EData of string * expr list
- | ETuple of expr list
-
- (* Type annotation. *)
- | EAnnot of expr * typescheme
-
- (* Cheating on the typechecker. *)
- | EMagic of expr (* Obj.magic *)
- | ERepr of expr (* Obj.repr *)
-
- (* Records. *)
- | ERecord of (string * expr) list
- | ERecordAccess of expr * string
- | ERecordWrite of expr * string * expr
-
- (* Textual Objective Caml code. *)
- | ETextual of Stretch.t
-
- (* Comments. *)
- | EComment of string * expr
- | EPatComment of string * pattern * expr
-
- (* Arrays. *)
- | EArray of expr list
- | EArrayAccess of expr * expr
-
-and branch = {
-
- (* Branch pattern. *)
- branchpat: pattern;
-
- (* Branch body. *)
- branchbody: expr;
-
- }
-
-and pattern =
-
- (* Wildcard. *)
- | PWildcard
-
- (* Variable. *)
- | PVar of string
-
- (* Data deconstruction. Tuples of length 1 are considered nonexistent,
- that is, [PTuple [p]] is considered the same pattern as [p]. *)
- | PUnit
- | PData of string * pattern list
- | PTuple of pattern list
- | PRecord of (string * pattern) list
-
- (* Disjunction. *)
- | POr of pattern list
-
- (* Type annotation. *)
- | PAnnot of pattern * typ
-
-and directive =
- | DirOpen of string
- | DirInclude of string
-
-(* Module definitions. *)
-
-and moduledef = {
-
- (* The name of the module that is being defined. *)
-
- modulename: string;
-
- (* The module expression to which it is being bound. *)
-
- modulerhs: modexpr;
-
-}
-
-(* Module expressions. *)
-
-and modexpr =
- | MVar of string
- | MStruct of structure
- | MApp of modexpr * modexpr
-
-(* Structures. This is somewhat redundant with the structure of programs,
- but will do for now. *)
-
-and structure = {
-
- (* Exception definitions. *)
- struct_excdefs: excdef list;
-
- (* Algebraic data type definitions (mutually recursive). *)
- struct_typedefs: typedef list;
-
- (* Value definitions (not mutually recursive). *)
- struct_nonrecvaldefs: valdef list;
-
-}
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* Input-output utilities. *)
-
-(* ------------------------------------------------------------------------- *)
-(* [exhaust channel] reads all of the data that's available on [channel]. *)
-
-let chunk_size =
- 2048
-
-let exhaust channel =
- let buffer = Buffer.create chunk_size in
- let chunk = String.create chunk_size in
- let rec loop () =
- let length = input channel chunk 0 chunk_size in
- if length = 0 then
- Buffer.contents buffer
- else begin
- Buffer.add_substring buffer chunk 0 length;
- loop()
- end
- in
- loop()
-
-(* ------------------------------------------------------------------------- *)
-(* [invoke command] invokes an external command (which expects no
- input) and returns its output, if the command succeeds. It returns
- [None] if the command fails. *)
-
-let invoke command =
- let ic = Unix.open_process_in command in
- let result = exhaust ic in
- match Unix.close_process_in ic with
- | Unix.WEXITED 0 ->
- Some result
- | _ ->
- None
-
-(* ------------------------------------------------------------------------- *)
-(* [winvoke writers command cleaners] invokes each of the [writer]
- functions, invokes the command [command], and runs each of the
- [cleaner] functions. Then, it either returns the command's output,
- if the command succeeded, or exits, otherwise. *)
-
-let winvoke writers command cleaners =
- let call action =
- action ()
- in
- List.iter call writers;
- let output = invoke command in
- List.iter call cleaners;
-
- (* Stop if the command failed. Otherwise, return its output. *)
-
- match output with
- | None ->
- (* Presumably, the command printed an error message for us. *)
- exit 1
- | Some output ->
- output
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* Input-output utilities. *)
-
-(* [exhaust channel] reads all of the data that's available on [channel]. *)
-
-val exhaust: in_channel -> string
-
-(* [invoke command] invokes an external command (which expects no input)
- and returns its output, if the command succeeds. It returns [None] if
- the command fails. *)
-
-val invoke: string -> string option
-
-(* [winvoke writers command cleaners] invokes each of the [writer]
- functions, invokes the command [command], and runs each of the
- [cleaner] functions. Then, it either returns the command's output,
- if the command succeeded, or exits, otherwise. *)
-
-val winvoke: (unit -> unit) list -> string -> (unit -> unit) list -> string
-
+++ /dev/null
-requires = ""
-description = "Runtime support for code generated by Menhir"
-archive(byte) = "menhirLib.cmo"
-archive(native) = "menhirLib.cmx"
-version = "20120123"
+++ /dev/null
-.PHONY: clean
-
-COLD += clean
-
-# ----------------------------------------------------------------------------
-
-# A few settings differ on Windows versus Unix.
-
-include ../Makefile.arch
-
-# ----------------------------------------------------------------------------
-# Locating the ocaml compilers.
-# If ocamlfind is available, then it is used for that purpose.
-
-CAMLTOP := ocaml
-
-CAMLC := $(shell if ocamlfind ocamlc -v >/dev/null 2>&1 ; \
- then echo ocamlfind ocamlc ; \
- elif ocamlc.opt -v >/dev/null 2>&1 ; \
- then echo ocamlc.opt ; \
- else echo ocamlc ; fi)
-
-CAMLOPT := $(shell if ocamlfind ocamlopt -v >/dev/null 2>&1 ; \
- then echo ocamlfind ocamlopt ; \
- elif ocamlopt.opt -v >/dev/null 2>&1 ; \
- then echo ocamlopt.opt ; \
- else echo ocamlopt ; fi)
-
-CAMLDEP := $(shell if ocamlfind ocamldep -version >/dev/null 2>&1 ; \
- then echo ocamlfind ocamldep ; \
- elif ocamldep.opt -version >/dev/null 2>&1 ; \
- then echo ocamldep.opt ; \
- else echo ocamldep ; fi)
-
-CAMLDEPWRAPPER := ../demos/ocamldep.wrapper
-
-CAMLLEX := ocamllex
-
-CAMLYACC := ocamlyacc -v
-
-# -------------------------------------------------------------------------
-
-# Compilation flags.
-
-BFLAGS := -g
-OFLAGS := -inline 1000
-LNKBFLAGS := -g
-LNKOFLAGS :=
-BLIBS := unix.cma
-OLIBS := unix.cmxa
-PGFLAGS := -v -lg 1 -la 1 -lc 1 --comment --infer --error-recovery --stdlib . --strict
-
-# -------------------------------------------------------------------------
-
-# A list of the source files that must be generated prior to dependency
-# analysis.
-
-GENERATED := installation.ml lexmli.ml lexer.ml parser.mli parser.ml \
-lineCount.ml lexdep.ml sentenceParser.mli sentenceParser.ml sentenceLexer.ml
-
-# -------------------------------------------------------------------------
-
-# A list of the modules that must be linked into the MenhirLib library.
-
-# This library is used both at compile time (i.e., within Menhir itself)
-# and at run time (i.e., it is made available to Menhir users, who need
-# to link it with their own executables if they have used the --table
-# option).
-
-# If you change this list, please also update the files LICENSE and
-# GNUmakefile in the toplevel directory.
-
-LIBMODULES := infiniteArray packedIntArray rowDisplacement engineTypes \
-engine tableFormat tableInterpreter convert
-
-# -------------------------------------------------------------------------
-
-# A list of the modules that must be linked into the Menhir executable.
-
-MODULES := menhirLib Fix stringSet stringMap mark compressedBitSet \
- unionFind tarjan nonpositiveCycles patricia misc option \
- breadth listMonad dot installation version settings time \
- positions error parameters keyword lineCount printer \
- rawPrinter action parserAux parser lexer partialGrammar \
- parameterizedGrammar reachability unparameterizedPrinter \
- preFront codeBits tokenType interface IO lexmli lexdep \
- infer nonTerminalDefinitionInlining front grammar item lr0 \
- slr lr1 lr1partial derivation conflict invariant codePieces \
- sentenceParser sentenceLexer pprint cst \
- referenceInterpreter interpret tableBackend codeBackend \
- coqBackend traverse inliner back
-
-# -------------------------------------------------------------------------
-
-# How to bootstrap.
-
-# Set TARGET to byte or opt depending on the desired architecture.
-
-ifndef TARGET
- TARGET := opt
-endif
-
-# The variable GOAL is the name of the executable file.
-
-GOAL := menhir.$(TARGET)
-
-# We create a symbolic link of GOAL to MENHIREXE.
-
-$(MENHIREXE): .versioncheck
-# Build a stage one executable using ocamlyacc.
- $(MAKE) -s PGEN="$(CAMLYACC)" PARSER=parser $(GOAL)
-# Remove the ocamlyacc-built parser.
- @/bin/rm -f parser.ml parser.mli
-# Build a stage two executable using the stage one executable (which is overwritten).
- $(MAKE) -s PGEN="./$(GOAL) $(PGFLAGS)" PARSER=fancy-parser $(GOAL)
-# Create a stage three parser and make sure that it is identical.
- @./$(GOAL) $(PGFLAGS) -b reference fancy-parser.mly 2>/dev/null
- @if diff parser.mli reference.mli 2>&1 >/dev/null ; then \
- if diff parser.ml reference.ml 2>&1 >/dev/null ; then \
- echo "Bootstrap successful." ; \
- else \
- echo "Bootstrap FAILED: the implementation files differ." && false ; \
- fi ; \
- else \
- echo "Bootstrap FAILED: the interface files differ." && false ; \
- fi
- @rm -f reference.ml reference.mli
-# Rename the stage two executable to the desired name.
-# Use a symbolic link, so that further development builds implicitly update
-# menhir.
- @ln -sf $(GOAL) $@
-
-# -------------------------------------------------------------------------
-
-# Linking.
-
-menhirLib.cmo menhirLib.cmi: $(LIBMODULES:=.cmo)
- $(CAMLC) $(BFLAGS) -pack -o menhirLib.cmo $^
-
-menhirLib.cmx menhirLib.o: $(LIBMODULES:=.cmx)
- $(CAMLOPT) -pack -o menhirLib.cmx $^
-
-menhir.byte: $(MODULES:=.cmo)
- $(CAMLC) -o $@ $(LNKBFLAGS) $(BLIBS) $^
-
-menhir.opt: $(MODULES:=.cmx)
- $(CAMLOPT) -o $@ $(LNKOFLAGS) $(OLIBS) $^
-
-# -------------------------------------------------------------------------
-
-# Computing dependencies. This can be done in a simple way, even though
-# we exploit --infer, because we compile in two stages. Not a good example
-# of how to do it yourself -- have a look at demos/Makefile.shared.
-
-# For completeness, we must force ocamldep to understand that MenhirLib
-# is a module name. We do this by creating phantom source files for it.
-
-.depend: $(wildcard *.ml *.mli) $(GENERATED)
- @/bin/rm -f .depend
- for i in *.ml *.mli; do \
- $(CAMLDEPWRAPPER) menhirLib.ml menhirLib.mli - $(CAMLDEP) $$i \
- >> $@; \
- done
-
-ifeq ($(findstring $(MAKECMDGOALS),$(COLD)),)
--include .depend
-endif
-
-# -------------------------------------------------------------------------
-
-# Cleaning up.
-
-clean::
- /bin/rm -f menhir.byte menhir.opt $(MENHIREXE)
- /bin/rm -f *.cmi *.cmx *.cmo *.$(OBJ) *~ .*~
- /bin/rm -f reference.ml reference.mli $(GENERATED)
- /bin/rm -f .depend *.conflicts *.automaton *.annot *.output
-
-# -------------------------------------------------------------------------
-
-# Compiling. The parser source is found in $(PARSER).mly and is
-# processed using $(PGEN).
-
-# These two default definitions really shouldn't be necessary, but
-# there are corner cases where they are needed (e.g. when make is
-# invoked without a target and the .depend file is regenerated).
-
-ifndef PGEN
- PGEN := $(CAMLYACC)
-endif
-ifndef PARSER
- PARSER := parser
-endif
-
-%.cmi: %.mli
- $(CAMLC) $(BFLAGS) -c $<
-
-%.cmo: %.ml
- $(CAMLC) $(BFLAGS) -c $<
-
-# If the module that is being compiled is part of MenhirLib, add the
-# -for-pack option to the command line. This is required only when
-# compiling to native code (the bytecode compiler accepts but ignores
-# this option).
-
-PACK = $(shell if echo $(LIBMODULES) | grep $* >/dev/null ; then echo -for-pack MenhirLib ; else echo ; fi)
-
-%.cmx %.o: %.ml
- $(CAMLOPT) $(OFLAGS) $(PACK) -c $<
-
-# The source file for this parser varies. It is either parser.mly or
-# fancy-parser.mly.
-#
-parser.ml parser.mli: $(PARSER).mly
- @/bin/rm -f parser.ml parser.mli
- $(PGEN) -b parser $<
-
-# This parser must be built with ocamlyacc, because its client
-# watches for Parsing.Parse_error!
-#
-# Using ocamlyacc or Menhir interchangeably would be possible,
-# via an ocamlyacc wrapper that adds the definition "exception
-# Error = Parsing.Parse_error" at the end of the generated .ml
-# and .mli files.
-#
-sentenceParser.ml sentenceParser.mli : sentenceParser.mly
- @/bin/rm -f sentenceParser.ml sentenceParser.mli
- $(CAMLYACC) -b sentenceParser $<
-
-%.ml: %.mll
- @/bin/rm -f $@
- $(CAMLLEX) $<
-
-# ----------------------------------------------------------------------------
-# Checking the version of the ocaml compiler.
-#
-# We check the bytecode compiler only, because some architectures don't have
-# the native code compiler. We assume that both compilers, if present, are in
-# sync.
-
-# We build a bytecode executable (rather than use the toplevel loop) because
-# we need to load str.cma and some ocaml ports do not support dynamic loading
-# (e.g. ocaml 3.09, MacOS/Intel).
-
-.versioncheck:
- @ echo Checking that Objective Caml is recent enough...
- @ $(CAMLC) -o check-ocaml-version str.cma checkOCamlVersion.ml
- @ ./check-ocaml-version --verbose --gt "3.09"
- @ rm check-ocaml-version
- @ touch .versioncheck
-
-clean::
- rm -f .versioncheck
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: action.ml,v 1.10 2006/06/26 09:41:33 regisgia Exp $ *)
-
-open Keyword
-
-type t =
- {
- expr : IL.expr;
- keywords : Keyword.KeywordSet.t;
- filenames : string list;
- pkeywords : Keyword.keyword Positions.located list
- }
-
-let from_stretch s =
- {
- expr = IL.ETextual s;
- filenames = [ s.Stretch.stretch_filename ];
- keywords = Keyword.KeywordSet.from_list (List.map Positions.value s.Stretch.stretch_keywords);
- pkeywords = s.Stretch.stretch_keywords;
- }
-
-let parenthesize s =
- if String.length s < 2 || s.[0] <> '(' || s.[String.length s - 1] <> ')' then
- "(" ^ s ^ ")"
- else
- s
-
-let rec parenthesize_stretch = function
- | IL.ETextual s ->
- IL.ETextual { s with Stretch.stretch_raw_content = parenthesize s.Stretch.stretch_raw_content }
- | IL.ELet (es, e) ->
- IL.ELet (List.map (fun (p, e) -> (p, parenthesize_stretch e)) es, parenthesize_stretch e)
- | x -> x
-
-let compose x a1 a2 =
- {
- expr = IL.ELet ([ IL.PVar x, parenthesize_stretch a1.expr ], a2.expr);
- keywords = Keyword.KeywordSet.union a1.keywords a2.keywords;
- filenames = a1.filenames @ a2.filenames;
- pkeywords = a1.pkeywords @ a2.pkeywords;
- }
-
-let rename_inlined_psym (psym, first_prod, last_prod) phi l =
- List.fold_left
- (fun (l, phi, (used1, used2)) pk ->
- match pk.Positions.value with
- | Position (subject, where, flavor) ->
- let (subject', where'), (used1, used2) =
- match subject, where with
- | RightNamed s, w ->
- (* In the host rule, $startpos(x) is changed
- to $startpos(first_prod) (same thing for $endpos). *)
- if s = psym then
- match w with
- | WhereStart -> first_prod, (true, used2)
- | WhereEnd -> last_prod, (used1, true)
- else
- (* Otherwise, we just that the renaming into account. *)
- let s' = try
- List.assoc s phi
- with Not_found -> s
- in
- (RightNamed s', w), (used1, used2)
- | _ -> (subject, where), (used1, used2)
- in
- let from_pos = Keyword.posvar subject where flavor
- and to_pos = Keyword.posvar subject' where' flavor in
- (Positions.with_pos pk.Positions.position
- (Position (subject', where', flavor)) :: l,
- (if from_pos <> to_pos && not (List.mem_assoc from_pos phi) then
- (from_pos, to_pos) :: phi else phi),
- (used1, used2))
-
- | _ -> pk :: l, phi, (used1, used2)
- )
- ([], phi, (false, false)) l
-
-(* Rename the keywords related to position to handle the composition
- of semantic actions during non terminal inlining.
-
- The first argument describes the context:
- - [first_prod] is the first producer that starts the action's rule.
- - [last_prod] is the last one.
- For instance, if %inline rule r is A -> B C and rule r' is D -> E A F,
- then [first_prod] is B and [last_prod] is C.
- If r is A -> and r' is unchanged. [first_prod] is E and [last_prod] is F.
- - [psym] is the producer that is being inlined.
-
-*)
-let rename_pkeywords (psym, first_prod, last_prod) phi l =
- List.fold_left (fun (l, phi, (used1, used2)) pk -> match pk.Positions.value with
- | Position (subject, where, flavor) ->
- let (subject', where'), (used1, used2) =
- match subject, where with
- (* $startpos is changed to $startpos(first_prod) in the
- inlined rule. *)
- | Left, WhereStart -> first_prod, (true, used2)
- (* Similarly for $endpos. *)
- | Left, WhereEnd -> last_prod, (used1, true)
- (* $i cannot be combined with inlining. *)
- | RightDollar i, w -> assert false
- | RightNamed s, w ->
- (* In the host rule, $startpos(x) is changed to
- to $startpos(first_prod) (same thing for $endpos). *)
- if s = psym then
- match w with
- | WhereStart -> first_prod, (true, used2)
- | WhereEnd -> last_prod, (used1, true)
- else
- (* Otherwise, we just that the renaming into account. *)
- let s' = try List.assoc s phi with Not_found -> s in
- (RightNamed s', w), (used1, used2)
- in
- let from_pos = Keyword.posvar subject where flavor
- and to_pos = Keyword.posvar subject' where' flavor in
- (Positions.with_pos pk.Positions.position
- (Position (subject', where', flavor)) :: l,
- (if from_pos <> to_pos && not (List.mem_assoc from_pos phi) then
- (from_pos, to_pos) :: phi else phi),
- (used1, used2))
-
- | x -> pk :: l, phi, (used1, used2))
-
- ([], phi, (false, false)) l
-
-let rename renaming_fun renaming_env phi a =
- let pkeywords, phi, used_fg = renaming_fun renaming_env phi a.pkeywords in
- { a with
- (* We use the let construct to rename without modification of the semantic
- action code. *)
- expr =
- IL.ELet (List.map (fun (x, x') -> (IL.PVar x, IL.EVar x')) phi,
- a.expr);
-
- (* Keywords related to positions are updated too. *)
- keywords =
- List.fold_left
- (fun acu pk -> Keyword.KeywordSet.add pk.Positions.value acu)
- Keyword.KeywordSet.empty
- pkeywords;
-
- pkeywords = pkeywords
- }, used_fg
-
-let rename_inlined_psym =
- rename rename_inlined_psym
-
-let rename =
- rename rename_pkeywords
-
-let to_il_expr action =
- action.expr
-
-let filenames action =
- action.filenames
-
-let keywords action =
- action.keywords
-
-let pkeywords action =
- action.pkeywords
-
-let rec print f action =
- let module P = Printer.Make (struct let f = f
- let locate_stretches = None
- let raw_stretch_action = true
- end)
- in
- P.expr action.expr
-
-let has_previouserror action =
- KeywordSet.mem PreviousError (keywords action)
-
-let has_syntaxerror action =
- KeywordSet.mem SyntaxError (keywords action)
-
-let has_leftstart action =
- KeywordSet.exists (function
- | Position (Left, WhereStart, _) ->
- true
- | _ ->
- false
- ) (keywords action)
-
-let has_leftend action =
- KeywordSet.exists (function
- | Position (Left, WhereEnd, _) ->
- true
- | _ ->
- false
- ) (keywords action)
-
-let has_dollar i action =
- KeywordSet.exists (function
- | Dollar j when i = j ->
- true
- | _ ->
- false
- ) (keywords action)
-
-let use_dollar action =
- KeywordSet.exists (function
- | Dollar _ ->
- true
- | _ ->
- false
- ) (keywords action)
-
-
-
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: action.mli,v 1.8 2006/06/26 09:41:33 regisgia Exp $ *)
-
-(** Semantic action's type. *)
-type t
-
-(** [compose x a1 a2] builds the action [let x = a1 in a2]. This
- feature is used during the processing of the %inline keyword. *)
-val compose : string -> t -> t -> t
-
-(** [rename renaming_env phi a] builds the action
- [let x1 = x1' and ... xn = xn' in a] if [phi] is [(x1, x1') ... (xn, xn')].
- Moreover, [renaming_env] is used to correctly replace $startpos/$endpos
- present in the semantic action. *)
-val rename:
- string * (Keyword.subject * Keyword.where) * (Keyword.subject * Keyword.where)
- -> (string * string) list -> t -> t * (bool * bool)
-
-(** [rename_inlined_psym renaming_env phi a] updates the occurrences of the
- inlined non terminal in the action [a].
-*)
-val rename_inlined_psym:
- string * (Keyword.subject * Keyword.where) * (Keyword.subject * Keyword.where)
- -> (string * string) list -> t -> t * (bool * bool)
-
-(** Semantic actions are translated into [IL] code using the
- [IL.ETextual] and [IL.ELet] constructors. *)
-val to_il_expr: t -> IL.expr
-
-(** A semantic action might be the inlining of several others. The
- filenames of the different parts are given by [filenames a]. This
- can be used, for instance, to check whether all parts come from
- the standard library. *)
-val filenames: t -> string list
-
-(** [pkeywords a] returns a list of all keyword occurrences in [a]. *)
-val pkeywords: t -> Keyword.keyword Positions.located list
-
-(** [keywords a] is the set of keywords used in the semantic action [a]. *)
-val keywords: t -> Keyword.KeywordSet.t
-
-(** [print f a] prints [a] to channel [f]. *)
-val print: out_channel -> t -> unit
-
-(** [from_stretch s] builds an action out of a textual piece of code. *)
-val from_stretch: Stretch.t -> t
-
-(** Check whether the keyword $previouserror is used in the action. *)
-val has_previouserror: t -> bool
-
-(** Check whether the keyword $syntaxerror is used in the action. *)
-val has_syntaxerror: t -> bool
-
-(** Check whether the keyword $start is used in the action. *)
-val has_leftstart: t -> bool
-
-(** Check whether the keyword $end is used in the action. *)
-val has_leftend: t -> bool
-
-(** Check whether a particular $i keyword is used in the action. *)
-val has_dollar: int -> t -> bool
-
-(** Check whether any $i keyword is used in the action. *)
-val use_dollar: t -> bool
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* Driver for the back-end. *)
-
-open UnparameterizedSyntax
-
-(* Define an .ml file writer . *)
-
-let write program =
- let module P = Printer.Make (struct
- let filename = Settings.base ^ ".ml"
- let f = open_out filename
- let locate_stretches =
- if Settings.infer then
- (* Typechecking should not fail at this stage. Omit #line directives. *)
- None
- else
- (* 2011/10/19: do not use [Filename.basename]. The [#] annotations that
- we insert in the [.ml] file must retain their full path. This does
- mean that the [#] annotations depend on how menhir is invoked -- e.g.
- [menhir foo/bar.mly] and [cd foo && menhir bar.mly] will produce
- different files. Nevertheless, this seems useful/reasonable. *)
- Some filename
- let raw_stretch_action = false
- end) in
- P.program program
-
-(* Construct the code, using either the table-based or the code-based
- back-end, and pass it on to the printer. (This continuation-passing
- style is imposed by the fact that there is no conditional in ocaml's
- module language.) *)
-
-let () =
- if Settings.coq then
- let module B = CoqBackend.Run (struct end) in
- let filename = Settings.base ^ ".v" in
- let f = open_out filename in
- B.write_all f;
- exit 0
- else
- if Settings.table then
- let module B = TableBackend.Run (struct end) in
- write B.program
- else
- let module B = CodeBackend.Run (struct end) in
- write (Inliner.inline B.program)
-
-(* Write the interface file. *)
-
-let () =
- Interface.write()
-
-let () =
- Time.tick "Printing"
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module drives the back-end. No functionality is offered by
- this module. *)
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module implements generic breadth-first search
- over a graph with labeled edges. *)
-
-module Make (G : sig
-
- (* This is the type of graph vertices. *)
-
- type vertex
-
- (* This is the type of graph labels. *)
-
- type label
-
- (* These allow marking a vertex and checking whether
- it is marked. *)
-
- val set_mark: vertex -> Mark.t -> unit
- val get_mark: vertex -> Mark.t
-
- (* This is an iterator over the graph's entry vertices. *)
-
- val entry: (vertex -> unit) -> unit
-
- (* This provides access to a vertex' successors. *)
-
- val successors: (label -> vertex -> unit) -> vertex -> unit
-
-end) = struct
-
- let search f =
-
- let queue : G.vertex Queue.t =
- Queue.create ()
-
- and mark =
- Mark.fresh()
-
- in
-
- let visited vertex =
- Mark.same mark (G.get_mark vertex)
-
- and visit vertex =
- G.set_mark vertex mark;
- Queue.add vertex queue
-
- in
-
- G.entry visit;
- Misc.qiter (fun vertex ->
- G.successors (fun label son ->
- if not (visited son) then begin
- visit son;
- f true vertex label son
- end
- else
- f false vertex label son
- ) vertex
- ) queue
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module implements generic breadth-first search
- over a graph with labeled edges. *)
-
-module Make (G : sig
-
- (* This is the type of graph vertices. *)
-
- type vertex
-
- (* This is the type of graph labels. *)
-
- type label
-
- (* These allow marking a vertex and checking whether
- it is marked. *)
-
- val set_mark: vertex -> Mark.t -> unit
- val get_mark: vertex -> Mark.t
-
- (* This is an iterator over the graph's entry vertices. *)
-
- val entry: (vertex -> unit) -> unit
-
- (* This provides access to a vertex' successors. *)
-
- val successors: (label -> vertex -> unit) -> vertex -> unit
-
-end) : sig
-
- (* [search f] invokes [f discovery v label v'] once for every edge
- from vertex [v] to vertex [v'] carrying label [label]. Vertices
- [v'] are presented breadth-first. The flag [discovery] tells
- whether the edge is a discovery edge, that is, whether it belongs
- to the spanning forest of shortest paths that is being built. *)
-
- val search: (bool -> G.vertex -> G.label -> G.vertex -> unit) -> unit
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id $*)
-(* This module parses ocaml version and confronts it with a user-provided
- version. *)
-
-(* According to OCaml's manual, the Sys.ocaml_version value follows the
- regexp [version_regexp].
-*)
-let mnum = "\\([0-9]+\\)"
-
-(* version = major.minor[.patchlevel][+additional-info]. *)
-let version_regexp =
- Str.regexp
- (Printf.sprintf "%s\\.%s\\(\\.%s\\)?\\(\\+\\(.+\\)\\)?" mnum mnum mnum)
-
-let must field = function
- | None -> failwith (Printf.sprintf "\"%s\" field is undefined." field)
- | Some s -> s
-
-let as_int s =
- try
- int_of_string s
- with Failure _ ->
- Printf.eprintf "Invalid number '%s'\n" s;
- exit 1
-
-let parse_version version =
- let get i =
- try
- Some (Str.matched_group i version)
- with Not_found ->
- None
- in
- if Str.string_match version_regexp version 0 then (
- as_int (must "major" (get 1)),
- as_int (must "minor" (get 2)),
- get 4, get 6
- ) else
- begin
- Printf.eprintf "Failed to retrieve ocaml version.\n";
- exit 1
- end
-
-(* The user can compare its version with three different orderings:
- - eq means major and minor numbers are equal ;
- - eq-strict means that even the patchlevel and the additional information
- are equal ;
- - lt means that ocaml version is older that the user-provided version ;
- - gt means that ocaml version is newer that the user-provided version. *)
-let eq, eq_strict, gt, lt = ref false, ref false, ref false, ref false
-
-let verbose = ref false
-
-let options = Arg.align
- [
- "--eq", Arg.Set eq, " Is the version equal to <version> ?";
- "--eq-strict", Arg.Set eq_strict,
- " Is the version strictly equal to <version> ? \
- (taking into account patchlevel and additional information)";
- "--gt", Arg.Set gt, " Is the version newer than <version> ? (default)";
- "--lt", Arg.Set lt, " Is the version older than <version> ?";
- "--verbose", Arg.Set verbose, " Show version."
- ]
-
-let usage = "check-ocaml-version [options] <version>\n"
-
-let version = ref None
-
-let set_version s =
- version := Some s
-
-let _ =
- Arg.parse options set_version usage
-
-let compare, compare_str, strict =
- match !eq, !gt, !lt with
- | true, false, false -> ( = ) , "", !eq_strict
- | false, true, false -> ( >= ), "or greater ", false
- | false, false, true -> ( <= ), "or lesser ", false
- | false, false, false -> (Printf.printf "%s\n%!" Sys.ocaml_version; exit 1)
- | _ -> failwith "(eq|gt|lt) flags must be used independently"
-
-let compare_version (major, minor, p, a) (major', minor', p', a') =
- if major = major' then
- if minor = minor' then
- if strict then
- (p = p') && (a = a')
- else true
- else compare minor minor'
- else
- compare major major'
-
-let _ =
-
- match !version with
- | None ->
- Printf.printf "%s\n%!" Sys.ocaml_version
-
- | Some version ->
- let ov = parse_version Sys.ocaml_version
- and uv = parse_version version in
- if compare_version ov uv then begin
- if !verbose then
- Printf.printf "Version %s is OK.\n%!" Sys.ocaml_version;
- exit 0
- end
- else begin
- if !verbose then
- Printf.printf "%s is NOT OK: version %s %swas required.%!\n" Sys.ocaml_version version compare_str;
- exit 1
- end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* The code generator. *)
-
-(* TEMPORARY env.startp seems to be always equal to env.lexbuf.lex_start_p,
- and similarly for env.endp. Is there a point to copying these
- positions to the env record? Maybe just making these positions
- accessible via a single indirection, instead of two? I forget. *)
-
-module Run (T : sig end) = struct
-
-open Grammar
-open IL
-open CodeBits
-open CodePieces
-open TokenType
-open Interface
-
-(* ------------------------------------------------------------------------ *)
-(* Here is a description of our code generation mechanism.
-
- Every internal function that we produce is parameterized by the
- parser environment [env], which contains (pointers to) the lexer,
- the lexing buffer, the last token read, etc. No global variables
- are exploited, so our parsers are reentrant. The functions that we
- export do not expect an environment as a parameter; they create a
- fresh one when invoked.
-
- Every state [s] is translated to a [run] function and an [action]
- function. To a first approximation, the only parameter of the [run]
- function, besides [env], is the stack. However, in some cases
- (consult the predicate [runpushes]), the top stack cell is not yet
- allocated when [run s] is called. The cell's contents are passed as
- extra parameters, and it is [run]'s responsibility to allocate that
- cell.
-
- (When [run] is the target of a shift transition, the position
- parameters [startp] and [endp] are redundant with the [env]
- parameter, because they are always equal to [env.startp] and
- [env.endp]. However, this does not appear to make a great
- difference in terms of code size, and makes our life easier, so we
- do not attempt to eliminate this redundancy.)
-
- The first thing in [run] is to discard a token, if the state was
- entered through a shift transition, and to peek at the lookahead
- token. When the current token is to be discarded, the [discard]
- function is invoked. It discards the current token, invokes the
- lexer to obtain a new token, and returns the latter. When we only
- wish to peek at the current token, without discarding it, we simply
- read [env.token]. (We have to be careful in cases where the current
- lookahead token might be [error], since, in those cases,
- [env.token] is meaningless; see below.)
-
- Once the lookahead token is obtained, [run] calls [action]. The
- parameters of [action] are the stack and the lookahead token.
-
- [action] performs a case analysis of the lookahead token. Each
- branch performs one of the following. In shift branches, control is
- dispatched to another [run] function, with appropriate parameters,
- typically the current stack plus the information that should go
- into the new top stack cell (a state, a semantic value, locations).
- In reduce branches, a [reduce] function is invoked. In the default
- branch, error handling is initiated (see below).
-
- The [reduce] function associated with production [prod] pops as
- many stack cells as necessary, retrieving semantic values and the
- state [s] that initiated the reduction. It then evaluates the
- semantic action, which yields a new semantic value. (This is the
- only place where semantic actions are evaluated, so that semantic
- actions are never duplicated.) It then passes control on to the
- [goto] function associated with the nonterminal [nt], where [nt]
- is the left-hand side of the production [prod].
-
- The [goto] function associated with nonterminal [nt] expects just
- one parameter besides the environment -- namely, the
- stack. However, in some cases (consult the predicate [gotopushes]),
- the top stack cell is not allocated yet, so its contents are passed
- as extra parameters. In that case, [goto] first allocates that
- cell. Then, it examines the state found in that cell and performs a
- goto transition, that is, a shift transition on the nonterminal
- symbol [nt]. This simply consists in passing control to the [run]
- function associated with the transition's target state. If this
- case analysis only has one branch, because all transitions for [nt]
- lead to the same target state, then no case analysis is required.
-
- In principle, a stack cell contains a state, a semantic value, and
- start and end positions. However, the state can be omitted if it is
- never consulted by a [goto] function. The semantic value can be
- omitted if it is associated with a token that was declared not to
- carry a semantic value. (One could also omit semantic values for
- nonterminals whose type was declared to be [unit], but that does
- not seem very useful.) The start or end position can be omitted if
- they are associated with a symbol that does not require keeping
- track of positions. When all components of a stack cell are
- omitted, the entire cell disappears, so that no memory allocation
- is required.
-
- For each start symbol [nt], an entry point function, named after
- [nt], is generated. Its parameters are a lexer and a lexing buffer.
- The function allocates and initializes a parser environment and
- transfers control to the appropriate [run] function.
-
- Our functions are grouped into one huge [let rec] definition. The
- inliner, implemented as a separate module, will inline functions
- that are called at most once, remove dead code (although there
- should be none or next to none), and possibly perform other
- transformations.
-
- I note that, if a state can be entered only through (nondefault)
- reductions, then, in that state, the lookahead token must be a
- member of the set of tokens that allow these reductions, and by
- construction, there must exist an action on that token in that
- state. Thus, the default branch (which signals an error when
- the lookahead token is not a member of the expected set) is in
- fact dead. It would be nice (but difficult) to exploit types
- to prove that. However, one could at least replace the code of
- that branch with a simple [assert false]. TEMPORARY do it *)
-
-(* ------------------------------------------------------------------------ *)
-(* Here is a description of our error recovery mechanism.
-
- With every state [s], we associate an [error] function.
-
- If [s] is willing to act when the lookahead token is [error], then
- this function tells how. This includes *both* shift *and* reduce
- actions. (For some reason, yacc/ocamlyacc/mule/bison can only shift
- on [error].)
-
- If [s] is unable to act when the lookahead token is [error], then
- this function pops a stack cell, extracts a state [s'] out of it,
- and transfers control, via a global [errorcase] dispatch function,
- to the [error] function associated with [s']. (Because some stack
- cells do not physically hold a state, this description is somewhat
- simpler than the truth, but that's the idea.)
-
- When an error is detected in state [s], one of two things happens
- (see [initiate]).
-
- a. If [s] can do error recovery and if no token was successfully
- shifted since the last [error] token was shifted, then the
- current token is discarded and the current state remains
- unchanged, that is, the [action] function associated with [s]
- is re-entered.
-
- b. Otherwise, the [error] function associated with [s] is
- invoked.
-
- In case (b), immediately before invoking the [error] function, the
- counter [env.shifted] is reset to -1. By convention, this means
- that the current token is discarded and replaced with an [error]
- token. The [error] token transparently inherits the positions
- associated with the underlying concrete token.
-
- Whenever we attempt to consult the current token, we check whether
- [env.shifted] is -1 and, if that is the case, resume error handling
- by calling the [error] function associated with the current state.
- This allows a series of reductions to correctly take place when the
- lookahead token is [error]. In many states, though, it is possible
- to statically prove that [env.shifted] cannot be -1. In that case,
- we produce a lookup of [env.token] without checking [env.shifted].
-
- The counter [env.shifted] is incremented when a token is
- shifted. In particular, immediately after the [error] token is
- shifted, [env.shifted] is zero. The increment is conditional, so as
- to avoid overflow. It is performed inside [discard].
-
- States with default reductions perform a reduction regardless of
- the current lookahead token, which can be either [error] or a
- regular token.
-
- A question that bothered me for a while was, when unwinding the
- stack, do we stop at a state that has a default reduction? Should
- it be considered able to handle the error token? I now believe that
- the answer is, this cannot happen. Indeed, if a state has a default
- reduction, then, whenever it is entered, reduction is performed and
- that state is exited, which means that it is never pushed onto the
- stack. So, it is fine to consider that a state with a default
- reduction is unable to handle errors.
-
- I note that a state that can handle [error] and has a default
- reduction must in fact have a reduction action on [error].
-
- A state that can perform error recovery (that is, a state whose
- incoming symbol is [error]) never performs a default reduction. The
- reason why this is so is given in [Invariant]. A consequence of
- this decision is that reduction is not performed until error
- recovery is successful. This behavior could be surprising if it
- were the default behavior; however, recall that error recovery is
- disabled unless [--error-recovery] was specified.
-
- When an error is detected and an error production is reduced, the
- user might like to know how recent the previous error was, so as
- (for instance) to suppress diagnostic messages if it was too
- recent. (yacc and ocamlyacc have their own, hard-wired,
- idiosyncratic mechanism for that.) We provide access to this
- information as follows. When a new error is detected and
- [env.shifted] is set to -1, the previous value of [env.shifted] is
- saved to [env.previouserror]. Thus, the number of tokens that were
- shifted between the two errors is recorded. This information is
- then made available to the user via the $previouserror keyword.
-
- I note that error recovery, case (a) above, can cause the parser to
- enter an infinite loop. Indeed, the token stream is in principle
- infinite -- for instance, many lexers will return an EOF token
- forever after some finite supply of tokens has been exhausted. If
- we hit EOF while in error recovery mode, and if EOF is not accepted
- at the current state, we will keep discarding EOF and asking for a
- new token. The way out of this situation is to design the grammar
- in such a way that it cannot happen. We provide a warning to help
- with this task. *)
-
-(* The type of environments. *)
-
-let tcenv =
- env
-
-let tenv =
- TypApp (tcenv, [])
-
-(* The [assertfalse] function. We have just one of these, in order to
- save code size. It should become unnecessary when we add GADTs. *)
-
-let assertfalse =
- prefix "fail"
-
-(* The [discard] function. *)
-
-let discard =
- prefix "discard"
-
-(* The [initenv] function. *)
-
-let initenv =
- prefix "init"
-
-(* The [run] function associated with a state [s]. *)
-
-let run s =
- prefix (Printf.sprintf "run%d" (Lr1.number s))
-
-(* The [action] function associated with a state [s]. *)
-
-let action s =
- prefix (Printf.sprintf "action%d" (Lr1.number s))
-
-(* The [goto] function associated with a nonterminal [nt]. *)
-
-let goto nt =
- prefix (Printf.sprintf "goto_%s" (Nonterminal.print true nt))
-
-(* The [reduce] function associated with a production [prod]. *)
-
-let reduce prod =
- prefix (Printf.sprintf "reduce%d" (Production.p2i prod))
-
-(* The [errorcase] function. *)
-
-let errorcase =
- prefix "errorcase"
-
-(* The [error] function associated with a state [s]. *)
-
-let error s =
- prefix (Printf.sprintf "error%d" (Lr1.number s))
-
-(* The constant associated with a state [s]. *)
-
-let statecon s =
- dataprefix (Printf.sprintf "State%d" (Lr1.number s))
-
-let estatecon s =
- EData (statecon s, [])
-
-let rec begins_with s1 s2 i1 i2 n1 n2 =
- if i1 = n1 then
- true
- else if i2 = n2 then
- false
- else if String.unsafe_get s1 i1 = String.unsafe_get s2 i2 then
- begins_with s1 s2 (i1 + 1) (i2 + 1) n1 n2
- else
- false
-
-let begins_with s1 s2 =
- begins_with s1 s2 0 0 (String.length s1) (String.length s2)
-
-(* This predicate tells whether a data constructor represents a state.
- It is based on the name, which is inelegant and inefficient. TEMPORARY *)
-
-let is_statecon : string -> bool =
- begins_with (dataprefix "State")
-
-let pstatecon s =
- PData (statecon s, [])
-
-let pstatescon ss =
- POr (List.map pstatecon ss)
-
-(* The type of states. *)
-
-let tcstate =
- prefix "state"
-
-let tstate =
- TypApp (tcstate, [])
-
-(* The [print_token] function. This automatically generated function
- is used in [--trace] mode. *)
-
-let print_token =
- prefix "print_token"
-
-(* Fields in the environment record. *)
-
-let flexer =
- prefix "lexer"
-
-let flexbuf =
- prefix "lexbuf"
-
-let ftoken =
- prefix "token"
-
-let fshifted =
- prefix "shifted"
-
-let fstartp =
- prefix "startp"
-
-let fendp =
- prefix "endp"
-
-let fpreviouserror =
- prefix "previouserror"
-
-(* The type variable that represents the stack tail. *)
-
-let tvtail =
- tvprefix "tail"
-
-let ttail =
- TypVar tvtail
-
-(* The result type for every function. TEMPORARY *)
-
-let tvresult =
- tvprefix "return"
-
-let tresult =
- TypVar tvresult
-
-(* ------------------------------------------------------------------------ *)
-(* Helpers for code production. *)
-
-let concatif condition xs =
- if condition then
- xs
- else
- []
-
-let insertif condition x =
- if condition then
- [ x ]
- else
- []
-
-let var x : expr =
- EVar x
-
-let vars xs =
- List.map var xs
-
-let pvar x : pattern =
- PVar x
-
-let magic e : expr =
- EMagic e
-
-let nomagic e =
- e
-
-(* [env.shifted] is either [-1], which means that we have an [error] token
- at the head of the token stream, or a nonnegative number. (The code in
- [discard], which increments [env.shifted], takes care to avoid overflow.)
-
- The following assertion checks that [env.shifted] is not [-1], that is,
- it is greater than or equal to [0]. Prior to 2011/01/24, two forms of
- this test co-existed, but it seems more uniform to have just one form. *)
-
-let assertshifted : pattern * expr =
- PUnit,
- EApp (EVar "assert",
- [ EApp (EVar "Pervasives.(<>)", [ ERecordAccess (EVar env, fshifted); EIntConst (-1) ]) ])
-
-let etuple = function
- | [] ->
- assert false
- | [ e ] ->
- e
- | es ->
- ETuple es
-
-let ptuple = function
- | [] ->
- assert false
- | [ p ] ->
- p
- | ps ->
- PTuple ps
-
-let trace (format : string) (args : expr list) : (pattern * expr) list =
- if Settings.trace then
- [ PUnit, EApp (EVar "Printf.fprintf", (EVar "Pervasives.stderr") :: (EStringConst (format ^"\n%!")) :: args) ]
- else
- []
-
-let tracecomment (comment : string) (body : expr) : expr =
- if Settings.trace then
- blet (trace comment [], body)
- else
- EComment (comment, body)
-
-let auto2scheme t =
- scheme [ tvtail; tvresult ] t
-
-(* ------------------------------------------------------------------------ *)
-(* Determine whether at least one semantic action mentions $previouserror. *)
-
-let previouserror_required : bool =
- Production.foldx (fun prod accu ->
- accu || Action.has_previouserror (Production.action prod)
- ) false
-
-(* ------------------------------------------------------------------------ *)
-(* Determine whether the [goto] function for nonterminal [nt] will push
- a new cell onto the stack. If it doesn't, then that job is delegated
- to the [run] functions called by [goto].
-
- One could decide that [gotopushes] always returns true, and produce
- decent code. As a refinement, we decide to drive the [push]
- operation inside the [run] functions if all of them are able to
- eliminate this operation via shiftreduce optimization. This will be
- the case if all of these [run] functions implement a default
- reduction of a non-epsilon production.
-
- If that is not the case, then [gotopushes] returns true. In
- general, it is good to place the [push] operation inside [goto],
- because multiple [reduce] functions transfer control to [goto], and
- [goto] in turn transfers control to multiple [run] functions. Hence,
- this is where code sharing is maximal. All of the [run] functions
- that [goto] can transfer control to expect a stack cell of the same
- shape (indeed, the symbol [nt] is the same in every case, and the
- state is always represented), which makes this decision possible. *)
-
-let gotopushes : Nonterminal.t -> bool =
- Nonterminal.tabulate (fun nt ->
- not (
- Lr1.targets (fun accu _ target ->
- accu &&
- match Invariant.has_default_reduction target with
- | Some (prod, _) ->
- Production.length prod > 0
- | None -> false
- ) true (Symbol.N nt)
- )
- )
-
-(* ------------------------------------------------------------------------ *)
-(* Determine whether the [run] function for state [s] will push a new cell
- onto the stack.
-
- Our convention is this. If this [run] function is entered via a shift
- transition, then it is in charge of pushing a new stack cell. If it
- is entered via a goto transition, then it is in charge of pushing a
- new cell if and only if the [goto] function that invoked it did not
- do so. Last, if this [run] function is invoked directly by an entry
- point, then it does not push a stack cell. *)
-
-let runpushes s =
- match Lr1.incoming_symbol s with
- | Some (Symbol.T _) ->
- true
- | Some (Symbol.N nt) ->
- not (gotopushes nt)
- | None ->
- false
-
-(* ------------------------------------------------------------------------ *)
-(* In some situations, we are able to fuse a shift (or goto)
- transition with a reduce transition, which means that we save the
- cost (in speed and in code size) of pushing and popping the top
- stack cell.
-
- This involves creating a modified version of the [reduce] function
- associated with a production [prod], where the contents of the top
- stack cell are passed as extra parameters. Because we wish to avoid
- code duplication, we perform this change only if all call sites for
- [reduce] agree on this modified calling convention.
-
- At the call site, the optimization is possible only if a stack cell
- allocation exists and is immediately followed by a call to
- [reduce]. This is the case inside the [run] function for state [s]
- when [run] pushes a stack cell and performs a default reduction.
-
- This optimization amounts to coalescing the push operation inside
- [run] with the pop operation that follows inside [reduce].
-
- Unit production elimination, on the other hand, would coalesce the
- pop operation inside [reduce] with the push operation that follows
- inside [goto]. For this reason, the two are contradictory. As a
- result, we do not attempt to perform unit production elimination.
- In fact, we did implement it at one point and found that it was
- seldom applicable, because preference was given to the shiftreduce
- optimization.
-
- There are cases where shiftreduce optimization does not make any
- difference, for instance, if production [prod] is never reduced, or
- if the top stack cell is in fact nonexistent. *)
-
-let (shiftreduce : Production.index -> bool), shiftreducecount =
- Production.tabulate (fun prod ->
-
- (* Check that this production pops at least one stack cell. *)
-
- Production.length prod > 0 &&
-
- (* Check that all call sites push a stack cell and have a
- default reduction. *)
-
- Invariant.fold_reduced (fun s accu ->
- accu && (match Invariant.has_default_reduction s with None -> false | Some _ -> true)
- && (runpushes s)
- ) prod true
-
- )
-
-let () =
- Error.logC 1 (fun f ->
- Printf.fprintf f
- "%d out of %d productions exploit shiftreduce optimization.\n"
- shiftreducecount Production.n)
-
-(* Check that, as predicted above, [gotopushes nt] returns [false]
- only when all of the [run] functions that follow it perform
- shiftreduce optimization.
-
- This can be proved as follows. If [gotopushes nt] returns [false],
- then every successor state [s] has a default reduction for some
- non-epsilon production [prod]. Furthermore, all states that can
- reduce [prod] must be successors of that same [goto] function:
- indeed, because the right-hand side of the production ends with
- symbol [nt], every state that can reduce [prod] must be entered
- through [nt]. So, at all such states, [runpushes] is true, which
- guarantees that [shiftreduce prod] is true as well. *)
-
-let () =
- assert (
- Nonterminal.fold (fun nt accu ->
- accu &&
- if gotopushes nt then
- true
- else
- Lr1.targets (fun accu _ target ->
- accu &&
- match Invariant.has_default_reduction target with
- | Some (prod, _) ->
- shiftreduce prod
- | None ->
- false
- ) true (Symbol.N nt)
- ) true
- )
-
-(* ------------------------------------------------------------------------ *)
-(* Type production. *)
-
-(* This is the type of states. Only states that are represented are
- declared. *)
-
-let statetypedef = {
- typename = tcstate;
- typeparams = [];
- typerhs = TDefSum (
- Lr1.fold (fun defs s ->
- if Invariant.represented s then {
- dataname = statecon s;
- datavalparams = [];
- datatypeparams = None
- } :: defs
- else defs
- ) []
- );
- typeconstraint = None
-}
-
-(* This is the type of parser environments. *)
-
-let field modifiable name t =
- {
- modifiable = modifiable;
- fieldname = name;
- fieldtype = type2scheme t
- }
-
-let envtypedef = {
- typename = tcenv;
- typeparams = [];
- typerhs =
- TDefRecord ([
-
- (* The lexer itself. *)
-
- field false flexer tlexer;
-
- (* The lexing buffer. *)
-
- field false flexbuf tlexbuf;
-
- (* The last token that was read from the lexer. This is the
- head of the token stream, unless [env.shifted] is [-1]. *)
-
- field true ftoken ttoken;
-
- (* The start position of the above token. *)
-
- field true fstartp tposition;
-
- (* The end position of the above token. *)
-
- field true fendp tposition;
-
- (* How many tokens were successfully shifted since the last
- [error] token was shifted. When this counter is -1, the head
- of the token stream is the [error] token, and the contents of
- the [token] field is irrelevant. The token following [error]
- is obtained by invoking the lexer again. *)
-
- field true fshifted tint;
-
- ] @
-
- (* If at least one semantic action mentions $previouserror, then we keep
- track of this information. *)
-
- insertif previouserror_required (field true fpreviouserror tint)
-
- );
- typeconstraint = None
-}
-
-(* [curry] curries the top stack cell in a type [t] of the form
- [(stack type) arrow (result type)]. [t] remains unchanged if the
- stack type does not make at least one cell explicit. *)
-
-let curry = function
- | TypArrow (TypTuple (tstack :: tcell), tresult) ->
- TypArrow (tstack, marrow tcell tresult)
- | TypArrow _ as t ->
- t
- | _ ->
- assert false
-
-(* [curryif true] is [curry], [curryif false] is the identity. *)
-
-let curryif flag t =
- if flag then curry t else t
-
-(* Types for stack cells.
-
- [celltype tailtype holds_state symbol] returns the type of a stack
- cell. The parameter [tailtype] is the type of the tail of the
- stack. The flag [holds_state] tells whether the cell holds a state.
- The parameter [symbol] is used to determine whether the cell holds
- a semantic value and what its type is.
-
- A subtlety here and in [curry] above is that singleton stack cells
- give rise to singleton tuple types, which the type printer
- eliminates, but which do exist internally. As a result, [curry]
- always correctly removes the top stack cell, even if it is a
- singleton tuple cell. *)
-
-let celltype tailtype holds_state symbol _ =
- TypTuple (
- tailtype ::
- insertif holds_state tstate @
- semvtype symbol @
- insertif (Invariant.startp symbol) tposition @
- insertif (Invariant.endp symbol) tposition
- )
-
-(* Types for stacks.
-
- [stacktype s] is the type of the stack at state
- [s]. [reducestacktype prod] is the type of the stack when about to
- reduce production [prod]. [gotostacktype nt] is the type of the
- stack when the [goto] function associated with [nt] is called.
-
- In all cases, the tail (that is, the unknown part) of the stack is
- represented by [ttail], currently a type variable.
-
- These stack types are obtained by folding [celltype] over a
- description of the stack provided by module [Invariant]. *)
-
-let stacktype s =
- Invariant.fold celltype ttail (Invariant.stack s)
-
-let reducestacktype prod =
- Invariant.fold celltype ttail (Invariant.prodstack prod)
-
-let gotostacktype nt =
- Invariant.fold celltype ttail (Invariant.gotostack nt)
-
-(* The type of the [run] function. As announced earlier, if [s] is the
- target of shift transitions, the type of the stack is curried, that
- is, the top stack cell is not yet allocated, so its contents are
- passed as extra parameters. If [s] is the target of goto
- transitions, the top stack cell is allocated. If [s] is a start
- state, this issue makes no difference. *)
-
-let runtypescheme s =
- auto2scheme (
- arrow tenv (
- curryif (runpushes s) (
- arrow (stacktype s) tresult
- )
- )
- )
-
-(* The type of the [action] function. The top stack cell is not
- curried. There is an additional parameter of type [token]. *)
-
-let actiontypescheme s =
- auto2scheme (marrow [ tenv; stacktype s; ttoken ] tresult)
-
-(* The type of the [goto] function. The top stack cell is curried. *)
-
-let gototypescheme nt =
- auto2scheme (arrow tenv (curry (arrow (gotostacktype nt) tresult)))
-
-(* If [prod] is an epsilon production and if the [goto] function
- associated with it expects a state parameter, then the [reduce]
- function associated with [prod] also requires a state parameter. *)
-
-let reduce_expects_state_param prod =
- let nt = Production.nt prod in
- Production.length prod = 0 &&
- Invariant.fold (fun _ holds_state _ _ -> holds_state) false (Invariant.gotostack nt)
-
-(* The type of the [reduce] function. If shiftreduce optimization
- is performed for this production, then the top stack cell is
- not explicitly allocated. *)
-
-let reducetypescheme prod =
- auto2scheme (
- arrow tenv (
- curryif (shiftreduce prod) (
- arrow (reducestacktype prod) (
- arrowif (reduce_expects_state_param prod) tstate tresult
- )
- )
- )
- )
-
-(* The type of the [errorcase] function. The shape of the stack is
- unknown, and is determined by examining the state parameter. *)
-
-let errorcasetypescheme =
- auto2scheme (marrow [ tenv; ttail; tstate ] tresult)
-
-(* The type of the [error] function. The shape of the stack is the
- one associated with state [s]. *)
-
-let errortypescheme s =
- auto2scheme ( marrow [ tenv; stacktype s ] tresult)
-
-(* ------------------------------------------------------------------------ *)
-(* Code production preliminaries. *)
-
-(* This flag will be set to [true] if we ever raise the [Error]
- exception. This happens when we unwind the entire stack without
- finding a state that can handle errors. *)
-
-let can_die =
- ref false
-
-(* A code pattern for an exception handling construct where both
- alternatives are in tail position. Concrete syntax for this would
- be [let x = e in e1 unless Error -> e2]. Since Objective Caml does
- not support this construct, we emulate it using a combination of
- [try/with], [match/with], and an [option] value. *)
-
-let letunless e x e1 e2 =
- EMatch (
- ETry (
- EData ("Some", [ e ]),
- [ { branchpat = PData (excname, []); branchbody = EData ("None", []) } ]
- ),
- [ { branchpat = PData ("Some", [ PVar x ]); branchbody = e1 };
- { branchpat = PData ("None", []); branchbody = e2 } ]
- )
-
-(* ------------------------------------------------------------------------ *)
-(* Calling conventions. *)
-
-(* The contents of a stack cell, exposed as individual parameters. The
- choice of identifiers is suitable for use in the definition of
- [run]. *)
-
-let runcellparams var holds_state symbol =
- insertif holds_state (var state) @
- symval symbol (var semv) @
- insertif (Invariant.startp symbol) (var startp) @
- insertif (Invariant.endp symbol) (var endp)
-
-(* The contents of a stack cell, exposed as individual parameters, again.
- The choice of identifiers is suitable for use in the definition of a
- [reduce] function.
-
- [prod] is the production's index. The integer [i] tells which
- symbol on the right-hand side we are focusing on, that is, which
- symbol this stack cell is associated with. *)
-
-let reducecellparams prod i holds_state symbol =
- let ids = Production.identifiers prod
- and used = Production.used prod in
-
- (* If the semantic value is used in the semantic action, then it is
- bound to the variable [ids.(i)]. If the semantic value is not
- used in the semantic action, then it is dropped using a wildcard
- pattern. *)
-
- let semvpat t =
- if used.(i) then
- PVar ids.(i)
- else
- PWildcard
- in
-
- insertif holds_state (if i = 0 then PVar state else PWildcard) @
- symvalt symbol semvpat @
- insertif (Invariant.startp symbol) (PVar (Printf.sprintf "_startpos_%s_" ids.(i))) @
- insertif (Invariant.endp symbol) (PVar (Printf.sprintf "_endpos_%s_" ids.(i)))
-
-(* The contents of a stack cell, exposed as individual parameters,
- again. The choice of identifiers is suitable for use in the
- definition of [error]. *)
-
-let errorcellparams (i, pat) holds_state symbol _ =
- i + 1,
- ptuple (
- pat ::
- insertif holds_state (if i = 0 then PVar state else PWildcard) @
- symval symbol PWildcard @
- insertif (Invariant.startp symbol) PWildcard @
- insertif (Invariant.endp symbol) PWildcard
- )
-
-(* Calls to [run]. *)
-
-let runparams magic var s =
- var env ::
- magic (var stack) ::
- concatif (runpushes s) (Invariant.fold_top (runcellparams var) [] (Invariant.stack s))
-
-let call_run s actuals =
- EApp (EVar (run s), actuals)
-
-(* Calls to [action]. *)
-
-let actionparams var =
- [ var env; var stack; var token ]
-
-let call_action s =
- EApp (EVar (action s), actionparams var)
-
-(* The parameters to [reduce]. When shiftreduce optimization is in
- effect, the top stack cell is not allocated, so extra parameters
- are required. Note that [shiftreduce prod] and
- [reduce_expects_state_param prod] are mutually exclusive
- conditions, so the [state] parameter is never bound twice. *)
-
-let reduceparams prod =
- PVar env ::
- PVar stack ::
- concatif (shiftreduce prod) (
- Invariant.fold_top
- (reducecellparams prod (Production.length prod - 1))
- [] (Invariant.prodstack prod)
- ) @
- insertif (reduce_expects_state_param prod) (PVar state)
-
-(* Calls to [reduce]. One must specify the production [prod] as well
- as the current state [s]. *)
-
-let call_reduce prod s =
- let actuals =
- (EVar env) ::
- (EMagic (EVar stack)) ::
- concatif (shiftreduce prod)
- (Invariant.fold_top (runcellparams var) [] (Invariant.stack s))
- (* compare with [runpushcell s] *) @
- insertif (reduce_expects_state_param prod) (estatecon s)
- in
- EApp (EVar (reduce prod), actuals)
-
-(* Calls to [goto]. *)
-
-let gotoparams var nt =
- var env ::
- var stack ::
- Invariant.fold_top (runcellparams var) [] (Invariant.gotostack nt)
-
-let call_goto nt =
- EApp (EVar (goto nt), gotoparams var nt)
-
-(* Calls to [errorcase]. *)
-
-let errorcaseparams magic var =
- [ var env; magic (var stack); var state ]
-
-let call_errorcase =
- EApp (EVar errorcase, errorcaseparams magic var)
-
-(* Calls to [error]. *)
-
-let errorparams magic var =
- [ var env; magic (var stack) ]
-
-let call_error magic s =
- EApp (EVar (error s), errorparams magic var)
-
-let call_error_via_errorcase magic s = (* TEMPORARY document *)
- if Invariant.represented s then
- EApp (EVar errorcase, [ var env; magic (var stack); estatecon s ])
- else
- call_error magic s
-
-(* Calls to [assertfalse]. *)
-
-let call_assertfalse =
- EApp (EVar assertfalse, [ EVar "()" ])
-
-(* ------------------------------------------------------------------------ *)
-(* Emit a warning when a state can do error recovery but does not
- accept EOF. This can lead to non-termination if the end of file
- is reached while attempting to recover from an error. *)
-
-let check_recoverer covered s =
- match Terminal.eof with
- | None ->
- (* We do not know which token represents the end of file,
- so we say nothing. *)
- ()
- | Some eof ->
- if not (TerminalSet.mem eof covered) then
- (* This state has no (shift or reduce) action at EOF. *)
- Error.warning []
- (Printf.sprintf
- "state %d can perform error recovery, but does not accept EOF.\n\
- ** Hitting the end of file during error recovery will cause non-termination."
- (Lr1.number s))
-
-(* ------------------------------------------------------------------------ *)
-(* Code production for the automaton functions. *)
-
-(* Count how many states actually perform error recovery. This figure
- is, in general, inferior or equal to the number of states at which
- [Invariant.recoverer] is true. Indeed, some of these states have a
- default reduction, while some will accept every token; in either
- case, error recovery is not performed. *)
-
-let recoverers =
- ref 0
-
-(* Count how many states actually can peek at an error recovery. This
- figure is, in general, inferior or equal to the number of states at
- which [Invariant.errorpeeker] is true, because some of these states
- have a default reduction and will not consult the lookahead
- token. *)
-
-let errorpeekers =
- ref 0
-
-(* Code for calling the reduction function for token [prod] upon
- finding a token within [toks]. This produces a branch, to be
- inserted in an [action] function for state [s]. *)
-
-let reducebranch toks prod s =
- {
- branchpat =
- tokspat toks;
- branchbody =
- call_reduce prod s
- }
-
-(* Code for shifting from state [s] to state [s'] via the token [tok].
- This produces a branch, to be inserted in an [action] function for
- state [s].
-
- The callee, [run s'], is responsible for taking the current token
- off the input stream. (There is actually a case where the token is
- *not* taken off the stream: when [s'] has a default reduction on
- [#].)
-
- It is also responsible for pushing a new stack cell. The rationale
- behind this decision is that there may be multiple shift
- transitions into [s'], so we actually share that code by placing it
- inside [run s'] rather than inside every transition. *)
-
-let shiftbranchbody s tok s' =
-
- (* Construct the actual parameters for [run s']. *)
-
- let actuals =
- (EVar env) ::
- (EMagic (EVar stack)) ::
- Invariant.fold_top (fun holds_state symbol ->
- assert (Symbol.equal (Symbol.T tok) symbol);
- insertif holds_state (estatecon s) @
- tokval tok (EVar semv) @
- insertif (Invariant.startp symbol) (ERecordAccess (EVar env, fstartp)) @
- insertif (Invariant.endp symbol) (ERecordAccess (EVar env, fendp))
- ) [] (Invariant.stack s')
- in
-
- (* Call [run s']. *)
-
- tracecomment
- (Printf.sprintf "Shifting (%s) to state %d" (Terminal.print tok) (Lr1.number s'))
- (call_run s' actuals)
-
-let shiftbranch s tok s' =
- assert (not (Terminal.pseudo tok));
- {
- branchpat =
- PData (tokenprefix (Terminal.print tok), tokval tok (PVar semv));
- branchbody =
- shiftbranchbody s tok s'
- }
-
-(* This generates code for pushing a new stack cell upon entering the
- [run] function for state [s]. *)
-
-let runpushcell s e =
- if runpushes s then
- let contents = var stack :: Invariant.fold_top (runcellparams var) [] (Invariant.stack s) in
- mlet [ pvar stack ] [ etuple contents ] e
- else
- e
-
-let runpushcellunless shiftreduce s e =
- if shiftreduce then
- EComment ("Not allocating top stack cell", e)
- else
- runpushcell s e
-
-(* This generates code for dealing with the lookahead token upon
- entering the [run] function for state [s]. If [s] is the target of
- a shift transition, then we must take the current token (which was
- consumed in the shift transition) off the input stream. Whether [s]
- was entered through a shift or a goto transition, we want to peek
- at the next token, unless we are performing a default reduction.
- The parameter [defred] tells which default reduction, if any, we
- are about to perform. *)
-
-let gettoken s defred e =
- match Lr1.incoming_symbol s, defred with
-
- | Some (Symbol.T _), Some (_, toks)
- when TerminalSet.mem Terminal.sharp toks ->
- assert (TerminalSet.cardinal toks = 1);
-
- (* There is a default reduction on token [#]. We cannot
- request the next token, since that might drive the
- lexer off the end of the input stream, so we cannot
- call [discard]. Do nothing. *)
-
- e
-
- | Some (Symbol.T _), Some _ ->
-
- (* There is some other default reduction. Discard the first
- input token. *)
-
- blet ([ PWildcard, EApp (EVar discard, [ EVar env ]) ], e)
-
- | Some (Symbol.T _), None ->
-
- (* There is no default reduction. Discard the first input token
- and peek at the next one. *)
-
- blet ([ PVar token, EApp (EVar discard, [ EVar env ]) ], e)
-
- | (Some (Symbol.N _) | None), Some _ ->
-
- (* There is some default reduction. Do not peek at the input
- token. *)
-
- e
-
- | (Some (Symbol.N _) | None), None ->
-
- (* There is no default reduction. Peek at the first input token,
- without taking it off the input stream. This is normally done
- by reading [env.token], unless the token might be [error]:
- then, we check [env.shifted] first. *)
-
- if Invariant.errorpeeker s then begin
- incr errorpeekers;
- EIfThenElse (
- EApp (EVar "Pervasives.(=)", [ ERecordAccess (EVar env, fshifted); EIntConst (-1) ]),
- tracecomment "Resuming error handling" (call_error_via_errorcase magic s),
- blet ([ PVar token, ERecordAccess (EVar env, ftoken) ], e)
- )
- end
- else
- blet ([ assertshifted;
- PVar token, ERecordAccess (EVar env, ftoken) ], e)
-
-(* This produces the definition of a [run] function. *)
-
-let rundef s body =
- let body =
- tracecomment (Printf.sprintf "State %d:" (Lr1.number s)) body
- in {
- valpublic = false;
- valpat = PVar (run s);
- valval = EAnnot (EFun (runparams nomagic pvar s, body), runtypescheme s)
- }
-
-(* This produces the definition of an [action] function. *)
-
-let actiondef s body = {
- valpublic = false;
- valpat = PVar (action s);
- valval = EAnnot (EFun (actionparams pvar, body), actiontypescheme s)
-}
-
-(* This produces the comment attached with a default reduction. *)
-
-let defaultreductioncomment toks e =
- EPatComment (
- "Reducing without looking ahead at ",
- tokspat toks,
- e
- )
-
-(* This produces some bookkeeping code that is used when initiating
- error handling.
-
- First, we copy [env.shifted] to [env.previouserror]. Of course,
- this is done only if at least one semantic action uses the
- [$previouserror] keyword.
-
- Then, we reset the count of tokens shifted since the last error to
- -1, so that it becomes zero *after* the error token itself is
- shifted. By convention, when [shifted] is -1, the field [env.token]
- becomes meaningless and one considers that the first token on the
- input stream is [error]. As a result, the next peek at the
- lookahead token will cause error handling to be resumed. The next
- call to [discard] will take the [error] token off the input stream
- and increment [env.shifted] to zero. *)
-
-let errorbookkeeping e =
- tracecomment
- "Initiating error handling"
- (blet (
- concatif previouserror_required
- [ PUnit, ERecordWrite (EVar env, fpreviouserror, ERecordAccess (EVar env, fshifted)) ] @
- [ PUnit, ERecordWrite (EVar env, fshifted, EIntConst (-1)) ],
- e
- ))
-
-(* This code is used to indicate that a new error has been detected in
- state [s]. [covered] is the set of tokens that [s] knows how to
- handle.
-
- If I am correct, the count of shifted tokens is never -1
- here. Indeed, that would mean that we first found an error, and
- then signaled another error before being able to shift the first
- error token. My understanding is that this cannot happen: when the
- first error is signaled, we end up at a state that is willing to
- handle the error token, by a series of reductions followed by a
- shift.
-
- In the simplest case, the state [s] cannot do error recovery. In
- that case, we initiate error handling, which is done by first
- performing the standard bookkeeping described above, then
- transferring control to the [error] function associated with [s].
-
- If, on the other hand, [s] can do error recovery, then we check
- whether any tokens at all were shifted since the last error
- occurred. If none were, then we discard the current token and
- transfer control back to the [action] function associated with [s].
-
- The token is discarded via a call to [discard], followed by
- resetting [env.shifted] to zero, to counter-act the effect of
- [discard], which increments that counter. *)
-
-let initiate covered s =
-
- blet (
- [ assertshifted ],
-
- if Invariant.recoverer s then begin
-
- incr recoverers;
- check_recoverer covered s;
-
- EIfThenElse (
- EApp (EVar "Pervasives.(=)", [ ERecordAccess (EVar env, fshifted); EIntConst 0 ]),
- blet (
- trace "Discarding last token read (%s)"
- [ EApp (EVar print_token, [ ERecordAccess (EVar env, ftoken) ]) ] @
- [
- PVar token, EApp (EVar discard, [ EVar env ]);
- PUnit, ERecordWrite (EVar env, fshifted, EIntConst 0)
- ],
- call_action s
- ),
- errorbookkeeping (call_error_via_errorcase magic s)
- )
-
- end
- else
- errorbookkeeping (call_error_via_errorcase magic s)
-
- )
-
-(* This produces the definitions of the [run] and [action] functions
- associated with state [s].
-
- The [action] function implements the internal case analysis. It
- receives the lookahead token as a parameter. It does not affect the
- input stream. It does not set up exception handlers for dealing
- with errors. The existence of this internal function is made
- necessary by the error recovery mechanism (which discards tokens
- when attempting to resynchronize after an error). In many states,
- recovery can in fact not be performed, so no self-call to [action]
- will be generated and [action] will be inlined into [run]. *)
-
-let rec runactiondef s : valdef list =
-
- match Invariant.has_default_reduction s with
- | Some (prod, toks) as defred ->
-
- (* Perform reduction without looking ahead. In this case,
- no separate [action] function is required.
-
- If shiftreduce optimization is being performed, then no
- stack cell is allocated. The contents of the top stack
- cell are passed do [reduce] as extra parameters. *)
-
- [
- rundef s (
- runpushcellunless (shiftreduce prod) s (
- gettoken s defred (
- defaultreductioncomment toks (
- call_reduce prod s
- )
- )
- )
- )
- ]
-
- | None ->
-
- (* If this state is willing to act on the error token, ignore
- that -- this is taken care of elsewhere. *)
-
- let transitions =
- SymbolMap.remove (Symbol.T Terminal.error) (Lr1.transitions s)
- and reductions =
- TerminalMap.remove Terminal.error (Lr1.reductions s)
- in
-
- (* Construct the main case analysis that determines what action
- should be taken next.
-
- A default branch, where an error is detected, is added if the
- analysis is not exhaustive. In the default branch, we
- initiate error handling. *)
-
- let covered, branches =
- ProductionMap.fold (fun prod toks (covered, branches) ->
- (* There is a reduction for these tokens. *)
- TerminalSet.union toks covered,
- reducebranch toks prod s :: branches
- ) (Lr1.invert reductions) (TerminalSet.empty, [])
- in
-
- let covered, branches =
- SymbolMap.fold (fun symbol s' (covered, branches) ->
- match symbol with
- | Symbol.T tok ->
- (* There is a shift transition for this token. *)
- TerminalSet.add tok covered,
- shiftbranch s tok s' :: branches
- | Symbol.N _ ->
- covered, branches
- ) transitions (covered, branches)
- in
-
- let branches =
- if TerminalSet.subset TerminalSet.universe covered then
- branches
- else
- branches @ [ { branchpat = PWildcard; branchbody = initiate covered s } ]
- in
-
- (* Finally, construct the code for [run] and [action]. The
- former pushes things onto the stack, obtains the lookahead
- token, and calls the [action] function. The latter performs
- the main case analysis on the lookahead token. *)
-
- [
- rundef s (
- runpushcell s (
- gettoken s None (
- call_action s
- )
- )
- );
- actiondef s (
- EMatch (
- EVar token,
- branches
- )
- )
- ]
-
-(* This is the body of the [reduce] function associated with
- production [prod]. *)
-
-let reducebody prod =
-
- (* Find out about the left-hand side of this production and about
- the identifiers that have been bound to the symbols in the
- right-hand side. These represent variables that we should bind to
- semantic values before invoking the semantic action. *)
-
- let nt, rhs = Production.def prod
- and ids = Production.identifiers prod
- and used = Production.used prod
- and length = Production.length prod in
-
- (* Build a pattern that represents the shape of the stack. Out of
- the stack, we extract a state (except when the production is an
- epsilon production) and a number of semantic values.
-
- If shiftreduce optimization is being performed, then the top
- stack cell is not explicitly allocated, so we do not include
- it in the pattern that is built. *)
-
- let (_ : int), pat =
- Invariant.fold (fun (i, pat) holds_state symbol _ ->
- i + 1,
- if i = length - 1 && shiftreduce prod then
- pat
- else
- ptuple (pat :: reducecellparams prod i holds_state symbol)
- ) (0, PVar stack) (Invariant.prodstack prod)
- in
-
- (* If any identifiers refer to terminal symbols without a semantic
- value, then bind these identifiers to the unit value. This
- provides the illusion that every symbol, terminal or nonterminal,
- has a semantic value. This is more regular and allows applying
- operators such as ? to terminal symbols without a semantic
- value. *)
-
- let unitbindings =
- Misc.foldi length (fun i unitbindings ->
- if used.(i) then
- match semvtype rhs.(i) with
- | [] ->
- (PVar ids.(i), EUnit) :: unitbindings
- | _ ->
- unitbindings
- else
- unitbindings
- ) []
- in
-
- (* If necessary, determine start and end positions for the left-hand
- side of the production. If the right-hand side is nonempty, this
- is done by extracting position information out of the first and
- last symbols of the right-hand side. If it is empty, then both
- positions are taken to be the current lookahead token's start
- position.
-
- Note that [Keyword.has_leftstart keywords] does not imply
- [Invariant.startp symbol], and similarly for end positions. *)
-
- let symbol =
- Symbol.N nt
- in
-
- let posbindings action =
- let bind_startp =
- Action.has_leftstart action || Invariant.startp symbol
- and bind_endp =
- Action.has_leftend action || Invariant.endp symbol
- in
- insertif bind_startp
- ( PVar startp,
- if length > 0 then
- EVar (Printf.sprintf "_startpos_%s_" ids.(0))
- else
- ERecordAccess (EVar env, fstartp)
- ) @
- insertif bind_endp
- ( PVar endp,
- if length > 0 then
- EVar (Printf.sprintf "_endpos_%s_" ids.(length - 1))
- else
- if bind_startp then EVar startp else ERecordAccess (EVar env, fstartp)
- )
- in
-
- (* If this production is one of the start productions, then reducing
- it means accepting the input. In that case, we return a final
- semantic value and stop. Otherwise, we transfer control to the
- [goto] function, unless the semantic action raises [Error], in
- which case we transfer control to [errorcase]. *)
-
- match Production.classify prod with
- | Some nt ->
-
- tracecomment
- "Accepting"
- (blet (
- [ pat, EVar stack ],
- EMagic (EVar ids.(0))
- ))
-
- | None ->
-
- let action =
- Production.action prod
- in
- let act =
- EAnnot (Action.to_il_expr action, type2scheme (semvtypent nt))
- in
-
- tracecomment
- (Printf.sprintf "Reducing production %s" (Production.print prod))
- (blet (
- (pat, EVar stack) ::
- unitbindings @
- posbindings action @
- extrabindings fpreviouserror action,
-
- (* If the semantic action is susceptible of raising [Error],
- use a [let/unless] construct, otherwise use [let]. *)
-
- if Action.has_syntaxerror action then
- letunless act semv (call_goto nt) (errorbookkeeping call_errorcase)
- else
- blet ([ PVar semv, act ], call_goto nt)
- ))
-
-(* This is the definition of the [reduce] function associated with
- production [prod]. *)
-
-let reducedef prod =
- {
- valpublic =
- false;
- valpat =
- PVar (reduce prod);
- valval =
- EAnnot (
- EFun (
- reduceparams prod,
- reducebody prod
- ),
- reducetypescheme prod
- )
- }
-
-(* This generates code for pushing a new stack cell inside [goto]. *)
-
-let gotopushcell nt e =
- if gotopushes nt then
- let contents = var stack :: Invariant.fold_top (runcellparams var) [] (Invariant.gotostack nt) in
- mlet [ pvar stack ] [ etuple contents ] e
- else
- e
-
-(* This is the heart of the [goto] function associated with
- nonterminal [nt]. *)
-
-let gotobody nt =
-
- (* Examine the current state to determine where to go next. *)
-
- let branches =
- Lr1.targets (fun branches sources target ->
- {
- branchpat =
- pstatescon sources;
- branchbody =
- call_run target (runparams magic var target)
- } :: branches
- ) [] (Symbol.N nt)
- in
-
- match branches with
- | [] ->
-
- (* If there are no branches, then this [goto] function is never
- invoked. The inliner will drop it, so whatever we generate
- here is unimportant. *)
-
- call_assertfalse
-
- | [ branch ] ->
-
- (* If there is only one branch, no case analysis is required.
- This optimization is not strictly necessary if GADTs are used
- by the compiler to prove that the case analysis is
- exhaustive. It does improve readability, though, and is also
- useful if the compiler does not have GADTs. *)
-
- EPatComment (
- "State should be ",
- branch.branchpat,
- branch.branchbody
- )
-
- | _ ->
-
- (* In the general case, we keep the branches computed above and,
- unless [nt] is universal, add a default branch, which is
- theoretically useless but helps avoid warnings if the
- compiler does not have GADTs. *)
-
- let default = {
- branchpat = PWildcard;
- branchbody = call_assertfalse
- } in
- EMatch (
- EVar state,
- branches @ (if Invariant.universal (Symbol.N nt) then [] else [ default ])
- )
-
-(* This the [goto] function associated with nonterminal [nt]. *)
-
-let gotodef nt = {
- valpublic =
- false;
- valpat =
- PVar (goto nt);
- valval =
- EAnnot (EFun (gotoparams pvar nt, gotopushcell nt (gotobody nt)), gototypescheme nt)
-}
-
-(* ------------------------------------------------------------------------ *)
-(* Code production for the error handling functions. *)
-
-(* This is the body of the [error] function associated with state [s]. *)
-
-let handle s e =
- tracecomment (Printf.sprintf "Handling error in state %d" (Lr1.number s)) e
-
-let errorbody s =
- try
- let s' = SymbolMap.find (Symbol.T Terminal.error) (Lr1.transitions s) in
-
- (* There is a shift transition on error. *)
-
- handle s (
- shiftbranchbody s Terminal.error s'
- )
-
- with Not_found ->
- try
- let prods = TerminalMap.lookup Terminal.error (Lr1.reductions s) in
- let prod = Misc.single prods in
-
- (* There is a reduce transition on error. If shiftreduce
- optimization is enabled for this production, then we must pop
- an extra cell for [reduce]'s calling convention to be met. *)
-
- let extrapop e =
- if shiftreduce prod then
- let pat =
- ptuple (PVar stack :: Invariant.fold_top (runcellparams pvar) [] (Invariant.stack s))
- in
- blet ([ pat, EVar stack ], e)
- else
- e
- in
-
- handle s (
- extrapop (
- call_reduce prod s
- )
- )
-
- with Not_found ->
-
- (* This state is unable to handle errors. Pop the stack to find
- a state that does handle errors, a state that can further pop
- the stack, or die. *)
-
- match Invariant.rewind s with
- | Invariant.Die ->
- can_die := true;
- ERaise errorval
- | Invariant.DownTo (w, st) ->
- let _, pat = Invariant.fold errorcellparams (0, PVar stack) w in
- blet (
- [ pat, EVar stack ],
- match st with
- | Invariant.Represented ->
- call_errorcase
- | Invariant.UnRepresented s ->
- call_error magic s
- )
-
-(* This is the [error] function associated with state [s]. *)
-
-let errordef s = {
- valpublic =
- false;
- valpat =
- PVar (error s);
- valval =
- EAnnot (
- EFun (
- errorparams nomagic pvar,
- errorbody s
- ),
- errortypescheme s
- )
-}
-
-(* This is the [errorcase] function. It examines its state parameter
- and dispatches control to an appropriate [error] function. *)
-
-let errorcasedef =
- let branches =
- Lr1.fold (fun branches s ->
- if Invariant.represented s then
- {
- branchpat = pstatecon s;
- branchbody = EApp (EVar (error s), [ EVar env; EMagic (EVar stack) ])
- } :: branches
- else
- branches
- ) []
- in
- {
- valpublic =
- false;
- valpat =
- PVar errorcase;
- valval =
- EAnnot (
- EFun (
- errorcaseparams nomagic pvar,
- EMatch (
- EVar state,
- branches
- )
- ),
- errorcasetypescheme
- )
- }
-
-(* ------------------------------------------------------------------------ *)
-(* Code production for the entry points. *)
-
-(* This is the entry point associated with a start state [s]. By
- convention, it is named after the nonterminal [nt] that corresponds
- to this state. This is a public definition.
-
- The code initializes a parser environment, an empty stack, and
- invokes [run]. *)
-
-let entrydef s =
- let nt = Item.startnt (Lr1.start2item s) in
- let lexer = "lexer"
- and lexbuf = "lexbuf" in
- {
- valpublic = true;
- valpat = PVar (Nonterminal.print true nt);
- valval = EAnnot (
- EFun ( [ PVar lexer; PVar lexbuf ],
- blet (
- [ PVar env, EApp (EVar initenv, [ EVar lexer; EVar lexbuf ]) ],
- EMagic (EApp (EVar (run s), [ EVar env; EUnit ]))
- )
- ),
- entrytypescheme (Nonterminal.print true nt)
- )
- }
-
-(* ------------------------------------------------------------------------ *)
-(* Code production for auxiliary functions. *)
-
-(* This is [assertfalse], used when internal failure is detected.
- This should never happen if our tool is correct. *)
-
-let assertfalsedef = {
- valpublic = false;
- valpat = PVar assertfalse;
- valval =
- EAnnot (
- EFun ([ PUnit ],
- blet ([
- PUnit, EApp (EVar "Printf.fprintf",
- [ EVar "Pervasives.stderr";
- EStringConst "Internal failure -- please contact the parser generator's developers.\n%!" ]);
- ],
- EApp (EVar "assert", [ efalse ])
- )
- ),
- scheme [ "a" ] (arrow tunit (tvar "a"))
- )
-}
-
-(* This is [print_token], used to print tokens in [--trace] mode. *)
-
-let printtokendef =
- destructuretokendef
- print_token
- tstring
- false
- (fun tok -> EStringConst (Terminal.print tok))
-
-(* This is [discard], used to take a token off the input stream and
- query the lexer for a new one. The code queries the lexer for a new
- token and stores it into [env.token], overwriting the previous
- token. It also stores the start and positions of the new token.
- Last, if [env.shifted] has not yet reached its limit, then it is
- incremented.
-
- We use the lexer's [lex_start_p] and [lex_curr_p] fields to extract
- the start and end positions of the token that we just read. In
- practice, it seems that [lex_start_p] can be inaccurate (that is
- the case when the lexer calls itself recursively, instead of simply
- recognizing an atomic pattern and returning immediately). However,
- we are 100% compatible with ocamlyacc here, and there is no better
- solution anyway. *)
-
-let discarddef = {
- valpublic = false;
- valpat = PVar discard;
- valval =
- let lexbuf = "lexbuf"
- and shifted = "shifted" in
- EAnnot (
- EFun (
- [ PVar env ],
- blet ([
- PVar lexbuf, ERecordAccess (EVar env, flexbuf);
- PVar token, EApp (ERecordAccess (EVar env, flexer), [ EVar lexbuf ]);
- PUnit, ERecordWrite (EVar env, ftoken, EVar token);
- PUnit, ERecordWrite (EVar env, fstartp, ERecordAccess (EVar lexbuf, "Lexing.lex_start_p"));
- PUnit, ERecordWrite (EVar env, fendp, ERecordAccess (EVar lexbuf, "Lexing.lex_curr_p")) ] @
- trace "Lookahead token is now %s (%d-%d)"
- [ EApp (EVar print_token, [ EVar token ]);
- ERecordAccess (ERecordAccess (EVar env, fstartp), "Lexing.pos_cnum");
- ERecordAccess (ERecordAccess (EVar env, fendp), "Lexing.pos_cnum") ] @ [
- PVar shifted, EApp (EVar "Pervasives.(+)", [ ERecordAccess (EVar env, fshifted); EIntConst 1 ]);
- PUnit, EIfThen (
- EApp (EVar "Pervasives.(>=)", [ EVar shifted; EIntConst 0 ]),
- ERecordWrite (EVar env, fshifted, EVar shifted)
- )
- ],
- EVar token
- )
- ),
- type2scheme (arrow tenv ttoken)
- )
-}
-
-(* This is [initenv], used to allocate a fresh parser environment.
- It performs the very first call to the lexer, and fills in all
- fields in a straightforward way. *)
-
-let initenvdef =
- let lexer = "lexer"
- and lexbuf = "lexbuf" in
- {
- valpublic = false;
- valpat = PVar initenv;
- valval =
- EAnnot (
- EFun ( [ PVar lexer; PVar lexbuf ],
- blet (
- [ PVar token, EApp (EVar lexer, [ EVar lexbuf ]) ] @
- trace "Lookahead token is now %s (%d-%d)"
- [ EApp (EVar print_token, [ EVar token ]);
- ERecordAccess (ERecordAccess (EVar lexbuf, "Lexing.lex_start_p"), "Lexing.pos_cnum");
- ERecordAccess (ERecordAccess (EVar lexbuf, "Lexing.lex_curr_p"), "Lexing.pos_cnum") ],
- ERecord ([
- (flexer, EVar lexer);
- (flexbuf, EVar lexbuf);
- (ftoken, EVar token);
- (fstartp, ERecordAccess (EVar lexbuf, "Lexing.lex_start_p"));
- (fendp, ERecordAccess (EVar lexbuf, "Lexing.lex_curr_p"));
- (fshifted, EIntConst max_int)
- ] @
- insertif previouserror_required (fpreviouserror, EIntConst max_int)
- )
- )
- ),
- type2scheme (marrow [ tlexer; tlexbuf ] tenv)
- )
- }
-
-(* ------------------------------------------------------------------------ *)
-(* Here is complete code for the parser. *)
-
-let program = {
-
- paramdefs =
- Front.grammar.UnparameterizedSyntax.parameters;
-
- prologue =
- Front.grammar.UnparameterizedSyntax.preludes;
-
- excdefs =
- [ excdef ];
-
- typedefs =
- tokentypedef @
- [ envtypedef; statetypedef ];
-
- nonrecvaldefs =
- [ excvaldef ];
-
- valdefs =
- ProductionMap.fold (fun _ s defs ->
- entrydef s :: defs
- ) Lr1.entry (
- Lr1.fold (fun defs s ->
- runactiondef s @ errordef s :: defs
- ) (
- Nonterminal.foldx (fun nt defs ->
- gotodef nt :: defs
- ) (Production.fold (fun prod defs ->
- if Invariant.ever_reduced prod then
- reducedef prod :: defs
- else
- defs
- ) [ discarddef; initenvdef; printtokendef; assertfalsedef; errorcasedef ])));
-
- moduledefs =
- [];
-
- postlogue =
- Front.grammar.UnparameterizedSyntax.postludes
-
-}
-
-(* ------------------------------------------------------------------------ *)
-(* We are done! *)
-
-let () =
- Error.logC 1 (fun f ->
- Printf.fprintf f
- "%d out of %d states can peek at an error.\n\
- %d out of %d states can do error recovery.\n"
- !errorpeekers Lr1.n
- !recoverers Lr1.n)
-
-let () =
- if not !can_die then
- Error.logC 1 (fun f -> Printf.fprintf f
- "The generated parser cannot raise Error.\n")
-
-let () =
- Time.tick "Producing abstract syntax"
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* The (code-based) code generator. *)
-
-module Run (T : sig end) : sig
-
- val program: IL.program
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module provides a number of tiny functions that help produce
- [IL] code. *)
-
-open IL
-
-(* The unit type. *)
-
-let tunit =
- TypApp ("unit", [])
-
-(* The integer type. *)
-
-let tint =
- TypApp ("int", [])
-
-(* The string type. *)
-
-let tstring =
- TypApp ("string", [])
-
-(* The exception type. *)
-
-let texn =
- TypApp ("exn", [])
-
-(* The type of lexer positions. *)
-
-let tposition =
- TypApp ("Lexing.position", [])
-
-(* The type of lexer buffers. *)
-
-let tlexbuf =
- TypApp ("Lexing.lexbuf", [])
-
-(* The type of untyped semantic values. *)
-
-let tobj =
- TypApp ("Obj.t", [])
-
-(* Building a type variable. *)
-
-let tvar x : typ =
- TypVar x
-
-(* Building a type scheme. *)
-
-let scheme qs t =
- {
- quantifiers = qs;
- body = t
- }
-
-(* Building a type scheme with no quantifiers out of a type. *)
-
-let type2scheme t =
- scheme [] t
-
-let pat2var = function
- | PVar x ->
- x
- | _ ->
- assert false
-
-(* [simplify] removes bindings of the form [let v = v in ...] and
- [let _ = v in ...]. *)
-
-let rec simplify = function
- | [] ->
- []
- | (PVar v1, EVar v2) :: bindings when v1 = v2 ->
- (* Avoid a useless let binding. *)
- simplify bindings
- | (PWildcard, EVar _) :: bindings ->
- (* Avoid a useless let binding. *)
- simplify bindings
- | binding :: bindings ->
- binding :: simplify bindings
-
-(* Building a [let] construct, with on-the-fly simplification. *)
-
-let rec blet (bindings, body) =
- match simplify bindings with
- | [] ->
- body
- | bindings ->
- ELet (bindings, body)
-
-let mlet formals actuals body =
- blet (List.combine formals actuals, body)
-
-(* [bottom] is an expression that has every type. Its semantics is
- irrelevant. *)
-
-let bottom =
- ERaise (EData ("Not_found", []))
-
-(* Boolean constants. *)
-
-let efalse : expr =
- EData ("false", [])
-
-let etrue : expr =
- EData ("true", [])
-
-let eboolconst b =
- if b then etrue else efalse
-
-(* These help build function types. *)
-
-let arrow typ body : typ =
- TypArrow (typ, body)
-
-let arrowif flag typ body : typ =
- if flag then
- arrow typ body
- else
- body
-
-let marrow typs body : typ =
- List.fold_right arrow typs body
-
-(* ------------------------------------------------------------------------ *)
-(* Here is a bunch of naming conventions. Our names are chosen to minimize
- the likelihood that a name in a semantic action is captured. In other
- words, all global definitions as well as the parameters to [reduce]
- are given far-fetched names, unless [--no-prefix] was specified. Note
- that the prefix must begin with '_'. This allows avoiding warnings
- about unused variables with ocaml 3.09 and later. *)
-
-let prefix name =
- if Settings.noprefix then
- name
- else
- "_menhir_" ^ name
-
-let dataprefix name =
- if Settings.noprefix then
- name
- else
- "Menhir" ^ name
-
-let tvprefix name =
- if Settings.noprefix then
- name
- else
- "ttv_" ^ name
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module provides a number of tiny functions that help produce
- [IL] code. *)
-
-open IL
-
-(* Standard types. *)
-
-val tunit: typ
-val tint: typ
-val tstring: typ
-val texn: typ
-val tposition: typ
-val tlexbuf: typ
-val tobj : typ
-
-(* Building a type variable. *)
-
-val tvar: string -> typ
-
-(* Building a type scheme. *)
-
-val scheme: string list -> typ -> typescheme
-val type2scheme: typ -> typescheme
-
-(* Projecting out of a [PVar] pattern. *)
-
-val pat2var: pattern -> string
-
-(* Building a [let] construct, with on-the-fly simplification. *)
-
-val blet: (pattern * expr) list * expr -> expr
-val mlet: pattern list -> expr list -> expr -> expr
-
-(* [bottom] is an expression that has every type. Its semantics is
- irrelevant. *)
-
-val bottom: expr
-
-(* Boolean constants. *)
-
-val etrue: expr
-val efalse: expr
-val eboolconst: bool -> expr
-
-(* These help build function types. *)
-
-val arrow: typ -> typ -> typ
-val arrowif: bool -> typ -> typ -> typ
-val marrow: typ list -> typ -> typ
-
-(* These functions are used to generate names in menhir's namespace. *)
-val prefix: string -> string
-val dataprefix: string -> string
-val tvprefix: string -> string
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module defines many internal naming conventions for use by the
- two code generators, [CodeBackend] and [TableBackend]. It also offers
- a few code generation facilities. *)
-
-open IL
-open CodeBits
-open Grammar
-
-(* ------------------------------------------------------------------------ *)
-
-(* Naming conventions. *)
-
-(* The type variable associated with a nonterminal [nt]. *)
-
-let ntvar nt =
- Infer.ntvar (Nonterminal.print true nt)
-
-(* The variable that holds the environment. This is a parameter to all
- functions. We do not make it a global variable because we wish to
- preserve re-entrancy. *)
-
-let env =
- prefix "env"
-
-(* A variable used to hold a semantic value. *)
-
-let semv =
- "_v"
-
-(* A variable used to hold a stack. *)
-
-let stack =
- prefix "stack"
-
-(* A variable used to hold a state. *)
-
-let state =
- prefix "s"
-
-(* A variable used to hold a token. *)
-
-let token =
- "_tok"
-
-(* Variables used to hold start and end positions. Do not change these
- names! They are chosen to coincide with the $startpos and $endpos
- keywords, which the lexer rewrites to _startpos and _endpos, so
- that binding these variables before executing a semantic action is
- meaningful. *)
-
-let startp =
- "_startpos"
-
-let endp =
- "_endpos"
-
-(* ------------------------------------------------------------------------ *)
-
-(* Types for semantic values. *)
-
-(* [semvtypent nt] is the type of the semantic value associated
- with nonterminal [nt]. *)
-
-let semvtypent nt =
- match Nonterminal.ocamltype nt with
- | None ->
-
- (* [nt] has unknown type. If we we have run [Infer], then this
- can't happen. However, running type inference is only an
- option, so we still have to deal with that case. *)
-
- TypVar (ntvar nt)
-
- | Some ocamltype ->
-
- (* [nt] has known type. *)
-
- TypTextual ocamltype
-
-(* [semvtypetok tok] is the type of the semantic value associated with
- token [tok]. There is no such type if the token does not have a
- semantic value. *)
-
-let semvtypetok tok =
- match Terminal.ocamltype tok with
- | None ->
-
- (* Token has unit type and is omitted in stack cell. *)
-
- []
-
- | Some ocamltype ->
-
- (* Token has known type. *)
-
- [ TypTextual ocamltype ]
-
-(* [semvtype symbol] is the type of the semantic value associated with
- [symbol]. *)
-
-let semvtype = function
- | Symbol.T tok ->
- semvtypetok tok
- | Symbol.N nt ->
- [ semvtypent nt ]
-
-(* [symvalt] returns the empty list if the symbol at hand carries no
- semantic value and the singleton list [[f t]] if it carries a
- semantic value of type [t]. *)
-
-let symvalt symbol f =
- match semvtype symbol with
- | [] ->
- []
- | [ t ] ->
- [ f t ]
- | _ ->
- assert false
-
-(* [symval symbol x] returns either the empty list or the singleton
- list [[x]], depending on whether [symbol] carries a semantic
- value. *)
-
-let symval symbol x =
- match semvtype symbol with
- | [] ->
- []
- | [ t ] ->
- [ x ]
- | _ ->
- assert false
-
-(* [tokval] is a version of [symval], specialized for terminal symbols. *)
-
-let tokval tok x =
- symval (Symbol.T tok) x
-
-(* ------------------------------------------------------------------------ *)
-
-(* Patterns for tokens. *)
-
-(* [tokpat tok] is a pattern that matches the token [tok], without binding
- its semantic value. *)
-
-let tokpat tok =
- PData (TokenType.tokenprefix (Terminal.print tok), tokval tok PWildcard)
-
-(* [tokpatv tok] is a pattern that matches the token [tok], and binds
- its semantic value, if it has one, to the variable [semv]. *)
-
-let tokpatv tok =
- PData (TokenType.tokenprefix (Terminal.print tok), tokval tok (PVar semv))
-
-(* [tokspat toks] is a pattern that matches any token in the set [toks],
- without binding its semantic value. *)
-
-let tokspat toks =
- POr (
- TerminalSet.fold (fun tok pats ->
- tokpat tok :: pats
- ) toks []
- )
-
-(* [destructuretokendef name codomain bindsemv branch] generates the
- definition of a function that destructures tokens. [name] is the
- name of the function that is generated. [codomain] is its return
- type. [bindsemv] tells whether the variable [semv] should be
- bound. [branch] is applied to each (non-pseudo) terminal and must
- produce code for each branch. *)
-
-let destructuretokendef name codomain bindsemv branch = {
- valpublic = false;
- valpat = PVar name;
- valval =
- EAnnot (
- EFun ([ PVar token ],
- EMatch (EVar token,
- Terminal.fold (fun tok branches ->
- if Terminal.pseudo tok then
- branches
- else
- { branchpat = (if bindsemv then tokpatv else tokpat) tok;
- branchbody = branch tok } :: branches
- ) []
- )
- ),
- type2scheme (arrow TokenType.ttoken codomain)
- )
-}
-
-(* ------------------------------------------------------------------------ *)
-
-(* Bindings for exotic keywords. *)
-
-(* [extrabindings fpreviouserror action] provides definitions for the
- [$startofs], [$endofs], and [$previouserror] keywords, if required
- by a semantic action. The parameter [fpreviouserror] is the name of
- the [previouserror] field in the environment -- the table-based and
- code-based back-ends use different names. The parameter [action] is
- the semantic action within which these keywords might be used. *)
-
-(* The [ofs] keyword family is defined in terms of the [pos] family by
- accessing the [pos_cnum] field. The [$previouserror] keyword simply
- provides access to the current value of [env.previouserror]. *)
-
-let extrabindings fpreviouserror action =
- Keyword.KeywordSet.fold (fun keyword bindings ->
- match keyword with
- | Keyword.Dollar _
- | Keyword.Position (_, _, Keyword.FlavorPosition)
- | Keyword.SyntaxError ->
- bindings
- | Keyword.Position (s, w, (Keyword.FlavorOffset as f)) ->
- (PVar (Keyword.posvar s w f),
- ERecordAccess (EVar (Keyword.posvar s w Keyword.FlavorPosition), "Lexing.pos_cnum")) :: bindings
- | Keyword.PreviousError ->
- (PVar "_previouserror", ERecordAccess (EVar env, fpreviouserror)) :: bindings
- ) (Action.keywords action) []
-
-(* ------------------------------------------------------------------------ *)
-
-(* A global variable holds the exception [Error]. *)
-
-(* We preallocate the [Error] exception and store it into a global
- variable. This allows saving code at the sites where the exception
- is raised. Don't change the conventional name [_eRR], it is shared
- with the lexer, which replaces occurrences of the [$syntaxerror]
- keyword with [(raise _eRR)]. *)
-
-let parse_error =
- "_eRR"
-
-let errorval =
- EVar parse_error
-
-let excvaldef = {
- valpublic = false;
- valpat = PVar parse_error;
- valval = EData (Interface.excname, [])
-}
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module defines many internal naming conventions for use by the
- two code generators, [CodeBackend] and [TableBackend]. It also offers
- a few code generation facilities. *)
-
-open IL
-open Grammar
-
-(* ------------------------------------------------------------------------ *)
-
-(* Naming conventions. *)
-
-(* The type variable associated with a nonterminal [nt]. *)
-
-val ntvar : Nonterminal.t -> string
-
-(* The variable that holds the environment. This is a parameter to all
- functions. We do not make it a global variable because we wish to
- preserve re-entrancy. *)
-
-val env : string
-
-(* A variable used to hold a semantic value. *)
-
-val semv : string
-
-(* A variable used to hold a stack. *)
-
-val stack: string
-
-(* A variable used to hold a state. *)
-
-val state: string
-
-(* A variable used to hold a token. *)
-
-val token: string
-
-(* Variables used to hold start and end positions. *)
-
-val startp: string
-val endp: string
-
-(* ------------------------------------------------------------------------ *)
-
-(* Types for semantic values. *)
-
-(* [semvtypent nt] is the type of the semantic value associated
- with nonterminal [nt]. *)
-
-val semvtypent : Nonterminal.t -> typ
-
-(* [semvtypetok tok] is the type of the semantic value associated with
- token [tok]. There is no such type if the token does not have a
- semantic value. *)
-
-val semvtypetok : Terminal.t -> typ list
-
-(* [semvtype symbol] is the type of the semantic value associated with
- [symbol]. *)
-
-val semvtype : Symbol.t -> typ list
-
-(* [symvalt] returns the empty list if the symbol at hand carries no
- semantic value and the singleton list [[f t]] if it carries a
- semantic value of type [t]. *)
-
-val symvalt : Symbol.t -> (typ -> 'a) -> 'a list
-
-(* [symval symbol x] returns either the empty list or the singleton
- list [[x]], depending on whether [symbol] carries a semantic
- value. *)
-
-val symval : Symbol.t -> 'a -> 'a list
-
-(* [tokval] is a version of [symval], specialized for terminal symbols. *)
-
-val tokval : Terminal.t -> 'a -> 'a list
-
-(* ------------------------------------------------------------------------ *)
-
-(* Patterns for tokens. *)
-
-(* [tokpat tok] is a pattern that matches the token [tok], without binding
- its semantic value. *)
-
-val tokpat: Terminal.t -> pattern
-
-(* [tokpatv tok] is a pattern that matches the token [tok], and binds
- its semantic value, if it has one, to the variable [semv]. *)
-
-val tokpatv: Terminal.t -> pattern
-
-(* [tokspat toks] is a pattern that matches any token in the set [toks],
- without binding its semantic value. *)
-
-val tokspat: TerminalSet.t -> pattern
-
-(* [destructuretokendef name codomain bindsemv branch] generates the
- definition of a function that destructure tokens. [name] is the
- name of the function that is generated. [codomain] is its return
- type. [bindsemv] tells whether the variable [semv] should be
- bound. [branch] is applied to each (non-pseudo) terminal and must
- produce code for each branch. *)
-
-val destructuretokendef: string -> typ -> bool -> (Terminal.t -> expr) -> valdef
-
-(* ------------------------------------------------------------------------ *)
-
-(* Bindings for exotic keywords. *)
-
-(* This provides definitions for the [$startofs], [$endofs], and
- [$previouserror] keywords, if required by a semantic action. The
- [ofs] keyword family is defined in terms of the [pos] family by
- accessing the [pos_cnum] field. The [$previouserror] keyword simply
- provides access to the current value of [env.previouserror]. *)
-
-val extrabindings: string -> Action.t -> (pattern * expr) list
-
-(* ------------------------------------------------------------------------ *)
-
-(* A global variable holds the exception [Error]. *)
-
-(* The definition of this global variable. *)
-
-val excvaldef: valdef
-
-(* A reference to this global variable. *)
-
-val errorval: expr
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* A compressed (or should we say sparse?) bit set is a list of pairs
- of integers. The first component of every pair is an index, while
- the second component is a bit field. The list is sorted by order
- of increasing indices. *)
-
-type t =
- | N
- | C of int * int * t
-
-type element =
- int
-
-let word_size =
- Sys.word_size - 1
-
-let empty =
- N
-
-let is_empty = function
- | N ->
- true
- | C _ ->
- false
-
-let add i s =
- let ioffset = i mod word_size in
- let iaddr = i - ioffset
- and imask = 1 lsl ioffset in
- let rec add = function
- | N ->
- (* Insert at end. *)
- C (iaddr, imask, N)
- | C (addr, ss, qs) as s ->
- if iaddr < addr then
- (* Insert in front. *)
- C (iaddr, imask, s)
- else if iaddr = addr then
- (* Found appropriate cell, update bit field. *)
- let ss' = ss lor imask in
- if ss' = ss then
- s
- else
- C (addr, ss', qs)
- else
- (* Not there yet, continue. *)
- let qs' = add qs in
- if qs == qs' then
- s
- else
- C (addr, ss, qs')
- in
- add s
-
-let singleton i =
- add i N
-
-let remove i s =
- let ioffset = i mod word_size in
- let iaddr = i - ioffset
- and imask = 1 lsl ioffset in
- let rec remove = function
- | N ->
- N
- | C (addr, ss, qs) as s ->
- if iaddr < addr then
- s
- else if iaddr = addr then
- (* Found appropriate cell, update bit field. *)
- let ss' = ss land (lnot imask) in
- if ss' = 0 then
- qs
- else if ss' = ss then
- s
- else
- C (addr, ss', qs)
- else
- (* Not there yet, continue. *)
- let qs' = remove qs in
- if qs == qs' then
- s
- else
- C (addr, ss, qs')
- in
- remove s
-
-let rec fold f s accu =
- match s with
- | N ->
- accu
- | C (base, ss, qs) ->
- let limit = base + word_size in
- let rec loop i ss accu =
- if i = limit then
- accu
- else
- loop (i + 1) (ss lsr 1) (if ss land 1 = 1 then f i accu else accu)
- in
- fold f qs (loop base ss accu)
-
-let iter f s =
- fold (fun x () -> f x) s ()
-
-let cardinal s =
- fold (fun _ m -> m + 1) s 0
-
-let elements s =
- fold (fun tl hd -> tl :: hd) s []
-
-let rec subset s1 s2 =
- match s1, s2 with
- | N, _ ->
- true
- | _, N ->
- false
- | C (addr1, ss1, qs1), C (addr2, ss2, qs2) ->
- if addr1 < addr2 then
- false
- else if addr1 = addr2 then
- if (ss1 land ss2) <> ss1 then
- false
- else
- subset qs1 qs2
- else
- subset s1 qs2
-
-let mem i s =
- subset (singleton i) s
-
-let rec union s1 s2 =
- match s1, s2 with
- | N, s
- | s, N ->
- s
- | C (addr1, ss1, qs1), C (addr2, ss2, qs2) ->
- if addr1 < addr2 then
- C (addr1, ss1, union qs1 s2)
- else if addr1 > addr2 then
- let s = union s1 qs2 in
- if s == qs2 then
- s2
- else
- C (addr2, ss2, s)
- else
- let ss = ss1 lor ss2 in
- let s = union qs1 qs2 in
- if ss == ss2 && s == qs2 then
- s2
- else
- C (addr1, ss, s)
-
-let rec inter s1 s2 =
- match s1, s2 with
- | N, _
- | _, N ->
- N
- | C (addr1, ss1, qs1), C (addr2, ss2, qs2) ->
- if addr1 < addr2 then
- inter qs1 s2
- else if addr1 > addr2 then
- inter s1 qs2
- else
- let ss = ss1 land ss2 in
- let s = inter qs1 qs2 in
- if ss = 0 then
- s
- else
- if (ss = ss1) && (s == qs1) then
- s1
- else
- C (addr1, ss, s)
-
-exception Found of int
-
-let choose s =
- try
- iter (fun x ->
- raise (Found x)
- ) s;
- raise Not_found
- with Found x ->
- x
-
-let rec compare s1 s2 =
- match s1, s2 with
- N, N -> 0
- | _, N -> 1
- | N, _ -> -1
- | C (addr1, ss1, qs1), C (addr2, ss2, qs2) ->
- if addr1 < addr2 then -1
- else if addr1 > addr2 then 1
- else if ss1 < ss2 then -1
- else if ss1 > ss2 then 1
- else compare qs1 qs2
-
-let rec equal s1 s2 =
- compare s1 s2 = 0
-
-let rec disjoint s1 s2 =
- match s1, s2 with
- | N, _
- | _, N ->
- true
- | C (addr1, ss1, qs1), C (addr2, ss2, qs2) ->
- if addr1 = addr2 then
- if (ss1 land ss2) = 0 then
- disjoint qs1 qs2
- else
- false
- else if addr1 < addr2 then
- disjoint qs1 s2
- else
- disjoint s1 qs2
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-include GSet.S with type element = int
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: concreteSyntax.mli,v 1.3 2005/12/01 16:20:06 regisgia Exp $ *)
-type grammar =
- {
- pg_filename : Syntax.filename;
- pg_declarations : (Syntax.declaration Positions.located) list;
- pg_rules : Syntax.parameterized_rule list;
- pg_trailer : Syntax.trailer option;
- }
-
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-(* -------------------------------------------------------------------------- *)
-(* Our output channel. *)
-
-let out =
- lazy (open_out (Settings.base ^ ".conflicts"))
-
-(* -------------------------------------------------------------------------- *)
-(* Explaining shift actions. *)
-
-(* The existence of a shift action stems from the existence of a shift
- item in the LR(0) core that underlies the LR(1) state of interest.
- That is, lookahead sets are not relevant. The existence of a shift
- item in the LR(0) core is explained by finding a path from a start
- item to the shift item in the LR(0) nondeterministic automaton,
- such that the symbols read along this path form the (previously
- fixed) symbol string that leads to the conflict state in the LR(1)
- automaton. There may be several such paths: a shortest one is
- chosen. There may also be several shift items in the conflict
- state: an arbitrary one is chosen. I believe it would not be
- interesting to display traces for several shift items: they would
- be identical except in their last line (where the desired shift
- item actually appears). *)
-
-(* Symbolic execution of the nondeterministic LR(0) automaton. *)
-
-(* Configurations are pairs of an LR(0) item and an offset into
- the input string, which indicates how much has been read so
- far. *)
-
-type configuration0 =
- Item.t * int
-
-(* This function builds a derivation out of a (nonempty, reversed) sequence of
- configurations. The derivation is constructed from bottom to top, that is,
- beginning at the last configuration and moving back towards to the start
- configuration. *)
-
-let rec follow derivation offset' = function
- | [] ->
- assert (offset' = 0);
- derivation
- | (item, offset) :: configs ->
- let _, _, rhs, pos, _ = Item.def item in
- let derivation =
- if offset = offset' then
- (* This is an epsilon transition. Put a new root node on top of
- the existing derivation. *)
- Derivation.build pos rhs derivation None
- else
- (* This was a shift transition. Tack symbol in front of the
- forest. *)
- Derivation.prepend rhs.(pos) derivation
- in
- follow derivation offset configs
-
-(* Symbolic execution begins with a start item (corresponding
- to one of the automaton's entry nodes), a fixed string of
- input symbols, to be fully consumed, and a goal item. The
- objective is to find a path through the automaton that
- leads from the start configuration [(stop, 0)] to the goal
- configuration [(stop, n)], where [n] is the length of the
- input string. The automaton is explored via breadth-first
- search. A hash table is used to record which configurations
- have been visited and to build a spanning tree of shortest
- paths. *)
-
-exception Done
-
-let explain_shift_item
- (start : Item.t)
- (input : Symbol.t array)
- (stop : Item.t)
- : Derivation.t =
-
- let n =
- Array.length input
- in
-
- let table : (configuration0, configuration0 option) Hashtbl.t =
- Hashtbl.create 1023
- in
-
- let queue : configuration0 Queue.t =
- Queue.create()
- in
-
- let enqueue ancestor config =
- try
- let _ = Hashtbl.find table config in
- ()
- with Not_found ->
- Hashtbl.add table config ancestor;
- Queue.add config queue
- in
-
- enqueue None (start, 0);
- try
- Misc.qiter (function (item, offset) as config ->
-
- (* If the item we're looking at is the goal item and if
- we have read all of the input symbols, stop. *)
-
- if (Item.equal item stop) && (offset = n) then
- raise Done;
-
- (* Otherwise, explore the transitions out of this item. *)
-
- let prod, _, rhs, pos, length = Item.def item in
-
- (* Shift transition, followed only if the symbol matches
- the symbol found in the input string. *)
-
- if (pos < length)
- && (offset < n)
- && (Symbol.equal rhs.(pos) input.(offset)) then begin
- let config' = (Item.import (prod, pos+1), offset+1) in
- enqueue (Some config) config'
- end;
-
- (* Epsilon transitions. *)
-
- if pos < length then
- match rhs.(pos) with
- | Symbol.N nt ->
- Production.iternt nt (fun prod ->
- let config' = (Item.import (prod, 0), offset) in
- enqueue (Some config) config'
- )
- | Symbol.T _ ->
- ()
-
- ) queue;
- assert false
- with Done ->
-
- (* We have found a (shortest) path from the start configuration to
- the goal configuration. Turn it into an explicit derivation. *)
-
- let configs = Misc.materialize table (stop, n) in
- let _, _, rhs, pos, _ = Item.def stop in
- let derivation = Derivation.tail pos rhs in
- let derivation = follow derivation n configs in
- derivation
-
-(* -------------------------------------------------------------------------- *)
-(* Explaining reduce actions. *)
-
-(* The existence of a reduce action stems from the existence of a
- reduce item, whose lookahead set contains the token of interest, in
- the state of interest. Here, lookahead sets are relevant only
- insofar as they contain or do not contain the token of interest --
- in other words, lookahead sets can be abstracted by Boolean
- values. The existence of the reduce item is explained by finding a
- path from a start item to the reduce item in the LR(1)
- nondeterministic automaton, such that the symbols read along this
- path form the (previously fixed) symbol string that leads to the
- conflict state in the LR(1) automaton. There may be several such
- paths: a shortest one is chosen. *)
-
-(* Symbolic execution of the nondeterministic LR(1) automaton. *)
-
-(* Configurations are pairs of an LR(1) item and an offset into the
- input string, which indicates how much has been read so far. An
- LR(1) item is itself represented as the combination of an LR(0)
- item and a Boolean flag, telling whether the token of interest
- appears or does not appear in the lookahead set. *)
-
-type configuration1 =
- Item.t * bool * int
-
-(* This function builds a derivation out of a sequence of configurations. The
- end of the sequence is dealt with specially -- we want to explain how the
- lookahead symbol appears and is inherited. Once that is done, the rest
- (that is, the beginning) of the derivation is dealt with as above. *)
-
-let config1toconfig0 (item, _, offset) =
- (item, offset)
-
-let rec follow1 tok derivation offset' = function
- | [] ->
- assert (Terminal.equal tok Terminal.sharp);
- (* One could emit a comment saying that the lookahead token is
- initially [#]. That comment would have to be displayed above
- the derivation, though, and there is no support for that
- at the moment, so let's skip it. *)
- derivation
- | (item, _, offset) :: configs ->
- let _, _, rhs, pos, length = Item.def item in
- if offset = offset' then
-
- (* This is an epsilon transition. Attack a new line and add
- a comment that explains why the lookahead symbol is
- produced or inherited. *)
-
- let nullable, first = Analysis.nullable_first_rhs rhs (pos + 1) in
-
- if TerminalSet.mem tok first then
-
- (* The lookahead symbol is produced (and perhaps also inherited,
- but let's ignore that). *)
-
- let e = Analysis.explain_first_rhs tok rhs (pos + 1) in
- let comment =
- "lookahead token appears" ^ (if e = "" then "" else " because " ^ e)
- in
- let derivation =
- Derivation.build pos rhs derivation (Some comment)
- in
-
- (* Print the rest of the derivation without paying attention to
- the lookahead symbols. *)
-
- follow derivation offset (List.map config1toconfig0 configs)
-
- else begin
-
- (* The lookahead symbol is not produced, so it is definitely inherited. *)
-
- assert nullable;
-
- let comment =
- "lookahead token is inherited" ^
- (if pos + 1 < length then Printf.sprintf " because %scan vanish" (Symbol.printao (pos + 1) rhs) else "")
- in
- let derivation =
- Derivation.build pos rhs derivation (Some comment)
- in
-
- follow1 tok derivation offset configs
-
- end
-
- else
-
- (* This is a shift transition. Tack symbol in front of forest. *)
-
- let derivation =
- Derivation.prepend rhs.(pos) derivation
- in
-
- follow1 tok derivation offset configs
-
-(* Symbolic execution is performed in the same manner as above. *)
-
-let explain_reduce_item
- (tok : Terminal.t)
- (start : Item.t)
- (input : Symbol.t array)
- (stop : Item.t)
- : Derivation.t =
-
- let n =
- Array.length input
- in
-
- let table : (configuration1, configuration1 option) Hashtbl.t =
- Hashtbl.create 1023
- in
-
- let queue : configuration1 Queue.t =
- Queue.create()
- in
-
- let enqueue ancestor config =
- try
- let _ = Hashtbl.find table config in
- ()
- with Not_found ->
- Hashtbl.add table config ancestor;
- Queue.add config queue
- in
-
- (* If the lookahead token is #, then it initially appear in the lookahead
- set, otherwise it doesn't. *)
-
- enqueue None (start, Terminal.equal tok Terminal.sharp, 0);
- try
- Misc.qiter (function (item, lookahead, offset) as config ->
-
- (* If the item we're looking at is the goal item and if
- we have read all of the input symbols, stop. *)
-
- if (Item.equal item stop) && lookahead && (offset = n) then
- raise Done;
-
- (* Otherwise, explore the transitions out of this item. *)
-
- let prod, nt, rhs, pos, length = Item.def item in
-
- (* Shift transition, followed only if the symbol matches
- the symbol found in the input string. *)
-
- if (pos < length)
- && (offset < n)
- && (Symbol.equal rhs.(pos) input.(offset)) then begin
- let config' = (Item.import (prod, pos+1), lookahead, offset+1) in
- enqueue (Some config) config'
- end;
-
- (* Epsilon transitions. *)
-
- if pos < length then
- match rhs.(pos) with
- | Symbol.N nt ->
- let nullable, first = Analysis.nullable_first_rhs rhs (pos + 1) in
- let first : bool = TerminalSet.mem tok first in
- let lookahead' =
- if nullable then first || lookahead else first
- in
- Production.iternt nt (fun prod ->
- let config' = (Item.import (prod, 0), lookahead', offset) in
- enqueue (Some config) config'
- )
- | Symbol.T _ ->
- ()
-
- ) queue;
- assert false
- with Done ->
-
- (* We have found a (shortest) path from the start configuration to
- the goal configuration. Turn it into an explicit derivation. *)
-
- let configs = Misc.materialize table (stop, true, n) in
- let derivation = Derivation.empty in
- let derivation = follow1 tok derivation n configs in
- derivation
-
-(* -------------------------------------------------------------------------- *)
-(* Putting it all together. *)
-
-let () =
- if Settings.explain then begin
-
- Lr1.conflicts (fun toks node ->
-
- (* Construct a partial LR(1) automaton, looking for a conflict
- in a state that corresponds to this node. Because Pager's
- algorithm can merge two states as soon as one of them has a
- conflict, we can't be too specific about the conflict that we
- expect to find in the canonical automaton. So, we must supply
- a set of conflict tokens and accept any kind of conflict that
- involves one of them. *)
-
- (* TEMPORARY with the new compatibility criterion, we can be
- sure that every conflict token is indeed involved in a
- conflict. Exploit that? Avoid focusing on a single token? *)
-
- let module P = Lr1partial.Run (struct
- let tokens = toks
- let goal = node
- end) in
-
- let closure =
- Lr0.closure P.goal in
-
- (* Determine what kind of conflict was found. *)
-
- let shift, reduce = Item.Map.fold (fun item toks (shift, reduce) ->
- match Item.classify item with
- | Item.Shift (Symbol.T tok, _)
- when Terminal.equal tok P.token ->
- shift + 1, reduce
- | Item.Reduce prod
- when TerminalSet.mem P.token toks ->
- shift, reduce + 1
- | _ ->
- shift, reduce
- ) closure (0, 0) in
-
- let kind =
- if (shift > 0) && (reduce > 1) then
- "shift/reduce/reduce"
- else if (shift > 0) then
- "shift/reduce"
- else
- "reduce/reduce"
- in
-
- (* Explain how the conflict state is reached. *)
-
- let out = Lazy.force out in
-
- Printf.fprintf out "\n\
- ** Conflict (%s) in state %d.\n\
- ** Token%s involved: %s\n%s\
- ** This state is reached from %s after reading:\n\n%s\n"
- kind (Lr1.number node)
- (if TerminalSet.cardinal toks > 1 then "s" else "")
- (TerminalSet.print toks)
- (if TerminalSet.cardinal toks > 1 then
- Printf.sprintf "** The following explanations concentrate on token %s.\n" (Terminal.print P.token)
- else "")
- (Nonterminal.print false (Item.startnt P.source))
- (Symbol.printa P.path);
-
- (* Examine the items in that state, focusing on one particular
- token. Out of the shift items, we explain just one -- this
- seems enough. We explain each of the reduce items. *)
-
- (* First, build a mapping of items to derivations. *)
-
- let (_ : bool), derivations =
- Item.Map.fold (fun item toks (still_looking_for_shift_item, derivations) ->
- match Item.classify item with
-
- | Item.Shift (Symbol.T tok, _)
- when still_looking_for_shift_item && (Terminal.equal tok P.token) ->
-
- false,
- let derivation = explain_shift_item P.source P.path item in
- Item.Map.add item derivation derivations
-
- | Item.Reduce prod
- when TerminalSet.mem P.token toks ->
-
- still_looking_for_shift_item,
- let derivation = explain_reduce_item P.token P.source P.path item in
- Item.Map.add item derivation derivations
-
- | _ ->
-
- still_looking_for_shift_item,
- derivations
-
- ) closure (true, Item.Map.empty)
- in
-
- (* Factor out the common context among all derivations, so as to avoid
- repeating it. This helps prevent derivation trees from drifting too
- far away towards the right. It also helps produce sub-derivations
- that are quite compact. *)
-
- let context, derivations =
- Derivation.factor derivations
- in
-
- (* Display the common context. *)
-
- Printf.fprintf out
- "\n** The derivations that appear below have the following common factor:\
- \n** (The question mark symbol (?) represents the spot where the derivations begin to differ.)\n\n";
- Derivation.printc out context;
-
- (* Then, display the sub-derivations. *)
-
- Item.Map.iter (fun item derivation ->
-
- Printf.fprintf out
- "\n** In state %d, looking ahead at %s, "
- (Lr1.number node)
- (Terminal.print P.token);
-
- begin match Item.classify item with
- | Item.Shift _ ->
- Printf.fprintf out "shifting is permitted\n** because of the following sub-derivation:\n\n"
- | Item.Reduce prod ->
- Printf.fprintf out
- "reducing production\n** %s\n** is permitted because of the following sub-derivation:\n\n"
- (Production.print prod)
- end;
-
- Derivation.print out derivation
-
- ) derivations;
-
- flush out
-
- );
- Time.tick "Explaining conflicts"
-
- end
-
-(* ------------------------------------------------------------------------ *)
-(* Resolve the conflicts that remain in the automaton. *)
-
-let () =
- Lr1.default_conflict_resolution();
- Time.tick "Resolving remaining conflicts"
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module explains conflicts. Explanations are written
- to the .conflicts file. No functionality is offered by this
- module. *)
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* An ocamlyacc-style, or Menhir-style, parser requires access to
- the lexer, which must be parameterized with a lexing buffer, and
- to the lexing buffer itself, where it reads position information. *)
-
-(* This traditional API is convenient when used with ocamllex, but
- inelegant when used with other lexer generators. *)
-
-type ('token, 'semantic_value) traditional =
- (Lexing.lexbuf -> 'token) -> Lexing.lexbuf -> 'semantic_value
-
-(* This revised API is independent of any lexer generator. Here, the
- parser only requires access to the lexer, and the lexer takes no
- parameters. The tokens returned by the lexer may contain position
- information. *)
-
-type ('token, 'semantic_value) revised =
- (unit -> 'token) -> 'semantic_value
-
-(* --------------------------------------------------------------------------- *)
-
-(* Converting a traditional parser, produced by ocamlyacc or Menhir,
- into a revised parser. *)
-
-(* A token of the revised lexer is essentially a triple of a token
- of the traditional lexer (or raw token), a start position, and
- and end position. The three [get] functions are accessors. *)
-
-(* We do not require the type ['token] to actually be a triple type.
- This enables complex applications where it is a record type with
- more than three fields. It also enables simple applications where
- positions are of no interest, so ['token] is just ['raw_token]
- and [get_startp] and [get_endp] return dummy positions. *)
-
-let traditional2revised
- (get_raw_token : 'token -> 'raw_token)
- (get_startp : 'token -> Lexing.position)
- (get_endp : 'token -> Lexing.position)
- (parser : ('raw_token, 'semantic_value) traditional)
-: ('token, 'semantic_value) revised =
-
- (* Accept a revised lexer. *)
-
- fun (lexer : unit -> 'token) ->
-
- (* Create a dummy lexing buffer. *)
-
- let lexbuf : Lexing.lexbuf =
- Lexing.from_string ""
- in
-
- (* Wrap the revised lexer as a traditional lexer. A traditional
- lexer returns a raw token and updates the fields of the lexing
- buffer with new positions, which will be read by the parser. *)
-
- let lexer (lexbuf : Lexing.lexbuf) : 'raw_token =
- let token : 'token = lexer() in
- lexbuf.Lexing.lex_start_p <- get_startp token;
- lexbuf.Lexing.lex_curr_p <- get_endp token;
- get_raw_token token
- in
-
- (* Invoke the traditional parser. *)
-
- parser lexer lexbuf
-
-(* --------------------------------------------------------------------------- *)
-
-(* Converting a revised parser back to a traditional parser. *)
-
-let revised2traditional
- (make_token : 'raw_token -> Lexing.position -> Lexing.position -> 'token)
- (parser : ('token, 'semantic_value) revised)
-: ('raw_token, 'semantic_value) traditional =
-
- (* Accept a traditional lexer and a lexing buffer. *)
-
- fun (lexer : Lexing.lexbuf -> 'raw_token) (lexbuf : Lexing.lexbuf) ->
-
- (* Wrap the traditional lexer as a revised lexer. *)
-
- let lexer () : 'token =
- let token : 'raw_token = lexer lexbuf in
- make_token token lexbuf.Lexing.lex_start_p lexbuf.Lexing.lex_curr_p
- in
-
- (* Invoke the revised parser. *)
-
- parser lexer
-
-(* --------------------------------------------------------------------------- *)
-
-(* Simplified versions of the above, where concrete triples are used. *)
-
-module Simplified = struct
-
- let traditional2revised parser =
- traditional2revised
- (fun (token, _, _) -> token)
- (fun (_, startp, _) -> startp)
- (fun (_, _, endp) -> endp)
- parser
-
- let revised2traditional parser =
- revised2traditional
- (fun token startp endp -> (token, startp, endp))
- parser
-
-end
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* An ocamlyacc-style, or Menhir-style, parser requires access to
- the lexer, which must be parameterized with a lexing buffer, and
- to the lexing buffer itself, where it reads position information. *)
-
-(* This traditional API is convenient when used with ocamllex, but
- inelegant when used with other lexer generators. *)
-
-type ('token, 'semantic_value) traditional =
- (Lexing.lexbuf -> 'token) -> Lexing.lexbuf -> 'semantic_value
-
-(* This revised API is independent of any lexer generator. Here, the
- parser only requires access to the lexer, and the lexer takes no
- parameters. The tokens returned by the lexer may contain position
- information. *)
-
-type ('token, 'semantic_value) revised =
- (unit -> 'token) -> 'semantic_value
-
-(* --------------------------------------------------------------------------- *)
-
-(* Converting a traditional parser, produced by ocamlyacc or Menhir,
- into a revised parser. *)
-
-(* A token of the revised lexer is essentially a triple of a token
- of the traditional lexer (or raw token), a start position, and
- and end position. The three [get] functions are accessors. *)
-
-(* We do not require the type ['token] to actually be a triple type.
- This enables complex applications where it is a record type with
- more than three fields. It also enables simple applications where
- positions are of no interest, so ['token] is just ['raw_token]
- and [get_startp] and [get_endp] return dummy positions. *)
-
-val traditional2revised:
- ('token -> 'raw_token) ->
- ('token -> Lexing.position) ->
- ('token -> Lexing.position) ->
- ('raw_token, 'semantic_value) traditional ->
- ('token, 'semantic_value) revised
-
-(* --------------------------------------------------------------------------- *)
-
-(* Converting a revised parser back to a traditional parser. *)
-
-val revised2traditional:
- ('raw_token -> Lexing.position -> Lexing.position -> 'token) ->
- ('token, 'semantic_value) revised ->
- ('raw_token, 'semantic_value) traditional
-
-(* --------------------------------------------------------------------------- *)
-
-(* Simplified versions of the above, where concrete triples are used. *)
-
-module Simplified : sig
-
- val traditional2revised:
- ('token, 'semantic_value) traditional ->
- ('token * Lexing.position * Lexing.position, 'semantic_value) revised
-
- val revised2traditional:
- ('token * Lexing.position * Lexing.position, 'semantic_value) revised ->
- ('token, 'semantic_value) traditional
-
-end
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Printf
-open Grammar
-
-module Run (T: sig end) = struct
-
- let print_term t =
- assert (not (Terminal.pseudo t));
- sprintf "%s_t" (Terminal.print t)
-
- let print_nterm nt =
- sprintf "%s_nt" (Nonterminal.print true nt)
-
- let print_symbol = function
- | Symbol.N nt -> sprintf "NT %s" (print_nterm nt)
- | Symbol.T t -> sprintf "T %s" (print_term t)
-
- let print_type ty =
- if Settings.coq_no_actions then
- "unit"
- else
- match ty with
- | None -> raise Not_found
- | Some t -> match t with
- | Stretch.Declared s -> s.Stretch.stretch_content
- | Stretch.Inferred _ -> assert false (* We cannot infer coq types *)
-
- let print_nis nis =
- sprintf "Nis_%d" (Lr1.number nis)
-
- let print_st st =
- match Lr1.incoming_symbol st with
- | Some _ -> sprintf "Ninit %s" (print_nis st)
- | None -> "Init"
-
- let print_prod p =
- sprintf "Prod_%d" (Production.p2i p)
-
- let print_pseudoprod p =
- match Production.classify p with
- | None -> sprintf "Some %s" (print_prod p)
- | Some _ -> "None"
-
- let start_nt =
- match
- ProductionMap.fold (fun _ rhs accu ->
- match accu with
- | None -> (match rhs with [|Symbol.N nt|] -> Some nt | _ -> assert false)
- | _ -> Error.error [] ("Multiple start symbols are not supported "^
- "by the coq back-end"))
- (ProductionMap.start Production.rhs)
- None
- with
- | Some start -> start
- | _ -> Error.error [] "There is no start symbol"
-
- let () =
- if not Settings.coq_no_actions then
- begin
- Nonterminal.iterx (fun nonterminal ->
- match Nonterminal.ocamltype nonterminal with
- | None -> Error.error [] (sprintf "I don't know the type of non-terminal %s"
- (Nonterminal.print false nonterminal))
- | Some _ -> ());
- Production.iterx (fun prod ->
- let act = Production.action prod in
- if Action.has_previouserror act || Action.has_syntaxerror act ||
- Action.has_leftstart act || Action.has_leftend act ||
- Action.use_dollar act then
- Error.error [] ("$previouserror, $syntaxerror, $start, $end, $i are not "^
- "supported by the coq back-end"))
- end;
-
- Production.iterx (fun prod ->
- Array.iter (fun symb ->
- match symb with
- | Symbol.T t ->
- if t = Terminal.error then
- Error.error [] "The coq back-end does not support error"
- | _ -> ())
- (Production.rhs prod));
-
- if Front.grammar.UnparameterizedSyntax.parameters <> [] then
- Error.error [] "The coq back-end does not support %parameter"
-
- let write_inductive_alphabet f name constrs =
- fprintf f "Inductive %s' :=" name;
- List.iter (fprintf f "\n | %s") constrs;
- fprintf f ".\n";
- fprintf f "Definition %s := %s'.\n\n" name name;
- if List.length constrs > 0 then
- begin
- let iteri f = ignore (List.fold_left (fun k x -> f k x; succ k) 0 constrs) in
- fprintf f "Open Scope N_scope.\n";
- fprintf f "Program Instance %sNum : Numbered %s :=\n" name name;
- fprintf f " { injN := fun x => match x return _ with ";
- iteri (fun k constr -> fprintf f "| %s => %d " constr k);
- fprintf f "end;\n";
- fprintf f " surjN := fun n => match n return _ with ";
- iteri (fprintf f "| %d => %s ");
- fprintf f "| _ => %s end;\n" (List.hd constrs);
- fprintf f " injN_bound := %d }.\n" (List.length constrs);
- fprintf f "Solve Obligations using (intro x; case x; reflexivity).\n\n";
- end
- else
- begin
- fprintf f "Program Instance %sAlph : Alphabet %s :=\n" name name;
- fprintf f " { AlphabetComparable := {| compare := fun x y =>\n";
- fprintf f " match x, y return comparison with end |};\n";
- fprintf f " AlphabetEnumerable := {| all_list := [] |} }.";
- fprintf f "Solve Obligations using (intro x; case x)."
- end
-
- let write_terminals f =
- write_inductive_alphabet f "terminal" (
- Terminal.fold (fun t l -> if Terminal.pseudo t then l else print_term t::l)
- []);
- fprintf f "Instance TerminalAlph : Alphabet terminal := _.\n\n"
-
- let write_nonterminals f =
- write_inductive_alphabet f "nonterminal" (
- Nonterminal.foldx (fun nt l -> (print_nterm nt)::l) []);
- fprintf f "Instance NonTerminalAlph : Alphabet nonterminal := _.\n\n"
-
- let write_symbol_semantic_type f =
- fprintf f "Definition symbol_semantic_type (s:symbol) : Type:=\n";
- fprintf f " match s with\n";
-
- fprintf f " | T t =>\n";
- fprintf f " match t with\n";
- Terminal.iter (fun terminal ->
- if not (Terminal.pseudo terminal) then
- fprintf f " | %s => %s%%type\n"
- (print_term terminal)
- (try print_type (Terminal.ocamltype terminal) with Not_found -> "unit")
- );
- fprintf f " end\n";
-
- fprintf f " | NT nt =>\n";
- fprintf f " match nt with\n";
- Nonterminal.iterx (fun nonterminal ->
- fprintf f " | %s => %s%%type\n"
- (print_nterm nonterminal)
- (print_type (Nonterminal.ocamltype nonterminal)));
- fprintf f " end\n";
-
- fprintf f " end.\n\n"
-
- let write_productions f =
- write_inductive_alphabet f "production" (
- Production.foldx (fun prod l -> (print_prod prod)::l) []);
- fprintf f "Instance ProductionAlph : Alphabet production := _.\n\n"
-
- let write_productions_contents f =
- fprintf f "Definition prod_contents (p:production) :\n";
- fprintf f " { p:nonterminal * list symbol &\n";
- fprintf f " arrows (map symbol_semantic_type (snd p))\n";
- fprintf f " (symbol_semantic_type (NT (fst p))) }\n";
- fprintf f " :=\n";
- fprintf f " let box := existT (fun p =>\n";
- fprintf f " arrows (map symbol_semantic_type (snd p))\n";
- fprintf f " (symbol_semantic_type (NT (fst p))))\n";
- fprintf f " in\n";
- fprintf f " match p with\n";
- Production.iterx (fun prod ->
- fprintf f " | %s => box\n" (print_prod prod);
- fprintf f " (%s, [%s])\n"
- (print_nterm (Production.nt prod))
- (String.concat "; "
- (List.map print_symbol (Array.to_list (Production.rhs prod))));
- if Production.length prod = 0 then
- fprintf f " (\n"
- else
- fprintf f " (fun %s => \n"
- (String.concat " " (Array.to_list (Production.identifiers prod)));
- if Settings.coq_no_actions then
- fprintf f "()"
- else
- Action.print f (Production.action prod);
- fprintf f "\n)\n");
- fprintf f " end.\n\n";
-
- fprintf f "Definition prod_lhs (p:production) :=\n";
- fprintf f " fst (projT1 (prod_contents p)).\n";
- fprintf f "Definition prod_rhs (p:production) :=\n";
- fprintf f " snd (projT1 (prod_contents p)).\n";
- fprintf f "Definition prod_action (p:production) :=\n";
- fprintf f " projT2 (prod_contents p).\n\n"
-
- let write_nullable_first f =
- fprintf f "Definition nullable_nterm (nt:nonterminal) : bool :=\n";
- fprintf f " match nt with\n";
- Nonterminal.iterx (fun nt ->
- fprintf f " | %s => %b\n"
- (print_nterm nt)
- (fst (Analysis.nullable_first_rhs (Array.of_list [Symbol.N nt]) 0)));
- fprintf f " end.\n\n";
-
- fprintf f "Definition first_nterm (nt:nonterminal) : list terminal :=\n";
- fprintf f " match nt with\n";
- Nonterminal.iterx (fun nt ->
- let firstSet =
- snd (Analysis.nullable_first_rhs (Array.of_list [Symbol.N nt]) 0)
- in
- fprintf f " | %s => [" (print_nterm nt);
- let first = ref true in
- TerminalSet.iter (fun t ->
- if !first then first := false else fprintf f "; ";
- fprintf f "%s" (print_term t)
- ) firstSet;
- fprintf f "]\n");
- fprintf f " end.\n\n"
-
- let write_grammar f =
- fprintf f "Module Import Gram <: Grammar.T.\n\n";
- write_terminals f;
- write_nonterminals f;
- fprintf f "Include Grammar.Symbol.\n\n";
- write_symbol_semantic_type f;
- write_productions f;
- write_productions_contents f;
- fprintf f "Definition start_symbol := %s.\n\n" (print_symbol (Symbol.N start_nt));
- fprintf f "Include Grammar.Defs.\n\n";
- fprintf f "End Gram.\n\n"
-
- let write_nis f =
- write_inductive_alphabet f "noninitstate" (
- Lr1.foldx (fun l node -> (print_nis node)::l) []);
- fprintf f "Instance NonInitStateAlph : Alphabet noninitstate := _.\n\n"
-
- let write_actions f =
- fprintf f "Definition action_table (state:state) :\n";
- fprintf f " default_action + (forall term:terminal, action term) :=\n";
- fprintf f " match state with\n";
- Lr1.iter (fun node ->
- fprintf f " | %s => " (print_st node);
- match Invariant.has_default_reduction node with
- | Some (prod, _) ->
- begin match Production.classify prod with
- | Some _ -> fprintf f "inl Accept_act\n"
- | None ->
- fprintf f "inl (Default_reduce_act %s)\n" (print_prod prod)
- end
- | None ->
- fprintf f "inr (fun terminal:terminal =>\n";
- fprintf f " match terminal return action terminal with\n";
- let has_fail = ref false in
- Terminal.iter (fun t ->
- if not (Terminal.pseudo t) then
- begin
- try
- let target = SymbolMap.find (Symbol.T t) (Lr1.transitions node) in
- fprintf f " | %s => Shift_act %s (eq_refl _)\n" (print_term t) (print_nis target)
- with Not_found ->
- try
- let prod =
- Misc.single (TerminalMap.find t (Lr1.reductions node))
- in
- fprintf f " | %s => Reduce_act %s\n" (print_term t) (print_prod prod)
- with Not_found -> has_fail := true
- end);
- if !has_fail then
- fprintf f " | _ => Fail_act\n";
- fprintf f " end)\n"
- );
- fprintf f " end.\n\n"
-
- let write_gotos f =
- fprintf f "Definition goto_table (state:state) (nt:nonterminal) :=\n";
- fprintf f " match state, nt return option { s:noninitstate | last_symb_of_non_init_state s = NT nt } with\n";
- Lr1.iter (fun node ->
- Nonterminal.iterx (fun nt ->
- try
- let target = SymbolMap.find (Symbol.N nt) (Lr1.transitions node) in
- fprintf f " | %s, %s => Some (exist _ %s (eq_refl _))\n"
- (print_st node) (print_nterm nt) (print_nis target)
- with Not_found -> ()));
- fprintf f " | _, _ => None\n";
- fprintf f " end.\n\n"
-
- let write_last_symb f =
- fprintf f "Definition last_symb_of_non_init_state (noninitstate:noninitstate) : symbol :=\n";
- fprintf f " match noninitstate with\n";
- Lr1.iterx (fun node ->
- match Lr1.incoming_symbol node with
- | Some s -> fprintf f " | %s => %s\n" (print_nis node) (print_symbol s)
- | None -> assert false);
- fprintf f " end.\n\n"
-
- let write_past_symb f =
- fprintf f "Definition past_symb_of_non_init_state (noninitstate:noninitstate) : list symbol :=\n";
- fprintf f " match noninitstate with\n";
- Lr1.iterx (fun node ->
- let s =
- String.concat "; " (List.tl
- (Invariant.fold (fun l _ symb _ -> print_symbol symb::l)
- [] (Invariant.stack node)))
- in
- fprintf f " | %s => [%s]\n" (print_nis node) s);
- fprintf f " end.\n";
- fprintf f "Extract Constant past_symb_of_non_init_state => \"fun _ -> []\".\n\n"
-
- let write_past_states f =
- fprintf f "Definition past_state_of_non_init_state (s:noninitstate) : list (state -> bool) :=\n";
- fprintf f " match s with\n";
- Lr1.iterx (fun node ->
- let s =
- String.concat ";\n " (Invariant.fold
- (fun accu _ _ states ->
- let b = Buffer.create 16 in
- bprintf b "fun s:state =>\n";
- bprintf b " match s return bool with\n";
- bprintf b " ";
- Lr1.NodeSet.iter
- (fun st -> bprintf b "| %s " (print_st st)) states;
- bprintf b "=> true\n";
- bprintf b " | _ => false\n";
- bprintf b " end";
- Buffer.contents b::accu)
- [] (Invariant.stack node))
- in
- fprintf f " | %s =>\n [ %s ]\n" (print_nis node) s);
- fprintf f " end.\n\n";
- fprintf f "Extract Constant past_state_of_non_init_state => \"fun _ -> []\".\n\n"
-
- let write_items f =
- if not Settings.coq_no_complete then
- begin
- Lr1.iter (fun node ->
- fprintf f "Definition items_of_state_%d : list item :=\n" (Lr1.number node);
- fprintf f " [ ";
- let first = ref true in
- Item.Map.iter (fun item lookaheads ->
- let prod, pos = Item.export item in
- if !first then first := false
- else fprintf f ";\n ";
- fprintf f "{| pseudoprod_item := %s;\n" (print_pseudoprod prod);
- fprintf f " dot_pos_item := %d;\n" pos;
- fprintf f " lookaheads_item := [";
- let first = ref true in
- let lookaheads =
- if TerminalSet.mem Terminal.sharp lookaheads then TerminalSet.universe
- else lookaheads
- in
- TerminalSet.iter (fun lookahead ->
- if !first then first := false
- else fprintf f "; ";
- fprintf f "%s" (print_term lookahead)
- ) lookaheads;
- fprintf f "] |}"
- ) (Lr0.closure (Lr0.export (Lr1.state node)));
- fprintf f " ].\n";
- fprintf f "Extract Inlined Constant items_of_state_%d => \"assert false\".\n\n" (Lr1.number node)
- );
-
- fprintf f "Definition items_of_state (s:state) : list item :=\n";
- fprintf f " match s with\n";
- Lr1.iter (fun node ->
- fprintf f " | %s => items_of_state_%d\n" (print_st node) (Lr1.number node));
- fprintf f " end.\n";
- end
- else
- fprintf f "Definition items_of_state (s:state): list item := [].\n";
- fprintf f "Extract Constant items_of_state => \"fun _ -> []\".\n\n"
-
- let write_automaton f =
- fprintf f "Module Aut <: Automaton.T.\n\n";
- fprintf f "Module Gram := Gram.\n";
- fprintf f "Module GramDefs := Gram.\n\n";
- write_nullable_first f;
- write_nis f;
- write_last_symb f;
- fprintf f "Include Automaton.Types.\n\n";
- write_actions f;
- write_gotos f;
- write_past_symb f;
- write_past_states f;
- write_items f;
- fprintf f "End Aut.\n\n"
-
- let write_theorems f =
- fprintf f "Require Import Main.\n\n";
-
- fprintf f "Module Parser := Main.Make Aut.\n";
-
- fprintf f "Theorem safe:\n";
- fprintf f " Parser.safe_validator = true.\n";
- fprintf f "Proof eq_refl true<:Parser.safe_validator = true.\n\n";
-
- if not Settings.coq_no_complete then
- begin
- fprintf f "Theorem complete:\n";
- fprintf f " Parser.complete_validator = true.\n";
- fprintf f "Proof eq_refl true<:Parser.complete_validator = true.\n\n";
- end;
-
- fprintf f "Definition parse := Parser.parse safe.\n\n";
-
- fprintf f "Theorem parse_correct iterator buffer:\n";
- fprintf f " match parse iterator buffer with\n";
- fprintf f " | Parser.Inter.Parsed_pr sem buffer_new =>\n";
- fprintf f " exists word,\n";
- fprintf f " buffer = Parser.Inter.app_str word buffer_new /\\\n";
- fprintf f " Gram.has_semantic_value word sem\n";
- fprintf f " | _ => True\n";
- fprintf f " end.\n";
- fprintf f "Proof. apply Parser.parse_correct. Qed.\n\n";
-
- if not Settings.coq_no_complete then
- begin
- fprintf f "Theorem parse_complete (iterator:nat) word buffer_end (output:%s):\n"
- (print_type (Nonterminal.ocamltype start_nt));
- fprintf f " forall tree:Gram.parse_tree (%s) word output,\n" (print_symbol (Symbol.N start_nt));
- fprintf f " match parse iterator (Parser.Inter.app_str word buffer_end) with\n";
- fprintf f " | Parser.Inter.Fail_pr => False\n";
- fprintf f " | Parser.Inter.Parsed_pr output_res buffer_end_res =>\n";
- fprintf f " output_res = output /\\ buffer_end_res = buffer_end /\\\n";
- fprintf f " ge iterator (Gram.parse_tree_size tree+2)\n";
- fprintf f " | Parser.Inter.Timeout_pr => lt iterator (Gram.parse_tree_size tree+2)\n";
- fprintf f " end.\n";
- fprintf f "Proof. apply Parser.parse_complete; exact complete. Qed.\n\n";
- end
-
- let write_all f =
- if not Settings.coq_no_actions then
- List.iter (fun s -> fprintf f "%s\n\n" s.Stretch.stretch_content)
- Front.grammar.UnparameterizedSyntax.preludes;
-
- fprintf f "Require Import List.\n";
- fprintf f "Require Import Syntax.\n";
- fprintf f "Require Import NArith.\n";
- fprintf f "Require Import Tuples.\n";
- fprintf f "Require Import Alphabet.\n";
- fprintf f "Require Grammar.\n";
- fprintf f "Require Automaton.\n\n";
- write_grammar f;
- write_automaton f;
- write_theorems f;
-
- if not Settings.coq_no_actions then
- List.iter (fprintf f "\n\n%s")
- Front.grammar.UnparameterizedSyntax.postludes
-end
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* The coq code generator. *)
-
-module Run (T: sig end) : sig
-
- val write_all: out_channel -> unit
-
-end
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-(* Concrete syntax trees. *)
-
-(* A concrete syntax tree is one of a leaf -- which corresponds to a
- terminal symbol; a node -- which corresponds to a non-terminal
- symbol, and whose immediate descendants form an expansion of that
- symbol; or an error leaf -- which corresponds to a point where the
- [error] pseudo-token was shifted. *)
-
-type cst =
- | CstTerminal of Terminal.t
- | CstNonTerminal of Production.index * cst array
- | CstError
-
-(* This is a (mostly) unambiguous printer for concrete syntax trees,
- in an sexp-like notation. *)
-
-let rec pcst b = function
- | CstTerminal tok ->
-
- (* A leaf is denoted by a terminal symbol. *)
-
- Printf.bprintf b "%s" (Terminal.print tok)
-
- | CstNonTerminal (prod, csts) ->
-
- (* A node is denoted by a bracketed, whitespace-separated list,
- whose head is a non-terminal symbol (followed with a colon)
- and whose tail consists of the node's descendants. *)
-
- (* There is in fact some ambiguity in this notation, since we
- only print the non-terminal symbol that forms the left-hand
- side of production [prod], instead of the production itself.
-
- This abuse makes things much more readable, and should be
- acceptable for the moment. The cases where ambiguity actually
- arises should be rare. *)
-
- Printf.bprintf b "[%s:%a]"
- (Nonterminal.print false (Production.nt prod))
- pcsts csts
-
- | CstError ->
-
- (* An error leaf is denoted by [error]. *)
-
- Printf.bprintf b "error"
-
-and pcsts b (csts : cst array) =
- Array.iter (fun cst ->
- Printf.bprintf b " %a" pcst cst
- ) csts
-
-(* This is the public interface. *)
-
-let wrap print f x =
- let b = Buffer.create 32768 in
- print b x;
- Buffer.output_buffer f b
-
-let print =
- wrap pcst
-
-(* This is a pretty-printer for concrete syntax trees. The notation is
- the same as that used by the above printer; the only difference is
- that the [Pprint] library is used to manage indentation. *)
-
-open Pprint
-
-let rec build : cst -> document = function
- | CstTerminal tok ->
- text (Terminal.print tok)
- | CstNonTerminal (prod, csts) ->
- brackets (
- group (
- text (Nonterminal.print false (Production.nt prod)) ^^
- colon ^^
- group (
- nest 2 (
- Array.fold_left (fun doc cst ->
- doc ^^ break1 ^^ build cst
- ) empty csts
- )
- ) ^^
- break0
- )
- )
- | CstError ->
- text "error"
-
-let show f cst =
- Channel.pretty 0.8 80 f (build cst)
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-(* Concrete syntax trees. *)
-
-(* A concrete syntax tree is one of a leaf -- which corresponds to a
- terminal symbol; a node -- which corresponds to a non-terminal
- symbol, and whose immediate descendants form an expansion of that
- symbol; or an error leaf -- which corresponds to a point where the
- [error] pseudo-token was shifted. *)
-
-type cst =
- | CstTerminal of Terminal.t
- | CstNonTerminal of Production.index * cst array
- | CstError
-
-(* This is a (mostly) unambiguous printer for concrete syntax trees,
- in an sexp-like notation. *)
-
-val print: out_channel -> cst -> unit
-
-(* This is a pretty-printer for concrete syntax trees. The notation is
- the same as that used by the above printer; the only difference is
- that the [Pprint] library is used to manage indentation. *)
-
-val show: out_channel -> cst -> unit
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-(* -------------------------------------------------------------------------- *)
-
-(* This is a data structure for linear derivation trees. These are derivation
- trees that are list-like (that is, they do not branch), because a single
- path is of interest.
-
- A tree is either empty or formed of a non-terminal symbol at the root and a
- forest below the root.
-
- A forest is an ordered list of elements. However, its elements are not
- trees, as one would perhaps expect. Because we are interested in *linear*
- derivation trees, only one element of the forest receives focus and is a
- tree. All other elements remain un-expanded, so they are just symbols.
-
- In other words, a linear derivation tree is roughly just a list of levels,
- where each forest corresponds to one level. *)
-
-type 'focus level = {
- prefix: Symbol.t list;
- focus: 'focus;
- suffix: Symbol.t list;
- comment: string
- }
-
-type tree =
- | TEmpty
- | TRooted of Symbol.t * forest
-
-and forest =
- tree level
-
-(* We make use of contexts with a forest-shaped hole. We have tree contexts
- and forest contexts.
-
- Tree contexts do not have a case for holes, since we work with
- forest-shaped holes only. Forest contexts have one. *)
-
-type ctree =
- | CRooted of Symbol.t * cforest
-
-and cforest =
- | CHole
- | CCons of ctree level
-
-(* Make a few types visible to clients. *)
-
-type t =
- forest
-
-type context =
- cforest
-
-(* -------------------------------------------------------------------------- *)
-
-(* Construction. *)
-
-let rec array_to_list a i j =
- if i = j then
- []
- else
- a.(i) :: array_to_list a (i + 1) j
-
-let empty =
- {
- prefix = [];
- focus = TEmpty;
- suffix = [];
- comment = ""
- }
-
-let tail pos rhs =
- let length = Array.length rhs in
- assert (pos < length);
- {
- prefix = [];
- focus = TEmpty;
- suffix = array_to_list rhs pos length;
- comment = ""
- }
-
-let build pos rhs forest comment =
- let length = Array.length rhs in
- assert (pos < length);
- match rhs.(pos) with
- | Symbol.T _ ->
- assert false
- | Symbol.N _ as symbol ->
- {
- prefix = [];
- focus = TRooted (symbol, forest);
- suffix = array_to_list rhs (pos + 1) length;
- comment = (match comment with None -> "" | Some comment -> comment)
- }
-
-let prepend symbol forest =
- { forest with
- prefix = symbol :: forest.prefix }
-
-(* -------------------------------------------------------------------------- *)
-
-(* Display. *)
-
-let buffer =
- Buffer.create 32768
-
-let rec print_blank k =
- if k > 0 then begin
- Buffer.add_char buffer ' ';
- print_blank (k - 1)
- end
-
-let print_symbol symbol =
- let word = Symbol.print symbol in
- Buffer.add_string buffer word;
- Buffer.add_char buffer ' ';
- String.length word + 1
-
-let print_symbols symbols =
- List.fold_left (fun offset symbol ->
- offset + print_symbol symbol
- ) 0 symbols
-
-let print_level print_focus_root print_focus_remainder offset forest =
- print_blank offset;
- let offset = offset + print_symbols forest.prefix in
- print_focus_root forest.focus;
- let (_ : int) = print_symbols forest.suffix in
- if String.length forest.comment > 0 then begin
- Buffer.add_string buffer "// ";
- Buffer.add_string buffer forest.comment
- end;
- Buffer.add_char buffer '\n';
- print_focus_remainder offset forest.focus
-
-let print_tree_root = function
- | TEmpty ->
- Buffer.add_string buffer ". "
- | TRooted (symbol, _) ->
- let (_ : int) = print_symbol symbol in
- ()
-
-let rec print_forest offset forest =
- print_level print_tree_root print_tree_remainder offset forest
-
-and print_tree_remainder offset = function
- | TEmpty ->
- ()
- | TRooted (_, forest) ->
- print_forest offset forest
-
-let print_ctree_root = function
- | CRooted (symbol, _) ->
- let (_ : int) = print_symbol symbol in
- ()
-
-let rec print_cforest offset cforest =
- match cforest with
- | CHole ->
- print_blank offset;
- Buffer.add_string buffer "(?)\n"
- | CCons forest ->
- print_level print_ctree_root print_ctree_remainder offset forest
-
-and print_ctree_remainder offset = function
- | CRooted (_, cforest) ->
- print_cforest offset cforest
-
-let wrap print channel x =
- Buffer.clear buffer;
- print 0 x;
- Buffer.output_buffer channel buffer
-
-let print =
- wrap print_forest
-
-let printc =
- wrap print_cforest
-
-(* -------------------------------------------------------------------------- *)
-
-(* [punch] turns a (tree or forest) into a pair of a (tree or forest) context
- and a residual forest, where the context is chosen maximal. In other words,
- the residual forest consists of a single level -- its focus is [TEmpty]. *)
-
-let rec punch_tree tree : (ctree * forest) option =
- match tree with
- | TEmpty ->
- None
- | TRooted (symbol, forest) ->
- let forest1, forest2 = punch_forest forest in
- Some (CRooted (symbol, forest1), forest2)
-
-and punch_forest forest : cforest * forest =
- match punch_tree forest.focus with
- | None ->
- CHole, forest
- | Some (ctree1, forest2) ->
- CCons {
- prefix = forest.prefix;
- focus = ctree1;
- suffix = forest.suffix;
- comment = forest.comment
- }, forest2
-
-(* [fill] fills a (tree or forest) context with a forest so as to produce
- a new (tree or forest). *)
-
-let rec fill_tree ctree1 forest2 : tree =
- match ctree1 with
- | CRooted (symbol1, cforest1) ->
- TRooted (symbol1, fill_forest cforest1 forest2)
-
-and fill_forest cforest1 forest2 : forest =
- match cforest1 with
- | CHole ->
- forest2
- | CCons level1 ->
- {
- prefix = level1.prefix;
- focus = fill_tree level1.focus forest2;
- suffix = level1.suffix;
- comment = level1.comment
- }
-
-(* [common] factors the maximal common (tree or forest) context out of a pair
- of a (tree or forest) context and a (tree or forest). It returns the (tree
- or forest) context as well as the residuals of the two parameters. *)
-
-let rec common_tree ctree1 tree2 : (ctree * cforest * forest) option =
- match ctree1, tree2 with
- | CRooted _, TEmpty ->
- None
- | CRooted (symbol1, cforest1), TRooted (symbol2, forest2) ->
- if Symbol.equal symbol1 symbol2 then
- let cforest, cforest1, forest2 =
- common_forest cforest1 forest2
- in
- Some (CRooted (symbol1, cforest), cforest1, forest2)
- else
- None
-
-and common_forest cforest1 forest2 : cforest * cforest * forest =
- match cforest1 with
- | CHole ->
- CHole, cforest1, forest2
- | CCons forest1 ->
- if Symbol.lequal forest1.prefix forest2.prefix
- && Symbol.lequal forest1.suffix forest2.suffix
- && forest1.comment = forest2.comment
- then begin
- match common_tree forest1.focus forest2.focus with
- | None ->
- CHole, cforest1, forest2
- | Some (ctree, csubforest1, subforest2) ->
- let cforest = {
- prefix = forest1.prefix;
- focus = ctree;
- suffix = forest1.suffix;
- comment = forest1.comment
- } in
- CCons cforest, csubforest1, subforest2
- end
- else
- CHole, cforest1, forest2
-
-(* [factor] factors the maximal common forest context out of a nonempty family
- of forests. We assume that the family is represented as a map indexed by
- items, because this is convenient for the application that we have in mind,
- but this assumption is really irrelevant. *)
-
-let rec factor forests =
- match
- Item.Map.fold (fun item forest accu ->
- match accu with
- | None ->
-
- (* First time through the loop, so [forest] is the first forest
- that we examine. Punch it, so as to produce a maximal forest
- context and a residual forest. *)
-
- let context, residual = punch_forest forest in
- Some (context, Item.Map.singleton item residual)
-
- | Some (context, residuals) ->
-
- (* Another iteration through the loop. [context] and [residuals] are
- the maximal common context and the residuals of the forests
- examined so far. *)
-
- (* Combine the common context obtained so far with the forest at hand.
- This yields a new, smaller common context, as well as residuals for
- the previous common context and for the forest at hand. *)
-
- let context, contextr, forestr = common_forest context forest in
-
- (* The residual forests are now: (i) the residual forest [forestr];
- and (ii) the previous residual forests [residuals], each of which
- must be placed with the residual context [contextr]. *)
-
- let residuals =
- Item.Map.add item forestr (Item.Map.map (fill_forest contextr) residuals)
- in
-
- Some (context, residuals)
-
- ) forests None
- with
- | None ->
- assert false (* parameter [forests] was an empty map *)
- | Some (context, residuals) ->
- context, residuals
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-(* -------------------------------------------------------------------------- *)
-
-(* This is the type of derivations. Derivations are forests: see inside. *)
-
-type t
-
-(* This is the type of derivations contexts, or derivations with a
- derivation-shaped hole. *)
-
-type context
-
-(* -------------------------------------------------------------------------- *)
-
-(* Construction. *)
-
-(* [empty] is the forest that consists of a single empty tree. *)
-
-val empty: t
-
-(* [tail pos rhs] is the forest: (i) whose first element is the empty tree,
- and (ii) whose remaining elements are the symbols found at positions
- greater than or equal to [pos] in the array [rhs]. *)
-
-val tail: int -> Symbol.t array -> t
-
-(* [build pos rhs forest comment] is the forest: (i) whose first element is
- the tree that has the non-terminal symbol [rhs.(pos)] at its root and the
- forest [forest] below its root, and (ii) whose remaining elements are the
- symbols found at positions greater than [pos] in the array [rhs]. *)
-
-val build: int -> Symbol.t array -> t -> string option -> t
-
-(* [prepend symbol forest] is the forest: (i) whose first element is the
- symbol [symbol], and (ii) whose remaining elements form the forest
- [forest]. *)
-
-val prepend: Symbol.t -> t -> t
-
-(* -------------------------------------------------------------------------- *)
-
-(* Factoring. *)
-
-(* [factor] factors the maximal common derivation context out of a
- nonempty family of derivations. It produces a pair of the context
- and of the residual derivations. *)
-
-val factor: t Item.Map.t -> context * t Item.Map.t
-
-(* -------------------------------------------------------------------------- *)
-
-(* Display. *)
-
-(* [print] prints a derivation. *)
-
-val print: out_channel -> t -> unit
-
-(* [printc] prints a derivation context. *)
-
-val printc: out_channel -> context -> unit
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Printf
-
-(* ------------------------------------------------------------------------- *)
-
-(* Type definitions. *)
-
-type size =
- float * float (* in inches *)
-
-type orientation =
- | Portrait
- | Landscape
-
-type rankdir =
- | LeftToRight
- | TopToBottom
-
-type ratio =
- | Compress
- | Fill
- | Auto
-
-type style =
-
- (* Both nodes and edges. *)
-
- | Solid
- | Dashed
- | Dotted
- | Bold
- | Invisible
-
- (* Nodes only. *)
-
- | Filled
- | Diagonals
- | Rounded
-
-(* ------------------------------------------------------------------------- *)
-
-(* Basic printers. *)
-
-let print_style = function
- | None ->
- ""
- | Some style ->
- let style =
- match style with
- | Solid ->
- "solid"
- | Dashed ->
- "dashed"
- | Dotted ->
- "dotted"
- | Bold ->
- "bold"
- | Invisible ->
- "invis"
- | Filled ->
- "filled"
- | Diagonals ->
- "diagonals"
- | Rounded ->
- "rounded"
- in
- sprintf ", style = %s" style
-
-(* ------------------------------------------------------------------------- *)
-
-(* The graph printer. *)
-
-module Print (G : sig
-
- type vertex
-
- val name: vertex -> string
-
- val successors: (?style:style -> label:string -> vertex -> unit) -> vertex -> unit
-
- val iter: (?style:style -> label:string -> vertex -> unit) -> unit
-
-end) = struct
-
- let print
- ?(directed = true)
- ?size
- ?(orientation = Landscape)
- ?(rankdir = LeftToRight)
- ?(ratio = Compress)
- (f : out_channel)
- =
-
- fprintf f "%s G {\n" (if directed then "digraph" else "graph");
- Option.iter (fun (hsize, vsize) ->
- fprintf f "size=\"%f, %f\";\n" hsize vsize
- ) size;
- begin match orientation with
- | Portrait ->
- fprintf f "orientation = portrait;\n"
- | Landscape ->
- fprintf f "orientation = landscape;\n"
- end;
- begin match rankdir with
- | LeftToRight ->
- fprintf f "rankdir = LR;\n"
- | TopToBottom ->
- fprintf f "rankdir = TB;\n"
- end;
- begin match ratio with
- | Compress ->
- fprintf f "ratio = compress;\n"
- | Fill ->
- fprintf f "ratio = fill;\n"
- | Auto ->
- fprintf f "ratio = auto;\n"
- end;
-
- G.iter (fun ?style ~label vertex ->
- fprintf f "%s [ label=\"%s\"%s ] ;\n"
- (G.name vertex)
- label
- (print_style style)
- );
-
- G.iter (fun ?style ~label source ->
- G.successors (fun ?style ~label destination ->
- fprintf f "%s %s %s [ label=\"%s\"%s ] ;\n"
- (G.name source)
- (if directed then "->" else "--")
- (G.name destination)
- label
- (print_style style)
- ) source
- );
-
- fprintf f "\n}\n"
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module displays graphs in graphviz dot format. It is much more
- basic than the one bundled with the ocamlgraph library, but offers
- the advantage of being stand-alone. *)
-
-(* ------------------------------------------------------------------------- *)
-
-(* Type definitions. *)
-
-type size =
- float * float (* in inches *)
-
-type orientation =
- | Portrait
- | Landscape
-
-type rankdir =
- | LeftToRight
- | TopToBottom
-
-type ratio =
- | Compress
- | Fill
- | Auto
-
-type style =
-
- (* Both nodes and edges. *)
-
- | Solid
- | Dashed
- | Dotted
- | Bold
- | Invisible
-
- (* Nodes only. *)
-
- | Filled
- | Diagonals
- | Rounded
-
-(* ------------------------------------------------------------------------- *)
-
-(* The graph printer. *)
-
-module Print (G : sig
-
- type vertex
-
- val name: vertex -> string
-
- val successors: (?style:style -> label:string -> vertex -> unit) -> vertex -> unit
-
- val iter: (?style:style -> label:string -> vertex -> unit) -> unit
-
-end) : sig
-
- val print:
- ?directed: bool ->
- ?size: size ->
- ?orientation: orientation ->
- ?rankdir: rankdir ->
- ?ratio: ratio ->
- out_channel ->
- unit
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open EngineTypes
-
-(* The LR parsing engine. *)
-
-(* This module is used:
-
- - at compile time, if so requested by the user, via the --interpret options;
- - at run time, in the table-based back-end. *)
-
-module Make (T : TABLE) = struct
-
- (* This propagates type and exception definitions. *)
-
- include T
-
- let _eRR : exn =
- Error
-
- (* --------------------------------------------------------------------------- *)
-
- (* [discard] takes a token off the input stream, queries the lexer
- for a new one, and stores it into [env.token], overwriting the
- previous token. If [env.shifted] has not yet reached its limit,
- it is incremented. *)
-
- let discard env =
- let lexbuf = env.lexbuf in
- let token = env.lexer lexbuf in
- env.token <- token;
- Log.lookahead_token lexbuf (T.token2terminal token);
- let shifted = env.shifted + 1 in
- if shifted >= 0 then
- env.shifted <- shifted
-
- (* --------------------------------------------------------------------------- *)
-
- (* The type [void] is empty. Many of the functions below have return type
- [void]. This guarantees that they never return a value. Instead, they
- must stop by raising an exception: either [Accept] or [Error]. *)
-
- type void
-
- (* --------------------------------------------------------------------------- *)
-
- (* In the code-based back-end, the [run] function is sometimes responsible
- for pushing a new cell on the stack. This is motivated by code sharing
- concerns. In this interpreter, there is no such concern; [run]'s caller
- is always responsible for updating the stack. *)
-
- (* In the code-based back-end, there is a [run] function for each state
- [s]. This function can behave in two slightly different ways, depending
- on when it is invoked, or (equivalently) depending on [s].
-
- If [run] is invoked after shifting a terminal symbol (or, equivalently,
- if [s] has a terminal incoming symbol), then [run] discards a token,
- unless [s] has a default reduction on [#]. (Indeed, in that case,
- requesting the next token might drive the lexer off the end of the input
- stream.)
-
- If, on the other hand, [run] is invoked after performing a goto transition,
- or invoked directly by an entry point, then there is nothing to discard.
-
- These two cases are reflected in [CodeBackend.gettoken].
-
- Here, the code is structured in a slightly different way. It is up to
- the caller of [run] to indicate whether to discard a token. *)
-
- let rec run env please_discard : void =
-
- (* Log the fact that we just entered this state. *)
-
- let s = env.current in
- Log.state s;
-
- (* If [please_discard] is set, discard a token and fetch the next one. *)
-
- (* This flag is set when [s] is being entered by shifting a terminal
- symbol and [s] does not have a default reduction on [#]. *)
-
- if please_discard then
- discard env;
-
- (* Examine what situation we are in. This case analysis is analogous to
- that performed in [CodeBackend.gettoken], in the sub-case where we do
- not have a terminal incoming symbol. *)
-
- T.default_reduction
- s
- reduce (* there is a default reduction; perform it *)
- continue (* there is none; continue below *)
- env
-
- and continue env : void =
-
- (* There is no default reduction. Consult the current lookahead token
- so as to determine which action should be taken. *)
-
- (* Peeking at the first input token, without taking it off the input
- stream, is normally done by reading [env.token]. However, we check
- [env.shifted] first: if it is -1, then the lookahead token is the
- [error] token. *)
-
- (* Note that, if we just called [discard] above, then the lookahead
- token cannot be [error]. *)
-
- if env.shifted = (-1) then begin
- Log.resuming_error_handling();
- error env
- end
- else
- action env
-
- (* --------------------------------------------------------------------------- *)
-
- (* When [action] is invoked, we know that the current state does not have
- a default reduction. We also know that the current lookahead token is
- not [error]: it is a real token, stored in [env.token]. *)
-
- and action env : void =
-
- (* We consult the two-dimensional action table, indexed by the
- current state and the current lookahead token, in order to
- determine which action should be taken. *)
-
- let token = env.token in
- T.action
- env.current (* determines a row *)
- (T.token2terminal token) (* determines a column *)
- (T.token2value token)
- shift (* shift continuation *)
- reduce (* reduce continuation *)
- initiate (* failure continuation *)
- env
-
- (* --------------------------------------------------------------------------- *)
-
- (* This function takes care of shift transitions along a terminal symbol.
- (Goto transitions are taken care of within [reduce] below.) The symbol
- can be either an actual token or the [error] pseudo-token. *)
-
- and shift env
- (please_discard : bool)
- (terminal : terminal)
- (value : semantic_value)
- (s' : state)
- : void =
-
- (* Log the transition. *)
-
- Log.shift terminal s';
-
- (* Push a new cell onto the stack, containing the identity of the
- state that we are leaving. *)
-
- let lexbuf = env.lexbuf in
- env.stack <- {
- state = env.current;
- semv = value;
- startp = lexbuf.Lexing.lex_start_p;
- endp = lexbuf.Lexing.lex_curr_p;
- next = env.stack;
- };
-
- (* Switch to state [s']. *)
-
- env.current <- s';
- run env please_discard
-
- (* --------------------------------------------------------------------------- *)
-
- (* This function takes care of reductions. *)
-
- and reduce env (prod : production) : void =
-
- (* Log a reduction event. *)
-
- Log.reduce_or_accept prod;
-
- (* Invoke the semantic action. The semantic action is responsible for
- truncating the stack, updating the current state, producing a cell that
- contains a new semantic value, and raising [Accept] or [Error] if
- appropriate. *)
-
- (* If the semantic action raises [Error], we catch it immediately and
- initiate error handling. *)
-
- (* The apparently weird idiom used here is an encoding for a
- [let/unless] construct, which does not exist in ocaml. *)
-
- if (
- try
- T.semantic_action prod env;
- true
- with Error ->
- false
- ) then begin
-
- (* By our convention, the semantic action is responsible for updating
- the stack. The state now found in the top stack cell is the return
- state. *)
-
- (* Perform a goto transition. The target state is determined
- by consulting the goto table at the return state and at
- production [prod]. *)
-
- env.current <- T.goto env.stack.state prod;
- run env false
-
- end
- else
- errorbookkeeping env
-
-
- (* --------------------------------------------------------------------------- *)
-
- (* The following functions deal with errors. *)
-
- (* [initiate] and [errorbookkeeping] initiate error handling. See the functions
- by the same names in [CodeBackend]. *)
-
- and initiate env : void =
- assert (env.shifted >= 0);
- if T.recovery && env.shifted = 0 then begin
- Log.discarding_last_token (T.token2terminal env.token);
- discard env;
- env.shifted <- 0;
- action env
- end
- else
- errorbookkeeping env
-
- and errorbookkeeping env =
- Log.initiating_error_handling();
- env.previouserror <- env.shifted;
- env.shifted <- (-1);
- error env
-
- (* [error] handles errors. *)
-
- and error env : void =
-
- (* Consult the column associated with the [error] pseudo-token in the
- action table. *)
-
- T.action
- env.current (* determines a row *)
- T.error_terminal (* determines a column *)
- T.error_value
- error_shift (* shift continuation *)
- error_reduce (* reduce continuation *)
- error_fail (* failure continuation *)
- env
-
- and error_shift env please_discard terminal value s' =
-
- (* Here, [terminal] is [T.error_terminal], and [value] is [T.error_value]. *)
-
- assert (terminal = T.error_terminal && value = T.error_value);
-
- (* This state is capable of shifting the [error] token. *)
-
- Log.handling_error env.current;
- shift env please_discard terminal value s'
-
- and error_reduce env prod =
-
- (* This state is capable of performing a reduction on [error]. *)
-
- Log.handling_error env.current;
- reduce env prod
-
- and error_fail env =
-
- (* This state is unable to handle errors. Attempt to pop a stack
- cell. *)
-
- let cell = env.stack in
- let next = cell.next in
- if next == cell then
-
- (* The stack is empty. Die. *)
-
- raise _eRR
-
- else begin
-
- (* The stack is nonempty. Pop a cell, updating the current state
- with that found in the popped cell, and try again. *)
-
- env.stack <- next;
- env.current <- cell.state;
- error env
-
- end
-
- (* --------------------------------------------------------------------------- *)
-
- let entry
- (s : state)
- (lexer : Lexing.lexbuf -> token)
- (lexbuf : Lexing.lexbuf)
- : semantic_value =
-
- (* Build an empty stack. This is a dummy cell, which is its own
- successor. Its fields other than [next] contain dummy values. *)
-
- let rec empty = {
- state = s; (* dummy *)
- semv = T.error_value; (* dummy *)
- startp = lexbuf.Lexing.lex_start_p; (* dummy *)
- endp = lexbuf.Lexing.lex_curr_p; (* dummy *)
- next = empty;
- } in
-
- (* Perform an initial call to the lexer. *)
-
- let token : token =
- lexer lexbuf
- in
-
- (* Log our first lookahead token. *)
-
- Log.lookahead_token lexbuf (T.token2terminal token);
-
- (* Build an initial environment. *)
-
- let env = {
- lexer = lexer;
- lexbuf = lexbuf;
- token = token;
- shifted = max_int;
- previouserror = max_int;
- stack = empty;
- current = s;
- } in
-
- (* Run. Catch [Accept], which represents normal termination. Let [Error]
- escape. *)
-
- try
-
- (* If ocaml offered a [match/with] construct with zero branches, this is
- what we would use here, since the type [void] has zero cases. *)
-
- let (_ : void) = run env false in
- assert false (* cannot fail *)
-
- with
- | Accept v ->
- v
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open EngineTypes
-
-(* The LR parsing engine. *)
-
-module Make (T : TABLE) : ENGINE with type state = T.state
- and type token = T.token
- and type semantic_value = T.semantic_value
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This file defines several types and module types that are used in the
- specification of module [Engine]. *)
-
-(* --------------------------------------------------------------------------- *)
-
-(* It would be nice if we could keep the structure of stacks and environments
- hidden. However, stacks and environments must be accessible to semantic
- actions, so the following data structure definitions must be public. *)
-
-(* --------------------------------------------------------------------------- *)
-
-(* A stack is a linked list of cells. A sentinel cell -- which is its own
- successor -- is used to mark the bottom of the stack. The sentinel cell
- itself is not significant -- it contains dummy values. *)
-
-type ('state, 'semantic_value) stack = {
-
- (* The state that we should go back to if we pop this stack cell. *)
-
- (* This convention means that the state contained in the top stack cell is
- not the current state [env.current]. It also means that the state found
- within the sentinel is a dummy -- it is never consulted. This convention
- is the same as that adopted by the code-based back-end. *)
-
- state: 'state;
-
- (* The semantic value associated with the chunk of input that this cell
- represents. *)
-
- semv: 'semantic_value;
-
- (* The start and end positions of the chunk of input that this cell
- represents. *)
-
- startp: Lexing.position;
- endp: Lexing.position;
-
- (* The next cell down in the stack. If this is a self-pointer, then this
- cell is the sentinel, and the stack is conceptually empty. *)
-
- next: ('state, 'semantic_value) stack;
-
-}
-
-(* --------------------------------------------------------------------------- *)
-
-(* A parsing environment contains basically all of the automaton's state. *)
-
-type ('state, 'semantic_value, 'token) env = {
-
- (* The lexer. *)
-
- lexer: Lexing.lexbuf -> 'token;
-
- (* The lexing buffer. It is used as an argument to the lexer, and also
- accessed directly when extracting positions. *)
-
- lexbuf: Lexing.lexbuf;
-
- (* The last token that was obtained from the lexer. *)
-
- mutable token: 'token;
-
- (* A count of how many tokens were shifted since the beginning, or since
- the last [error] token was encountered. By convention, if [shifted]
- is (-1), then the current lookahead token is [error]. *)
-
- mutable shifted: int;
-
- (* A copy of the value of [shifted] just before the most recent error
- was detected. This value is not used by the automaton itself, but
- is made accessible to semantic actions. *)
-
- mutable previouserror: int;
-
- (* The stack. In [CodeBackend], it is passed around on its own,
- whereas, here, it is accessed via the environment. *)
-
- mutable stack: ('state, 'semantic_value) stack;
-
- (* The current state. In [CodeBackend], it is passed around on its
- own, whereas, here, it is accessed via the environment. *)
-
- mutable current: 'state;
-
-}
-
-(* --------------------------------------------------------------------------- *)
-
-(* This signature describes the parameters that must be supplied to the LR
- engine. *)
-
-module type TABLE = sig
-
- (* The type of automaton states. *)
-
- type state
-
- (* The type of tokens. These can be thought of as real tokens, that is,
- tokens returned by the lexer. They carry a semantic value. This type
- does not include the [error] pseudo-token. *)
-
- type token
-
- (* The type of terminal symbols. These can be thought of as integer codes.
- They do not carry a semantic value. This type does include the [error]
- pseudo-token. *)
-
- type terminal
-
- (* The type of semantic values. *)
-
- type semantic_value
-
- (* A token is conceptually a pair of a (non-[error]) terminal symbol and
- a semantic value. The following two functions are the pair projections. *)
-
- val token2terminal: token -> terminal
- val token2value: token -> semantic_value
-
- (* Even though the [error] pseudo-token is not a real token, it is a
- terminal symbol. Furthermore, for regularity, it must have a semantic
- value. *)
-
- val error_terminal: terminal
- val error_value: semantic_value
-
- (* The type of productions. *)
-
- type production
-
- (* If a state [s] has a default reduction on production [prod], then, upon
- entering [s], the automaton should reduce [prod] without consulting the
- lookahead token. The following function allows determining which states
- have default reductions. *)
-
- (* Instead of returning a value of a sum type -- either [DefRed prod], or
- [NoDefRed] -- it accepts two continuations, and invokes just one of
- them. This mechanism allows avoiding a memory allocation. *)
-
- val default_reduction:
- state ->
- ('env -> production -> 'answer) ->
- ('env -> 'answer) ->
- 'env -> 'answer
-
- (* An LR automaton can normally take three kinds of actions: shift, reduce,
- or fail. (Acceptance is a particular case of reduction: it consists in
- reducing a start production.) *)
-
- (* There are two variants of the shift action. [shift/discard s] instructs
- the automaton to discard the current token, request a new one from the
- lexer, and move to state [s]. [shift/nodiscard s] instructs it to move to
- state [s] without requesting a new token. This instruction should be used
- when [s] has a default reduction on [#]. See [CodeBackend.gettoken] for
- details. *)
-
- (* This is the automaton's action table. It maps a pair of a state and a
- terminal symbol to an action. *)
-
- (* Instead of returning a value of a sum type -- one of shift/discard,
- shift/nodiscard, reduce, or fail -- this function accepts three
- continuations, and invokes just one them. This mechanism allows avoiding
- a memory allocation. *)
-
- (* In summary, the parameters to [action] are as follows:
-
- - the first two parameters, a state and a terminal symbol, are used to
- look up the action table;
-
- - the next parameter is the semantic value associated with the above
- terminal symbol; it is not used, only passed along to the shift
- continuation, as explained below;
-
- - the shift continuation expects an environment; a flag that tells
- whether to discard the current token; the terminal symbol that
- is being shifted; its semantic value; and the target state of
- the transition;
-
- - the reduce continuation expects an environment and a production;
-
- - the fail continuation expects an environment;
-
- - the last parameter is the environment; it is not used, only passed
- along to the selected continuation. *)
-
- val action:
- state ->
- terminal ->
- semantic_value ->
- ('env -> bool -> terminal -> semantic_value -> state -> 'answer) ->
- ('env -> production -> 'answer) ->
- ('env -> 'answer) ->
- 'env -> 'answer
-
- (* This is the automaton's goto table. It maps a pair of a state and a
- production to a new state.
-
- This convention is slightly different from the textbook approach. The
- goto table is usually indexed by a state and a non-terminal symbol. *)
-
- val goto: state -> production -> state
-
- (* By convention, a semantic action is responsible for:
-
- 1. fetching whatever semantic values and positions it needs off the stack;
-
- 2. popping an appropriate number of cells off the stack, as dictated
- by the length of the right-hand side of the production; this involves
- updating [env.stack];
-
- 3. computing a new semantic value, as well as new start and end positions;
-
- 4. pushing a new stack cell, which contains the three values
- computed in step 3; this again involves updating [env.stack]
- (only one update is necessary).
-
- Point 1 is essentially forced upon us: if semantic values were fetched
- off the stack by this interpreter, then the calling convention for
- semantic actions would be variadic: not all semantic actions would have
- the same number of arguments. The rest follows rather naturally. *)
-
- (* If production [prod] is an accepting production, then the semantic action
- is responsible for raising exception [Accept], instead of returning
- normally. This convention allows us to not distinguish between regular
- productions and accepting productions. All we have to do is catch that
- exception at top level. *)
-
- (* Semantic actions are allowed to raise [Error]. *)
-
- exception Accept of semantic_value
- exception Error
-
- type semantic_action =
- (state, semantic_value, token) env -> unit
-
- val semantic_action: production -> semantic_action
-
- (* The LR engine can attempt error recovery. This consists in discarding
- tokens, just after an error has been successfully handled, until a token
- that can be successfully handled is found. This mechanism is optional.
- The following flag enables it. *)
-
- val recovery: bool
-
- (* The LR engine requires a number of hooks, which are used for logging. *)
-
- (* The comments below indicate the conventional messages that correspond
- to these hooks in the code-based back-end; see [CodeBackend]. *)
-
- module Log : sig
-
- (* State %d: *)
-
- val state: state -> unit
-
- (* Shifting (<terminal>) to state <state> *)
-
- val shift: terminal -> state -> unit
-
- (* Reducing a production should be logged either as a reduction
- event (for regular productions) or as an acceptance event (for
- start productions). *)
-
- (* Reducing production <production> / Accepting *)
-
- val reduce_or_accept: production -> unit
-
- (* Lookahead token is now <terminal> (<pos>-<pos>) *)
-
- val lookahead_token: Lexing.lexbuf -> terminal -> unit
-
- (* Initiating error handling *)
-
- val initiating_error_handling: unit -> unit
-
- (* Resuming error handling *)
-
- val resuming_error_handling: unit -> unit
-
- (* Handling error in state <state> *)
-
- val handling_error: state -> unit
-
- (* Discarding last token read (<terminal>) *)
-
- val discarding_last_token: terminal -> unit
-
- end
-
-end
-
-(* --------------------------------------------------------------------------- *)
-
-(* This signature describes the LR engine. *)
-
-module type ENGINE = sig
-
- type state
-
- type token
-
- type semantic_value
-
- (* An entry point to the engine requires a start state, a lexer, and a lexing
- buffer. It either succeeds and produces a semantic value, or fails and
- raises [Error]. *)
-
- exception Error
-
- val entry:
- state ->
- (Lexing.lexbuf -> token) ->
- Lexing.lexbuf ->
- semantic_value
-
-end
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Printf
-open Lexing
-
-(* TEMPORARY Vérifier que les messages d'erreur sont standardisés au
- maximum, localisés au maximum. Supprimer autant de fonctions que
- possible dans ce module. *)
-
-(* TEMPORARY reprendre compl`etement implementation et interface
- de ce module *)
-
-(* ---------------------------------------------------------------------------- *)
-
-(* Global state. *)
-
-let get_initialized_ref ref =
- match !ref with
- | None ->
- assert false
- | Some contents ->
- contents
-
-let filename =
- ref (None : string option)
-
-let filemark =
- ref Mark.none
-
-(* 2011/10/19: do not use [Filename.basename]. The [#] annotations that
- we insert in the [.ml] file must retain their full path. This does
- mean that the [#] annotations depend on how menhir is invoked -- e.g.
- [menhir foo/bar.mly] and [cd foo && menhir bar.mly] will produce
- different files. Nevertheless, this seems useful/reasonable. *)
-
-(* This also influences the type error messages produced by [--infer]. *)
-
-let set_filename name =
- filename := Some name;
- filemark := Mark.fresh()
-
-let get_filename () =
- get_initialized_ref filename
-
-let get_filemark () =
- !filemark
-
-let file_contents =
- ref (None : string option)
-
-let get_file_contents () =
- get_initialized_ref file_contents
-
-(* ---------------------------------------------------------------------------- *)
-
-(* Logging and log levels. *)
-
-let log kind verbosity msg =
- if kind >= verbosity then
- Printf.fprintf stderr "%t%!" msg
-
-let logG =
- log Settings.logG
-
-let logA =
- log Settings.logA
-
-let logC =
- log Settings.logC
-
-(* ---------------------------------------------------------------------------- *)
-
-(* Errors and warnings. *)
-
-let errors =
- ref false
-
-let printN positions message =
- List.iter (fun position ->
- fprintf stderr "%s:\n" (Positions.string_of_pos position)
- ) positions;
- fprintf stderr "%s\n%!" message
-
-let error_message message =
- "Error: " ^ message
-
-let error positions message =
- printN positions (error_message message);
- exit 1
-
-let errorp v message =
- error [ Positions.position v ] message
-
-let signal positions message =
- printN positions message;
- errors := true
-
-let warning positions message =
- printN positions (Printf.sprintf "Warning: %s" message)
-
-let errors () =
- !errors
-
-(* Certain warnings about the grammar can optionally be treated as errors.
- The following function emits a warning or error message, via [warning] or
- [signal]. It does not stop the program; the client must at some point call
- [errors] and stop the program if any errors have been reported. *)
-
-let grammar_warning positions message =
- if Settings.strict then
- signal positions (error_message message)
- else
- warning positions message
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module helps report errors and maintains some information
- about the source file that is being read. *)
-
-(* ---------------------------------------------------------------------------- *)
-
-(* Call [set_filename] before lexing and parsing in order to inform
- the module [Error] about the name of the file that is being
- examined. *)
-
-(* TEMPORARY limiter ou supprimer ou commenter cette interface stateful *)
-
-val set_filename: string -> unit
-
-val get_filename: unit -> string
-
-val get_filemark: unit -> Mark.t
-
-val file_contents: string option ref
-
-val get_file_contents: unit -> string
-
-(* ---------------------------------------------------------------------------- *)
-
-(* Logging and log levels. *)
-
-val logG: int -> (out_channel -> unit) -> unit
-val logA: int -> (out_channel -> unit) -> unit
-val logC: int -> (out_channel -> unit) -> unit
-
-(* ---------------------------------------------------------------------------- *)
-
-(* Errors and warnings. *)
-
-(* [error ps msg] displays the error message [msg], referring to the
- positions [ps], and exits. *)
-
-val error: Positions.positions -> string -> 'a
-
-(* [errorp v msg] displays the error message [msg], referring to the
- position range carried by [v], and exits. *)
-
-val errorp: 'a Positions.located -> string -> 'b
-
-(* [warning ps msg] displays the warning message [msg], referring to
- the positions [ps]. *)
-
-val warning: Positions.positions -> string -> unit
-
-(* [signal ps msg] displays the error message [msg], referring to the
- positions [ps], and does not exit immediately. *)
-
-val signal: Positions.positions -> string -> unit
-
-(* [errors] returns [true] if [signal] was previously called. Together
- [signal] and [errors] allow reporting multiple errors before aborting. *)
-
-val errors: unit -> bool
-
-(* Certain warnings about the grammar can optionally be treated as errors.
- The following function emits a warning or error message, via [warning] or
- [signal]. It does not stop the program; the client must at some point call
- [errors] and stop the program if any errors have been reported. *)
-
-val grammar_warning: Positions.positions -> string -> unit
-
+++ /dev/null
-/**************************************************************************/
-/* */
-/* Menhir */
-/* */
-/* François Pottier, INRIA Rocquencourt */
-/* Yann Régis-Gianas, PPS, Université Paris Diderot */
-/* */
-/* Copyright 2005-2008 Institut National de Recherche en Informatique */
-/* et en Automatique. All rights reserved. This file is distributed */
-/* under the terms of the Q Public License version 1.0, with the change */
-/* described in file LICENSE. */
-/* */
-/**************************************************************************/
-
-/* This is the fancy version of the parser, to be processed by menhir.
- It is kept in sync with [Parser], but exercises menhir's features. */
-
-/* ------------------------------------------------------------------------- */
-/* Imports. */
-
-%{
-
-open Keyword
-open ConcreteSyntax
-open Syntax
-open Positions
-
-%}
-
-/* ------------------------------------------------------------------------- */
-/* Tokens. */
-
-%token TOKEN TYPE LEFT RIGHT NONASSOC START PREC PUBLIC COLON BAR EOF EQUAL
-%token INLINE LPAREN RPAREN COMMA QUESTION STAR PLUS PARAMETER
-%token <string Positions.located> LID UID
-%token <Stretch.t> HEADER
-%token <Stretch.ocamltype> OCAMLTYPE
-%token <string Lazy.t> PERCENTPERCENT
-%token <Action.t> ACTION
-
-/* ------------------------------------------------------------------------- */
-/* Start symbol. */
-
-%start <ConcreteSyntax.grammar> grammar
-
-/* ------------------------------------------------------------------------- */
-/* Priorities. */
-
-/* These declarations solve a shift-reduce conflict in favor of
- shifting: when the declaration of a non-terminal symbol begins with
- a leading bar, it is understood as an (insignificant) leading
- optional bar, *not* as an empty right-hand side followed by a bar.
- This ambiguity arises due to the existence of a new notation for
- letting several productions share a single semantic action. */
-
-%nonassoc no_optional_bar
-%nonassoc BAR
-
-/* These declarations encourage the [error] token to be shifted if
- found at the end of what seems like a legal declaration. */
-
-%nonassoc decl
-%nonassoc error
-
-%%
-
-/* ------------------------------------------------------------------------- */
-/* A grammar consists of declarations and rules, followed by an optional
- trailer, which we do not parse. */
-
-grammar:
- ds = declaration* PERCENTPERCENT rs = rule* t = trailer
- {
- {
- pg_filename = ""; (* filled in by the caller *)
- pg_declarations = List.flatten ds;
- pg_rules = List.flatten rs;
- pg_trailer = t
- }
- }
-
-/* ------------------------------------------------------------------------- */
-/* A declaration is an %{ Objective Caml header %}, or a %token, %start,
- %type, %left, %right, or %nonassoc declaration. */
-
-declaration:
-
-| h = HEADER /* lexically delimited by %{ ... %} */
- { [ with_poss $startpos $endpos (DCode h) ] }
-
-| TOKEN t = OCAMLTYPE? ts = clist(terminal) %prec decl
- { List.map (Positions.map (fun terminal -> DToken (t, terminal))) ts }
-
-| TOKEN OCAMLTYPE? clist(terminal) error
-| TOKEN OCAMLTYPE? error
- { Error.signal (Positions.two $startpos $endpos) "\
-Syntax error in a %token declaration.
-Here are sample valid declarations:
- %token DOT SEMICOLON
- %token <string> LID UID";
- []
- }
-
-| START t = OCAMLTYPE? nts = clist(nonterminal) %prec decl
- /* %start <ocamltype> foo is syntactic sugar for %start foo %type <ocamltype> foo */
- {
- match t with
- | None ->
- List.map (Positions.map (fun nonterminal -> DStart nonterminal)) nts
- | Some t ->
- Misc.mapd (fun ntloc ->
- Positions.mapd (fun nt -> DStart nt, DType (t, ParameterVar ntloc)) ntloc) nts
- }
-
-| START OCAMLTYPE? clist(nonterminal) error
-| START OCAMLTYPE? error
- { Error.signal (Positions.two $startpos $endpos) "\
-Syntax error in a %start declaration.
-Here are sample valid declarations:
- %start expression phrase
- %start <int> date time";
- []
- }
-
-| TYPE t = OCAMLTYPE ss = clist(actual_parameter) %prec decl
- { List.map (Positions.map (fun nt -> DType (t, nt)))
- (List.map Parameters.with_pos ss) }
-
-| TYPE OCAMLTYPE clist(actual_parameter) error
-| TYPE OCAMLTYPE error
-| TYPE error
- { Error.signal (Positions.two $startpos $endpos) "\
-Syntax error in a %type declaration.
-Here are sample valid declarations:
- %type <Syntax.expression> expression
- %type <int> date time";
- []
- }
-
-| k = priority_keyword ss = clist(symbol) %prec decl
- { let prec = ParserAux.current_token_precedence $startpos(k) $endpos(k) in
- List.map (Positions.map (fun symbol -> DTokenProperties (symbol, k, prec))) ss }
-
-| priority_keyword clist(symbol) error
-| priority_keyword error
- { Error.signal (Positions.two $startpos $endpos) "\
-Syntax error in a precedence declaration.
-Here are sample valid declarations:
- %left PLUS TIMES
- %nonassoc unary_minus
- %right CONCAT";
- []
- }
-
-| PARAMETER t = OCAMLTYPE
- { [ with_poss $startpos $endpos (DParameter t) ] }
-
-| PARAMETER error
- { Error.signal (Positions.two $startpos $endpos) "\
-Syntax error in a %parameter declaration.
-Here is a sample valid declaration:
- %parameter <X : sig type t end>";
- []
- }
-
-/* This error production should lead to resynchronization on the next %something.
- The use of $previouserror prevents reporting errors that are too close to one
- another -- presumably, the second error only means that we failed to properly
- recover after the first error. */
-| error
- { if $previouserror >= 3 then
- Error.signal (Positions.two $startpos $endpos) "Syntax error inside a declaration.";
- [] }
-
-/* This production recognizes tokens that are valid in the rules section,
- but not in the declarations section. This is a hint that a %% was
- forgotten. */
-
-| rule_specific_token
- {
- if $previouserror >= 3 then
- Error.signal (Positions.two $startpos $endpos)
- "Syntax error inside a declaration.\n\
- Did you perhaps forget the %% that separates declarations and rules?";
-
- (* Do not attempt to perform error recovery. There is no way of
- forcing the automaton into a state where rules are expected. *)
-
- exit 1
- }
-
-priority_keyword:
- LEFT
- { LeftAssoc }
-| RIGHT
- { RightAssoc }
-| NONASSOC
- { NonAssoc }
-
-rule_specific_token:
-| PUBLIC
-| INLINE
-| COLON
-| EOF
- { () }
-
-/* ------------------------------------------------------------------------- */
-/* Our lists of symbols are separated with optional commas. Order is
- irrelevant. */
-
-%inline clist(X):
- xs = separated_nonempty_list(COMMA?, X)
- { xs }
-
-/* ------------------------------------------------------------------------- */
-/* A symbol is a terminal or nonterminal symbol. One would like to
- require nonterminal symbols to begin with a lowercase letter, so as
- to lexically distinguish them from terminal symbols, which must
- begin with an uppercase letter. However, for compatibility with
- ocamlyacc, this is impossible. It can be required only for
- nonterminal symbols that are also start symbols. */
-
-symbol:
- id = LID
-| id = UID
- { id }
-
-/* ------------------------------------------------------------------------- */
-/* Terminals must begin with an uppercase letter. Nonterminals that are
- declared to be start symbols must begin with a lowercase letter. */
-
-%inline terminal:
- id = UID
- { id }
-
-%inline nonterminal:
- id = LID
- { id }
-
-/* ------------------------------------------------------------------------- */
-/* A rule defines a symbol. It is optionally declared %public, and optionally
- carries a number of formal parameters. The right-hand side of the definition
- consists of a list of productions. */
-
-rule:
- flags = flags /* flags */
- symbol = symbol /* the symbol that is being defined */
- params = plist(symbol) /* formal parameters */
- COLON optional_bar
- prods = separated_nonempty_list(BAR, production_group) /* productions */
- {
- let public, inline = flags in
- [
- {
- pr_public_flag = public;
- pr_inline_flag = inline;
- pr_nt = Positions.value symbol;
- pr_positions = [ Positions.position symbol ];
- pr_parameters = List.map Positions.value params;
- pr_branches = List.flatten prods
- }
- ]
- }
-| error
- /* This error production should lead to resynchronization on the next
- well-formed rule. */
- { if $previouserror >= 3 then
- Error.signal (Positions.two $startpos $endpos) "Syntax error inside the definition of a nonterminal symbol.";
- [] }
-
-flags:
- /* epsilon */
- { false, false }
-| PUBLIC
- { true, false }
-| INLINE
- { false, true }
-| PUBLIC INLINE
-| INLINE PUBLIC
- { true, true }
-
-optional_bar:
- /* epsilon */ %prec no_optional_bar
-| BAR
- { () }
-
-/* ------------------------------------------------------------------------- */
-/* A production group consists of a list of productions, followed by a
- semantic action and an optional precedence specification. */
-
-production_group:
- productions = separated_nonempty_list(BAR, production)
- action = ACTION
- oprec2 = precedence?
- {
- ParserAux.check_production_group
- productions
- $startpos(action) $endpos(action) action;
-
- List.map (fun (producers, oprec1, rprec, pos) -> {
- pr_producers = producers;
- pr_action = action;
- pr_branch_shift_precedence = ParserAux.override pos oprec1 oprec2;
- pr_branch_reduce_precedence = rprec;
- pr_branch_position = pos
- }) productions
- }
-| error ACTION precedence?
-| error EOF
- /* This error production should lead to resynchronization on the next
- semantic action, unless the end of file is reached before a semantic
- action is found. */
- { if $previouserror >= 3 then
- Error.signal (Positions.two $startpos($1) $endpos($1)) "Syntax error inside a production.";
- [] }
-
-%inline precedence:
- PREC symbol = symbol
- { symbol }
-
-/* ------------------------------------------------------------------------- */
-/* A production is a list of producers, optionally followed by a
- precedence declaration. */
-
-production:
- producers = producer* oprec = precedence?
- { producers,
- oprec,
- ParserAux.current_reduce_precedence(),
- Positions.lex_join $startpos $endpos
- }
-
-/* ------------------------------------------------------------------------- */
-/* A producer is an actual parameter, possibly preceded by a
- binding.
-
- Because both [ioption] and [terminated] are defined as inlined by
- the standard library, this definition expands to two productions,
- one of which begins with id = LID, the other of which begins with
- p = actual_parameter. The token LID is in FIRST(actual_parameter),
- but the LR(1) formalism can deal with that. If [option] was used
- instead of [ioption], an LR(1) conflict would arise -- looking
- ahead at LID would not allow determining whether to reduce an
- empty [option] or to shift. */
-
-producer:
-| id = ioption(terminated(LID, EQUAL)) p = actual_parameter
- { id, p }
-
-/* ------------------------------------------------------------------------- */
-/* The syntax of actual parameters allows applications, whereas the syntax
- of formal parameters does not. It also allows use of the "?", "+", and
- "*" shortcuts. */
-
-actual_parameter:
- symbol = symbol actuals = plist(actual_parameter) modifier = modifier?
- { Parameters.oapp1 modifier (Parameters.app symbol actuals) }
-
-/* ------------------------------------------------------------------------- */
-/* Formal or actual parameter lists are delimited with parentheses and
- separated with commas. They are optional. */
-
-%inline plist(X):
- params = loption(delimited(LPAREN, separated_nonempty_list(COMMA, X), RPAREN))
- { params }
-
-/* ------------------------------------------------------------------------- */
-/* The "?", "+", and "*" modifiers are short-hands for applications of
- certain parameterized nonterminals, defined in the standard library. */
-
-modifier:
- QUESTION
- { with_poss $startpos $endpos "option" }
-| PLUS
- { with_poss $startpos $endpos "nonempty_list" }
-| STAR
- { with_poss $startpos $endpos "list" }
-
-/* ------------------------------------------------------------------------- */
-/* A trailer is announced by %%, but is optional. */
-
-trailer:
- EOF
- { None }
-| p = PERCENTPERCENT /* followed by actual trailer */
- { Some (Lazy.force p) }
-
-%%
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* Start where [PreFront] left off. *)
-
-let grammar =
- PreFront.grammar
-
-(* Perform reachability analysis. *)
-
-let grammar =
- Reachability.trim grammar
-
-let () =
- Time.tick "Trimming"
-
-(* If [--depend] was specified on the command line, perform
- dependency analysis and stop. *)
-
-let () =
- match Settings.depend with
- | Settings.OMRaw
- | Settings.OMPostprocess ->
- Infer.depend grammar (* never returns *)
- | Settings.OMNone ->
- ()
-
-(* If [--infer] was specified on the command line, perform
- type inference and stop. *)
-
-let grammar =
- if Settings.infer then
- let grammar = Infer.infer grammar in
- Time.tick "Inferring types for nonterminals";
- grammar
- else
- grammar
-
-(* If [--no-inline] was specified on the command line, skip the
- inlining of non terminal definitions marked with %inline. *)
-
-let grammar =
- if Settings.inline then begin
- let grammar, inlined =
- NonTerminalDefinitionInlining.inline grammar
- in
- if not Settings.infer && inlined && not Settings.coq then
- Error.warning []
- "you are using the standard library and/or the %inline keyword. We\n\
- recommend switching on --infer in order to avoid obscure type error messages.";
- Time.tick "Inlining";
- grammar
- end
- else
- grammar
-
-(* If [--only-preprocess] or [--only-preprocess-drop] was specified on the
- command line, print the grammar and stop. Otherwise, continue. *)
-
-let () =
- match Settings.preprocess_mode with
- | Settings.PMOnlyPreprocess mode ->
- UnparameterizedPrinter.print mode stdout grammar;
- exit 0
- | Settings.PMNormal ->
- ()
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module drives the second half of the front-end. It starts
- where [PreFront] left off, and performs type inference. This yields
- the grammar that the back-end works with (through the interface
- provided by module [Grammar]). *)
-
-val grammar: UnparameterizedSyntax.grammar
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-module type S = sig
-
- (* Keys are assumed to have a natural total order. *)
-
- type key
-
- (* The type of maps whose data have type ['a]. *)
-
- type 'a t
-
- (* The empty map. *)
-
- val empty: 'a t
-
- (* [lookup k m] looks up the value associated to the key [k] in the
- map [m], and raises [Not_found] if no value is bound to [k]. *)
-
- val lookup: key -> 'a t -> 'a
- val find: key -> 'a t -> 'a
-
- (* [add k d m] returns a map whose bindings are all bindings in [m],
- plus a binding of the key [k] to the datum [d]. If a binding
- already exists for [k], it is overridden. *)
-
- val add: key -> 'a -> 'a t -> 'a t
-
- (* [strict_add k d m] returns a map whose bindings are all bindings
- in [m], plus a binding of the key [k] to the datum [d]. If a
- binding already exists for [k] then [Unchanged] is raised. *)
-
- exception Unchanged
-
- val strict_add: key -> 'a -> 'a t -> 'a t
-
- (* [fine_add decide k d m] returns a map whose bindings are all
- bindings in [m], plus a binding of the key [k] to the datum
- [d]. If a binding from [k] to [d0] already exists, then the
- resulting map contains a binding from [k] to [decide d0 d]. *)
-
- type 'a decision = 'a -> 'a -> 'a
-
- val fine_add: 'a decision -> key -> 'a -> 'a t -> 'a t
-
- (* [mem k m] tells whether the key [k] appears in the domain of the
- map [m]. *)
-
- val mem: key -> 'a t -> bool
-
- (* [singleton k d] returns a map whose only binding is from [k] to [d]. *)
-
- val singleton: key -> 'a -> 'a t
-
- (* [is_empty m] returns [true] if and only if the map [m] defines no
- bindings at all. *)
-
- val is_empty: 'a t -> bool
-
- (* [is_singleton s] returns [Some x] if [s] is a singleton
- containing [x] as its only element; otherwise, it returns
- [None]. *)
-
- val is_singleton: 'a t -> (key * 'a) option
-
- (* [cardinal m] returns [m]'s cardinal, that is, the number of keys
- it binds, or, in other words, the cardinal of its domain. *)
-
- val cardinal: 'a t -> int
-
- (* [choose m] returns an arbitrarily chosen binding in [m], if [m]
- is nonempty, and raises [Not_found] otherwise. *)
-
- val choose: 'a t -> key * 'a
-
- (* [lookup_and_remove k m] looks up the value [v] associated to the
- key [k] in the map [m], and raises [Not_found] if no value is
- bound to [k]. The call returns the value [v], together with the
- map [m] deprived from the binding from [k] to [v]. *)
-
- val lookup_and_remove: key -> 'a t -> 'a * 'a t
- val find_and_remove: key -> 'a t -> 'a * 'a t
-
- (* [remove k m] is the map [m] deprived from any binding for [k]. *)
-
- val remove: key -> 'a t -> 'a t
-
- (* [union m1 m2] returns the union of the maps [m1] and
- [m2]. Bindings in [m2] take precedence over those in [m1]. *)
-
- val union: 'a t -> 'a t -> 'a t
-
- (* [fine_union decide m1 m2] returns the union of the maps [m1] and
- [m2]. If a key [k] is bound to [x1] (resp. [x2]) within [m1]
- (resp. [m2]), then [decide] is called. It is passed [x1] and
- [x2], and must return the value that shall be bound to [k] in the
- final map. *)
-
- val fine_union: 'a decision -> 'a t -> 'a t -> 'a t
-
- (* [iter f m] invokes [f k x], in turn, for each binding from key
- [k] to element [x] in the map [m]. Keys are presented to [f] in
- increasing order. *)
-
- val iter: (key -> 'a -> unit) -> 'a t -> unit
-
- (* [fold f m seed] invokes [f k d accu], in turn, for each binding
- from key [k] to datum [d] in the map [m]. Keys are presented to
- [f] in increasing order. The initial value of [accu] is [seed];
- then, at each new call, its value is the value returned by the
- previous invocation of [f]. The value returned by [fold] is the
- final value of [accu]. *)
-
- val fold: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-
- (* [fold_rev] performs exactly the same job as [fold], but presents
- keys to [f] in the opposite order. *)
-
- val fold_rev: (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
-
- (* It is valid to evaluate [iter2 f m1 m2] if and only if [m1] and
- [m2] have equal domains. Doing so invokes [f k x1 x2], in turn,
- for each key [k] bound to [x1] in [m1] and to [x2] in
- [m2]. Bindings are presented to [f] in increasing order. *)
-
- val iter2: (key -> 'a -> 'b -> unit) -> 'a t -> 'b t -> unit
-
- (* [map f m] returns the map obtained by composing the map [m] with
- the function [f]; that is, the map $k\mapsto f(m(k))$. *)
-
- val map: ('a -> 'b) -> 'a t -> 'b t
-
- (* [endo_map] is similar to [map], but attempts to physically share
- its result with its input. This saves memory when [f] is the
- identity function. *)
-
- val endo_map: ('a -> 'a) -> 'a t -> 'a t
-
- (* If [dcompare] is an ordering over data, then [compare dcompare]
- is an ordering over maps. *)
-
- val compare: ('a -> 'a -> int) -> 'a t -> 'a t -> int
-
- (* A map's domain is a set. Thus, to be able to perform operations
- on domains, we need set operations, provided by the [Domain]
- sub-module. The two-way connection between maps and their domains
- is given by two additional functions, [domain] and
- [lift]. [domain m] returns [m]'s domain. [lift f s] returns the
- map $k\mapsto f(k)$, where $k$ ranges over a set of keys [s]. *)
-
- module Domain : GSet.S with type element = key
-
- val domain: 'a t -> Domain.t
- val lift: (key -> 'a) -> Domain.t -> 'a t
-
- (* [corestrict m d] performs a co-restriction of the map [m] to the
- domain [d]. That is, it returns the map $k\mapsto m(k)$, where
- $k$ ranges over all keys bound in [m] but \emph{not} present in
- [d]. *)
-
- val corestrict: 'a t -> Domain.t -> 'a t
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This is a stripped down version of [GSet] that describes both [Patricia]
- and [CompressedBitSet]. The full version of [GSet] is in [AlphaLib]. *)
-
-module type S = sig
-
- (* Elements are assumed to have a natural total order. *)
-
- type element
-
- (* Sets. *)
-
- type t
-
- (* The empty set. *)
-
- val empty: t
-
- (* [is_empty s] tells whether [s] is the empty set. *)
-
- val is_empty: t -> bool
-
- (* [singleton x] returns a singleton set containing [x] as its only
- element. *)
-
- val singleton: element -> t
-
- (* [cardinal s] returns the cardinal of [s]. *)
-
- val cardinal: t -> int
-
- (* [choose s] returns an arbitrarily chosen element of [s], if [s]
- is nonempty, and raises [Not_found] otherwise. *)
-
- val choose: t -> element
-
- (* [mem x s] returns [true] if and only if [x] appears in the set
- [s]. *)
-
- val mem: element -> t -> bool
-
- (* [add x s] returns a set whose elements are all elements of [s],
- plus [x]. *)
-
- val add: element -> t -> t
-
- (* [remove x s] returns a set whose elements are all elements of
- [s], except [x]. *)
-
- val remove: element -> t -> t
-
- (* [union s1 s2] returns the union of the sets [s1] and [s2]. *)
-
- val union: t -> t -> t
-
- (* [inter s t] returns the set intersection of [s] and [t], that is,
- $s\cap t$. *)
-
- val inter: t -> t -> t
-
- (* [disjoint s1 s2] returns [true] if and only if the sets [s1] and
- [s2] are disjoint, i.e. iff their intersection is empty. *)
-
- val disjoint: t -> t -> bool
-
- (* [iter f s] invokes [f x], in turn, for each element [x] of the
- set [s]. Elements are presented to [f] in increasing order. *)
-
- val iter: (element -> unit) -> t -> unit
-
- (* [fold f s seed] invokes [f x accu], in turn, for each element [x]
- of the set [s]. Elements are presented to [f] in increasing
- order. The initial value of [accu] is [seed]; then, at each new
- call, its value is the value returned by the previous invocation
- of [f]. The value returned by [fold] is the final value of
- [accu]. In other words, if $s = \{ x_1, x_2, \ldots, x_n \}$,
- where $x_1 < x_2 < \ldots < x_n$, then [fold f s seed] computes
- $([f]\,x_n\,\ldots\,([f]\,x_2\,([f]\,x_1\,[seed]))\ldots)$. *)
-
- val fold: (element -> 'b -> 'b) -> t -> 'b -> 'b
-
- (* [elements s] is a list of all elements in the set [s]. *)
-
- val elements: t -> element list
-
- (* [compare] is an ordering over sets. *)
-
- val compare: t -> t -> int
-
- (* [equal] implements equality over sets. *)
-
- val equal: t -> t -> bool
-
- (* [subset] implements the subset predicate over sets. *)
-
- val subset: (t -> t -> bool)
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open UnparameterizedSyntax
-open Syntax
-open Stretch
-open Positions
-
-(* ------------------------------------------------------------------------ *)
-(* Precedence levels for tokens or pseudo-tokens alike. *)
-
-module TokPrecedence = struct
-
- (* This set records, on a token by token basis, whether the token's
- precedence level is ever useful. This allows emitting warnings
- about useless precedence declarations. *)
-
- let ever_useful : StringSet.t ref =
- ref StringSet.empty
-
- let use id =
- ever_useful := StringSet.add id !ever_useful
-
- (* This function is invoked when someone wants to consult a token's
- precedence level. This does not yet mean that this level is
- useful, though. Indeed, if it is subsequently compared against
- [UndefinedPrecedence], it will not allow solving a conflict. So,
- in addition to the desired precedence level, we return a delayed
- computation which, when evaluated, records that this precedence
- level was useful. *)
-
- let levelip id properties =
- lazy (use id), properties.tk_priority
-
- let leveli id =
- let properties =
- try
- StringMap.find id Front.grammar.tokens
- with Not_found ->
- assert false (* well-formedness check has been performed earlier *)
- in
- levelip id properties
-
- (* This function is invoked after the automaton has been constructed.
- It warns about unused precedence levels. *)
-
- let diagnostics () =
- StringMap.iter (fun id properties ->
- if not (StringSet.mem id !ever_useful) then
- match properties.tk_priority with
- | UndefinedPrecedence ->
- ()
- | PrecedenceLevel (_, _, pos1, pos2) ->
- Error.grammar_warning (Positions.two pos1 pos2)
- (Printf.sprintf "the precedence level assigned to %s is never useful." id)
- ) Front.grammar.tokens
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Nonterminals. *)
-
-module Nonterminal = struct
-
- type t = int
-
- let n2i i = i
-
- let compare = (-)
-
- (* Determine how many nonterminals we have and build mappings
- both ways between names and indices. A new nonterminal is
- created for every start symbol. *)
-
- let new_start_nonterminals =
- StringSet.fold (fun symbol ss -> (symbol ^ "'") :: ss) Front.grammar.start_symbols []
-
- let original_nonterminals =
- StringMap.fold (fun nt _ rules -> nt :: rules) Front.grammar.rules []
-
- let start =
- List.length new_start_nonterminals
-
- let (n : int), (name : string array), (map : int StringMap.t) =
- Misc.index (new_start_nonterminals @ original_nonterminals)
-
- let () =
- Error.logG 1 (fun f ->
- Printf.fprintf f
- "Grammar has %d nonterminal symbols, among which %d start symbols.\n"
- (n - start) start
- )
-
- let is_start nt =
- nt < start
-
- let print normalize nt =
- if normalize then
- Misc.normalize name.(nt)
- else
- name.(nt)
-
- let lookup name =
- StringMap.find name map
-
- let positions nt =
- (StringMap.find (print false nt) Front.grammar.rules).positions
-
- let iter f =
- Misc.iteri n f
-
- let fold f accu =
- Misc.foldi n f accu
-
- let map f =
- Misc.mapi n f
-
- let iterx f =
- for nt = start to n - 1 do
- f nt
- done
-
- let foldx f accu =
- Misc.foldij start n f accu
-
- let ocamltype nt =
- assert (not (is_start nt));
- try
- Some (StringMap.find (print false nt) Front.grammar.types)
- with Not_found ->
- None
-
- let tabulate f =
- Array.get (Array.init n f)
-
-end
-
-(* Sets and maps over nonterminals, used only below. *)
-
-module NonterminalMap = Patricia.Big
-
-module NonterminalSet = Patricia.Big.Domain
-
-(* ------------------------------------------------------------------------ *)
-(* Terminals. *)
-
-module Terminal = struct
-
- type t = int
-
- let t2i i = i
-
- let compare = (-)
-
- let equal (tok1 : t) (tok2 : t) =
- tok1 = tok2
-
- (* Determine how many terminals we have and build mappings
- both ways between names and indices. A new terminal "#"
- is created. A new terminal "error" is created. The fact
- that the integer code assigned to the "error" pseudo-terminal
- is the last one is exploited in the table-based back-end.
-
- Pseudo-tokens (used in %prec declarations, but never
- declared using %token) are filtered out. *)
-
- let (n : int), (name : string array), (map : int StringMap.t) =
- let tokens =
- StringMap.fold (fun token properties tokens ->
- if properties.tk_is_declared then token :: tokens else tokens
- ) Front.grammar.tokens []
- in
- match tokens with
- | [] ->
- Error.error [] "no tokens have been declared."
- | _ ->
- Misc.index ("error" :: tokens @ [ "#" ])
-
- let print tok =
- name.(tok)
-
- let lookup name =
- StringMap.find name map
-
- let sharp =
- lookup "#"
-
- let error =
- lookup "error"
-
- let pseudo tok =
- (tok = sharp) || (tok = error)
-
- let token_properties =
- let not_so_dummy_properties = (* applicable to [error] and [#] *)
- {
- tk_filename = "__primitives__";
- tk_priority = UndefinedPrecedence;
- tk_associativity = UndefinedAssoc;
- tk_ocamltype = None;
- tk_is_declared = true;
- tk_position = Positions.dummy;
- }
- in
- Array.init n (fun tok ->
- try
- StringMap.find name.(tok) Front.grammar.tokens
- with Not_found ->
- assert (tok = sharp || tok = error);
- not_so_dummy_properties
- )
-
- let () =
- Error.logG 1 (fun f ->
- Printf.fprintf f "Grammar has %d terminal symbols.\n" (n - 2)
- )
-
- let precedence_level tok =
- TokPrecedence.levelip (print tok) token_properties.(tok)
-
- let associativity tok =
- token_properties.(tok).tk_associativity
-
- let ocamltype tok =
- token_properties.(tok).tk_ocamltype
-
- let iter f =
- Misc.iteri n f
-
- let fold f accu =
- Misc.foldi n f accu
-
- let map f =
- Misc.mapi n f
-
- let mapx f =
- assert (sharp = n - 1);
- Misc.mapi (n-1) f
-
- (* If a token named [EOF] exists, then it is assumed to represent
- ocamllex's [eof] pattern, which means that the lexer may
- eventually produce an infinite stream of [EOF] tokens. This,
- combined with our error recovery mechanism, may lead to
- non-termination. We provide a warning against this somewhat
- obscure situation.
-
- Relying on the token's name is somewhat fragile, but this saves
- introducing an extra keyword for declaring which token represents
- [eof], and should not introduce much confusion. *)
-
- let eof =
- try
- Some (lookup "EOF")
- with Not_found ->
- None
-
-end
-
-(* Sets of terminals are used intensively in the LR(1) construction,
- so it is important that they be as efficient as possible. *)
-
-module TerminalSet = struct
-
- include CompressedBitSet
-
- let print toks =
- let _, accu =
- fold (fun tok (first, accu) ->
- false,
- if first then
- accu ^ (Terminal.print tok)
- else
- accu ^ " " ^ (Terminal.print tok)
- ) toks (true, "") in
- accu
-
- let universe =
- remove Terminal.sharp (
- remove Terminal.error (
- Terminal.fold add empty
- )
- )
-
-end
-
-(* Maps over terminals. *)
-
-module TerminalMap = Patricia.Big
-
-(* ------------------------------------------------------------------------ *)
-(* Symbols. *)
-
-module Symbol = struct
-
- type t =
- | N of Nonterminal.t
- | T of Terminal.t
-
- let compare sym1 sym2 =
- match sym1, sym2 with
- | N nt1, N nt2 ->
- Nonterminal.compare nt1 nt2
- | T tok1, T tok2 ->
- Terminal.compare tok1 tok2
- | N _, T _ ->
- 1
- | T _, N _ ->
- -1
-
- let equal sym1 sym2 =
- compare sym1 sym2 = 0
-
- let rec lequal syms1 syms2 =
- match syms1, syms2 with
- | [], [] ->
- true
- | sym1 :: syms1, sym2 :: syms2 ->
- equal sym1 sym2 && lequal syms1 syms2
- | _ :: _, []
- | [], _ :: _ ->
- false
-
- let print = function
- | N nt ->
- Nonterminal.print false nt
- | T tok ->
- Terminal.print tok
-
- let nonterminal = function
- | T _ ->
- false
- | N _ ->
- true
-
- (* Printing an array of symbols. [offset] is the start offset -- we
- print everything to its right. [dot] is the dot offset -- we
- print a dot at this offset, if we find it. *)
-
- let printaod offset dot symbols =
- let buffer = Buffer.create 512 in
- let length = Array.length symbols in
- for i = offset to length do
- if i = dot then
- Buffer.add_string buffer ". ";
- if i < length then begin
- Buffer.add_string buffer (print symbols.(i));
- Buffer.add_char buffer ' '
- end
- done;
- Buffer.contents buffer
-
- let printao offset symbols =
- printaod offset (-1) symbols
-
- let printa symbols =
- printao 0 symbols
-
- let printl symbols =
- printa (Array.of_list symbols)
-
- let lookup name =
- try
- T (Terminal.lookup name)
- with Not_found ->
- try
- N (Nonterminal.lookup name)
- with Not_found ->
- assert false (* well-formedness check has been performed earlier *)
-
-end
-
-(* Sets of symbols. *)
-
-module SymbolSet = Set.Make(Symbol)
-
-(* Maps over symbols. *)
-
-module SymbolMap = struct
-
- include Map.Make(Symbol)
-
- let domain m =
- fold (fun symbol _ accu ->
- symbol :: accu
- ) m []
-
- let purelynonterminal m =
- fold (fun symbol _ accu ->
- accu && Symbol.nonterminal symbol
- ) m true
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Productions. *)
-
-module Production = struct
-
- type index =
- int
-
- (* Create an array of productions. Record which productions are
- associated with every nonterminal. A new production S' -> S
- is created for every start symbol S. It is known as a
- start production. *)
-
- let n : int =
- let n = StringMap.fold (fun _ { branches = branches } n ->
- n + List.length branches
- ) Front.grammar.rules 0 in
- Error.logG 1 (fun f -> Printf.fprintf f "Grammar has %d productions.\n" n);
- n + StringSet.cardinal Front.grammar.start_symbols
-
- let p2i prod =
- prod
-
- let i2p prod =
- assert (prod >= 0 && prod < n);
- prod
-
- let table : (Nonterminal.t * Symbol.t array) array =
- Array.make n (-1, [||])
-
- let identifiers : identifier array array =
- Array.make n [||]
-
- let used : bool array array =
- Array.make n [||]
-
- let actions : action option array =
- Array.make n None
-
- let ntprods : (int * int) array =
- Array.make Nonterminal.n (-1, -1)
-
- let positions : Positions.t list array =
- Array.make n []
-
- let (start : int),
- (startprods : index NonterminalMap.t) =
- StringSet.fold (fun nonterminal (k, startprods) ->
- let nt = Nonterminal.lookup nonterminal
- and nt' = Nonterminal.lookup (nonterminal ^ "'") in
- table.(k) <- (nt', [| Symbol.N nt |]);
- identifiers.(k) <- [| "_1" |];
- used.(k) <- [| true |];
- ntprods.(nt') <- (k, k+1);
- positions.(k) <- Nonterminal.positions nt;
- k+1,
- NonterminalMap.add nt k startprods
- ) Front.grammar.start_symbols (0, NonterminalMap.empty)
-
- let prec_decl : symbol located option array =
- Array.make n None
-
- let reduce_precedence : precedence_level array =
- Array.make n UndefinedPrecedence
-
- let (_ : int) = StringMap.fold (fun nonterminal { branches = branches } k ->
- let nt = Nonterminal.lookup nonterminal in
- let k' = List.fold_left (fun k branch ->
- let action = branch.action
- and sprec = branch.branch_shift_precedence
- and rprec = branch.branch_reduce_precedence in
- let symbols = Array.of_list branch.producers in
- table.(k) <- (nt, Array.map (fun (v, _) -> Symbol.lookup v) symbols);
- identifiers.(k) <- Array.mapi (fun i (_, ido) ->
- match ido with
- | None ->
- (* Symbols for which no name was chosen will be represented
- by variables named _1, _2, etc. *)
- Printf.sprintf "_%d" (i + 1)
- | Some id ->
- (* Symbols for which a name was explicitly chosen will be
- known by that name in semantic actions. *)
- id
- ) symbols;
- used.(k) <- Array.mapi (fun i (_, ido) ->
- match ido with
- | None ->
- (* A symbol referred to as [$i] is used if and only if the
- [$i] keyword appears in the semantic action. *)
- Action.has_dollar (i + 1) action
- | Some _ ->
- (* A symbol referred to via a name is considered used.
- This is a conservative approximation. *)
- true
- ) symbols;
- actions.(k) <- Some action;
- reduce_precedence.(k) <- rprec;
- prec_decl.(k) <- sprec;
- positions.(k) <- [ branch.branch_position ];
- k+1
- ) k branches in
- ntprods.(nt) <- (k, k');
- k'
- ) Front.grammar.rules start
-
- (* Iteration over the productions associated with a specific
- nonterminal. *)
-
- let iternt nt f =
- let k, k' = ntprods.(nt) in
- for prod = k to k' - 1 do
- f prod
- done
-
- let foldnt (nt : Nonterminal.t) (accu : 'a) (f : index -> 'a -> 'a) : 'a =
- let k, k' = ntprods.(nt) in
- let rec loop accu prod =
- if prod < k' then
- loop (f prod accu) (prod + 1)
- else
- accu
- in
- loop accu k
-
- (* Accessors. *)
-
- let def prod =
- table.(prod)
-
- let nt prod =
- let nt, _ = table.(prod) in
- nt
-
- let rhs prod =
- let _, rhs = table.(prod) in
- rhs
-
- let length prod =
- Array.length (rhs prod)
-
- let identifiers prod =
- identifiers.(prod)
-
- let used prod =
- used.(prod)
-
- let is_start prod =
- prod < start
-
- let classify prod =
- if is_start prod then
- match (rhs prod).(0) with
- | Symbol.N nt ->
- Some nt
- | Symbol.T _ ->
- assert false
- else
- None
-
- let action prod =
- match actions.(prod) with
- | Some action ->
- action
- | None ->
- (* Start productions have no action. *)
- assert (is_start prod);
- assert false
-
- let positions prod =
- positions.(prod)
-
- let startsymbol2startprod nt =
- try
- NonterminalMap.find nt startprods
- with Not_found ->
- assert false (* [nt] is not a start symbol *)
-
- (* Iteration. *)
-
- let iter f =
- Misc.iteri n f
-
- let fold f accu =
- Misc.foldi n f accu
-
- let map f =
- Misc.mapi n f
-
- let iterx f =
- for prod = start to n - 1 do
- f prod
- done
-
- let foldx f accu =
- Misc.foldij start n f accu
-
- (* Printing a production. *)
-
- let print prod =
- assert (not (is_start prod));
- let nt, rhs = table.(prod) in
- Printf.sprintf "%s -> %s" (Nonterminal.print false nt) (Symbol.printao 0 rhs)
-
- (* Tabulation. *)
-
- let tabulate f =
- Misc.tabulateb n f
-
- (* This array allows recording, on a production by production basis,
- whether the production's shift precedence is ever useful. This
- allows emitting warnings about useless %prec declarations. *)
-
- let prec_decl_ever_useful =
- Array.make n false
-
- let consult_prec_decl prod =
- lazy (prec_decl_ever_useful.(prod) <- true),
- prec_decl.(prod)
-
- let diagnostics () =
- iterx (fun prod ->
- if not prec_decl_ever_useful.(prod) then
- match prec_decl.(prod) with
- | None ->
- ()
- | Some id ->
- Error.grammar_warning [Positions.position id] "this %prec declaration is never useful."
- )
-
- (* Determining the precedence level of a production. If no %prec
- declaration was explicitly supplied, it is the precedence level
- of the rightmost terminal symbol in the production's right-hand
- side. *)
-
- type production_level =
- | PNone
- | PRightmostToken of Terminal.t
- | PPrecDecl of symbol
-
- let rightmost_terminal prod =
- Array.fold_left (fun accu symbol ->
- match symbol with
- | Symbol.T tok ->
- PRightmostToken tok
- | Symbol.N _ ->
- accu
- ) PNone (rhs prod)
-
- let combine e1 e2 =
- lazy (Lazy.force e1; Lazy.force e2)
-
- let shift_precedence prod =
- let fact1, prec_decl = consult_prec_decl prod in
- let oterminal =
- match prec_decl with
- | None ->
- rightmost_terminal prod
- | Some { value = terminal } ->
- PPrecDecl terminal
- in
- match oterminal with
- | PNone ->
- fact1, UndefinedPrecedence
- | PRightmostToken tok ->
- let fact2, level = Terminal.precedence_level tok in
- combine fact1 fact2, level
- | PPrecDecl id ->
- let fact2, level = TokPrecedence.leveli id in
- combine fact1 fact2, level
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Maps over productions. *)
-
-module ProductionMap = struct
-
- include Patricia.Big
-
- (* Iteration over the start productions only. *)
-
- let start f =
- Misc.foldi Production.start (fun prod m ->
- add prod (f prod) m
- ) empty
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Build the grammar's forward and backward reference graphs.
-
- In the backward reference graph, edges relate each nonterminal [nt]
- to each of the nonterminals whose definition mentions [nt]. The
- reverse reference graph is used in the computation of the nullable,
- nonempty, and FIRST sets.
-
- The forward reference graph is unused but can be printed on demand. *)
-
-let forward : NonterminalSet.t array =
- Array.create Nonterminal.n NonterminalSet.empty
-
-let backward : NonterminalSet.t array =
- Array.create Nonterminal.n NonterminalSet.empty
-
-let () =
- Array.iter (fun (nt1, rhs) ->
- Array.iter (function
- | Symbol.T _ ->
- ()
- | Symbol.N nt2 ->
- forward.(nt1) <- NonterminalSet.add nt2 forward.(nt1);
- backward.(nt2) <- NonterminalSet.add nt1 backward.(nt2)
- ) rhs
- ) Production.table
-
-(* ------------------------------------------------------------------------ *)
-(* If requested, dump the forward reference graph. *)
-
-let () =
- if Settings.graph then
- let module P = Dot.Print (struct
- type vertex = Nonterminal.t
- let name nt =
- Printf.sprintf "nt%d" nt
- let successors (f : ?style:Dot.style -> label:string -> vertex -> unit) nt =
- NonterminalSet.iter (fun successor ->
- f ~label:"" successor
- ) forward.(nt)
- let iter (f : ?style:Dot.style -> label:string -> vertex -> unit) =
- Nonterminal.iter (fun nt ->
- f ~label:(Nonterminal.print false nt) nt
- )
- end) in
- let f = open_out (Settings.base ^ ".dot") in
- P.print f;
- close_out f
-
-(* ------------------------------------------------------------------------ *)
-(* Generic support for fixpoint computations.
-
- A fixpoint computation associates a property with every nonterminal.
- A monotone function tells how properties are computed. [compute nt]
- updates the property associated with nonterminal [nt] and returns a
- flag that tells whether the property actually needed an update. The
- state of the computation is maintained entirely inside [compute] and
- is invisible here.
-
- Whenever a property of [nt] is updated, the properties of the
- terminals whose definitions depend on [nt] are updated. The
- dependency graph must be explicitly supplied. *)
-
-let fixpoint (dependencies : NonterminalSet.t array) (compute : Nonterminal.t -> bool) : unit =
- let queue : Nonterminal.t Queue.t = Queue.create () in
- let onqueue : bool array = Array.make Nonterminal.n true in
- for i = 0 to Nonterminal.n - 1 do
- Queue.add i queue
- done;
- Misc.qiter (fun nt ->
- onqueue.(nt) <- false;
- let changed = compute nt in
- if changed then
- NonterminalSet.iter (fun nt ->
- if not onqueue.(nt) then begin
- Queue.add nt queue;
- onqueue.(nt) <- true
- end
- ) dependencies.(nt)
- ) queue
-
-(* ------------------------------------------------------------------------ *)
-(* Compute which nonterminals are nonempty, that is, recognize a
- nonempty language. Also, compute which nonterminals are
- nullable. The two computations are almost identical. The only
- difference is in the base case: a single terminal symbol is not
- nullable, but is nonempty. *)
-
-let compute (basecase : bool) : (bool array) * (Symbol.t -> bool) =
- let property : bool array =
- Array.make Nonterminal.n false
- in
- let symbol_has_property = function
- | Symbol.T _ ->
- basecase
- | Symbol.N nt ->
- property.(nt)
- in
- fixpoint backward (fun nt ->
- if property.(nt) then
- false (* no change *)
- else
- (* disjunction over all productions for this nonterminal *)
- let updated = Production.foldnt nt false (fun prod accu ->
- accu ||
- let rhs = Production.rhs prod in
- (* conjunction over all symbols in the right-hand side *)
- Array.fold_left (fun accu symbol ->
- accu && symbol_has_property symbol
- ) true rhs
- ) in
- property.(nt) <- updated;
- updated
- );
- property, symbol_has_property
-
-let () =
- let nonempty, _ = compute true in
- for nt = Nonterminal.start to Nonterminal.n - 1 do
- if not nonempty.(nt) then
- Error.grammar_warning
- (Nonterminal.positions nt)
- (Printf.sprintf "%s generates the empty language." (Nonterminal.print false nt))
- done
-
-let (nullable : bool array), (nullable_symbol : Symbol.t -> bool) =
- compute false
-
-(* ------------------------------------------------------------------------ *)
-(* Compute FIRST sets. *)
-
-let first =
- Array.make Nonterminal.n TerminalSet.empty
-
-let first_symbol = function
- | Symbol.T tok ->
- TerminalSet.singleton tok
- | Symbol.N nt ->
- first.(nt)
-
-let nullable_first_rhs (rhs : Symbol.t array) (i : int) : bool * TerminalSet.t =
- let length = Array.length rhs in
- assert (i <= length);
- let rec loop i toks =
- if i = length then
- true, toks
- else
- let symbol = rhs.(i) in
- let toks = TerminalSet.union (first_symbol symbol) toks in
- if nullable_symbol symbol then
- loop (i+1) toks
- else
- false, toks
- in
- loop i TerminalSet.empty
-
-let () =
- fixpoint backward (fun nt ->
- let original = first.(nt) in
- (* union over all productions for this nonterminal *)
- let updated = Production.foldnt nt TerminalSet.empty (fun prod accu ->
- let rhs = Production.rhs prod in
- let _, toks = nullable_first_rhs rhs 0 in
- TerminalSet.union toks accu
- ) in
- first.(nt) <- updated;
- TerminalSet.compare original updated <> 0
- )
-
-(* ------------------------------------------------------------------------ *)
-(* Dump the analysis results. *)
-
-let () =
- Error.logG 2 (fun f ->
- for nt = 0 to Nonterminal.n - 1 do
- Printf.fprintf f "nullable(%s) = %b\n"
- (Nonterminal.print false nt)
- nullable.(nt)
- done;
- for nt = 0 to Nonterminal.n - 1 do
- Printf.fprintf f "first(%s) = %s\n"
- (Nonterminal.print false nt)
- (TerminalSet.print first.(nt))
- done
- )
-
-let () =
- Time.tick "Analysis of the grammar"
-
-(* ------------------------------------------------------------------------ *)
-(* Compute FOLLOW sets. Unnecessary for us, but requested by a user. Also,
- this is useful for the SLR(1) test. Thus, we perform this analysis only
- on demand. *)
-
-let follow : TerminalSet.t array Lazy.t =
- lazy (
-
- let follow =
- Array.make Nonterminal.n TerminalSet.empty
-
- and forward : NonterminalSet.t array =
- Array.create Nonterminal.n NonterminalSet.empty
-
- and backward : NonterminalSet.t array =
- Array.create Nonterminal.n NonterminalSet.empty
-
- in
-
- (* Iterate over all productions. *)
- Array.iter (fun (nt1, rhs) ->
- (* Iterate over all nonterminal symbols [nt2] in the right-hand side. *)
- Array.iteri (fun i symbol ->
- match symbol with
- | Symbol.T _ ->
- ()
- | Symbol.N nt2 ->
- let nullable, first = nullable_first_rhs rhs (i+1) in
- (* The FIRST set of the remainder of the right-hand side
- contributes to the FOLLOW set of [nt2]. *)
- follow.(nt2) <- TerminalSet.union first follow.(nt2);
- (* If the remainder of the right-hand side is nullable,
- FOLLOW(nt1) contributes to FOLLOW(nt2). *)
- if nullable then begin
- forward.(nt1) <- NonterminalSet.add nt2 forward.(nt1);
- backward.(nt2) <- NonterminalSet.add nt1 backward.(nt2)
- end
- ) rhs
- ) Production.table;
-
- (* The fixpoint computation used here is not the most efficient
- algorithm -- one could do better by first collapsing the
- strongly connected components, then walking the graph in
- topological order. But this will do. *)
-
- fixpoint forward (fun nt ->
- let original = follow.(nt) in
- (* union over all contributors *)
- let updated = NonterminalSet.fold (fun nt' accu ->
- TerminalSet.union follow.(nt') accu
- ) backward.(nt) original in
- follow.(nt) <- updated;
- TerminalSet.compare original updated <> 0
- );
-
- follow
-
- )
-
-(* Define an accessor that triggers the computation of the FOLLOW sets
- if it has not been performed already. *)
-
-let follow nt =
- (Lazy.force follow).(nt)
-
-(* At log level 2, display the FOLLOW sets. *)
-
-let () =
- Error.logG 2 (fun f ->
- for nt = 0 to Nonterminal.n - 1 do
- Printf.fprintf f "follow(%s) = %s\n"
- (Nonterminal.print false nt)
- (TerminalSet.print (follow nt))
- done
- )
-
-(* ------------------------------------------------------------------------ *)
-(* Provide explanations about FIRST sets. *)
-
-(* The idea is to explain why a certain token appears in the FIRST set
- for a certain sequence of symbols. Such an explanation involves
- basic assertions of the form (i) symbol N is nullable and (ii) the
- token appears in the FIRST set for symbol N. We choose to take
- these basic facts for granted, instead of recursively explaining
- them, so as to keep explanations short. *)
-
-(* We first produce an explanation in abstract syntax, then
- convert it to a human-readable string. *)
-
-type explanation =
- | EObvious (* sequence begins with desired token *)
- | EFirst of Terminal.t * Nonterminal.t (* sequence begins with a nonterminal that produces desired token *)
- | ENullable of Symbol.t list * explanation (* sequence begins with a list of nullable symbols and ... *)
-
-let explain (tok : Terminal.t) (rhs : Symbol.t array) (i : int) =
- let length = Array.length rhs in
- let rec loop i =
- assert (i < length);
- let symbol = rhs.(i) in
- match symbol with
- | Symbol.T tok' ->
- assert (Terminal.equal tok tok');
- EObvious
- | Symbol.N nt ->
- if TerminalSet.mem tok first.(nt) then
- EFirst (tok, nt)
- else begin
- assert nullable.(nt);
- match loop (i + 1) with
- | ENullable (symbols, e) ->
- ENullable (symbol :: symbols, e)
- | e ->
- ENullable ([ symbol ], e)
- end
- in
- loop i
-
-let rec convert = function
- | EObvious ->
- ""
- | EFirst (tok, nt) ->
- Printf.sprintf "%s can begin with %s"
- (Nonterminal.print false nt)
- (Terminal.print tok)
- | ENullable (symbols, e) ->
- let e = convert e in
- Printf.sprintf "%scan vanish%s%s"
- (Symbol.printl symbols)
- (if e = "" then "" else " and ")
- e
-
-(* ------------------------------------------------------------------------ *)
-(* Package the analysis results. *)
-
-module Analysis = struct
-
- let nullable_first_rhs = nullable_first_rhs
-
- let explain_first_rhs (tok : Terminal.t) (rhs : Symbol.t array) (i : int) =
- convert (explain tok rhs i)
-
- let follow = follow
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Conflict resolution via precedences. *)
-
-module Precedence = struct
-
- type choice =
- | ChooseShift
- | ChooseReduce
- | ChooseNeither
- | DontKnow
-
- type order = Lt | Gt | Eq | Ic
-
- let precedence_order p1 p2 =
- match p1, p2 with
- | UndefinedPrecedence, _
- | _, UndefinedPrecedence ->
- Ic
-
- | PrecedenceLevel (m1, l1, _, _), PrecedenceLevel (m2, l2, _, _) ->
- if not (Mark.same m1 m2) then
- Ic
- else
- if l1 > l2 then
- Gt
- else if l1 < l2 then
- Lt
- else
- Eq
-
- let shift_reduce tok prod =
- let fact1, tokp = Terminal.precedence_level tok
- and fact2, prodp = Production.shift_precedence prod in
- match precedence_order tokp prodp with
-
- (* Our information is inconclusive. Drop [fact1] and [fact2],
- that is, do not record that this information was useful. *)
-
- | Ic ->
- DontKnow
-
- (* Our information is useful. Record that fact by evaluating
- [fact1] and [fact2]. *)
-
- | (Eq | Lt | Gt) as c ->
- Lazy.force fact1;
- Lazy.force fact2;
- match c with
-
- | Ic ->
- assert false (* already dispatched *)
-
- | Eq ->
- begin
- match Terminal.associativity tok with
- | LeftAssoc -> ChooseReduce
- | RightAssoc -> ChooseShift
- | NonAssoc -> ChooseNeither
- | _ -> assert false
- (* If [tok]'s precedence level is defined, then
- its associativity must be defined as well. *)
- end
-
- | Lt ->
- ChooseReduce
-
- | Gt ->
- ChooseShift
-
-
- let reduce_reduce prod1 prod2 =
- let rp1 = Production.reduce_precedence.(prod1)
- and rp2 = Production.reduce_precedence.(prod2) in
- match precedence_order rp1 rp2 with
- | Lt ->
- Some prod1
- | Gt ->
- Some prod2
- | Eq ->
- (* the order is strict except in presence of inlining:
- two branches can have the same precedence level when
- they come from an inlined one. *)
- None
- | Ic ->
- None
-
-end
-
-let diagnostics () =
- TokPrecedence.diagnostics();
- Production.diagnostics()
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module transforms [Front.grammar], an abstract syntax tree for
- the grammar, into an internal representation of the grammar that is
- more usable. *)
-
-(* ------------------------------------------------------------------------ *)
-(* Nonterminals. *)
-
-module Nonterminal : sig
-
- (* The type of nonterminals. *)
-
- type t
-
- (* The number of nonterminals. This includes the extra nonterminals
- that are internally generated for the grammar's entry points. *)
-
- val n: int
-
- (* [lookup] maps an identifier to a nonterminal, or raises [Not_found]. *)
-
- val lookup : string -> t
-
- (* Nonterminals can be converted to integers. This feature is
- exploited in the table-based back-end. *)
-
- val n2i: t -> int
-
- (* This produces a string representation of a nonterminal. It should
- in principle never be applied to one of the internally generated
- nonterminals, as we do not wish users to become aware of the
- existence of these extra nonterminals. However, we do sometimes
- violate this rule when it is difficult to do otherwise.
-
- The Boolean parameter tells whether the string representation
- should be normalized, that is, whether parentheses and commas
- should be eliminated. This is necessary if the string is intended
- for use as a valid nonterminal name or as a valid Objective Caml
- identifier. *)
-
- val print: bool -> t -> string
-
- (* This is the Objective Caml type associated with a nonterminal
- symbol. It is known only if a %type declaration was provided.
- This function is not applicable to the internally generated
- nonterminals. *)
-
- val ocamltype: t -> Stretch.ocamltype option
-
- (* Iteration over nonterminals. The order in which elements are
- examined, and the order of [map]'s output list, correspond to the
- numeric indices produced by [n2i] above. *)
-
- val iter: (t -> unit) -> unit
- val fold: (t -> 'a -> 'a) -> 'a -> 'a
- val map: (t -> 'a) -> 'a list
-
- (* Iteration over all nonterminals, except the start nonterminals. *)
-
- val iterx: (t -> unit) -> unit
- val foldx: (t -> 'a -> 'a) -> 'a -> 'a
-
- (* Tabulation of a function over nonterminals. *)
-
- val tabulate: (t -> 'a) -> (t -> 'a)
-
- (* [positions nt] is a list of the positions associated with the
- definition of [nt]. There can be more than one position because
- definitions can be split over multiple files. *)
-
- val positions: t -> Positions.t list
-
- (* This tells whether a non-terminal symbol is one of the start
- symbols. *)
-
- val is_start: t -> bool
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Terminals. *)
-
-module Terminal : sig
-
- (* The type of terminals. *)
-
- type t
-
- (* The number of terminals. This includes the two pseudo-tokens
- [#] and [error]. *)
-
- val n: int
-
- (* Comparison. *)
-
- val equal: t -> t -> bool
-
- (* [lookup] maps an identifier to a terminal, or raises [Not_found]. *)
-
- val lookup : string -> t
-
- (* Terminals can be converted to integers. This feature is exploited
- in the table-based back-end. *)
-
- val t2i: t -> int
-
- (* This produces a string representation of a terminal. *)
-
- val print: t -> string
-
- (* This is the Objective Caml type associated with a terminal
- symbol. It is known only if the %token declaration was
- accompanied with a type. *)
-
- val ocamltype: t -> Stretch.ocamltype option
-
- (* These are the two pseudo-tokens [#] and [error]. The former is
- used to denote the end of the token stream. The latter is
- accessible to the user and is used for handling errors. *)
-
- val sharp: t
- val error: t
-
- (* This is the programmer-defined [EOF] token, if there is one. It
- is recognized based solely on its name, which is fragile, but
- this behavior is documented. This token is assumed to represent
- [ocamllex]'s [eof] pattern. It is used only in emitting warnings
- in [--error-recovery] mode. *)
-
- val eof: t option
-
- (* This returns [true] if and only if the token at hand is one of
- [#] or [error]. *)
-
- val pseudo: t -> bool
-
- (* Iteration over terminals. The order in which elements are
- examined, and the order of [map]'s output list, correspond to the
- numeric indices produced by [t2i] above. [mapx] offers iteration
- over all terminals except [#]. *)
-
- val iter: (t -> unit) -> unit
- val fold: (t -> 'a -> 'a) -> 'a -> 'a
- val map: (t -> 'a) -> 'a list
- val mapx: (t -> 'a) -> 'a list
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Sets and maps over terminals. *)
-
-module TerminalSet : sig
-
- (* All of the operations documented in [GSet] are available. *)
-
- include GSet.S with type element = Terminal.t
-
- (* This offers a string representation of a set of terminals. The
- symbols are simply listed one after the other and separated with
- spaces. *)
-
- val print: t -> string
-
- (* This is the set of all terminal symbols except the pseudo-tokens
- [#] and [error]. *)
-
- val universe: t
-
-end
-
-(* All of the operations documented in [GMap] are available. *)
-
-module TerminalMap : GMap.S with type key = Terminal.t
-
-(* ------------------------------------------------------------------------ *)
-(* Symbols. *)
-
-module Symbol : sig
-
- (* A symbol is either a nonterminal or a terminal. *)
-
- type t =
- | N of Nonterminal.t
- | T of Terminal.t
-
- (* Comparison. *)
-
- val equal: t -> t -> bool
- val lequal: t list -> t list -> bool
-
- (* These produce a string representation of a symbol, of a list of
- symbols, or of an array of symbols. The symbols are simply listed
- one after the other and separated with spaces. [printao] prints
- an array of symbols, starting at a particular offset. [printaod]
- is analogous, but can also print a single dot at a particular
- position between two symbols. *)
-
- val print: t -> string
- val printl: t list -> string
- val printa: t array -> string
- val printao: int -> t array -> string
- val printaod: int -> int -> t array -> string
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Sets and maps over symbols. *)
-
-(* All of the operations documented in [Set] are available. *)
-
-module SymbolSet : Set.S with type elt = Symbol.t
-
-module SymbolMap : sig
-
- (* All of the operations documented in [Map] are available. *)
-
- include Map.S with type key = Symbol.t
-
- val domain: 'a t -> key list
-
- (* This returns [true] if and only if all of the symbols in
- the domain of the map at hand are nonterminals. *)
-
- val purelynonterminal: 'a t -> bool
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Productions. *)
-
-module Production : sig
-
- (* This is the type of productions. This includes user-defined
- productions as well as the internally generated productions
- associated with the start symbols. *)
-
- type index
-
- (* Productions can be converted to integers and back. This is unsafe
- and should be avoided as much as possible. This feature is
- exploited, for efficiency, in the encoding of items. *)
-
- val p2i: index -> int
- val i2p: int -> index
-
- (* The number of productions. *)
-
- val n: int
-
- (* These map a production index to the production's definition, that
- is, a nonterminal (the left-hand side) and an array of symbols
- (the right-hand side). *)
-
- val def: index -> Nonterminal.t * Symbol.t array
- val nt: index -> Nonterminal.t
- val rhs: index -> Symbol.t array
- val length: index -> int
-
- (* This maps a production index to an array of the identifiers that
- should be used for naming the semantic values of the symbols in
- the right-hand side. *)
-
- val identifiers: index -> Syntax.identifier array
-
- (* This maps a production index to an array of Boolean flag. Each
- flag tells whether the semantic value of the corresponding symbol
- is used in the semantic action. This is a conservative
- approximation: [true] means maybe, while [false] means certainly
- not. *)
-
- val used: index -> bool array
-
- (* This maps a production index to the production's semantic action.
- This function is not applicable to a start production. *)
-
- val action: index -> Syntax.action
-
- (* [positions prod] is a list of the positions associated with
- production [prod]. This is usually a singleton list, but there
- can be more than one position for start productions when the
- definition of the corresponding start symbol is split over
- multiple files. *)
-
- val positions: index -> Positions.t list
-
- (* Iteration over all productions. The order in which elements
- are examined, and the order of [map]'s output list, correspond
- to the numeric indices produced by [p2i] above. *)
-
- val iter: (index -> unit) -> unit
- val fold: (index -> 'a -> 'a) -> 'a -> 'a
- val map: (index -> 'a) -> 'a list
-
- (* Iteration over all productions, except the start productions. *)
-
- val iterx: (index -> unit) -> unit
- val foldx: (index -> 'a -> 'a) -> 'a -> 'a
-
- (* This maps a (user) non-terminal start symbol to the corresponding
- start production. *)
-
- val startsymbol2startprod: Nonterminal.t -> index
-
- (* Iteration over the productions associated with a specific
- nonterminal. *)
-
- val iternt: Nonterminal.t -> (index -> unit) -> unit
- val foldnt: Nonterminal.t -> 'a -> (index -> 'a -> 'a) -> 'a
-
- (* This allows determining whether a production is a start
- production. If it is a start production, the start symbol that it
- is associated with is returned. If it is a regular production,
- nothing is returned. *)
-
- val classify: index -> Nonterminal.t option
-
- (* This produces a string representation of a production. It should
- never be applied to a start production, as we do not wish users
- to become aware of the existence of these extra productions. *)
-
- val print: index -> string
-
- (* Tabulation of a Boolean function over nonterminals. [tabulate f]
- returns a tabulated version of [f] as well as the number of
- productions where [f] is true. *)
-
- val tabulate: (index -> bool) -> (index -> bool) * int
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Maps over productions. *)
-
-module ProductionMap : sig
-
- include GMap.S with type key = Production.index
-
- (* Iteration over the start productions only. *)
-
- val start: (Production.index -> 'a) -> 'a t
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Analysis of the grammar. *)
-
-module Analysis : sig
-
- (* [nullable_first_rhs rhs i] considers the string of symbols found at
- offset [i] in the array [rhs]. It returns its NULLABLE flag as well
- as its FIRST set. The offset [i] must be contained between [0] and
- [n], where [n] is the length of [rhs], inclusive. *)
-
- val nullable_first_rhs: Symbol.t array -> int -> bool * TerminalSet.t
-
- (* [explain_first_rhs tok rhs i] explains why the token [tok] appears
- in the FIRST set for the string of symbols found at offset [i] in
- the array [rhs]. *)
-
- val explain_first_rhs: Terminal.t -> Symbol.t array -> int -> string
-
- (* [follow nt] is the FOLLOW set of the non-terminal symbol [nt], that
- is, the set of terminal symbols that could follow an expansion of
- [nt] in a valid sentence. *)
-
- val follow: Nonterminal.t -> TerminalSet.t
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Conflict resolution via precedences. *)
-
-module Precedence : sig
-
- (* Shift/reduce conflicts require making a choice between shifting a
- token and reducing a production. How these choices are made is of
- no concern to the back-end, but here is a rough explanation.
-
- Shifting is preferred when the token has higher precedence than
- the production, or they have same precedence and the token is
- right-associative.
-
- Reducing is preferred when the token has lower precedence than
- the production, or they have same precedence and the token is
- left-associative.
-
- Neither is allowed when the token and the production have same
- precedence and the token is non-associative.
-
- No preference is explicitly specified when the token or the
- production has undefined precedence. In that case, the default
- choice is to prefer shifting, but a conflict will be reported. *)
-
- type choice =
- | ChooseShift
- | ChooseReduce
- | ChooseNeither
- | DontKnow
-
- val shift_reduce: Terminal.t -> Production.index -> choice
-
- (* Reduce/reduce conflicts require making a choice between reducing
- two distinct productions. This is done by exploiting a partial
- order on productions.
-
- For compatibility with ocamlyacc, this order should be total and
- should correspond to textual order when the two productions
- originate in the same source file. When they originate in
- different source files, the two productions should be
- incomparable. *)
-
- val reduce_reduce: Production.index -> Production.index -> Production.index option
-
-end
-
-(* ------------------------------------------------------------------------ *)
-(* Diagnostics. *)
-
-(* This function prints diagnostics about precedence declarations that
- are never consulted. It is called after the automaton is
- constructed. *)
-
-val diagnostics: unit -> unit
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Syntax
-open Stretch
-open UnparameterizedSyntax
-open IL
-open CodeBits
-open TokenType
-
-(* ------------------------------------------------------------------------- *)
-(* Naming conventions. *)
-
-(* The type variable associated with a nonterminal symbol. Its name
- begins with a prefix which ensures that it cannot clash with
- Objective Caml keywords. *)
-
-let ntvar symbol =
- Printf.sprintf "tv_%s" (Misc.normalize symbol)
-
-(* The name of the temporary file. *)
-
-let base =
- Settings.base
-
-let mlname =
- base ^ ".ml"
-
-let mliname =
- base ^ ".mli"
-
-(* ------------------------------------------------------------------------- *)
-(* Code production. *)
-
-(* [nttype nt] is the type of the nonterminal [nt], as currently
- known. *)
-
-let nttype grammar nt =
- try
- TypTextual (StringMap.find nt grammar.types)
- with Not_found ->
- TypVar (ntvar nt)
-
-(* [is_standard] determines whether a branch derives from a standard
- library definition. The method, based on a file name, is somewhat
- fragile. *)
-
-let is_standard branch =
- List.for_all (fun x -> x = Settings.stdlib_filename) (Action.filenames branch.action)
-
-(* [actiondef] turns a branch into a function definition. *)
-
-let actiondef grammar symbol branch =
-
- (* Construct a list of the semantic action's formal parameters that
- depend on the production's right-hand side. *)
-
- let _, formals =
- List.fold_left (fun (i, formals) (symbol, ido) ->
- let id, startp, endp, starto, endo =
- match ido with
- | None ->
- (* Symbols for which no name was chosen will be represented
- by variables named _1, _2, etc. *)
- Printf.sprintf "_%d" (i + 1),
- Printf.sprintf "_startpos__%d_" (i + 1),
- Printf.sprintf "_endpos__%d_" (i + 1),
- Printf.sprintf "_startofs__%d_" (i + 1),
- Printf.sprintf "_endofs__%d_" (i + 1)
- | Some id ->
- (* Symbols for which a name was explicitly chosen will be
- known by that name in semantic actions. *)
- id,
- Printf.sprintf "_startpos_%s_" id,
- Printf.sprintf "_endpos_%s_" id,
- Printf.sprintf "_startofs_%s_" id,
- Printf.sprintf "_endofs_%s_" id
- in
- let t =
- try
- let props = StringMap.find symbol grammar.tokens in
- (* Symbol is a terminal. *)
- match props.tk_ocamltype with
- | None ->
- tunit
- | Some ocamltype ->
- TypTextual ocamltype
- with Not_found ->
- (* Symbol is a nonterminal. *)
- nttype grammar symbol
- in
- i + 1,
- PAnnot (PVar id, t) ::
- PAnnot (PVar startp, tposition) ::
- PAnnot (PVar endp, tposition) ::
- PAnnot (PVar starto, tint) ::
- PAnnot (PVar endo, tint) ::
- formals
- ) (0, []) branch.producers
- in
-
- (* Extend the list with parameters that do not depend on the
- right-hand side. *)
-
- let formals =
- PAnnot (PVar "_previouserror", tint) ::
- PAnnot (PVar "_eRR", texn) ::
- PAnnot (PVar "_startpos", tposition) ::
- PAnnot (PVar "_endpos", tposition) ::
- PAnnot (PVar "_startofs", tint) ::
- PAnnot (PVar "_endofs", tint) ::
- formals
- in
-
- (* Construct a function definition out of the above bindings and the
- semantic action. *)
-
- let body =
- EAnnot (
- Action.to_il_expr branch.action,
- type2scheme (nttype grammar symbol)
- )
- in
-
- match formals with
- | [] ->
- body
- | _ ->
- EFun (formals, body)
-
-(* [program] turns an entire grammar into a test program. *)
-
-let program grammar =
-
- (* Turn the grammar into a bunch of function definitions. Grammar
- productions that derive from the standard library are reflected
- first, so that type errors are not reported in them. *)
-
- let bindings1, bindings2 =
- StringMap.fold (fun symbol rule (bindings1, bindings2) ->
- List.fold_left (fun (bindings1, bindings2) branch ->
- if is_standard branch then
- (PWildcard, actiondef grammar symbol branch) :: bindings1, bindings2
- else
- bindings1, (PWildcard, actiondef grammar symbol branch) :: bindings2
- ) (bindings1, bindings2) rule.branches
- ) grammar.rules ([], [])
- in
-
- (* Create entry points whose types are the unknowns that we are
- looking for. *)
-
- let ps, ts =
- StringMap.fold (fun symbol _ (ps, ts) ->
- PVar (Misc.normalize symbol) :: ps,
- nttype grammar symbol :: ts
- ) grammar.rules ([], [])
- in
-
- let def = {
- valpublic = true;
- valpat = PTuple ps;
- valval = ELet (bindings1 @ bindings2, EAnnot (bottom, type2scheme (TypTuple ts)))
- }
- in
-
- (* Insert markers to delimit the part of the file that we are
- interested in. These markers are recognized by [Lexmli]. This
- helps skip the values, types, exceptions, etc. that might be
- defined by the prologue or postlogue. *)
-
- let begindef = {
- valpublic = true;
- valpat = PVar "menhir_begin_marker";
- valval = EIntConst 0
- }
- and enddef = {
- valpublic = true;
- valpat = PVar "menhir_end_marker";
- valval = EIntConst 0
- } in
-
- (* Issue the test program. We include the definition of the type of
- tokens, because, in principle, the semantic actions may refer to
- it or to its data constructors. *)
-
- {
- paramdefs = PreFront.grammar.parameters;
- prologue = PreFront.grammar.preludes;
- excdefs = [];
- typedefs = tokentypedef;
- nonrecvaldefs = [ begindef; def; enddef ];
- moduledefs = [];
- valdefs = [];
- postlogue = PreFront.grammar.postludes
- }
-
-(* ------------------------------------------------------------------------- *)
-(* Writing the program associated with a grammar to a file. *)
-
-let write grammar () =
- let ml = open_out mlname in
- let module P = Printer.Make (struct
- let f = ml
- let locate_stretches = Some mlname
- let raw_stretch_action = false
- end) in
- P.program (program grammar);
- close_out ml
-
-let remove filename () =
- Sys.remove filename
-
-(* ------------------------------------------------------------------------- *)
-(* Moving away and restoring a file. *)
-
-let mover filename =
- if Sys.file_exists filename then
- let newname =
- filename ^ ".moved_by_menhir"
- in
- let moveaway () =
- Sys.rename filename newname
- and restore () =
- Sys.rename newname filename
- in
- moveaway, restore
- else
- let nothing () = () in
- nothing, nothing
-
-(* ------------------------------------------------------------------------- *)
-(* Running ocamldep on the program. *)
-
-type entry =
- string (* basename *) * string (* filename *)
-
-type line =
- entry (* target *) * entry list (* dependencies *)
-
-let depend grammar =
-
- (* Create an [.ml] file and an [.mli] file, then invoke ocamldep to
- compute dependencies for us. *)
-
- (* If an old [.ml] or [.mli] file exists, we are careful to preserve
- it. We temporarily move it out of the way and restore it when we
- are done. There is no reason why dependency analysis should
- destroy existing files. *)
-
- let moveml, restoreml =
- mover mlname
- and movemli, restoremli =
- mover mliname
- in
-
- let output =
- IO.winvoke
- [ moveml; movemli; write grammar; Interface.write ]
- (Printf.sprintf "%s %s %s" Settings.ocamldep (Filename.quote mlname) (Filename.quote mliname))
- [ remove mlname; remove mliname; restoreml; restoremli ]
- in
-
- (* Echo ocamldep's output. *)
-
- print_string output;
-
- (* If [--raw-depend] was specified on the command line, stop here.
- This option is used by omake, which performs its own
- postprocessing of [ocamldep]'s output. For normal [make] users,
- who use [--depend], some postprocessing is required, which is
- performed below. *)
-
- begin match Settings.depend with
- | Settings.OMNone ->
- assert false (* we wouldn't be here in the first place *)
- | Settings.OMRaw ->
- ()
- | Settings.OMPostprocess ->
-
- (* Make sense out of ocamldep's output. *)
-
- let lexbuf = Lexing.from_string output in
- let lines : line list = Lexdep.main lexbuf in
-
- (* Look for the line that concerns the [.cmo] target, and echo a
- modified version of this line, where the [.cmo] target is
- replaced with [.ml] and [.mli] targets, and where the dependency
- over the [.cmi] file is dropped.
-
- In doing so, we assume that the user's [Makefile] supports
- bytecode compilation, so that it makes sense to request [bar.cmo]
- to be built, as opposed to [bar.cmx]. This is not optimal, but
- will do. [camldep] exhibits the same behavior. *)
-
- (* TEMPORARY allow ocamldep to be called with flag -native. *)
-
- List.iter (fun ((_, target_filename), dependencies) ->
- if Filename.check_suffix target_filename ".cmo" then
- let dependencies = List.filter (fun (basename, _) ->
- basename <> base
- ) dependencies in
- if List.length dependencies > 0 then begin
- Printf.printf "%s.ml %s.mli:" base base;
- List.iter (fun (basename, filename) ->
- Printf.printf " %s" filename
- ) dependencies;
- Printf.printf "\n%!"
- end
- ) lines
-
- end;
-
- (* Stop. *)
-
- exit 0
-
-(* ------------------------------------------------------------------------- *)
-(* Inferring types for a grammar's nonterminals. *)
-
-let infer grammar =
-
- (* Invoke ocamlc to do type inference for us. *)
-
- let output =
- IO.winvoke
- [ write grammar ]
- (Printf.sprintf "%s -c -i %s" Settings.ocamlc (Filename.quote mlname))
- [ remove mlname ]
- in
-
- (* Make sense out of ocamlc's output. *)
-
- let env : (string * int * int) list =
- Lexmli.main (Lexing.from_string output)
- in
-
- let env : (string * ocamltype) list =
- List.map (fun (id, openingofs, closingofs) ->
- id, Inferred (String.sub output openingofs (closingofs - openingofs))
- ) env
- in
-
- (* Augment the grammar with new %type declarations. *)
-
- let types =
- StringMap.fold (fun symbol _ types ->
- let ocamltype =
- try
- List.assoc (Misc.normalize symbol) env
- with Not_found ->
- assert false
- in
- if StringMap.mem symbol grammar.types then
- (* If there was a declared type, keep it. *)
- types
- else
- (* Otherwise, insert the inferred type. *)
- StringMap.add symbol ocamltype types
- ) grammar.rules grammar.types
- in
-
- { grammar with types = types }
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* [ntvar symbol] is the name of the type variable associated with a
- nonterminal symbol. *)
-
-val ntvar: string -> string
-
-(* [infer grammar] analyzes the grammar [grammar] and returns a new
- grammar, augmented with a [%type] declaration for every nonterminal
- symbol. The [ocamlc] compiler is used to infer types. *)
-
-val infer: UnparameterizedSyntax.grammar -> UnparameterizedSyntax.grammar
-
-(* [depend grammar] prints (on the standard output channel) the
- Objective Caml dependencies induced by the semantic actions.
- Then, it exits the program. *)
-
-val depend: UnparameterizedSyntax.grammar -> 'a
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: infiniteArray.ml,v 1.6 2007/09/10 21:09:37 fpottier Exp $ *)
-
-(** This module implements infinite arrays, that is, arrays that grow
- transparently upon demand. *)
-
-type 'a t = {
- default: 'a;
- mutable table: 'a array;
- mutable extent: int; (* the index of the greatest [set] ever, plus one *)
- }
-
-let default_size =
- 16384 (* must be non-zero *)
-
-let make x = {
- default = x;
- table = Array.make default_size x;
- extent = 0;
-}
-
-let rec new_length length i =
- if i < length then
- length
- else
- new_length (2 * length) i
-
-let ensure a i =
- let table = a.table in
- let length = Array.length table in
- if i >= length then begin
- let table' = Array.make (new_length (2 * length) i) a.default in
- Array.blit table 0 table' 0 length;
- a.table <- table'
- end
-
-let get a i =
- ensure a i;
- a.table.(i)
-
-let set a i x =
- ensure a i;
- a.table.(i) <- x;
- a.extent <- max (i + 1) a.extent
-
-let extent a =
- a.extent
-
-let domain a =
- Array.sub a.table 0 a.extent
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: infiniteArray.mli,v 1.5 2007/09/10 21:09:37 fpottier Exp $ *)
-
-(** This module implements infinite arrays. **)
-type 'a t
-
-(** [make x] creates an infinite array, where every slot contains [x]. **)
-val make: 'a -> 'a t
-
-(** [get a i] returns the element contained at offset [i] in the array [a].
- Slots are numbered 0 and up. **)
-val get: 'a t -> int -> 'a
-
-(** [set a i x] sets the element contained at offset [i] in the array
- [a] to [x]. Slots are numbered 0 and up. **)
-val set: 'a t -> int -> 'a -> unit
-
-(** [extent a] is the length of an initial segment of the array [a]
- that is sufficiently large to contain all [set] operations ever
- performed. In other words, all elements beyond that segment have
- the default value. *)
-val extent: 'a t -> int
-
-(** [domain a] is a fresh copy of an initial segment of the array [a]
- whose length is [extent a]. *)
-val domain: 'a t -> 'a array
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open IL
-open CodeBits
-
-(* In the following, we only inline global functions. In order to
- avoid unintended capture, as we traverse terms, we keep track of
- local identifiers that hide global ones. The following little class
- helps do that. (The pathological case where a local binding hides a
- global one probably does not arise very often. Fortunately,
- checking against it in this way is quite cheap, and lets me sleep
- safely.) *)
-
-class locals table = object(self)
-
- method pvar (locals : StringSet.t) (id : string) =
- if Hashtbl.mem table id then StringSet.add id locals else locals
-
-end
-
-(* Here is the inliner. *)
-
-let inline ({ valdefs = defs } as p : program) =
-
- (* Create a table of all global definitions. *)
-
- let before, table = Traverse.tabulate_defs defs in
-
- (* Prepare to count how many times each function is used, including
- inside its own definition. The public functions serve as starting
- points for this discovery phase. *)
-
- let queue : valdef Queue.t =
- Queue.create()
- and usage : int StringMap.t ref =
- ref StringMap.empty
- in
-
- (* [visit] is called at every identifier occurrence. *)
-
- let visit locals id =
- if StringSet.mem id locals then
- (* This is a local identifier. Do nothing. *)
- ()
- else
- try
- let _, def = Hashtbl.find table id in
-
- (* This is a globally defined identifier. Increment its usage
- count. If it was never visited, enqueue its definition for
- exploration. *)
-
- let n =
- try
- StringMap.find id !usage
- with Not_found ->
- Queue.add def queue;
- 0
- in
- usage := StringMap.add id (n + 1) !usage
-
- with Not_found ->
- (* This identifier is not global. It is either local or a
- reference to some external library, e.g. ocaml's standard
- library. *)
- ()
- in
-
- (* Look for occurrences of identifiers inside expressions. *)
-
- let o =
- object
- inherit [ StringSet.t, unit ] Traverse.fold
- inherit locals table
- method evar locals () id =
- visit locals id
- end
- in
-
- (* Initialize the queue with all public definitions, and work from
- there. We assume that the left-hand side of every definition is
- a variable. *)
-
- List.iter (fun { valpublic = public; valpat = p } ->
- if public then
- visit StringSet.empty (pat2var p)
- ) defs;
- Misc.qfold (o#valdef StringSet.empty) () queue;
- let usage = !usage in
-
- (* Now, inline every function that is called at most once. At the
- same time, every function that is never called is dropped. The
- public functions again serve as starting points for the
- traversal. *)
-
- let queue : valdef Queue.t =
- Queue.create()
- and emitted =
- ref StringSet.empty
- in
-
- let enqueue def =
- let id = pat2var def.valpat in
- if not (StringSet.mem id !emitted) then begin
- emitted := StringSet.add id !emitted;
- Queue.add def queue
- end
- in
-
- (* A simple application is an application of a variable to a number
- of variables, constants, or record accesses out of variables. *)
-
- let rec is_simple_arg = function
- | EVar _
- | EData (_, [])
- | ERecordAccess (EVar _, _) ->
- true
- | EMagic e ->
- is_simple_arg e
- | _ ->
- false
- in
-
- let is_simple_app = function
- | EApp (EVar _, actuals) ->
- List.for_all is_simple_arg actuals
- | _ ->
- false
- in
-
- (* Taking a fresh instance of a type scheme. Ugly. *)
-
- let instance =
- let count = ref 0 in
- let fresh tv =
- incr count;
- tv, Printf.sprintf "freshtv%d" !count
- in
- fun scheme ->
- let mapping = List.map fresh scheme.quantifiers in
- let rec sub typ =
- match typ with
- | TypTextual _ ->
- typ
- | TypVar v ->
- begin try
- TypVar (List.assoc v mapping)
- with Not_found ->
- typ
- end
- | TypApp (f, typs) ->
- TypApp (f, List.map sub typs)
- | TypTuple typs ->
- TypTuple (List.map sub typs)
- | TypArrow (typ1, typ2) ->
- TypArrow (sub typ1, sub typ2)
- in
- sub scheme.body
- in
-
- (* Destructuring a type annotation. *)
-
- let rec annotate formals body typ =
- match formals, typ with
- | [], _ ->
- [], EAnnot (body, type2scheme typ)
- | formal :: formals, TypArrow (targ, tres) ->
- let formals, body = annotate formals body tres in
- PAnnot (formal, targ) :: formals, body
- | _ :: _, _ ->
- (* Type annotation has insufficient arity. *)
- assert false
- in
-
- (* The heart of the inliner: rewriting a function call to a [let]
- expression.
-
- If there was a type annotation at the function definition site,
- it is dropped, provided [--infer] was enabled. Otherwise, it is
- kept, because, due to the presence of [EMagic] expressions in the
- code, dropping a type annotation could cause an ill-typed program
- to become apparently well-typed. Keeping a type annotation
- requires taking a fresh instance of the type scheme, because
- OCaml doesn't have support for locally and existentially bound
- type variables. Yuck. *)
-
- let inline formals actuals body oscheme =
- assert (List.length actuals = List.length formals);
- match oscheme with
- | Some scheme
- when not Settings.infer ->
-
- let formals, body = annotate formals body (instance scheme) in
- mlet formals actuals body
-
- | _ ->
- mlet formals actuals body
- in
-
- (* Look for occurrences of identifiers inside expressions, branches,
- etc. and replace them with their definitions if they have only
- one use site or if their definitions are sufficiently simple. *)
-
- let o =
- object (self)
- inherit [ StringSet.t ] Traverse.map as super
- inherit locals table
- method eapp locals e actuals =
- match e with
- | EVar id when
- (Hashtbl.mem table id) && (* a global identifier *)
- (not (StringSet.mem id locals)) (* not hidden by a local identifier *)
- ->
-
- let _, def = Hashtbl.find table id in (* cannot fail, thanks to the above check *)
-
- let formals, body, oscheme =
- match def with
- | { valval = EFun (formals, body) } ->
- formals, body, None
- | { valval = EAnnot (EFun (formals, body), scheme) } ->
- formals, body, Some scheme
- | { valval = _ } ->
- (* The definition is not a function definition. This should not
- happen in the kind of code that we generate. *)
- assert false
- in
-
- assert (StringMap.mem id usage);
- if StringMap.find id usage = 1 || is_simple_app body then
-
- (* The definition can be inlined, with beta reduction. *)
-
- inline formals (self#exprs locals actuals) (EComment (id, self#expr locals body)) oscheme
-
- else begin
-
- (* The definition cannot be inlined. *)
-
- enqueue def;
- super#eapp locals e actuals
-
- end
-
- | _ ->
- (* The thing in function position is not a reference to a global. *)
- super#eapp locals e actuals
-
- end
- in
-
- (* Initialize the queue with all public definitions, and work from
- there. *)
-
- List.iter (function { valpublic = public } as def ->
- if public then
- enqueue def
- ) defs;
-
- let valdefs =
- Misc.qfold (fun defs def ->
- o#valdef StringSet.empty def :: defs
- ) [] queue
- in
-
- Error.logC 1 (fun f ->
- Printf.fprintf f "%d functions before inlining, %d functions after inlining.\n"
- before (List.length valdefs));
-
- Time.tick "Inlining";
-
- { p with valdefs = valdefs }
-
-(* The external entry point. *)
-
-let inline p =
- if Settings.code_inlining then inline p else p
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This transformer inlines every function that is called at most
- once. It also inlines some functions whose body consists of a
- single function call. At the same time, every function that is
- never called is dropped. Public functions are never inlined or
- dropped. *)
-
-val inline: IL.program -> IL.program
-
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module defines a number of installation settings.
- Its source code is generated by the main [Makefile]. *)
-
-(* The directory where Menhir's standard library, [standard.mly],
- is installed. *)
-
-val libdir: string
-
-(* Whether MenhirLib was installed via [ocamlfind] or (manually)
- in the above directory. *)
-
-val ocamlfind: bool
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open UnparameterizedSyntax
-open IL
-open CodeBits
-open TokenType
-
-(* This is the [Error] exception. *)
-
-let excname =
- "Error"
-
-let excdef = {
- excname = excname;
- exceq = None;
-}
-
-let excredef = {
- excdef with exceq = Some excname
-}
-
-(* The type of the entry point for the start symbol [symbol]. *)
-
-let entrytypescheme symbol =
- let ocamltype =
- try
- StringMap.find symbol PreFront.grammar.types
- with Not_found ->
- (* Every start symbol should have a type. *)
- assert false
- in
- type2scheme (marrow [ arrow tlexbuf ttoken; tlexbuf ] (TypTextual ocamltype))
-
-(* This is the interface of the generated parser. *)
-
-let interface = {
-
- paramdecls =
- PreFront.grammar.parameters;
-
- excdecls =
- [ excdef ];
-
- typedecls =
- tokentypedef;
-
- valdecls =
- StringSet.fold (fun symbol decls ->
- (Misc.normalize symbol, entrytypescheme symbol) :: decls
- ) PreFront.grammar.start_symbols []
-
-}
-
-(* Writing the interface to a file. *)
-
-let write () =
- let mli = open_out (Settings.base ^ ".mli") in
- let module P = Printer.Make (struct
- let f = mli
- let locate_stretches = None
- let raw_stretch_action = false
- end) in
- P.interface interface;
- close_out mli
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module defines the interface of the generated parser. *)
-
-(* This is the [Error] exception. *)
-
-val excname: string
-val excdef: IL.excdef
-val excredef: IL.excdef
-
-(* The type of the entry point for the nonterminal start symbol
- [symbol]. *)
-
-val entrytypescheme: string -> IL.typescheme
-
-(* This writes the interface of the generated parser to the [.mli]
- file. *)
-
-val write: unit -> unit
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-type grammar =
- {
- p_preludes : Stretch.t list;
- p_postludes : Syntax.trailer list;
- p_parameters : Stretch.t list;
- p_start_symbols : Positions.t StringMap.t;
- p_types : (Syntax.parameter * Stretch.ocamltype Positions.located) list;
- p_tokens : Syntax.token_properties StringMap.t;
- p_rules : Syntax.parameterized_rule StringMap.t;
- }
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module is in charge of handling the [--interpret] option,
- if it is present. *)
-
-open Grammar
-
-(* --------------------------------------------------------------------------- *)
-
-(* A sentence is a pair of an optional non-terminal start symbol and a
- list of terminal symbols. *)
-
-type sentence =
- Nonterminal.t option * Terminal.t list
-
-(* --------------------------------------------------------------------------- *)
-
-(* [stream] turns a finite list of terminals into a stream of terminals. *)
-
-exception EndOfStream
-
-let stream (toks : Terminal.t list) : unit -> Terminal.t * Lexing.position * Lexing.position =
- let toks = ref toks in
- fun () ->
-
- let tok =
- match !toks with
- | tok :: more ->
-
- (* Take a token off the list, and return it. *)
-
- toks := more;
- tok
-
- | [] ->
-
- (* The finite list has been exhausted. Here, two plausible behaviors
- come to mind.
-
- The first behavior consists in raising an exception. In that case,
- we are creating a finite stream, and it is up to the parser to not
- read past its end.
-
- The second behavior consists in returning a designated token. In
- that case, we are creating an infinite, eventually constant,
- stream.
-
- The choice between these two behaviors is somewhat arbitrary;
- furthermore, in the second case, the choice of the designated
- token is arbitrary as well. Here, we adopt the second behavior if
- and only if the grammar has an EOF token, and we use EOF as the
- designated token. Again, this is arbitrary, and could be changed
- in the future. *)
-
- match Terminal.eof with
- | Some eof ->
- eof
- | None ->
- raise EndOfStream
-
- in
-
- (* For now, return dummy positions. *)
-
- tok, Lexing.dummy_pos, Lexing.dummy_pos
-
-(* --------------------------------------------------------------------------- *)
-
-(* [interpret] interprets a sentence. *)
-
-let interpret ((nto, toks) : sentence) : unit =
-
- (* Check whether a start symbol was provided. If not, use the grammar's
- unique start symbol, if there is one. *)
-
- (* The code that finds the unique start symbol is not very pretty. *)
-
- let nt =
- match nto, ProductionMap.is_singleton Lr1.entry with
- | Some nt, _ ->
- nt
- | None, Some (prod, _) ->
- begin match Production.classify prod with
- | Some nt ->
- nt
- | None ->
- assert false
- end
- | None, None ->
- Error.error []
- "Because the grammar has multiple start symbols, each of the\n\
- sentences provided on the standard input channel must be of the\n\
- form: <start symbol>: <token>*"
- in
-
- (* Run the reference interpreter. This can produce a concrete syntax tree
- ([Some cst]), fail with a parser error ([None]), or fail with a lexer error
- ([EndOfStream]). *)
-
- (* In either case, we produce just one line of output, so it should be clear
- to the user which outcomes correspond to which sentences (should multiple
- sentences be supplied). *)
-
- begin try
- match
- MenhirLib.Convert.Simplified.traditional2revised
- (ReferenceInterpreter.interpret Settings.trace nt)
- (stream toks)
- with
-
- | Some cst ->
-
- (* Success. *)
-
- Printf.printf "ACCEPT";
- if Settings.interpret_show_cst then begin
- print_newline();
- Cst.show stdout cst
- end
-
- | None ->
-
- (* Parser failure. *)
-
- Printf.printf "REJECT"
-
- with EndOfStream ->
-
- (* Lexer failure. *)
-
- Printf.printf "OVERSHOOT"
-
- end;
- print_newline()
-
-(* --------------------------------------------------------------------------- *)
-
-(* If [--interpret] is set, interpret the sentences found on the standard
- input channel, then stop, without generating a parser. *)
-
-open Lexing
-
-let () =
- if Settings.interpret then begin
-
- (* Read a series of sentences from the standard input channel. *)
-
- (* For more comfortable interaction, we interpret each sentence
- as soon as it is read. *)
-
- let lexbuf =
- from_channel stdin
- in
- lexbuf.lex_curr_p <- { lexbuf.lex_curr_p with pos_fname = "(stdin)" };
-
- let read () =
- try
- SentenceParser.sentence SentenceLexer.lex lexbuf
- with Parsing.Parse_error ->
- Error.error (Positions.lexbuf lexbuf) "Ill-formed input sentence."
- in
-
- let rec loop () =
- match read() with
- | None ->
- exit 0
- | Some sentence ->
- interpret sentence;
- loop()
- in
- loop()
-
- end
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module is in charge of handling the [--interpret] option,
- if it is present. It offers no functionality. *)
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module discovers information about the shape of the stack
- in each of the automaton's states.
-
- It would probably be possible to predict this information, instead
- of discovering it, but it would then be less obvious that it is
- correct. In this approach, it is more obvious that the discovered
- invariant is correct. The drawback is that it is not necessarily
- clear why it is strong enough to guarantee that the generated code
- is well-typed. *)
-
-open Grammar
-
-(* ------------------------------------------------------------------------ *)
-(* Discover what is known of the structure of the stack in every
- automaton node. *)
-
-(* A concrete stack is a list of pairs of a symbol and a state. *)
-
-(* An abstract stack is (a finite representation of) a possibly
- infinite set of concrete stacks. *)
-
-(* The type [tail] has two values. [TailEmpty] represents a singleton
- set that contains (only) the empty stack. [TailUnknown] represents
- the full set of all stacks. *)
-
-type tail =
- | TailEmpty
- | TailUnknown
-
-(* An abstract cell is a pair of a symbol and a set of states. An
- abstract word is a list of abstract cells. An abstract stack
- is a pair of an abstract word, which represents a known suffix
- of the stack, and a tail, which provides information about the
- remainder of the stack. *)
-
-type cell =
- Symbol.t * Lr1.NodeSet.t
-
-type word =
- cell list
-
-type stack =
- word * tail
-
-(* ------------------------------------------------------------------------ *)
-(* Equality of abstract stacks. *)
-
-let eq_tail tail1 tail2 =
- match tail1, tail2 with
- | TailEmpty, TailEmpty
- | TailUnknown, TailUnknown ->
- true
- | _, _ ->
- false
-
-let eq_cell (symbol1, states1) (symbol2, states2) =
- Symbol.equal symbol1 symbol2 &&
- Lr1.NodeSet.equal states1 states2
-
-let rec eq_word w1 w2 =
- match w1, w2 with
- | [], [] ->
- true
- | cell1 :: w1, cell2 :: w2 ->
- eq_cell cell1 cell2 &&
- eq_word w1 w2
- | _, _ ->
- false
-
-let eq_stack (w1, tail1) (w2, tail2) =
- eq_tail tail1 tail2 &&
- eq_word w1 w2
-
-(* ------------------------------------------------------------------------ *)
-(* Extending an abstract stack with a new cell. *)
-
-let extend_stack cell stack =
- let (w, tail) = stack in
- cell :: w, tail
-
-(* ------------------------------------------------------------------------ *)
-(* Computing the join of two abstract stacks. *)
-
-(* The join of [stack1] and [stack2] is their least upper bound, that
- is, the best abstract description of the union of the two sets of
- concrete stacks denoted by [stack1] and [stack2]. *)
-
-let rec join_tail (tail1 : tail) (tail2 : tail) : tail =
- match tail1, tail2 with
- | TailEmpty, TailEmpty ->
- TailEmpty
- | TailUnknown, _
- | _, TailUnknown ->
- TailUnknown
-
-let rec join_word (w1 : word) (w2 : word) : word * tail =
- match w1, w2 with
- | [], [] ->
- (* Both stacks are empty. There is agreement. *)
- [], TailEmpty
- | [], _ :: _
- | _ :: _, [] ->
- (* One stack is empty, but the other isn't. The greatest
- common suffix is empty, and there is disagreement. *)
- [], TailUnknown
- | (symbol1, states1) :: w1, (symbol2, states2) :: w2 ->
- if Symbol.equal symbol1 symbol2 then
- (* The stacks agree on their top cell. It is therefore part
- of the greatest common suffix. *)
- let w, tail = join_word w1 w2 in
- (symbol1, Lr1.NodeSet.union states1 states2) :: w, tail
- else
- (* The stacks disagree on their top cell. Their greatest common
- suffix is therefore empty. *)
- [], TailUnknown
-
-let rec join_stack (stk1 : stack) (stk2 : stack) : stack =
- let w1, tail1 = stk1
- and w2, tail2 = stk2 in
- let w, tail = join_word w1 w2 in
- w, join_tail tail (join_tail tail1 tail2)
-
-(* ------------------------------------------------------------------------ *)
-(* Truncating an abstract stack at a certain depth. *)
-
-let truncate depth (w, tail) =
- assert (List.length w >= depth);
- Misc.truncate depth w, TailUnknown
-
-(* ------------------------------------------------------------------------ *)
-(* This abstract set denotes a singleton set of the empty stack. *)
-
-let empty : stack =
- [], TailEmpty
-
-(* 2011/04/28: although this seems difficult to believe, the code that was
- used until now to compute the invariant was completely broken. A single
- pass over the automaton was used, so the abstract stacks that were computed
- did not represent a least fixed point, but (for most of our sample
- grammars) were strictly below the least fixed point. (That is, they produce
- descriptions of the stack that were unsound / too strong.) For some
- reason, Menhir was apparently still able to produce correct code. (Some
- type annotations in the code were probably incorrect, but apparently this
- did not matter because the code is full of magic anyway.)
-
- I am now fixing this problem (I hope!) by explicitly requesting the
- computation of a least fixed point. *)
-
-(* ------------------------------------------------------------------------ *)
-(* The abstract stacks that we have presented above represent non-empty sets
- of concrete stacks. In order to perform the fixed point computation, we
- also need a bottom element, which represents an empty set of concrete
- stacks. This element is used during the fixed point computation, but does
- not appear in the least fixed point, provided every state of the automaton
- is reachable. (A state is reachable if only if the least fixed point
- associates it with a non-empty set of stacks.) *)
-
-type value =
- | VEmptySet
- | VNonEmptySet of stack
-
-let eq_value v1 v2 =
- match v1, v2 with
- | VEmptySet, VEmptySet ->
- true
- | VNonEmptySet stack1, VNonEmptySet stack2 ->
- eq_stack stack1 stack2
- | _, _ ->
- false
-
-let join_value v1 v2 =
- match v1, v2 with
- | VEmptySet, v
- | v, VEmptySet ->
- v
- | VNonEmptySet stack1, VNonEmptySet stack2 ->
- VNonEmptySet (join_stack stack1 stack2)
-
-let extend_value cell v =
- match v with
- | VEmptySet ->
- VEmptySet
- | VNonEmptySet stack ->
- VNonEmptySet (extend_stack cell stack)
-
-(* ------------------------------------------------------------------------ *)
-(* Instantiate the least fixed point computation machinery with states and
- values. *)
-
-module F =
- Fix.Make
- (struct
-
- type key =
- Lr1.NodeMap.key
-
- type 'data t =
- 'data Lr1.NodeMap.t ref
-
- let create () =
- ref Lr1.NodeMap.empty
-
- let clear t =
- t := Lr1.NodeMap.empty
-
- let add k d t =
- t := Lr1.NodeMap.add k d !t
-
- let find k t =
- Lr1.NodeMap.find k !t
-
- let iter f t =
- Lr1.NodeMap.iter f !t
-
- end)
- (struct
- type property = value
- let bottom = VEmptySet
- let equal = eq_value
- let is_maximal _ = false
- end)
-
-(* ------------------------------------------------------------------------ *)
-(* Define the fixed point. *)
-
-let lfp : Lr1.node -> value =
-
- F.lfp (fun node (get : Lr1.node -> value) ->
-
- (* We use the fact that a state has incoming transitions if and only if
- it is not a start state. This allows to us to simplify the following
- code slightly. *)
-
- match Lr1.incoming_symbol node with
-
- | None ->
- assert (Lr1.predecessors node = []);
-
- (* If [node] is a start state, then the stack at [node] may be (in
- fact, must be) the empty stack. *)
-
- VNonEmptySet empty
-
- | Some symbol ->
-
- (* If [node] is not a start state, then include the contribution of
- every incoming transition. We compute a join over all predecessors.
- The contribution of one predecessor is the abstract value found at
- this predecessor, extended with a new cell for this transition. *)
-
- List.fold_left (fun v predecessor ->
- join_value
- v
- (extend_value (symbol, Lr1.NodeSet.singleton predecessor) (get predecessor))
- ) VEmptySet (Lr1.predecessors node)
-
- )
-
-(* If every state is reachable, then the least fixed point must be non-bottom
- everywhere, so we may view it as a function that produces a [stack], a
- description of a non-empty set of stacks. *)
-
-let lfp (node : Lr1.node) : stack =
- match lfp node with
- | VEmptySet ->
- (* apparently this node is unreachable *)
- assert false
- | VNonEmptySet stack ->
- stack
-
-let stack =
- lfp
-
-(* ------------------------------------------------------------------------ *)
-(* We now discover what can be said of the structure of the stack when
- production [prod] is about to be reduced. At the same time, we
- count how many states can reduce each production and warn about
- productions that are never reduced. *)
-
-type info =
- (* Production is never reduced. *)
- | Zero
- (* Production can be reduced at certain nodes with a certain stack structure. *)
- | More of Lr1.NodeSet.t * stack
-
-type prodinfo =
- info ProductionMap.t
-
-let find prod prodinfo =
- try
- ProductionMap.lookup prod prodinfo
- with Not_found ->
- Zero
-
-let prodinfo : prodinfo =
- Lr1.fold (fun prodinfo node ->
- TerminalMap.fold (fun _ prods prodinfo ->
- let prod = Misc.single prods in
- ProductionMap.add prod (
- match find prod prodinfo with
- | Zero ->
- More (
- Lr1.NodeSet.singleton node,
- truncate (Production.length prod) (stack node)
- (* the use of [truncate] guarantees that we do not accidentally
- get more information than we would like; not sure whether/why
- this is necessary *)
- )
- | More (nodes, stk') ->
- More (
- Lr1.NodeSet.add node nodes,
- join_stack (stack node) stk'
- )
- ) prodinfo
- ) (Lr1.reductions node) prodinfo
- ) ProductionMap.empty
-
-let () =
- let count = ref 0 in
- Production.iter (fun prod ->
- match find prod prodinfo, Production.classify prod with
- | Zero, Some nt ->
- incr count;
- Error.grammar_warning
- (Nonterminal.positions nt)
- (Printf.sprintf "symbol %s is never accepted." (Nonterminal.print false nt))
- | Zero, None ->
- incr count;
- Error.grammar_warning
- (Production.positions prod)
- (Printf.sprintf "production %sis never reduced." (Production.print prod))
- | More (_, (w, _)), _ ->
- assert (List.length w = Production.length prod)
- );
- if !count > 0 then
- Error.grammar_warning []
- (Printf.sprintf "in total, %d productions are never reduced." !count)
-
-let prodstack prod =
- match find prod prodinfo with
- | Zero ->
- assert false
- | More (_, stk) ->
- stk
-
-(* ------------------------------------------------------------------------ *)
-(* We now determine which states must be represented, that is,
- explicitly pushed onto the stack. For simplicity, a state is either
- always represented or never represented. More fine-grained
- strategies, where a single state is sometimes pushed onto the stack
- and sometimes not pushed, depending on which outgoing transition is
- being taken, are conceivable, but quite tricky, and probably not
- worth the trouble.
-
- (1) If two states are liable to appear within a single stack cell,
- then one is represented if and only if the other is
- represented. This ensures that the structure of stacks is known
- everywhere and that we can propose types for stacks.
-
- (2) If a state [s] has an outgoing transition along nonterminal
- symbol [nt], and if the [goto] table for symbol [nt] has more than
- one target, then state [s] is represented.
-
- (3) If a stack cell contains more than one state and if at least
- one of these states is able to handle the [error] token, then these
- states are represented.
-
- (4) If the semantic action associated with a production mentions
- the [$syntaxerror] keyword, then the state that is being reduced to
- (that is, the state that initiated the recognition of this
- production) is represented. (Indeed, it will be passed as an
- argument to [errorcase].) *)
-
-(* Data. *)
-
-let rep : bool UnionFind.point array =
- Array.init Lr1.n (fun _ -> UnionFind.fresh false)
-
-(* Getter. *)
-
-let represented state =
- rep.(Lr1.number state)
-
-(* Setters. *)
-
-let represent state =
- UnionFind.change (represented state) true
-
-let represents states =
- represent (Lr1.NodeSet.choose states)
-
-(* Enforce condition (1) above. *)
-
-let share (w, _) =
- List.iter (fun (_, states) ->
- let dummy = UnionFind.fresh false in
- Lr1.NodeSet.iter (fun state ->
- UnionFind.eunion dummy (represented state)
- ) states
- ) w
-
-let () =
- Lr1.iter (fun node ->
- share (lfp node)
- );
- Production.iter (fun prod ->
- match find prod prodinfo with
- | Zero ->
- ()
- | More (_, stk) ->
- share stk
- )
-
-(* Enforce condition (2) above. *)
-
-let () =
- Nonterminal.iter (fun nt ->
- let count =
- Lr1.targets (fun count _ _ ->
- count + 1
- ) 0 (Symbol.N nt)
- in
- if count > 1 then
- Lr1.targets (fun () sources _ ->
- List.iter represent sources
- ) () (Symbol.N nt)
- )
-
-(* Enforce condition (3) above. *)
-
-let handler state =
- try
- let _ = SymbolMap.find (Symbol.T Terminal.error) (Lr1.transitions state) in
- true
- with Not_found ->
- try
- let _ = TerminalMap.lookup Terminal.error (Lr1.reductions state) in
- true
- with Not_found ->
- false
-
-let handlers states =
- Lr1.NodeSet.exists handler states
-
-let () =
- Lr1.iter (fun node ->
- let (w, _) = lfp node in
- List.iter (fun (_, states) ->
- if Lr1.NodeSet.cardinal states >= 2 && handlers states then
- represents states
- ) w
- )
-
-(* Enforce condition (4) above. *)
-
-let () =
- Production.iterx (fun prod ->
- if Action.has_syntaxerror (Production.action prod) then
- match find prod prodinfo with
- | Zero ->
- ()
- | More (sites, (w, _)) ->
- let length = Production.length prod in
- if length = 0 then
- Lr1.NodeSet.iter represent sites
- else
- let (_, states) = List.nth w (length - 1) in
- represents states
- )
-
-(* Define accessors. *)
-
-let represented state =
- UnionFind.find (represented state)
-
-let representeds states =
- if Lr1.NodeSet.is_empty states then
- assert false
- else
- represented (Lr1.NodeSet.choose states)
-
-let representedc (_, states) =
- representeds states
-
-let handlerc (_, states) =
- handlers states
-
-let fold f accu w =
- List.fold_right (fun (symbol, states) accu ->
- f accu (representeds states) symbol states
- ) w accu
-
-let fold_top f accu w =
- match w with
- | [] ->
- accu
- | (symbol, states) :: _ ->
- f (representeds states) symbol
-
-let () =
- Error.logC 1 (fun f ->
- let count =
- Lr1.fold (fun count node ->
- if represented node then count + 1 else count
- ) 0
- in
- Printf.fprintf f "%d out of %d states are represented.\n" count Lr1.n
- )
-
-(* ------------------------------------------------------------------------ *)
-(* Explain how the stack should be deconstructed when an error is
- found.
-
- We sometimes have a choice as too how many stack cells should be
- popped. Indeed, several cells in the known suffix of the stack may
- physically hold a state. If neither of these states handles errors,
- then we could jump to either. (Indeed, if we jump to one that's
- nearer, it will in turn pop further stack cells and jump to one
- that's farther.) In the interests of code size, we should pop as
- few stack cells as possible. So, we jump to the topmost represented
- state in the known suffix. *)
-
-type state =
- | Represented
- | UnRepresented of Lr1.node
-
-type instruction =
- | Die
- | DownTo of word * state
-
-let rewind node : instruction =
- let w, tail = stack node in
-
- let rec rewind w =
- match w, tail with
- | [], TailEmpty ->
- Die
- | [], TailUnknown ->
-
- (* I believe that every stack description either is definite
- (that is, ends with [TailEmpty]) or contains at least one
- represented state. This property, if true, ensures that
- this assertion cannot fail. *)
-
- (* TEMPORARY prove this property. If the property is not true in
- general, one could make it true by making more states
- represented. *)
-
- assert false
-
- | cell :: w, _ ->
-
- if representedc cell then
-
- (* Here is a represented state. We will pop this
- cell and no more. *)
-
- DownTo ([ cell ], Represented)
-
- else if handlerc cell then
-
- (* Here is an unrepresented state that can handle
- errors. The cell must hold a singleton set of states, so
- we know which state to jump to, even though it isn't
- represented. *)
-
- let (_, states) = cell in
- assert (Lr1.NodeSet.cardinal states = 1);
- let state = Lr1.NodeSet.choose states in
- DownTo ([ cell ], UnRepresented state)
-
- else
-
- (* Here is an unrepresented state that does not handle
- errors. Pop this cell and look further. *)
-
- match rewind w with
- | Die ->
- Die
- | DownTo (w, st) ->
- DownTo (cell :: w, st)
-
- in
- rewind w
-
-(* ------------------------------------------------------------------------ *)
-(* Accessors for information about the stack. *)
-
-let stack node : word =
- let (w, _) = stack node in
- w
-
-let prodstack prod : word =
- let (w, _) = prodstack prod in
- w
-
-let gotostack : Nonterminal.t -> word =
- Nonterminal.tabulate (fun nt ->
- let sources =
- Lr1.targets (fun accu sources _ ->
- List.fold_right Lr1.NodeSet.add sources accu
- ) Lr1.NodeSet.empty (Symbol.N nt)
- in
- [ Symbol.N nt, sources ]
- )
-
-(* ------------------------------------------------------------------------ *)
-(* We now determine which positions must be kept track of. For
- simplicity, we do this on a per symbol basis. That is, for each
- symbol, either we never keep track of position information, or we
- always do. In fact, we do distinguish start and end positions.
- This leads to computing two sets of symbols -- those that keep
- track of their start position and those that keep track of their
- end position.
-
- A symbol on the right-hand side of a production must keep track of
- its (start or end) position if that position is explicitly
- requested by a semantic action.
-
- Furthermore, if the left-hand symbol of a production must keep
- track of its start (resp. end) position, then the first
- (resp. last) symbol of its right-hand side (if there is one) must
- do so as well. That is, unless the right-hand side is empty. *)
-
-open Keyword
-
-let startp =
- ref SymbolSet.empty
-
-let endp =
- ref SymbolSet.empty
-
-let rec require where symbol =
- let wherep =
- match where with
- | WhereStart ->
- startp
- | WhereEnd ->
- endp
- in
- if not (SymbolSet.mem symbol !wherep) then begin
- wherep := SymbolSet.add symbol !wherep;
- match symbol with
- | Symbol.T _ ->
- ()
- | Symbol.N nt ->
- Production.iternt nt (require_aux where)
- end
-
-and require_aux where prod =
- let nt, rhs = Production.def prod in
- let length = Array.length rhs in
- if length > 0 then
- match where with
- | WhereStart ->
- require where rhs.(0)
- | WhereEnd ->
- require where rhs.(length - 1)
-
-let () =
- Production.iterx (fun prod ->
- let rhs = Production.rhs prod
- and ids = Production.identifiers prod
- and action = Production.action prod in
-
- KeywordSet.iter (function
- | Dollar _
- | PreviousError
- | SyntaxError ->
- ()
- | Position (Left, where, _) ->
- require_aux where prod
- | Position (RightDollar i, where, _) ->
- require where rhs.(i - 1)
- | Position (RightNamed id, where, _) ->
- Array.iteri (fun i id' ->
- if id = id' then
- require where rhs.(i)
- ) ids
- ) (Action.keywords action)
- )
-
-let startp =
- !startp
-
-let endp =
- !endp
-
-let () =
- Error.logC 1 (fun f ->
- Printf.fprintf f
- "%d out of %d symbols keep track of their start position.\n\
- %d out of %d symbols keep track of their end position.\n"
- (SymbolSet.cardinal startp) (Terminal.n + Nonterminal.n)
- (SymbolSet.cardinal endp) (Terminal.n + Nonterminal.n))
-
-let startp symbol =
- SymbolSet.mem symbol startp
-
-let endp symbol =
- SymbolSet.mem symbol endp
-
-(* ------------------------------------------------------------------------ *)
-(* Information about which productions are reduced and where. *)
-
-let ever_reduced prod =
- match find prod prodinfo with
- | Zero ->
- false
- | More _ ->
- true
-
-let fold_reduced f prod accu =
- match find prod prodinfo with
- | Zero ->
- accu
- | More (nodes, _) ->
- Lr1.NodeSet.fold f nodes accu
-
-(* ------------------------------------------------------------------------- *)
-(* Miscellaneous. *)
-
-let universal symbol =
- Lr1.fold (fun universal s ->
- universal && (if represented s then SymbolMap.mem symbol (Lr1.transitions s) else true)
- ) true
-
-(* ------------------------------------------------------------------------ *)
-(* Discover which states potentially can do error recovery.
-
- They are the states whose incoming symbol is [error]. At these
- states, [env.shifted] is zero, that is, no tokens have been
- successfully shifted since the last error token was shifted.
-
- We do not include in this definition the states where [env.shifted]
- *may be* zero. That would involve adding in all states reachable
- from the above states via reductions. However, error recovery will
- never be performed in these states. Indeed, imagine we shift an
- error token and enter a state that can do error recovery, according
- to the above definition. If, at this point, we consult the
- lookahead token [tok] and perform a reduction, then the new state
- that we reach is, by construction, able to act upon [tok], so no
- error recovery will be performed at that state, even though
- [env.shifted] is still zero. However, we must not perform default
- reductions at states that can do error recovery, otherwise we break
- this reasoning.
-
- If the option [--error-recovery] was not provided on the command
- line, then no states will perform error recovery. This makes things
- simpler (and saves some code) in the common case where people are
- not interested in error recovery. This also disables the warning
- about states that can do error recovery but do not accept the EOF
- token. *)
-
-let recoverers =
- if Settings.recovery then
- Lr1.fold (fun recoverers node ->
- match Lr1.incoming_symbol node with
- | Some (Symbol.T tok)
- when Terminal.equal tok Terminal.error ->
- Lr1.NodeSet.add node recoverers
- | _ ->
- recoverers
- ) Lr1.NodeSet.empty
- else
- Lr1.NodeSet.empty
-
-let recoverer node =
- Lr1.NodeSet.mem node recoverers
-
-(* ------------------------------------------------------------------------ *)
-(* Discover which states can peek at an error. These are the states
- where [env.shifted] may be -1, that is, where an error token may be
- on the stream. These are all states that are targets of a reduce
- action on [error]. *)
-
-let errorpeekers =
- Lr1.fold (fun errorpeekers node ->
- try
- let prods = TerminalMap.lookup Terminal.error (Lr1.reductions node) in
- let prod = Misc.single prods in
- let nt = Production.nt prod in
- Lr1.targets (fun errorpeekers _ target ->
- Lr1.NodeSet.add target errorpeekers
- ) errorpeekers (Symbol.N nt)
- with Not_found ->
- errorpeekers
- ) Lr1.NodeSet.empty
-
-let errorpeeker node =
- Lr1.NodeSet.mem node errorpeekers
-
-(* ------------------------------------------------------------------------ *)
-(* Here is how we check whether state [s] should have a default
- reduction.
-
- We check whether [s] has no outgoing shift transitions and only has
- one possible reduction action. In that case, we produce a default
- reduction action, that is, we perform reduction without consulting
- the lookahead token. This saves code, but can alter the parser's
- behavior in the presence of errors.
-
- A state that can perform error recovery (that is, a state whose
- incoming symbol is [error]) never performs a default
- reduction. This is explained above. Actually, we allow one
- exception: if the state has a single (reduction) action on "#", as
- explained in the next paragraph, then we perform this default
- reduction and do not allow error recovery to take place. Error
- recovery would not make much sense, since we believe we are at the
- end of file.
-
- The check for default actions subsumes the check for the case where
- [s] admits a reduce action with lookahead symbol "#". In that case,
- it must be the only possible action -- see
- [Lr1.default_conflict_resolution]. That is, we have reached a point
- where we have recognized a well-formed input and are now expecting
- an end-of-stream. In that case, performing reduction without
- looking at the next token is the right thing to do, since there
- should in fact be none. The state that we reduce to will also have
- the same property, and so on, so we will in fact end up rewinding
- the entire stack and accepting the input when the stack becomes
- empty.
-
- (New as of 2012/01/23.) A state where a shift/reduce conflict was
- solved in favor of neither (due to a use of the %nonassoc
- directive) must not perform a default reduction. Indeed, this would
- effectively mean that the failure that was requested by the user is
- forgotten and replaced with a reduction. This surprising behavior
- is present in ocamlyacc and was present in earlier versions of
- Menhir. See e.g. http://caml.inria.fr/mantis/view.php?id=5462
-
- There is a chance that we might run into trouble if the ideas
- described in the above two paragraphs collide, that is, if we
- forbid a default reduction (due to a shift/reduce conflict solved
- by %nonassoc) in a node where we would like to have default
- reduction on "#". This situation seems unlikely to arise, so I will
- not do anything about it for the moment. (Furthermore, someone who
- uses precedence declarations is looking for trouble anyway.)
-
-*)
-
-let (has_default_reduction : Lr1.node -> (Production.index * TerminalSet.t) option), hdrcount =
- Misc.tabulateo Lr1.number Lr1.fold Lr1.n (fun s ->
-
- if Lr1.forbid_default_reduction s then
- None
- else
-
- match ProductionMap.is_singleton (Lr1.invert (Lr1.reductions s)) with
- | Some (_, toks) as reduction
- when SymbolMap.purelynonterminal (Lr1.transitions s) ->
-
- if TerminalSet.mem Terminal.sharp toks then
- (* Perform default reduction on "#". *)
- reduction
- else if recoverer s then
- (* Do not perform default reduction. Allow error recovery. *)
- None
- else
- (* Perform default reduction. *)
- reduction
-
- | Some _
- | None ->
- None
-
- )
-
-let () =
- Error.logC 1 (fun f ->
- Printf.fprintf f
- "%d out of %d states have a default reduction.\n"
- hdrcount Lr1.n)
-
-(* ------------------------------------------------------------------------ *)
-
-let () =
- Time.tick "Constructing the invariant"
-
-(* ------------------------------------------------------------------------ *)
-
-(* If any fatal error was signaled up to this point, stop now. This may include
- errors signaled in the modules [lr1] and [invariant] by calling the function
- [Error.grammar_warning]. *)
-
-let () =
- if Error.errors() then
- exit 1
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module discovers and publishes information about the
- automaton.
-
- It determines the shape of the stack when a state is about to be
- entered, when a production is about to be reduced, and when a goto
- transition is about to be taken.
-
- It also determines which states should be represented (that is,
- need to physically exist on the stack at runtime) and which symbols
- need to keep track of (start or end) positions.
-
- It also determines which automaton states could potentially perform
- error recovery, and which states could have to deal with an [error]
- token. *)
-
-open Grammar
-
-(* ------------------------------------------------------------------------- *)
-(* A representation of stack shapes. *)
-
-(* A word is a representation of a stack or stack suffix. *)
-
-type word
-
-(* [fold] folds over a word. At each cell, [f] is applied to the
- accumulator, to a Boolean flag that tells whether the cell holds a
- state, to the set of possible states of the cell, and to the symbol
- associated with the cell. The stack is visited from bottom to top. *)
-
-val fold: ('a -> bool -> Symbol.t -> Lr1.NodeSet.t -> 'a) -> 'a -> word -> 'a
-
-(* [fold_top f accu s] is analogous to [fold], but only folds over the
- top stack cell, if there is one, so that [f] is either not invoked
- at all or invoked just once. *)
-
-val fold_top: (bool -> Symbol.t -> 'a) -> 'a -> word -> 'a
-
-(* ------------------------------------------------------------------------- *)
-(* Information about the stack. *)
-
-(* [stack s] is the structure of the stack at state [s]. *)
-
-val stack: Lr1.node -> word
-
-(* [prodstack prod] is the structure of the stack when production
- [prod] is about to be reduced. This function should not be called
- if production [prod] is never reduced. *)
-
-val prodstack: Production.index -> word
-
-(* [gotostack nt] is the structure of the stack when a shift
- transition over nonterminal [nt] is about to be taken. It
- consists of just one cell. *)
-
-val gotostack: Nonterminal.t -> word
-
-(* [rewind s] explains how to rewind the stack when dealing with an
- error in state [s]. It produces an instruction to either die
- (because no state on the stack can handle errors) or pop a suffix
- of the stack. In the latter case, one reaches a state that is
- either represented (its identity is physically stored in the
- bottommost cell that is popped) or unrepresented (its identity is
- statically known). *)
-
-type instruction =
- | Die
- | DownTo of word * state
-
-and state =
- | Represented
- | UnRepresented of Lr1.node
-
-val rewind: Lr1.node -> instruction
-
-(* ------------------------------------------------------------------------- *)
-(* Information about which states and positions need to physically
- exist on the stack. *)
-
-(* [represented s] tells whether state [s] must have an explicit
- representation, that is, whether it is pushed onto the stack. *)
-
-val represented: Lr1.node -> bool
-
-(* [startp symbol] and [endp symbol] tell whether start or end
- positions must be recorded for symbol [symbol]. *)
-
-val startp: Symbol.t -> bool
-val endp: Symbol.t -> bool
-
-(* ------------------------------------------------------------------------- *)
-(* Information about error handling. *)
-
-(* [recoverer s] tells whether state [s] can potentially do error
- recovery. *)
-
-val recoverer: Lr1.node -> bool
-
-(* [errorpeeker s] tells whether state [s] can potentially peek at an
- error. This is the case if, in state [s], [env.shifted] may be -1,
- that is, if an error token may be on the stream. *)
-
-val errorpeeker: Lr1.node -> bool
-
-(* ------------------------------------------------------------------------- *)
-(* Information about which productions are reduced and where. *)
-
-(* [ever_reduced prod] tells whether production [prod] is ever reduced. *)
-
-val ever_reduced: Production.index -> bool
-
-(* [fold_reduced prod] folds over all states that can reduce
- production [prod]. *)
-
-val fold_reduced: (Lr1.node -> 'a -> 'a) -> Production.index -> 'a -> 'a
-
-(* ------------------------------------------------------------------------- *)
-(* Information about default reductions. *)
-
-(* [has_default_reduction s] tells whether state [s] has a default reduction,
- and, if so, upon which set of tokens. *)
-val has_default_reduction : Lr1.node -> (Production.index * TerminalSet.t) option
-
-(* ------------------------------------------------------------------------- *)
-(* Miscellaneous. *)
-
-(* [universal symbol] tells whether every represented state has an
- outgoing transition along [symbol]. *)
-
-val universal: Symbol.t -> bool
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-(* ------------------------------------------------------------------------ *)
-(* Items. *)
-
-(* An LR(0) item encodes a pair of integers, namely the index of the
- production and the index of the bullet in the production's
- right-hand side. *)
-
-(* Both integers are packed into a single integer, using 7 bits for
- the bullet position and the rest (usually 24 bits) for the
- production index. These widths could be adjusted. *)
-
-type t = int
-
-let import (prod, pos) =
- assert (pos < 128);
- (Production.p2i prod) lsl 7 + pos
-
-let export t =
- (Production.i2p (t lsr 7), t mod 128)
-
-(* Comparison. *)
-
-let equal (item1 : t) (item2: t) =
- item1 = item2
-
-(* Position. *)
-
-let positions (item : t) =
- let prod, _ = export item in
- Production.positions prod
-
-(* [def item] looks up the production associated with this item in the
- grammar and returns [prod, nt, rhs, pos, length], where [prod] is
- the production's index, [nt] and [rhs] represent the production,
- [pos] is the position of the bullet in the item, and [length] is
- the length of the production's right-hand side. *)
-
-let def t =
- let prod, pos = export t in
- let nt, rhs = Production.def prod in
- let length = Array.length rhs in
- assert ((pos >= 0) && (pos <= length));
- prod, nt, rhs, pos, length
-
-let nt t =
- let _, nt, _, _, _ = def t in
- nt
-
-let startnt t =
- let _, _, rhs, pos, length = def t in
- assert (pos = 0 && length = 1);
- match rhs.(0) with
- | Symbol.N nt ->
- nt
- | Symbol.T _ ->
- assert false
-
-(* Printing. *)
-
-let print item =
- let _, nt, rhs, pos, length = def item in
- Printf.sprintf "%s -> %s" (Nonterminal.print false nt) (Symbol.printaod 0 pos rhs)
-
-(* Classifying items. *)
-
-type kind =
- | Shift of Symbol.t * t
- | Reduce of Production.index
-
-let classify item =
- let prod, _, rhs, pos, length = def item in
- if pos = length then
- Reduce prod
- else
- Shift (rhs.(pos), import (prod, pos + 1))
-
-(* Sets of items and maps over items. Hashing these data structures is
- specifically allowed, so balanced trees (for instance) would not be
- applicable here. *)
-
-module Map = Patricia.Big
-module Set = Map.Domain
-
-(* This functor performs precomputation that helps efficiently compute
- the closure of an LR(0) or LR(1) state. The precomputation requires
- time linear in the size of the grammar. The nature of the lookahead
- sets remains abstract. *)
-
-(* The precomputation consists in building the LR(0) nondeterministic
- automaton. This is a graph whose nodes are items and whose edges
- are epsilon transitions. (We do not care about shift transitions
- here.) Lookahead information can be attached to nodes and is
- propagated through the graph during closure computations. *)
-
-module Closure (L : Lookahead.S) = struct
-
- type state = L.t Map.t
-
- type node = {
-
- (* Nodes are sequentially numbered so as to allow applying
- Tarjan's algorithm (below). *)
-
- num: int;
-
- (* Each node is associated with an item. *)
-
- item: t;
-
- (* All of the epsilon transitions that leave a node have the
- same behavior with respect to lookahead information. *)
-
- (* The lookahead set transmitted along an epsilon transition is
- either a constant, or the union of a constant and the lookahead
- set at the source node. The former case corresponds to a source
- item whose trailer is not nullable, the latter to a source item
- whose trailer is nullable. *)
-
- epsilon_constant: L.t;
- epsilon_transmits: bool;
-
- (* Each node carries pointers to its successors through
- epsilon transitions. This field is never modified
- once initialization is over. *)
-
- mutable epsilon_transitions: node list;
-
- (* The following fields are transient, that is, only used
- temporarily during graph traversals. Marks are used to
- recognize which nodes have been traversed already. Lists
- of predecessors are used to record which edges have been
- traversed. Lookahead information is attached with each
- node. *)
-
- mutable mark: Mark.t;
- mutable predecessors: node list;
- mutable lookahead: L.t;
- }
-
- (* Allocate one graph node per item and build a mapping of
- items to nodes. *)
-
- let count =
- ref 0
-
- let mapping : node array array =
- Array.create Production.n [||]
-
- let item2node item =
- let prod, pos = export item in
- mapping.(Production.p2i prod).(pos)
-
- let () =
- Production.iter (fun prod ->
- let nt, rhs = Production.def prod in
- let length = Array.length rhs in
- mapping.(Production.p2i prod) <- Array.init (length+1) (fun pos ->
-
- let item = import (prod, pos) in
- let num = !count in
- count := num + 1;
-
- (* The lookahead set transmitted through an epsilon
- transition is the FIRST set of the remainder of
- the source item, plus, if that is nullable, the
- lookahead set of the source item. *)
-
- let constant, transmits =
- if pos < length then
- let nullable, first = Analysis.nullable_first_rhs rhs (pos + 1) in
- L.constant first, nullable
- else
- (* No epsilon transitions leave this item. *)
- L.empty, false
- in
-
- {
- num = num;
- item = item;
- epsilon_constant = constant;
- epsilon_transmits = transmits;
- epsilon_transitions = []; (* temporary placeholder *)
- mark = Mark.none;
- predecessors = [];
- lookahead = L.empty;
- }
-
- )
- )
-
- (* At each node, compute transitions. *)
-
- let () =
- Production.iter (fun prod ->
- let nt, rhs = Production.def prod in
- let length = Array.length rhs in
- Array.iteri (fun pos node ->
-
- node.epsilon_transitions <-
- if pos < length then
- match rhs.(pos) with
- | Symbol.N nt ->
- Production.foldnt nt [] (fun prod nodes ->
- (item2node (import (prod, 0))) :: nodes
- )
- | Symbol.T _ ->
- []
- else
- []
-
- ) mapping.(Production.p2i prod)
- )
-
- (* Detect and reject cycles of transitions that transmit a lookahead
- set.
-
- We need to ensure that there are no such cycles in order to be
- able to traverse these transitions in topological order.
-
- Each such cycle corresponds to a set of productions of the form
- A1 -> A2, A2 -> A3, ..., An -> A1 (modulo nullable
- trailers). Such cycles are unlikely to occur in realistic
- grammars, so our current approach is to reject the grammar if
- such a cycle exists. Actually, according to DeRemer and Pennello
- (1982), such a cycle is exactly an includes cycle, and implies
- that the grammar is not LR(k) for any k, unless A1, ..., An are
- in fact uninhabited. In other words, this is a pathological
- case. *)
-
- (* Yes, indeed, this is called a cycle in Aho & Ullman's book,
- and a loop in Grune & Jacobs' book. It is not difficult to
- see that (provided all symbols are inhabited) the grammar
- is infinitely ambiguous if and only if there is a loop. *)
-
- module P = struct
-
- type foo = node
- type node = foo
-
- let n =
- !count
-
- let index node =
- node.num
-
- let iter f =
- Array.iter (fun nodes ->
- Array.iter f nodes
- ) mapping
-
- let successors f node =
- if node.epsilon_transmits then
- List.iter f node.epsilon_transitions
-
- end
-
- module T = Tarjan.Run (P)
-
- let cycle scc =
- let items = List.map (fun node -> node.item) scc in
- let positions = List.flatten (List.map positions items) in
- let names = String.concat "\n" (List.map print items) in
- Error.error
- positions
- (Printf.sprintf "the grammar is ambiguous.\n\
- The following items participate in an epsilon-cycle:\n\
- %s" names)
-
- let () =
- P.iter (fun node ->
- let scc = T.scc node in
- match scc with
- | [] ->
- ()
- | [ node ] ->
-
- (* This is a strongly connected component of one node. Check
- whether it carries a self-loop. Forbidding self-loops is not
- strictly required by the code that follows, but is consistent
- with the fact that we forbid cycles of length greater than 1. *)
-
- P.successors (fun successor ->
- if successor.num = node.num then
- cycle scc
- ) node
-
- | _ ->
-
- (* This is a strongly connected component of at least two
- elements. *)
-
- cycle scc
- )
-
- (* Closure computation. *)
-
- let closure (items : state) : state =
-
- (* Explore the graph forwards, starting from these items. Marks
- are used to tell which nodes have been visited. Build a list of
- all visited nodes; this is in fact the list of all items in the
- closure.
-
- At initial nodes and when reaching a node through a transition,
- record a lookahead set.
-
- When we reach a node through a transition that transmits the
- lookahead set found at its source, record its source, so as to
- allow re-traversing this transition backwards (below). *)
-
- let this = Mark.fresh() in
- let nodes = ref [] in
-
- let rec visit father transmits toks node =
- if Mark.same node.mark this then begin
- (* Node has been visited already. *)
- node.lookahead <- L.union toks node.lookahead;
- if transmits then
- node.predecessors <- father :: node.predecessors
- end
- else begin
- (* Node is new. *)
- node.predecessors <- if transmits then [ father ] else [];
- node.lookahead <- toks;
- follow node
- end
-
- and follow node =
- node.mark <- this;
- nodes := node :: !nodes;
- List.iter
- (visit node node.epsilon_transmits node.epsilon_constant)
- node.epsilon_transitions
-
- in
-
- Map.iter (fun item toks ->
- let node = item2node item in
- visit node (* dummy! *) false toks node
- ) items;
-
- let nodes =
- !nodes in
-
- (* Explore the graph of transmitting transitions backwards. By
- hypothesis, it is acyclic, so this is a topological
- walk. Lookahead sets are inherited through transitions. *)
-
- let this = Mark.fresh() in
-
- let rec walk node =
- if not (Mark.same node.mark this) then begin
- (* Node is new. *)
- node.mark <- this;
- (* Explore all predecessors and merge their lookahead
- sets into the current node's own lookahead set. *)
- List.iter (fun predecessor ->
- walk predecessor;
- node.lookahead <- L.union predecessor.lookahead node.lookahead
- ) node.predecessors
- end
- in
-
- List.iter walk nodes;
-
- (* Done. Produce a mapping of items to lookahead sets.
- Clear all transient fields so as to reduce pressure
- on the GC -- this does not make much difference. *)
-
- List.fold_left (fun closure node ->
- node.predecessors <- [];
- let closure = Map.add node.item node.lookahead closure in
- node.lookahead <- L.empty;
- closure
- ) Map.empty nodes
-
- (* End of closure computation *)
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-(* An LR(0) item encodes a pair of integers, namely the index of the
- production and the index of the bullet in the production's
- right-hand side. *)
-
-type t
-val import: Production.index * int -> t
-val export: t -> Production.index * int
-
-(* Comparison. *)
-
-val equal: t -> t -> bool
-
-(* [def item] looks up the production associated with this item in the
- grammar and returns [prod, nt, rhs, pos, length], where [prod] is
- the production's index, [nt] and [rhs] represent the production,
- [pos] is the position of the bullet in the item, and [length] is
- the length of the production's right-hand side. *)
-
-val def: t -> Production.index * Nonterminal.t * Symbol.t array * int * int
-
-(* If [item] is a start item, [startnt item] returns the start
- nonterminal that corresponds to [item]. *)
-
-val startnt: t -> Nonterminal.t
-
-(* Printing. *)
-
-val print: t -> string
-
-(* Classifying items as shift or reduce items. A shift item is one
- where the bullet can still advance. A reduce item is one where the
- bullet has reached the end of the right-hand side. *)
-
-type kind =
- | Shift of Symbol.t * t
- | Reduce of Production.index
-
-val classify: t -> kind
-
-(* Sets of items and maps over items. Hashing these data structures is
- specifically allowed. *)
-
-module Set : GSet.S with type element = t
-module Map : GMap.S with type key = t
- and type Domain.t = Set.t
-
-(* This functor performs precomputation that helps efficiently compute
- the closure of an LR(0) or LR(1) state. The precomputation requires
- time linear in the size of the grammar. The nature of the lookahead
- sets remains abstract. *)
-
-module Closure (L : Lookahead.S) : sig
-
- (* A state maps items to lookahead information. *)
-
- type state = L.t Map.t
-
- (* This takes the closure of a state through all epsilon transitions. *)
-
- val closure: state -> state
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module provides some type and function definitions
- that help deal with the keywords that we recognize within
- semantic actions. *)
-
-(* ------------------------------------------------------------------------- *)
-(* Types. *)
-
-(* The user can request position information either at type
- [int] (a simple offset) or at type [Lexing.position]. *)
-
-type flavor =
- | FlavorOffset
- | FlavorPosition
-
-(* The user can request position information about the
- start or end of a symbol. *)
-
-type where =
- | WhereStart
- | WhereEnd
-
-(* The user can request position information about a production's
- left-hand side or about one of the symbols in its right-hand
- side, which he can refer to by position or by name. *)
-
-type subject =
- | Left
- | RightDollar of int
- | RightNamed of string
-
-(* Keywords inside semantic actions. They allow access to semantic
- values or to position information. *)
-
-type keyword =
- | Dollar of int
- | Position of subject * where * flavor
- | PreviousError
- | SyntaxError
-
-(* ------------------------------------------------------------------------- *)
-(* These auxiliary functions help map a [Position] keyword to the
- name of the variable that the keyword is replaced with. *)
-
-let where = function
- | WhereStart ->
- "start"
- | WhereEnd ->
- "end"
-
-let subject = function
- | Left ->
- ""
- | RightDollar i ->
- Printf.sprintf "__%d_" i
- | RightNamed id ->
- Printf.sprintf "_%s_" id
-
-let flavor = function
- | FlavorPosition ->
- "pos"
- | FlavorOffset ->
- "ofs"
-
-let posvar s w f =
- Printf.sprintf "_%s%s%s" (where w) (flavor f) (subject s)
-
-(* ------------------------------------------------------------------------- *)
-(* Sets of keywords. *)
-
-module KeywordSet =
- struct
- include Set.Make (struct
- type t = keyword
- let compare = compare
- end)
-
- (* This converts a list of keywords with positions into a set of keywords. *)
- let from_list keywords =
- List.fold_right add keywords empty
-
- end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module provides some type and function definitions
- that help deal with the keywords that we recognize within
- semantic actions. *)
-
-(* The user can request position information either at type
- [int] (a simple offset) or at type [Lexing.position]. *)
-
-type flavor =
- | FlavorOffset
- | FlavorPosition
-
-(* The user can request position information about the
- start or end of a symbol. *)
-
-type where =
- | WhereStart
- | WhereEnd
-
-(* The user can request position information about a production's
- left-hand side or about one of the symbols in its right-hand
- side, which he can refer to by position or by name. *)
-
-type subject =
- | Left
- | RightDollar of int
- | RightNamed of string
-
-(* Keywords inside semantic actions. They allow access to semantic
- values or to position information. *)
-
-type keyword =
- | Dollar of int
- | Position of subject * where * flavor
- | PreviousError
- | SyntaxError
-
-(* This maps a [Position] keyword to the name of the variable that the
- keyword is replaced with. *)
-
-val posvar: subject -> where -> flavor -> string
-
-(* Sets of keywords. *)
-module KeywordSet :
- sig
- include Set.S
-
- (* This converts a list of keywords with positions into a set of keywords. *)
- val from_list: elt list -> t
-
- end with type elt = keyword
-
-(* (\* TEMPORARY These functions are replaced by the ones found *)
-(* in [Action]. *\) *)
-(* (\* These iterate over a list of keywords with positions, disregarding *)
-(* the positions, and making sure that duplicate elements are not *)
-(* presented. *\) *)
-
-(* val iter: (keyword -> unit) -> (keyword * 'a * 'b) list -> unit *)
-(* val fold: (keyword -> 'c -> 'c) -> (keyword * 'a * 'b) list -> 'c -> 'c *)
-
-(* (\* These tell whether a list of keywords with positions contains *)
-(* a certain keyword. *\) *)
-
-(* val has_previouserror: (keyword * 'a * 'b) list -> bool *)
-(* val has_syntaxerror: (keyword * 'a * 'b) list -> bool *)
-(* val has_leftstart: (keyword * 'a * 'b) list -> bool *)
-(* val has_leftend: (keyword * 'a * 'b) list -> bool *)
-(* val has_dollar: int -> (keyword * 'a * 'b) list -> bool *)
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This code analyzes the output of [ocamldep] and returns the list
- of [.cmi] files that the [.cmo] file depends on. *)
-
-{
-
- open Lexing
-
- let fail lexbuf =
- Error.error []
- (Printf.sprintf
- "failed to make sense of ocamldep's output (character %d)."
- lexbuf.lex_curr_p.pos_cnum)
-
-}
-
-let newline = ('\n' | '\r' | "\r\n")
-
-let whitespace = ( ' ' | '\t' | ('\\' newline) )
-
-let entrychar = [^ '\n' '\r' '\t' ' ' '\\' ':' ]
-
-let entry = ((entrychar+ as basename) ".cm" ('i' | 'o' | 'x') as filename)
-
-(* [main] recognizes a sequence of lines, where a line consists of an
- entry, followed by a colon, followed by a list of entries. *)
-
-rule main = parse
-| eof
- { [] }
-| entry ":"
- { let bfs = collect [] lexbuf in
- ((basename, filename), bfs) :: main lexbuf }
-| _
- { fail lexbuf }
-
-(* [collect] recognizes a list of entries, separated with spaces and
- ending in a newline. *)
-
-and collect bfs = parse
-| whitespace+ entry
- { collect ((basename, filename) :: bfs) lexbuf }
-| whitespace* newline
- { bfs }
-| _
-| eof
- { fail lexbuf }
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-{
-
- open Lexing
- open Parser
- open Positions
-
- (* This wrapper saves the current lexeme start, invokes its argument,
- and restores it. This allows transmitting better positions to the
- parser. *)
-
- let savestart lexbuf f =
- let startp = lexbuf.lex_start_p in
- let token = f lexbuf in
- lexbuf.lex_start_p <- startp;
- token
-
- (* Updates the line counter, which is used in some error messages. *)
-
- let update_loc lexbuf =
- let pos = lexbuf.lex_curr_p in
- lexbuf.lex_curr_p <- { pos with
- pos_lnum = pos.pos_lnum + 1;
- pos_bol = pos.pos_cnum;
- }
-
- (* Extracts a chunk out of the source file. *)
-
- let chunk ofs1 ofs2 =
- let contents = Error.get_file_contents() in
- let len = ofs2 - ofs1 in
- String.sub contents ofs1 len
-
- (* Extracts a chunk out of the source file, delimited by
- one position and extending to the end of the file. *)
-
- let echunk ofs1 =
- let contents = Error.get_file_contents() in
- let len = String.length contents - ofs1 in
- String.sub contents ofs1 len
-
- (* Overwrites an old character with a new one at a specified
- offset in a string. *)
-
- let overwrite content offset c1 c2 =
- assert (content.[offset] = c1);
- content.[offset] <- c2
-
- (* Creates a stretch. *)
-
- let mk_stretch parenthesize pos1 pos2 pkeywords =
- let ofs1 = pos1.pos_cnum
- and ofs2 = pos2.pos_cnum in
- let raw_content = chunk ofs1 ofs2 in
- let content = String.copy raw_content in
- (* Turn our keywords into valid Objective Caml identifiers
- by replacing '$', '(', and ')' with '_'. Bloody. *)
- List.iter (function { value = keyword; position = pos } ->
- let pos = start_of_position pos in
- let ofs = pos.pos_cnum - ofs1 in
- overwrite content ofs '$' '_';
- match keyword with
- | Keyword.Dollar _
- | Keyword.Position (Keyword.Left, _, _)
- | Keyword.PreviousError ->
- ()
- | Keyword.SyntaxError ->
- (* $syntaxerror is replaced with
- (raise _eRR) *)
- let source = "(raise _eRR)" in
- String.blit source 0 content ofs (String.length source)
- | Keyword.Position (subject, where, _) ->
- let ofslpar =
- match where with
- | Keyword.WhereStart ->
- ofs + 9
- | Keyword.WhereEnd ->
- ofs + 7
- in
- overwrite content ofslpar '(' '_';
- match subject with
- | Keyword.Left ->
- assert false
- | Keyword.RightDollar i ->
- overwrite content (ofslpar + 1) '$' '_';
- overwrite content (ofslpar + 2 + String.length (string_of_int i)) ')' '_'
- | Keyword.RightNamed id ->
- overwrite content (ofslpar + 1 + String.length id) ')' '_'
- ) pkeywords;
- (* Add whitespace so that the column numbers match those of the source file.
- If requested, add parentheses so that the semantic action can be inserted
- into other code without ambiguity. *)
- let content =
- if parenthesize then
- (String.make (pos1.pos_cnum - pos1.pos_bol - 1) ' ') ^ "(" ^ content ^ ")"
- else
- (String.make (pos1.pos_cnum - pos1.pos_bol) ' ') ^ content
- in
- {
- Stretch.stretch_filename = Error.get_filename();
- Stretch.stretch_linenum = pos1.pos_lnum;
- Stretch.stretch_linecount = pos2.pos_lnum - pos1.pos_lnum;
- Stretch.stretch_content = content;
- Stretch.stretch_raw_content = raw_content;
- Stretch.stretch_keywords = pkeywords
- }
-
- (* Translates the family of position-related keywords to abstract
- syntax. *)
-
- let mk_keyword lexbuf w f n id =
- let where =
- match w with
- | Some _ ->
- Keyword.WhereStart
- | None ->
- Keyword.WhereEnd
- and flavor =
- match f with
- | Some _ ->
- Keyword.FlavorPosition
- | None ->
- Keyword.FlavorOffset
- and subject =
- match n, id with
- | Some n, None ->
- Keyword.RightDollar (int_of_string n)
- | None, Some id ->
- Keyword.RightNamed id
- | None, None ->
- Keyword.Left
- | Some _, Some _ ->
- assert false
- in
- let keyword = Keyword.Position (subject, where, flavor) in
- with_cpos lexbuf keyword
-
- (* Objective Caml's reserved words. *)
-
- let reserved =
- let table = Hashtbl.create 149 in
- List.iter (fun word -> Hashtbl.add table word ()) [
- "and";
- "as";
- "assert";
- "begin";
- "class";
- "constraint";
- "do";
- "done";
- "downto";
- "else";
- "end";
- "exception";
- "external";
- "false";
- "for";
- "fun";
- "function";
- "functor";
- "if";
- "in";
- "include";
- "inherit";
- "initializer";
- "lazy";
- "let";
- "match";
- "method";
- "module";
- "mutable";
- "new";
- "object";
- "of";
- "open";
- "or";
- "parser";
- "private";
- "rec";
- "sig";
- "struct";
- "then";
- "to";
- "true";
- "try";
- "type";
- "val";
- "virtual";
- "when";
- "while";
- "with";
- "mod";
- "land";
- "lor";
- "lxor";
- "lsl";
- "lsr";
- "asr";
- ];
- table
-
- (* A short-hand. *)
-
- let error1 pos msg =
- Error.error (Positions.one pos) msg
-
-}
-
-let newline = ('\010' | '\013' | "\013\010")
-
-let whitespace = [ ' ' '\t' ';' ]
-
-let lowercase = ['a'-'z' '\223'-'\246' '\248'-'\255' '_']
-
-let uppercase = ['A'-'Z' '\192'-'\214' '\216'-'\222']
-
-let identchar = ['A'-'Z' 'a'-'z' '_' '\192'-'\214' '\216'-'\246' '\248'-'\255' '0'-'9'] (* '\'' forbidden *)
-
-let poskeyword =
- '$'
- (("start" as w) | "end")
- (("pos" as f) | "ofs")
- ( '(' ( '$' (['0'-'9']+ as n) | ((lowercase identchar*) as id)) ')')?
-
-let previouserror =
- "$previouserror"
-
-let syntaxerror =
- "$syntaxerror"
-
-rule main = parse
-| "%token"
- { TOKEN }
-| "%type"
- { TYPE }
-| "%left"
- { LEFT }
-| "%right"
- { RIGHT }
-| "%nonassoc"
- { NONASSOC }
-| "%start"
- { START }
-| "%prec"
- { PREC }
-| "%public"
- { PUBLIC }
-| "%parameter"
- { PARAMETER }
-| "%inline"
- { INLINE }
-| "%%"
- { let ofs = lexeme_end lexbuf in
- PERCENTPERCENT (lazy (echunk ofs)) }
-| ":"
- { COLON }
-| ","
- { COMMA }
-| "="
- { EQUAL }
-| "("
- { LPAREN }
-| ")"
- { RPAREN }
-| "|"
- { BAR }
-| "?"
- { QUESTION }
-| "*"
- { STAR }
-| "+"
- { PLUS }
-| (lowercase identchar *) as id
- { if Hashtbl.mem reserved id then
- Error.errorp
- (Positions.with_poss (lexeme_start_p lexbuf) (lexeme_end_p lexbuf) ())
- "this is an Objective Caml reserved word."
- else
- LID (with_pos (cpos lexbuf) id)
- }
-| (uppercase identchar *) as id
- { UID (with_pos (cpos lexbuf) id) }
-| "//" [^ '\010' '\013']* newline (* skip C++ style comment *)
-| newline
- { update_loc lexbuf; main lexbuf }
-| whitespace+
- { main lexbuf }
-| "/*"
- { comment (lexeme_start_p lexbuf) lexbuf; main lexbuf }
-| "(*"
- { ocamlcomment (lexeme_start_p lexbuf) lexbuf; main lexbuf }
-| "<"
- { savestart lexbuf (ocamltype (lexeme_end_p lexbuf)) }
-| "%{"
- { savestart lexbuf (fun lexbuf ->
- let openingpos = lexeme_end_p lexbuf in
- let closingpos, _ = action true openingpos [] lexbuf in
- (* TEMPORARY if keyword list nonempty, issue an error *)
- HEADER (mk_stretch false openingpos closingpos [])
- ) }
-| "{"
- { savestart lexbuf (fun lexbuf ->
- let openingpos = lexeme_end_p lexbuf in
- let closingpos, pkeywords = action false openingpos [] lexbuf in
- let stretch = mk_stretch true openingpos closingpos pkeywords in
- ACTION (Action.from_stretch stretch)
- ) }
-(* TEMPORARY comprendre si la différence entre header et action est bien
- justifiée et si certains choix comme le parenthésage et le
- traitement des keywords ne pourraient pas être effectués
- plus loin. *)
-| eof
- { EOF }
-| _
- { error1 (lexeme_start_p lexbuf) "unexpected character(s)." }
-
-(* Skip C style comments. *)
-
-and comment openingpos = parse
-| newline
- { update_loc lexbuf; comment openingpos lexbuf }
-| "*/"
- { () }
-| eof
- { error1 openingpos "unterminated comment." }
-| _
- { comment openingpos lexbuf }
-
-(* Collect an O'Caml type delimited by angle brackets. Angle brackets can
- appear as part of O'Caml function types. They might also appear as part
- of O'Caml variant types, but we ignore that possibility for the moment. *)
-
-and ocamltype openingpos = parse
-| "->"
- { ocamltype openingpos lexbuf }
-| '>'
- { OCAMLTYPE (Stretch.Declared (mk_stretch true openingpos (lexeme_start_p lexbuf) [])) }
-| "(*"
- { ocamlcomment (lexeme_start_p lexbuf) lexbuf; ocamltype openingpos lexbuf }
-| newline
- { update_loc lexbuf; ocamltype openingpos lexbuf }
-| eof
- { error1 openingpos "unterminated Objective Caml type." }
-| _
- { ocamltype openingpos lexbuf }
-
-(* Collect O'Caml code delimited by curly brackets. Any occurrences of
- the special ``$i'' identifiers are recorded in the accumulating
- parameter [pkeywords]. Nested curly brackets must be properly
- counted. Nested parentheses are also kept track of, so as to better
- report errors when they are not balanced. *)
-
-and action percent openingpos pkeywords = parse
-| '{'
- { let _, pkeywords = action false (lexeme_end_p lexbuf) pkeywords lexbuf in
- action percent openingpos pkeywords lexbuf }
-| ("}" | "%}") as delimiter
- { match percent, delimiter with
- | true, "%}"
- | false, "}" ->
- (* This is the delimiter we were instructed to look for. *)
- lexeme_start_p lexbuf, pkeywords
- | _, _ ->
- (* This is not it. *)
- error1 openingpos "unbalanced opening brace."
- }
-| '('
- { let _, pkeywords = parentheses (lexeme_end_p lexbuf) pkeywords lexbuf in
- action percent openingpos pkeywords lexbuf }
-| '$' (['0'-'9']+ as n)
- { let pkeyword = with_cpos lexbuf (Keyword.Dollar (int_of_string n)) in
- action percent openingpos (pkeyword :: pkeywords) lexbuf }
-| poskeyword
- { let pkeyword = mk_keyword lexbuf w f n id in
- action percent openingpos (pkeyword :: pkeywords) lexbuf }
-| previouserror
- { let pkeyword = with_cpos lexbuf Keyword.PreviousError in
- action percent openingpos (pkeyword :: pkeywords) lexbuf }
-| syntaxerror
- { let pkeyword = with_cpos lexbuf Keyword.SyntaxError in
- action percent openingpos (pkeyword :: pkeywords) lexbuf }
-| '"'
- { string (lexeme_start_p lexbuf) lexbuf;
- action percent openingpos pkeywords lexbuf }
-| "'"
- { char lexbuf;
- action percent openingpos pkeywords lexbuf }
-| "(*"
- { ocamlcomment (lexeme_start_p lexbuf) lexbuf;
- action percent openingpos pkeywords lexbuf }
-| newline
- { update_loc lexbuf;
- action percent openingpos pkeywords lexbuf }
-| ')'
-| eof
- { error1 openingpos "unbalanced opening brace." }
-| _
- { action percent openingpos pkeywords lexbuf }
-
-and parentheses openingpos pkeywords = parse
-| '('
- { let _, pkeywords = parentheses (lexeme_end_p lexbuf) pkeywords lexbuf in
- parentheses openingpos pkeywords lexbuf }
-| ')'
- { lexeme_start_p lexbuf, pkeywords }
-| '{'
- { let _, pkeywords = action false (lexeme_end_p lexbuf) pkeywords lexbuf in
- parentheses openingpos pkeywords lexbuf }
-| '$' (['0'-'9']+ as n)
- { let pkeyword = with_cpos lexbuf (Keyword.Dollar (int_of_string n)) in
- parentheses openingpos (pkeyword :: pkeywords) lexbuf }
-| poskeyword
- { let pkeyword = mk_keyword lexbuf w f n id in
- parentheses openingpos (pkeyword :: pkeywords) lexbuf }
-| previouserror
- { let pkeyword = with_cpos lexbuf Keyword.PreviousError in
- parentheses openingpos (pkeyword :: pkeywords) lexbuf }
-| syntaxerror
- { let pkeyword = with_cpos lexbuf Keyword.SyntaxError in
- parentheses openingpos (pkeyword :: pkeywords) lexbuf }
-| '"'
- { string (lexeme_start_p lexbuf) lexbuf; parentheses openingpos pkeywords lexbuf }
-| "'"
- { char lexbuf; parentheses openingpos pkeywords lexbuf }
-| "(*"
- { ocamlcomment (lexeme_start_p lexbuf) lexbuf; parentheses openingpos pkeywords lexbuf }
-| newline
- { update_loc lexbuf; parentheses openingpos pkeywords lexbuf }
-| '}'
-| eof
- { error1 openingpos "unbalanced opening parenthesis." }
-| _
- { parentheses openingpos pkeywords lexbuf }
-
-(* Skip O'Caml comments. Comments can be nested and can contain
- strings or characters, which must be correctly analyzed. (A string
- could contain begin-of-comment or end-of-comment sequences, which
- must be ignored; a character could contain a begin-of-string
- sequence.) *)
-
-and ocamlcomment openingpos = parse
-| "*)"
- { () }
-| "(*"
- { ocamlcomment (lexeme_start_p lexbuf) lexbuf; ocamlcomment openingpos lexbuf }
-| '"'
- { string (lexeme_start_p lexbuf) lexbuf; ocamlcomment openingpos lexbuf }
-| "'"
- { char lexbuf; ocamlcomment openingpos lexbuf }
-| newline
- { update_loc lexbuf; ocamlcomment openingpos lexbuf }
-| eof
- { error1 openingpos "unterminated Objective Caml comment." }
-| _
- { ocamlcomment openingpos lexbuf }
-
-(* Skip O'Caml strings. *)
-
-and string openingpos = parse
-| '"'
- { () }
-| '\\' newline
-| newline
- { update_loc lexbuf; string openingpos lexbuf }
-| '\\' _
- (* Upon finding a backslash, skip the character that follows,
- unless it is a newline. Pretty crude, but should work. *)
- { string openingpos lexbuf }
-| eof
- { error1 openingpos "unterminated Objective Caml string." }
-| _
- { string openingpos lexbuf }
-
-(* Skip O'Caml characters. A lone quote character is legal inside
- a comment, so if we don't recognize the matching closing quote,
- we simply abandon. *)
-
-and char = parse
-| '\\'? newline "'"
- { update_loc lexbuf }
-| [^ '\\' '\''] "'"
-| '\\' _ "'"
-| '\\' ['0'-'9'] ['0'-'9'] ['0'-'9'] "'"
-| '\\' 'x' ['0'-'9' 'a'-'f' 'A'-'F'] ['0'-'9' 'a'-'f' 'A'-'F'] "'"
-| ""
- { () }
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This code analyzes the output of [ocamlc -i] and returns a list
- of identifiers together with their types. Types are represented
- by offsets in the source string. *)
-
-{
-
- let fail () =
- Error.error [] "failed to make sense of ocamlc's output."
-
-}
-
-let whitespace = [ ' ' '\t' '\n' '\r' ]
-
-let lowercase = ['a'-'z' '\223'-'\246' '\248'-'\255' '_']
-
-let identchar = ['A'-'Z' 'a'-'z' '_' '\192'-'\214' '\216'-'\246' '\248'-'\255' '0'-'9'] (* '\'' forbidden *)
-
-(* Read a list of bindings. We start immediately after a [val]
- keyword, so we expect either an end marker, or an identifier,
- followed by a colon, followed by a type, followed by another list
- of bindings. In the latter case, we recognize the identifier and
- the colon, record where the type begins, and pass control to
- [type_then_bindings]. *)
-
-rule bindings env = parse
-| "menhir_end_marker : int"
- { env }
-| whitespace* ((lowercase identchar*) as id) whitespace* ':' whitespace*
- { type_then_bindings env id (Lexing.lexeme_end lexbuf) lexbuf }
-| _
-| eof
- { fail() }
-
-(* Read a type followed by a list of bindings. *)
-
-and type_then_bindings env id openingofs = parse
-| whitespace+ "val" whitespace
- { let closingofs = Lexing.lexeme_start lexbuf in
- bindings ((id, openingofs, closingofs) :: env) lexbuf }
-| _
- { type_then_bindings env id openingofs lexbuf }
-| eof
- { fail() }
-
-(* Skip up to the first [val] keyword that follows the begin marker,
- and start from there. *)
-
-and main = parse
-| _* "val menhir_begin_marker : int" whitespace+ "val" whitespace+
- { bindings [] lexbuf }
-| _
-| eof
- { fail() }
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This simple function counts the number of newline characters
- in a string. *)
-
-let newline = ('\010' | '\013' | "\013\010")
-
-let ordinary = [^ '\010' '\013']+
-
-rule count n = parse
-| eof
- { n }
-| newline
- { count (n + 1) lexbuf }
-| ordinary
- { count n lexbuf }
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-type 'a m = 'a list
-
-let return x =
- [ x ]
-
-let bind l f =
- List.flatten (List.map f l)
-
-let ( >>= ) l f =
- bind l f
-
-(*
- 1. (return x) >>= f == f x
-
- bind [ x ] f
- = List.flatten (List.map f [ x ])
- = f x
-
- 2. m >>= return == m
-
- bind l return
- = List.flatten (List.map (fun x -> [ x ]) (x1::x2::..::xn))
- = List.flatten ([x1]::...::[xn])
- = x1::...::xn
- = l
-
- 3. (m >>= f) >>= g == m >>= (\x -> f x >>= g)
-
- bind (bind l f) g
- = List.flatten (List.map g (List.flatten (List.map f (x1::...::xn))))
- = List.flatten (List.map g (f x1 :: f x2 :: ... :: f xn))
- = List.flatten (List.map g ([fx1_1; fx1_2 ... ] :: [fx2_1; ... ] :: ...))
- = List.flatten ([ g fx1_1; g fx_1_2 ... ] :: [ g fx_2_1; ... ] ...)
- = List.flatten (List.map (fun x -> List.flatten (List.map g (f x))) l)
- = bind l (fun x -> bind (f x) g)
-
-*)
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: listMonad.mli,v 1.2 2005/12/01 16:20:06 regisgia Exp $ *)
-
-(** Monad type which represents a list of results. *)
-type 'a m = 'a list
-
-(** [bind x f] applies [f] to a list of results, returning
- a list of results. *)
-val bind: 'a m -> ('a -> 'b m) -> 'b m
-val ( >>= ) : 'a m -> ('a -> 'b m) -> 'b m
-
-(** [return x] is the left and right unit of [bind]. *)
-val return: 'a -> 'a m
-
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* These are the operations required of lookahead sets during
- a closure computation. This signature is exploited by the
- functor [Item.Closure]. *)
-
-module type S = sig
-
- (* The type of lookahead sets. *)
- type t
-
- (* The empty lookahead set. Redundant with the following, but
- convenient. *)
- val empty: t
-
- (* A concrete, constant set of terminal symbols. *)
- val constant: Grammar.TerminalSet.t -> t
-
- (* [union s1 s2] returns the union of [s1] and [s2]. *)
- val union: t -> t -> t
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-module InfiniteArray =
- MenhirLib.InfiniteArray
-
-(* ------------------------------------------------------------------------ *)
-(* Symbolic lookahead information. *)
-
-(* A symbolic lookahead set consists of an actual concrete set of
- terminal symbols and of a number of set variables. Set variables as
- encoded as integers. *)
-
-module SymbolicLookahead = struct
-
- type t =
- TerminalSet.t * CompressedBitSet.t
-
- let constant toks =
- (toks, CompressedBitSet.empty)
-
- let empty =
- constant TerminalSet.empty
-
- let union (toks1, vars1) ((toks2, vars2) as s2) =
- let toks = TerminalSet.union toks1 toks2
- and vars = CompressedBitSet.union vars1 vars2 in
- if toks2 == toks && vars2 == vars then
- s2
- else
- (toks, vars)
-
- let variable (var : int) : t =
- (TerminalSet.empty, CompressedBitSet.singleton var)
-
- let project (toks, vars) =
- assert (CompressedBitSet.is_empty vars);
- toks
-
-end
-
-(* We will perform closure operations over symbolic lookahead sets.
- This allows us to later represent LR(1) states as pairs of an
- LR(0) node number and an array of concrete lookahead sets. *)
-
-module SymbolicClosure =
- Item.Closure(SymbolicLookahead)
-
-(* Closure operations over concrete lookahead sets are also used (when
- explaining conflicts). One could take another instance of the
- functor. The approach below is somewhat less elegant and makes each
- call to [closure] somewhat slower, but saves the cost of
- instantiating the functor again -- which is linear in the size of
- the grammar. *)
-
-type concretelr1state =
- TerminalSet.t Item.Map.t
-
-let closure (state : concretelr1state) : concretelr1state =
- Item.Map.map SymbolicLookahead.project
- (SymbolicClosure.closure
- (Item.Map.map SymbolicLookahead.constant state))
-
-(* ------------------------------------------------------------------------ *)
-(* Finding which non-epsilon transitions leave a set of items. This
- code is parametric in the nature of lookahead sets. *)
-
-let transitions (state : 'a Item.Map.t) : 'a Item.Map.t SymbolMap.t =
-
- Item.Map.fold (fun item toks transitions ->
- match Item.classify item with
- | Item.Shift (symbol, item') ->
- let items : 'a Item.Map.t =
- try
- SymbolMap.find symbol transitions
- with Not_found ->
- Item.Map.empty
- in
- SymbolMap.add symbol (Item.Map.add item' toks items) transitions
- | Item.Reduce _ ->
- transitions
- ) state SymbolMap.empty
-
-(* ------------------------------------------------------------------------ *)
-(* Determining the reduction opportunities at a (closed) state. They
- are represented as a list of pairs of a lookahead set and a
- production index. This code is again parametric in the nature of
- lookahead sets. *)
-
-let reductions (state : 'a Item.Map.t) : ('a * Production.index) list =
- Item.Map.fold (fun item toks accu ->
- match Item.classify item with
- | Item.Reduce prod ->
- (toks, prod) :: accu
- | Item.Shift _ ->
- accu
- ) state []
-
-(* ------------------------------------------------------------------------ *)
-(* Construction of the the LR(0) automaton. *)
-
-(* Nodes are numbered sequentially. *)
-
-type node =
- int
-
-(* A symbolic transition is a pair of the target state number and an
- array of symbolic lookahead sets. The variables in these sets are
- numbered in [0,g) where g is the number of items in the source
- LR(0) state. Items are numbered in the order of presentation by
- [Item.Set.fold]. *)
-
-type symbolic_transition_target =
- node * SymbolicLookahead.t array
-
-(* The automaton is represented by (growing) arrays of states (sets of
- items), symbolic transition information, and symbolic reduction
- information, indexed by node numbers. Conversely, a hash table maps
- states (sets of items) to node numbers. *)
-
-let n =
- ref 0
-
-let states : Item.Set.t InfiniteArray.t =
- InfiniteArray.make Item.Set.empty
-
-let _transitions : symbolic_transition_target SymbolMap.t InfiniteArray.t =
- InfiniteArray.make SymbolMap.empty
-
-let _reductions : (SymbolicLookahead.t * Production.index) list InfiniteArray.t =
- InfiniteArray.make []
-
-let map : (Item.Set.t, node) Hashtbl.t =
- Hashtbl.create 50021
-
-(* The automaton is built depth-first. *)
-
-let rec explore (state : Item.Set.t) : node =
-
- (* Find out whether this state was already explored. *)
-
- try
- Hashtbl.find map state
- with Not_found ->
-
- (* If not, create a new node. *)
-
- let k = !n in
- n := k + 1;
- InfiniteArray.set states k state;
- Hashtbl.add map state k;
-
- (* Build a symbolic version of the current state, where each item
- is associated with a distinct lookahead set variable, numbered
- consecutively. *)
-
- let (_ : int), (symbolic_state : SymbolicClosure.state) =
- Item.Set.fold (fun item (i, symbolic_state) ->
- i+1, Item.Map.add item (SymbolicLookahead.variable i) symbolic_state
- ) state (0, Item.Map.empty) in
-
- (* Compute the symbolic closure. *)
-
- let closure = SymbolicClosure.closure symbolic_state in
-
- (* Compute symbolic information about reductions. *)
-
- InfiniteArray.set _reductions k (reductions closure);
-
- (* Compute symbolic information about the transitions, and, by
- dropping the symbolic lookahead information, explore the
- transitions to further LR(0) states. *)
-
- InfiniteArray.set _transitions k (SymbolMap.map (fun symbolic_state ->
- let (k : node) = explore (Item.Map.domain symbolic_state) in
- let lookahead : SymbolicLookahead.t array =
- Array.create (Item.Map.cardinal symbolic_state) SymbolicLookahead.empty in
- let (_ : int) = Item.Map.fold (fun _ s i ->
- lookahead.(i) <- s;
- i+1
- ) symbolic_state 0 in
- ((k, lookahead) : symbolic_transition_target)
- ) (transitions closure));
-
- k
-
-(* Creating a start state out of a start production. It contains a
- single item, consisting of the start production, at position 0. *)
-
-let start prod : Item.Set.t =
- Item.Set.singleton (Item.import (prod, 0))
-
-(* This starts the construction of the automaton and records the
- entry nodes in an array. *)
-
-let entry : node ProductionMap.t =
- ProductionMap.start (fun prod ->
- explore (start prod)
- )
-
-let () =
- Hashtbl.clear map
-
-let n =
- !n
-
-let () =
- Error.logA 1 (fun f -> Printf.fprintf f "Built an LR(0) automaton with %d states.\n" n);
- Time.tick "Construction of the LR(0) automaton"
-
-(* ------------------------------------------------------------------------ *)
-(* Accessors. *)
-
-let items node : Item.Set.t =
- InfiniteArray.get states node
-
-(* ------------------------------------------------------------------------ *)
-(* Help for building the LR(1) automaton. *)
-
-(* An LR(1) state is represented as a pair of an LR(0) state number
- and an array of concrete lookahead sets (whose length depends on
- the LR(0) state). *)
-
-type lr1state =
- node * TerminalSet.t array
-
-(* An encoded LR(1) state can be turned into a concrete representation,
- that is, a mapping of items to concrete lookahead sets. *)
-
-let export (k, toksr) =
- let (_ : int), items = Item.Set.fold (fun item (i, items) ->
- i+1, Item.Map.add item toksr.(i) items
- ) (InfiniteArray.get states k) (0, Item.Map.empty) in
- items
-
-(* Displaying a concrete state. *)
-
-let print_concrete (state : concretelr1state) =
- let buffer = Buffer.create 1024 in
- Item.Map.iter (fun item toks ->
- Printf.bprintf buffer "%s[ %s ]\n" (Item.print item) (TerminalSet.print toks)
- ) state;
- Buffer.contents buffer
-
-(* Displaying a state. By default, only the kernel is displayed, not
- the closure. *)
-
-let print state =
- print_concrete (export state)
-
-let print_closure state =
- print_concrete (closure (export state))
-
-(* The core of an LR(1) state is the underlying LR(0) state. *)
-
-let core (k, _) =
- k
-
-(* A sanity check. *)
-
-let well_formed (k, toksr) =
- Array.length toksr = Item.Set.cardinal (InfiniteArray.get states k)
-
-(* An LR(1) start state is the combination of an LR(0) start state
- (which consists of a single item) with a singleton lookahead set
- that consists of the end-of-file pseudo-token. *)
-
-let start k =
- let state = (k, [| TerminalSet.singleton Terminal.sharp |]) in
- assert (well_formed state);
- state
-
-(* Interpreting a symbolic lookahead set with respect to a source
- state. The variables in the symbolic lookahead set (which are
- integers) are interpreted as indices into the state's array of
- concrete lookahead sets. The result is a concrete lookahead set. *)
-
-let interpret
- ((_, toksr) as state : lr1state)
- ((toks, vars) : SymbolicLookahead.t)
- : TerminalSet.t =
-
- assert (well_formed state);
- CompressedBitSet.fold (fun var toks ->
- assert (var >= 0 && var < Array.length toksr);
- TerminalSet.union toksr.(var) toks
- ) vars toks
-
-(* Out of an LR(1) state, one produces information about reductions
- and transitions. This is done in an efficient way by interpreting
- the precomputed symbolic information with respect to that state. *)
-
-let reductions
- ((k, _) as state : lr1state)
- : (TerminalSet.t * Production.index) list =
-
- List.map (fun (s, prod) ->
- interpret state s, prod
- ) (InfiniteArray.get _reductions k)
-
-let transitions
- ((k, _) as state : lr1state)
- : lr1state SymbolMap.t =
-
- SymbolMap.map (fun ((k, sr) : symbolic_transition_target) ->
- ((k, Array.map (interpret state) sr) : lr1state)
- ) (InfiniteArray.get _transitions k)
-
-let outgoing_symbols
- (k : node)
- : Symbol.t list =
-
- SymbolMap.domain (InfiniteArray.get _transitions k)
-
-let transition
- symbol
- ((k, _) as state : lr1state)
- : lr1state =
-
- let ((k, sr) : symbolic_transition_target) =
- try
- SymbolMap.find symbol (InfiniteArray.get _transitions k)
- with Not_found ->
- assert false (* no transition along this symbol *)
- in
- (k, Array.map (interpret state) sr)
-
-(* Equality of states. *)
-
-let equal ((k1, toksr1) as state1) ((k2, toksr2) as state2) =
- assert (k1 = k2 && well_formed state1 && well_formed state2);
- let rec loop i =
- if i = 0 then
- true
- else
- let i = i - 1 in
- (TerminalSet.equal toksr1.(i) toksr2.(i)) && (loop i)
- in
- loop (Array.length toksr1)
-
-(* Subsumption between states. *)
-
-let subsume ((k1, toksr1) as state1) ((k2, toksr2) as state2) =
- assert (k1 = k2 && well_formed state1 && well_formed state2);
- let rec loop i =
- if i = 0 then
- true
- else
- let i = i - 1 in
- (TerminalSet.subset toksr1.(i) toksr2.(i)) && (loop i)
- in
- loop (Array.length toksr1)
-
-(* This function determines whether two (core-equivalent) states are
- compatible, according to a criterion that is close to Pager's weak
- compatibility criterion.
-
- Pager's criterion guarantees that if a merged state has a potential
- conflict at [(i, j)] -- that is, some token [t] appears within the
- lookahead sets of both item [i] and item [j] -- then there exists a
- state in the canonical automaton that also has a potential conflict
- at [(i, j)] -- that is, some token [u] appears within the lookahead
- sets of both item [i] and item [j]. Note that [t] and [u] can be
- distinct.
-
- Pager has shown that his weak compatibility criterion is stable,
- that is, preserved by transitions and closure. This means that, if
- two states can be merged, then so can their successors. This is
- important, because merging two states means committing to merging
- their successors, even though we have not even built these
- successors yet.
-
- The criterion used here is a slightly more restrictive version of
- Pager's criterion, which guarantees equality of the tokens [t] and
- [u]. This is done essentially by applying Pager's original
- criterion on a token-wise basis. Pager's original criterion states
- that two states can be merged if the new state has no conflict or
- one of the original states has a conflict. Our more restrictive
- criterion states that two states can be merged if, for every token
- [t], the new state has no conflict at [t] or one of the original
- states has a conflict at [t].
-
- This modified criterion is also stable. My experiments show that it
- is almost as effective in practice: out of more than a hundred
- real-world sample grammars, only one automaton was affected, and
- only one extra state appeared as a result of using the modified
- criterion. Its advantage is to potentially make conflict
- explanations easier: if there appears to be a conflict at [t], then
- some conflict at [t] can be explained. This was not true when using
- Pager's original criterion. *)
-
-let compatible (k1, toksr1) (k2, toksr2) =
- assert (k1 = k2);
- let n = Array.length toksr1 in
- (* Two states are compatible if and only if they are compatible
- at every pair (i, j), where i and j are distinct. *)
- let rec loopi i =
- if i = n then
- true
- else
- let toksr1i = toksr1.(i)
- and toksr2i = toksr2.(i) in
- let rec loopj j =
- if j = i then
- true
- else
- let toksr1j = toksr1.(j)
- and toksr2j = toksr2.(j) in
-
- (* The two states are compatible at (i, j) if every conflict
- token in the merged state already was a conflict token in
- one of the two original states. This could be written as
- follows:
-
- TerminalSet.subset
- (TerminalSet.inter (TerminalSet.union toksr1i toksr2i) (TerminalSet.union toksr1j toksr2j))
- (TerminalSet.union (TerminalSet.inter toksr1i toksr1j) (TerminalSet.inter toksr2i toksr2j))
-
- but is easily seen (on paper) to be equivalent to:
-
- *)
-
- TerminalSet.subset
- (TerminalSet.inter toksr2i toksr1j)
- (TerminalSet.union toksr1i toksr2j)
- &&
- TerminalSet.subset
- (TerminalSet.inter toksr1i toksr2j)
- (TerminalSet.union toksr2i toksr1j)
- &&
- loopj (j+1)
- in
- loopj 0 && loopi (i+1)
- in
- loopi 0
-
-(* This function determines whether two (core-equivalent) states can
- be merged without creating an end-of-stream conflict, now or in the
- future.
-
- The rule is, if an item appears in one state with the singleton "#"
- as its lookahead set, then its lookahead set in the other state
- must contain "#".
-
- So, either the second lookahead set is also the singleton "#", and
- no end-of-stream conflict exists, or it is larger, and the second
- state already contains an end-of-stream conflict.
-
- Put another way, we do not want to merge two lookahead sets when one
- contains "#" alone and the other does not contain "#".
-
- I invented this rule to complement Pager's criterion. I believe,
- but I am not 100% sure, that it does indeed prevent end-of-stream
- conflicts and that it is stable.
-
- Thanks to Sébastien Hinderer for reporting the bug caused by the
- absence of this extra criterion. *)
-
-let eos_compatible (k1, toksr1) (k2, toksr2) =
- assert (k1 = k2);
- let n = Array.length toksr1 in
- let rec loop i =
- if i = n then
- true
- else
- let toks1 = toksr1.(i)
- and toks2 = toksr2.(i) in
- begin
- if TerminalSet.mem Terminal.sharp toks1 && TerminalSet.cardinal toks1 = 1 then
- (* "#" is alone in one set: it must be a member of the other set. *)
- TerminalSet.mem Terminal.sharp toks2
- else if TerminalSet.mem Terminal.sharp toks2 && TerminalSet.cardinal toks2 = 1 then
- (* Symmetric condition. *)
- TerminalSet.mem Terminal.sharp toks1
- else
- true
- end
- && loop (i+1)
- in
- loop 0
-
-(* This function determines whether two (core-equivalent) states can
- be merged without creating spurious reductions on the [error]
- token.
-
- The rule is, we merge two states only if they agree on which
- reductions are permitted on the [error] token.
-
- Without this restriction, we might end up in a situation where we
- decide to introduce an [error] token into the input stream and
- perform a reduction, whereas a canonical LR(1) automaton,
- confronted with the same input string, would fail normally -- that
- is, it would introduce an [error] token into the input stream, but
- it would not be able to perform a reduction right away: the current
- state would be discarded.
-
- In the interest of more accurate (or sane, or predictable) error
- handling, I decided to introduce this restriction as of 20110124.
- This will cause an increase in the size of automata for grammars
- that use the [error] token. It might actually make the [error]
- token somewhat easier to use.
-
- Note that two sets can be in the subsumption relation and still
- be error-incompatible. Error-compatibility requires equality of
- the lookahead sets, restricted to [error].
-
- Thanks to Didier Rémy for reporting a bug caused by the absence
- of this extra criterion. *)
-
-let error_compatible (k1, toksr1) (k2, toksr2) =
- assert (k1 = k2);
- let n = Array.length toksr1 in
- let rec loop i =
- if i = n then
- true
- else
- let toks1 = toksr1.(i)
- and toks2 = toksr2.(i) in
- begin
- if TerminalSet.mem Terminal.error toks1 then
- (* [error] is a member of one set: it must be a member of the other set. *)
- TerminalSet.mem Terminal.error toks2
- else if TerminalSet.mem Terminal.error toks2 then
- (* Symmetric condition. *)
- TerminalSet.mem Terminal.error toks1
- else
- true
- end
- && loop (i+1)
- in
- loop 0
-
-(* Union of two states. The two states must have the same core. The
- new state is obtained by pointwise union of the lookahead sets. *)
-
-let union (k1, toksr1) (k2, toksr2) =
- assert (k1 = k2);
- k1, Array.init (Array.length toksr1) (fun i ->
- TerminalSet.union toksr1.(i) toksr2.(i)
- )
-
-(* Restriction of a state to a set of tokens of interest. Every
- lookahead set is intersected with that set. *)
-
-let restrict toks (k, toksr) =
- k, Array.map (fun toksri ->
- TerminalSet.inter toksri toks
- ) toksr
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-(* This module builds the LR(0) automaton associated with the grammar,
- then provides access to it. It also provides facilities for
- efficiently performing LR(1) constructions. *)
-
-(* ------------------------------------------------------------------------ *)
-(* The LR(0) automaton. *)
-
-(* The nodes of the LR(0) automaton are numbered. *)
-
-type node =
- int
-
-(* This is the number of nodes in the LR(0) automaton. *)
-
-val n: int
-
-(* These are the automaton's entry states, indexed by the start productions. *)
-
-val entry: node ProductionMap.t
-
-(* A node can be converted to the underlying LR(0) set of items. This set is
- not closed. *)
-
-val items: node -> Item.Set.t
-
-(* ------------------------------------------------------------------------ *)
-(* Help for building the LR(1) automaton. *)
-
-(* An LR(1) state is internally represented as a pair of an LR(0)
- state number and an array of concrete lookahead sets (whose length
- depends on the LR(0) state). *)
-
-type lr1state
-
-(* An encoded LR(1) state can be turned into a concrete representation,
- that is, a mapping of items to concrete lookahead sets. *)
-
-type concretelr1state =
- TerminalSet.t Item.Map.t
-
-val export: lr1state -> concretelr1state
-
-(* One can take the closure of a concrete LR(1) state. *)
-
-val closure: concretelr1state -> concretelr1state
-
-(* The core of an LR(1) state is the underlying LR(0) state. *)
-
-val core: lr1state -> node
-
-(* One can create an LR(1) start state out of an LR(0) start
- node. *)
-
-val start: node -> lr1state
-
-(* Information about the transitions and reductions at a state. *)
-
-val transitions: lr1state -> lr1state SymbolMap.t
-val outgoing_symbols: node -> Symbol.t list
-val transition: Symbol.t -> lr1state -> lr1state
-
-val reductions: lr1state -> (TerminalSet.t * Production.index) list
-
-(* Equality of states. The two states must have the same core. Then,
- they are equal if and only if their lookahead sets are pointwise
- equal. *)
-
-val equal: lr1state -> lr1state -> bool
-
-(* Subsumption between states. The two states must have the same
- core. Then, one subsumes the other if and only if their lookahead
- sets are (pointwise) in the subset relation. *)
-
-val subsume: lr1state -> lr1state -> bool
-
-(* A slightly modified version of Pager's weak compatibility
- criterion. The two states must have the same core. *)
-
-val compatible: lr1state -> lr1state -> bool
-
-(* This function determines whether two (core-equivalent) states can
- be merged without creating an end-of-stream conflict. *)
-
-val eos_compatible: lr1state -> lr1state -> bool
-
-(* This function determines whether two (core-equivalent) states can
- be merged without creating spurious reductions on the [error]
- token. *)
-
-val error_compatible: lr1state -> lr1state -> bool
-
-(* Union of two states. The two states must have the same core. The
- new state is obtained by pointwise union of the lookahead sets. *)
-
-val union: lr1state -> lr1state -> lr1state
-
-(* Restriction of a state to a set of tokens of interest. Every
- lookahead set is intersected with that set. *)
-
-val restrict: TerminalSet.t -> lr1state -> lr1state
-
-(* Displaying a concrete state. *)
-
-val print_concrete: concretelr1state -> string
-
-(* Displaying a state. By default, only the kernel is displayed, not
- the closure. *)
-
-val print: lr1state -> string
-val print_closure: lr1state -> string
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-(* This module constructs an LR(1) automaton by following Pager's method, that
- is, by merging states on the fly when they are weakly compatible. *)
-
-(* ------------------------------------------------------------------------ *)
-(* Nodes. *)
-
-type node = {
-
- (* A node number, assigned during construction. *)
-
- raw_number: int;
-
- (* A node number, assigned after conflict resolution has taken
- place and after inacessible nodes have been removed. This
- yields sequential numbers, from the client's point of view. *)
-
- mutable number: int;
-
- (* Each node is associated with a state. This state can change
- during construction as nodes are merged. *)
-
- mutable state: Lr0.lr1state;
-
- (* Each node carries information about its outgoing transitions
- and about its reductions. *)
-
- mutable transitions: node SymbolMap.t;
- mutable reductions: Production.index list TerminalMap.t;
-
- (* Tokens for which there are several possible behaviors are
- conflict tokens. *)
-
- mutable conflict_tokens: TerminalSet.t;
-
- (* Transitions are also stored in reverse, so as to allow reverse
- traversals of the automaton. *)
-
- mutable predecessors: node list;
-
- (* If a node has any incoming transitions, then they all carry
- the same symbol. This is it. *)
-
- mutable incoming_symbol: Symbol.t option;
-
- (* Transient marks are used during construction and traversal. *)
-
- mutable mark: Mark.t;
-
- (* (New as of 2012/01/23.) This flag records whether a shift/reduce
- conflict in this node was solved in favor of neither (%nonassoc).
- This is later used to forbid a default reduction at this node. *)
-
- mutable forbid_default_reduction: bool;
-
- }
-
-module Node = struct
- type t = node
- let compare node1 node2 =
- node1.number - node2.number
-end
-
-module NodeSet =
- Set.Make (Node)
-
-module NodeMap =
- Map.Make (Node)
-
-(* ------------------------------------------------------------------------ *)
-
-(* Output debugging information if [--follow-construction] is enabled. *)
-
-let follow_transition (again : bool) (source : node) (symbol : Symbol.t) (state : Lr0.lr1state) =
- if Settings.follow then
- Printf.fprintf stderr
- "%s transition out of state r%d along symbol %s.\nProposed target state:\n%s"
- (if again then "Re-examining" else "Examining")
- source.raw_number
- (Symbol.print symbol)
- (Lr0.print_closure state)
-
-let follow_state (msg : string) (node : node) (print : bool) =
- if Settings.follow then
- Printf.fprintf stderr
- "%s: r%d.\n%s\n"
- msg
- node.raw_number
- (if print then Lr0.print_closure node.state else "")
-
-(* ------------------------------------------------------------------------ *)
-
-(* The following two mutually recursive functions are invoked when the state
- associated with an existing node grows. The node's descendants are examined
- and grown into a fixpoint is reached.
-
- This work is performed in an eager manner: we do not attempt to build any
- new transitions until all existing nodes have been suitably grown. Indeed,
- building new transitions requires making merging decisions, and such
- decisions cannot be made on a sound basis unless all existing nodes have
- been suitably grown. Otherwise, one could run into a dead end where two
- successive, incompatible merging decisions are made, because the
- consequences of the first decision (growing descendant nodes) were not made
- explicit before the second decision was taken. This was a bug in versions
- of Menhir ante 20070520.
-
- Although I wrote this code independently, I later found out that it seems
- quite similar to the code in Karl Schimpf's Ph.D. thesis (1981), page 35.
-
- It is necessary that all existing transitions be explicit before the [grow]
- functions are called. In other words, if it has been decided that there will
- be a transition from [node1] to [node2], then [node1.transitions] must be
- updated before [grow] is invoked. *)
-
-(* [grow node state] grows the existing node [node], if necessary, so that its
- associated state subsumes [state]. If this represents an actual (strict)
- growth, then [node]'s descendants are grown as well. *)
-
-let rec grow node state =
- if Lr0.subsume state node.state then
- follow_state "Target state is unaffected" node false
- else begin
-
- (* In versions of Menhir prior to June 2008, I wrote this:
-
- If I know what I am doing, then the new state that is being
- merged into the existing state should be compatible, in
- Pager's sense, with the existing node. In other words,
- compatibility should be preserved through transitions.
-
- and the code contained this assertion:
-
- assert (Lr0.compatible state node.state);
- assert (Lr0.eos_compatible state node.state);
-
- However, this was wrong. See, for instance, the sample grammars
- cocci.mly and boris-mini.mly. The problem is particularly clearly
- apparent in boris-mini.mly, where it only involves inclusion of
- states -- the definition of Pager's weak compatibility does not
- enter the picture. Here is, roughly, what is going on.
-
- Assume we have built some state A, which, along some symbol S,
- has a transition to itself. This means, in fact, that computing
- the successor of A along S yields a *subset* of A, that is,
- succ(A, S) <= A.
-
- Then, we wish to build a new state A', which turns out to be a
- superset of A, so we decide to grow A. (The fact that A is a
- subset of A' implies that A and A' are Pager-compatible.) As
- per the code below, we immediately update the state A in place,
- to become A'. Then, we inspect the transition along symbol S.
- We find that the state succ(A', S) must be merged into A'.
-
- In this situation, the assertions above require succ(A', S)
- to be compatible with A'. However, this is not necessarily
- the case. By monotonicity of succ, we do have succ(A, S) <=
- succ(A', S). But nothing says that succ(A', S) are related
- with respect to inclusion, or even Pager-compatible. The
- grammar in boris-mini.mly shows that they are not.
-
- *)
-
- (* Grow [node]. *)
-
- node.state <- Lr0.union state node.state;
- follow_state "Growing existing state" node true;
-
- (* Grow [node]'s successors. *)
-
- grow_successors node
-
- end
-
-(* [grow_successors node] grows [node]'s successors. *)
-
-(* Note that, if there is a cycle in the graph, [grow_successors] can be
- invoked several times at a single node [node], with [node.state] taking on
- a new value every time. In such a case, this code should be correct,
- although probably not very efficient. *)
-
-and grow_successors node =
- SymbolMap.iter (fun symbol (successor_node : node) ->
- let successor_state = Lr0.transition symbol node.state in
- follow_transition true node symbol successor_state;
- grow successor_node successor_state
- ) node.transitions
-
-(* ------------------------------------------------------------------------ *)
-
-(* Data structures maintained during the construction of the automaton. *)
-
-(* A queue of pending nodes, whose outgoing transitions have not yet
- been built. *)
-
-let queue : node Queue.t =
- Queue.create()
-
-(* A mapping of LR(0) node numbers to lists of nodes. This allows us to
- efficiently find all existing nodes that are core-compatible with a
- newly found state. *)
-
-let map : node list array =
- Array.create Lr0.n []
-
-(* A counter that allows assigning raw numbers to nodes. *)
-
-let num =
- ref 0
-
-(* ------------------------------------------------------------------------ *)
-
-(* [create state] creates a new node that stands for the state [state].
- It is expected that [state] does not subsume, and is not subsumed by,
- any existing state. *)
-
-let create (state : Lr0.lr1state) : node =
-
- (* Allocate a new node. *)
-
- let node = {
- state = state;
- transitions = SymbolMap.empty;
- reductions = TerminalMap.empty;
- conflict_tokens = TerminalSet.empty;
- raw_number = Misc.postincrement num;
- number = 0; (* temporary placeholder *)
- mark = Mark.none;
- predecessors = [];
- incoming_symbol = None;
- forbid_default_reduction = false;
- } in
-
- (* Update the mapping of LR(0) cores to lists of nodes. *)
-
- let k = Lr0.core state in
- assert (k < Lr0.n);
- map.(k) <- node :: map.(k);
-
- (* Enqueue this node for further examination. *)
-
- Queue.add node queue;
-
- (* Debugging output. *)
-
- follow_state "Creating a new state" node false;
-
- (* Return the freshly created node. *)
-
- node
-
-(* ------------------------------------------------------------------------ *)
-
-(* Materializing a transition turns its target state into a (fresh or
- existing). There are three scenarios: the proposed new state can be
- subsumed by an existing state, compatible with an existing state, or
- neither. *)
-
-exception Subsumed of node
-
-exception Compatible of node
-
-let materialize (source : node) (symbol : Symbol.t) (target : Lr0.lr1state) : unit =
- try
-
- (* Debugging output. *)
-
- follow_transition false source symbol target;
-
- (* Find all existing core-compatible states. *)
-
- let k = Lr0.core target in
- assert (k < Lr0.n);
- let similar = map.(k) in
-
- (* Check whether one of these states subsumes the candidate new state. If
- so, there is no need to create a new node: just reuse the existing
- one. *)
-
- (* 20110124: require error compatibility in addition to subsumption. *)
-
- List.iter (fun node ->
- if Lr0.subsume target node.state &&
- Lr0.error_compatible target node.state then
- raise (Subsumed node)
- ) similar;
-
- (* Check whether one of the existing states is compatible, in Pager's
- sense, with the new state. If so, there is no need to create a new
- state: just merge the new state into the existing one. *)
-
- (* 20110124: require error compatibility in addition to the existing
- compatibility criteria. *)
-
- if Settings.pager then
- List.iter (fun node ->
- if Lr0.compatible target node.state &&
- Lr0.eos_compatible target node.state &&
- Lr0.error_compatible target node.state then
- raise (Compatible node)
- ) similar;
-
- (* Both of the above checks have failed. Create a new node. Two states
- that are in the subsumption relation are also compatible. This implies
- that the newly created node does not subsume any existing states. *)
-
- source.transitions <- SymbolMap.add symbol (create target) source.transitions
-
- with
-
- | Subsumed node ->
-
- (* Join an existing target node. *)
-
- follow_state "Joining existing state" node false;
- source.transitions <- SymbolMap.add symbol node source.transitions
-
- | Compatible node ->
-
- (* Join and grow an existing target node. It seems important that the
- new transition is created before [grow_successors] is invoked, so
- that all transition decisions made so far are explicit. *)
-
- node.state <- Lr0.union target node.state;
- follow_state "Joining and growing existing state (Pager says, fine)" node true;
- source.transitions <- SymbolMap.add symbol node source.transitions;
- grow_successors node
-
-(* ------------------------------------------------------------------------ *)
-
-(* The actual construction process. *)
-
-(* Populate the queue with the start nodes and store them in an array. *)
-
-let entry : node ProductionMap.t =
- ProductionMap.map (fun (k : Lr0.node) ->
- create (Lr0.start k)
- ) Lr0.entry
-
-(* Pick a node in the queue, that is, a node whose transitions have not yet
- been built. Build these transitions, and continue. *)
-
-(* Note that building a transition can cause existing nodes to grow, so
- [node.state] is not necessarily invariant throughout the inner loop. *)
-
-let () =
- Misc.qiter (fun node ->
- List.iter (fun symbol ->
- materialize node symbol (Lr0.transition symbol node.state)
- ) (Lr0.outgoing_symbols (Lr0.core node.state))
- ) queue
-
-(* Record how many nodes were constructed. *)
-
-let n =
- !num
-
-let () =
- Error.logA 1 (fun f -> Printf.fprintf f "Built an LR(1) automaton with %d states.\n" !num)
-
-(* ------------------------------------------------------------------------ *)
-(* We now perform one depth-first traversal of the automaton,
- recording predecessor edges, numbering nodes, sorting nodes
- according to their incoming symbol, building reduction tables, and
- finding out which nodes have conflicts. *)
-
-(* A count of all nodes. *)
-
-let () =
- num := 0
-
-(* A list of all nodes. *)
-
-let nodes : node list ref =
- ref []
-
-(* A list of nodes with conflicts. *)
-
-let conflict_nodes : node list ref =
- ref []
-
-(* Counts of nodes with shift/reduce and reduce/reduce conflicts. *)
-
-let shift_reduce =
- ref 0
-
-let reduce_reduce =
- ref 0
-
-(* Count of the shift/reduce conflicts that could be silently
- resolved. *)
-
-let silently_solved =
- ref 0
-
-(* A mapping of symbols to lists of nodes that admit this incoming
- symbol. *)
-
-let incoming : node list SymbolMap.t ref =
- ref SymbolMap.empty
-
-(* Go ahead. *)
-
-let () =
-
- let marked = Mark.fresh() in
-
- let rec visit node =
- if not (Mark.same node.mark marked) then begin
- node.mark <- marked;
- nodes := node :: !nodes;
-
- (* Number this node. *)
-
- let number = !num in
- num := number + 1;
- node.number <- number;
-
- (* Insertion of a new reduce action into the table of reductions. *)
-
- let addl prod tok reductions =
- let prods =
- try
- TerminalMap.lookup tok reductions
- with Not_found ->
- []
- in
- TerminalMap.add tok (prod :: prods) reductions
- in
-
- (* Build the reduction table. Here, we gather all potential
- reductions, without attempting to solve shift/reduce
- conflicts on the fly, because that would potentially hide
- shift/reduce/reduce conflicts, which we want to be aware
- of. *)
-
- let reductions =
- List.fold_left (fun reductions (toks, prod) ->
- TerminalSet.fold (addl prod) toks reductions
- ) TerminalMap.empty (Lr0.reductions node.state)
- in
-
- (* Detect conflicts. Attempt to solve shift/reduce conflicts
- when unambiguously allowed by priorities. *)
-
- let has_shift_reduce = ref false
- and has_reduce_reduce = ref false in
-
- node.reductions <-
- TerminalMap.fold (fun tok prods reductions ->
- if SymbolMap.mem (Symbol.T tok) node.transitions then begin
-
- (* There is a transition in addition to the reduction(s). We
- have (at least) a shift/reduce conflict. *)
-
- assert (not (Terminal.equal tok Terminal.sharp));
- match prods with
- | [] ->
- assert false
- | [ prod ] ->
- begin
-
- (* This is a single shift/reduce conflict. If priorities tell
- us how to solve it, we follow that and modify the automaton. *)
-
- match Precedence.shift_reduce tok prod with
-
- | Precedence.ChooseShift ->
-
- (* Suppress the reduce action. *)
-
- incr silently_solved;
- reductions
-
- | Precedence.ChooseReduce ->
-
- (* Record the reduce action and suppress the shift transition.
- The automaton is modified in place. This can have the subtle
- effect of making some nodes unreachable. Any conflicts in these
- nodes will then be ignored (as they should be). *)
-
- incr silently_solved;
- node.transitions <- SymbolMap.remove (Symbol.T tok) node.transitions;
- TerminalMap.add tok prods reductions
-
- | Precedence.ChooseNeither ->
-
- (* Suppress the reduce action and the shift transition. *)
-
- incr silently_solved;
- node.transitions <- SymbolMap.remove (Symbol.T tok) node.transitions;
- node.forbid_default_reduction <- true;
- reductions
-
- | Precedence.DontKnow ->
-
- (* Priorities don't allow concluding. Record the
- existence of a shift/reduce conflict. *)
-
- node.conflict_tokens <- Grammar.TerminalSet.add tok node.conflict_tokens;
- has_shift_reduce := true;
- TerminalMap.add tok prods reductions
-
- end
-
- | prod1 :: prod2 :: _ ->
-
- (* This is a shift/reduce/reduce conflict. If the priorities
- are such that each individual shift/reduce conflict is solved
- in favor of shifting or in favor of neither, then solve the entire
- composite conflict in the same way. Otherwise, report the conflict. *)
-
- let choices = List.map (Precedence.shift_reduce tok) prods in
-
- if List.for_all (fun choice ->
- match choice with
- | Precedence.ChooseShift -> true
- | _ -> false
- ) choices then begin
-
- (* Suppress the reduce action. *)
-
- silently_solved := !silently_solved + List.length prods;
- reductions
-
- end
- else if List.for_all (fun choice ->
- match choice with
- | Precedence.ChooseNeither -> true
- | _ -> false
- ) choices then begin
-
- (* Suppress the reduce action and the shift transition. *)
-
- silently_solved := !silently_solved + List.length prods;
- node.transitions <- SymbolMap.remove (Symbol.T tok) node.transitions;
- reductions
-
- end
- else begin
-
- (* Record a shift/reduce/reduce conflict. Keep all reductions. *)
-
- node.conflict_tokens <- Grammar.TerminalSet.add tok node.conflict_tokens;
- has_shift_reduce := true;
- has_reduce_reduce := true;
- TerminalMap.add tok prods reductions
-
- end
-
- end
- else
- let () =
- match prods with
- | []
- | [ _ ] ->
- ()
- | prod1 :: prod2 :: _ ->
-
- (* There is no transition in addition to the reduction(s). We
- have a pure reduce/reduce conflict. Do nothing about it at
- this point. *)
-
- node.conflict_tokens <- Grammar.TerminalSet.add tok node.conflict_tokens;
- has_reduce_reduce := true
-
- in
- TerminalMap.add tok prods reductions
-
- ) reductions TerminalMap.empty;
-
- (* Record statistics about conflicts. *)
-
- if not (TerminalSet.is_empty node.conflict_tokens) then begin
- conflict_nodes := node :: !conflict_nodes;
- if !has_shift_reduce then
- incr shift_reduce;
- if !has_reduce_reduce then
- incr reduce_reduce
- end;
-
- (* Continue the depth-first traversal. Record predecessors edges
- as we go. No ancestor appears twice in a list of
- predecessors, because two nodes cannot be related by two
- edges that carry distinct symbols. *)
-
- SymbolMap.iter (fun symbol son ->
- begin
- match son.incoming_symbol with
- | None ->
- son.incoming_symbol <- Some symbol;
- let others =
- try
- SymbolMap.find symbol !incoming
- with Not_found ->
- []
- in
- incoming := SymbolMap.add symbol (son :: others) !incoming
- | Some symbol' ->
- assert (Symbol.equal symbol symbol')
- end;
- son.predecessors <- node :: son.predecessors;
- visit son
- ) node.transitions
- end
- in
-
- ProductionMap.iter (fun _ node -> visit node) entry
-
-let nodes =
- List.rev !nodes (* list is now sorted by increasing node numbers *)
-
-let conflict_nodes =
- !conflict_nodes
-
-let incoming =
- !incoming
-
-let () =
- if !silently_solved = 1 then
- Error.logA 1 (fun f -> Printf.fprintf f "One shift/reduce conflict was silently solved.\n")
- else if !silently_solved > 1 then
- Error.logA 1 (fun f -> Printf.fprintf f "%d shift/reduce conflicts were silently solved.\n" !silently_solved);
- if !num < n then
- Error.logA 1 (fun f -> Printf.fprintf f "Only %d states remain after resolving shift/reduce conflicts.\n" !num)
-
-let () =
- Grammar.diagnostics()
-
-let n =
- !num
-
-let forbid_default_reduction node =
- node.forbid_default_reduction
-
-(* ------------------------------------------------------------------------ *)
-(* Breadth-first iteration over all nodes. *)
-
-let bfs =
- let module B = Breadth.Make (struct
- type vertex = node
- type label = Symbol.t
- let set_mark node m = node.mark <- m
- let get_mark node = node.mark
- let entry f = ProductionMap.iter (fun _ node -> f node) entry
- let successors f node = SymbolMap.iter f node.transitions
- end) in
- B.search
-
-(* ------------------------------------------------------------------------ *)
-(* Iteration over all nodes. *)
-
-let fold f accu =
- List.fold_left f accu nodes
-
-let iter f =
- fold (fun () node -> f node) ()
-
-let map f =
- List.map f nodes
-
-let foldx f =
- fold (fun accu node ->
- match node.incoming_symbol with
- | None -> accu
- | Some _ -> f accu node)
-
-let iterx f =
- iter (fun node ->
- match node.incoming_symbol with
- | None -> ()
- | Some _ -> f node)
-
-(* -------------------------------------------------------------------------- *)
-(* Our output channel. *)
-
-let out =
- lazy (open_out (Settings.base ^ ".automaton"))
-
-(* ------------------------------------------------------------------------ *)
-(* If requested, dump a verbose description of the automaton. *)
-
-let () =
- Time.tick "Construction of the LR(1) automaton";
- if Settings.dump then begin
- fold (fun () node ->
- let out = Lazy.force out in
- Printf.fprintf out "State %d%s:\n%s"
- node.number
- (if Settings.follow then Printf.sprintf " (r%d)" node.raw_number else "")
- (Lr0.print node.state);
- SymbolMap.iter (fun symbol node ->
- Printf.fprintf out "-- On %s shift to state %d\n"
- (Symbol.print symbol) node.number
- ) node.transitions;
- TerminalMap.iter (fun tok prods ->
- List.iter (fun prod ->
- (* TEMPORARY factoriser les symboles qui conduisent a reduire une meme production *)
- Printf.fprintf out "-- On %s " (Terminal.print tok);
- match Production.classify prod with
- | Some nt ->
- Printf.fprintf out "accept %s\n" (Nonterminal.print false nt)
- | None ->
- Printf.fprintf out "reduce production %s\n" (Production.print prod)
- ) prods
- ) node.reductions;
- if not (TerminalSet.is_empty node.conflict_tokens) then
- Printf.fprintf out "** Conflict on %s\n" (TerminalSet.print node.conflict_tokens);
- Printf.fprintf out "\n%!"
- ) ();
- Time.tick "Dumping the LR(1) automaton"
- end
-
-(* ------------------------------------------------------------------------ *)
-(* [reverse_dfs goal] performs a reverse depth-first search through
- the automaton, starting at node [goal], and marking the nodes
- traversed. It returns a function that tells whether a node is
- marked, that is, whether a path leads from that node to the goal
- node. *)
-
-let reverse_dfs goal =
-
- let mark = Mark.fresh() in
-
- let marked node =
- Mark.same node.mark mark
- in
-
- let rec visit node =
- if not (marked node) then begin
- node.mark <- mark;
- List.iter visit node.predecessors
- end
- in
-
- visit goal;
- marked
-
-(* ------------------------------------------------------------------------ *)
-(* Iterating over all nodes that are targets of edges carrying a
- certain symbol. The sources of the corresponding edges are also
- provided. *)
-
-let targets f accu symbol =
- let targets =
- try
- SymbolMap.find symbol incoming
- with Not_found ->
- (* There are no incoming transitions on the start symbols. *)
- []
- in
- List.fold_left (fun accu target ->
- f accu target.predecessors target
- ) accu targets
-
-(* ------------------------------------------------------------------------ *)
-(* Converting a start node into the single item that it contains. *)
-
-let start2item node =
- let state : Lr0.lr1state = node.state in
- let core : Lr0.node = Lr0.core state in
- let items : Item.Set.t = Lr0.items core in
- assert (Item.Set.cardinal items = 1);
- Item.Set.choose items
-
-(* ------------------------------------------------------------------------ *)
-(* Accessors. *)
-
-let number node =
- node.number
-
-let state node =
- node.state
-
-let transitions node =
- node.transitions
-
-let reductions node =
- node.reductions
-
-let conflicts f =
- List.iter (fun node ->
- f node.conflict_tokens node
- ) conflict_nodes
-
-let incoming_symbol node =
- node.incoming_symbol
-
-let predecessors node =
- node.predecessors
-
-(* ------------------------------------------------------------------------ *)
-
-(* This inverts a mapping of tokens to productions into a mapping of
- productions to sets of tokens. *)
-
-(* This is needed, in [CodeBackend], to avoid producing two (or more)
- separate branches that call the same [reduce] function. Instead,
- we generate just one branch, guarded by a [POr] pattern. *)
-
-let invert reductions : TerminalSet.t ProductionMap.t =
- TerminalMap.fold (fun tok prods inverse ->
- let prod = Misc.single prods in
- let toks =
- try
- ProductionMap.lookup prod inverse
- with Not_found ->
- TerminalSet.empty
- in
- ProductionMap.add prod (TerminalSet.add tok toks) inverse
- ) reductions ProductionMap.empty
-
-(* ------------------------------------------------------------------------ *)
-(* Computing which terminal symbols a state is willing to act upon.
-
- This function is currently unused, but could be used as part of an error
- reporting system.
-
- One must keep in mind that, due to the merging of states, a state might be
- willing to perform a reduction on a certain token, yet the reduction can
- take us to another state where this token causes an error. In other words,
- the set of terminal symbols that is computed here is really an
- over-approximation of the set of symbols that will not cause an error. And
- there seems to be no way of performing an exact computation, as we would
- need to know not only the current state, but the contents of the stack as
- well. *)
-
-let acceptable_tokens (s : node) =
-
- (* If this state is willing to act on the error token, ignore it -- we do
- not wish to report that an error would be accepted in this state :-) *)
-
- let transitions =
- SymbolMap.remove (Symbol.T Terminal.error) (transitions s)
- and reductions =
- TerminalMap.remove Terminal.error (reductions s)
- in
-
- (* Accumulate the tokens carried by outgoing transitions. *)
-
- let covered =
- SymbolMap.fold (fun symbol _ covered ->
- match symbol with
- | Symbol.T tok ->
- TerminalSet.add tok covered
- | Symbol.N _ ->
- covered
- ) transitions TerminalSet.empty
- in
-
- (* Accumulate the tokens that permit reduction. *)
-
- let covered =
- ProductionMap.fold (fun _ toks covered ->
- TerminalSet.union toks covered
- ) (invert reductions) covered
- in
-
- (* That's it. *)
-
- covered
-
-(* ------------------------------------------------------------------------ *)
-(* Report statistics. *)
-
-(* Produce the reports. *)
-
-let () =
- if !shift_reduce = 1 then
- Error.grammar_warning [] "one state has shift/reduce conflicts."
- else if !shift_reduce > 1 then
- Error.grammar_warning [] (Printf.sprintf "%d states have shift/reduce conflicts." !shift_reduce);
- if !reduce_reduce = 1 then
- Error.grammar_warning [] "one state has reduce/reduce conflicts."
- else if !reduce_reduce > 1 then
- Error.grammar_warning [] (Printf.sprintf "%d states have reduce/reduce conflicts." !reduce_reduce)
-
-(* There is a global check for errors at the end of [Invariant], so we do
- not need to check & stop here. *)
-
-(* ------------------------------------------------------------------------ *)
-(* When requested by the code generator, apply default conflict
- resolution to ensure that the automaton is deterministic. *)
-
-(* [best prod prods] chooses which production should be reduced
- among the list [prod :: prods]. It fails if no best choice
- exists. *)
-
-let rec best choice = function
- | [] ->
- choice
- | prod :: prods ->
- match Precedence.reduce_reduce choice prod with
- | Some choice ->
- best choice prods
- | None ->
- Error.signal
- (Production.positions choice @ Production.positions prod)
- (Printf.sprintf
- "will not resolve reduce/reduce conflict between\n\
- productions that originate in distinct source files:\n%s\n%s"
- (Production.print choice)
- (Production.print prod));
- choice (* dummy *)
-
-(* Go ahead. *)
-
-let default_conflict_resolution () =
-
- let shift_reduce =
- ref 0
- and reduce_reduce =
- ref 0
- in
-
- List.iter (fun node ->
-
- node.reductions <-
- TerminalMap.fold (fun tok prods reductions ->
- try
- let (_ : node) =
- SymbolMap.find (Symbol.T tok) node.transitions
- in
- (* There is a transition at this symbol, so this
- is a (possibly multiway) shift/reduce conflict.
- Resolve in favor of shifting by suppressing all
- reductions. *)
- shift_reduce := List.length prods + !shift_reduce;
- reductions
- with Not_found ->
- (* There is no transition at this symbol. Check
- whether we have multiple reductions. *)
- match prods with
- | [] ->
- assert false
- | [ _ ] ->
- TerminalMap.add tok prods reductions
- | prod :: ((_ :: _) as prods) ->
- (* We have a reduce/reduce conflict. Resolve, if
- possible, in favor of a single reduction.
- This reduction must be preferrable to each
- of the others. *)
- reduce_reduce := List.length prods + !reduce_reduce;
- TerminalMap.add tok [ best prod prods ] reductions
-
- ) node.reductions TerminalMap.empty
-
- ) conflict_nodes;
-
- if !shift_reduce = 1 then
- Error.warning [] "one shift/reduce conflict was arbitrarily resolved."
- else if !shift_reduce > 1 then
- Error.warning [] (Printf.sprintf "%d shift/reduce conflicts were arbitrarily resolved." !shift_reduce);
- if !reduce_reduce = 1 then
- Error.warning [] "one reduce/reduce conflict was arbitrarily resolved."
- else if !reduce_reduce > 1 then
- Error.warning [] (Printf.sprintf "%d reduce/reduce conflicts were arbitrarily resolved." !reduce_reduce);
-
- (* Now, ensure that states that have a reduce action at the
- pseudo-token "#" have no other action. *)
-
- let ambiguities =
- ref 0
- in
-
- fold (fun () node ->
-
- try
- let prods, reductions = TerminalMap.lookup_and_remove Terminal.sharp node.reductions in
- let prod = Misc.single prods in
-
- (* This node has a reduce action at "#". Determine whether there
- exist other actions. If there exist any other actions,
- suppress this reduce action, and signal an ambiguity.
-
- We signal an ambiguity even in the case where all actions at
- this node call for reducing a single production. Indeed, in
- that case, even though we know that this production must be
- reduced, we do not know whether we should first discard the
- current token (and call the lexer). *)
-
- let has_ambiguity = ref false in
- let toks = ref TerminalSet.empty in
-
- TerminalMap.iter (fun tok prods ->
- node.reductions <- reductions;
- has_ambiguity := true;
- toks := TerminalSet.add tok !toks
- ) reductions;
-
- SymbolMap.iter (fun symbol _ ->
- match symbol with
- | Symbol.N _ ->
- ()
- | Symbol.T tok ->
- node.reductions <- reductions;
- has_ambiguity := true;
- toks := TerminalSet.add tok !toks
- ) node.transitions;
-
- if !has_ambiguity then begin
- incr ambiguities;
- if Settings.dump then begin
- Printf.fprintf (Lazy.force out)
- "State %d has an end-of-stream conflict. There is a tension between\n\
- (1) %s\n\
- without even requesting a lookahead token, and\n\
- (2) checking whether the lookahead token is %s%s,\n\
- which would require some other action.\n\n"
- (number node)
- (match Production.classify prod with
- | Some nt ->
- Printf.sprintf "accepting %s" (Nonterminal.print false nt)
- | None ->
- Printf.sprintf "reducing production %s" (Production.print prod))
- (if TerminalSet.cardinal !toks > 1 then "one of " else "")
- (TerminalSet.print !toks)
- end
- end
-
- with Not_found ->
- ()
-
- ) ();
-
- if !ambiguities = 1 then
- Error.grammar_warning [] "one state has an end-of-stream conflict."
- else if !ambiguities > 1 then
- Error.grammar_warning [] (Printf.sprintf "%d states have an end-of-stream conflict." !ambiguities)
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-(* This module constructs an LR(1) automaton by following Pager's
- method, that is, by merging states on the fly when they are found
- to be (weakly) compatible. *)
-
-(* Shift/reduce conflicts are silently resolved when (and only when)
- that is allowed in a clean way by user-specified priorities. This
- includes shift/reduce/reduce conflicts when (and only when) there
- is agreement that the shift action should be preferred. Conflicts
- that cannot be silently resolved in this phase will be reported,
- explained, and arbitrarily resolved immediately before code
- generation. *)
-
-(* ------------------------------------------------------------------------- *)
-(* Accessors. *)
-
-(* This is the type of the automaton's nodes. *)
-
-type node
-
-module Node : Set.OrderedType with type t = node
-
-module NodeSet : Set.S with type elt = node
-
-module NodeMap : Map.S with type key = node
-
-(* These are the automaton's entry states, indexed by the start productions. *)
-
-val entry: node ProductionMap.t
-
-(* Nodes are numbered sequentially from [0] to [n-1]. *)
-
-val n: int
-val number: node -> int
-
-(* This provides access to the LR(1) state that a node stands for. *)
-
-val state: node -> Lr0.lr1state
-
-(* This converts a start node into the single item that it contains. *)
-
-val start2item: node -> Item.t
-
-(* This maps a node to its incoming symbol, that is, the symbol
- carried by all of the edges that enter this node. A node has zero
- incoming edges (and, thus, no incoming symbol) if and only if it is
- a start node. *)
-
-val incoming_symbol: node -> Symbol.t option
-
-(* This maps a node to its predecessors. *)
-
-val predecessors: node -> node list
-
-(* This provides access to a node's transitions and reductions. *)
-
-val transitions: node -> node SymbolMap.t
-val reductions: node -> Production.index list TerminalMap.t
-
-(* (New as of 2012/01/23.) This tells whether a shift/reduce conflict
- in this node was solved in favor of neither (%nonassoc). This implies
- that one must forbid a default reduction at this node. *)
-
-val forbid_default_reduction: node -> bool
-
-(* This inverts a mapping of tokens to productions into a mapping of
- productions to sets of tokens. *)
-
-val invert : ProductionMap.key list TerminalMap.t -> TerminalSet.t ProductionMap.t
-
-(* Computing which terminal symbols a state is willing to act upon.
-
- This function is currently unused, but could be used as part of an error
- reporting system. *)
-
-val acceptable_tokens: node -> TerminalSet.t
-
-(* Iteration over all nodes. The order in which elements are examined,
- and the order of [map]'s output list, correspond to the numeric
- indices produced by [number] above. *)
-
-val fold: ('a -> node -> 'a) -> 'a -> 'a
-val iter: (node -> unit) -> unit
-val map: (node -> 'a) -> 'a list
-
-(* Iteration over non-start nodes *)
-val foldx: ('a -> node -> 'a) -> 'a -> 'a
-val iterx: (node -> unit) -> unit
-
-(* Breadth-first iteration over all edges. See [Breadth]. *)
-
-val bfs: (bool -> node -> Symbol.t -> node -> unit) -> unit
-
-(* Iteration over all edges that carry a certain symbol. Edges are
- grouped in families, where all edges in a single family have the
- same target node. [targets f accu symbol] invokes [f accu sources
- target] once for every family, where [sources] are the sources of
- the edges in the family and [target] is their common target. *)
-
-val targets: ('a -> node list -> node -> 'a) -> 'a -> Symbol.t -> 'a
-
-(* Iteration over all nodes with conflicts. [conflicts f] invokes [f
- toks node] once for every node [node] with a conflict, where [toks]
- are the tokens involved in the conflicts at that node. *)
-
-val conflicts: (TerminalSet.t -> node -> unit) -> unit
-
-(* [reverse_dfs goal] performs a reverse depth-first search through
- the automaton, starting at node [goal], and marking the nodes
- traversed. It returns a function that tells whether a node is
- marked, that is, whether a path leads from that node to the goal
- node. *)
-
-val reverse_dfs: node -> (node -> bool)
-
-(* ------------------------------------------------------------------------- *)
-(* Modifications of the automaton. *)
-
-(* This function performs default conflict resolution.
-
- First, it resolves standard (shift/reduce and reduce/reduce)
- conflicts (thus ensuring that the automaton is deterministic) by
- removing some reduction actions.
-
- Second, it resolves end-of-stream conflicts by ensuring that states
- that have a reduce action at the pseudo-token "#" have no other
- action.
-
- It is called after conflicts have been explained and before code
- generation takes place. The automaton is modified in place. *)
-
-val default_conflict_resolution: unit -> unit
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-module Run (X : sig
-
- (* A restricted set of tokens of interest. *)
-
- val tokens: TerminalSet.t
-
- (* A state of the (merged) LR(1) automaton that we're trying to
- simulate. *)
-
- val goal: Lr1.node
-
-end) = struct
-
- (* First, let's restrict our interest to the nodes of the merged
- LR(1) automaton that can reach the goal node. Some experiments
- show that this can involve one tenth to one half of all nodes.
- This optimization seems minor, but is easy to implement. *)
-
- let relevant =
- Lr1.reverse_dfs X.goal
-
- (* Second, all of the states that we shall consider are restricted
- to the set of tokens of interest. This is an important idea: by
- abstracting away some information, we make the construction much
- faster. *)
-
- let restrict =
- Lr0.restrict X.tokens
-
- (* Constructing the automaton. The automaton is represented as a
- graph. States are never merged -- this is a canonical LR(1)
- construction!
-
- As we go, we record the correspondence between nodes in this
- automaton and nodes in the merged LR(1) automaton. This allows
- us to tell when we have reached the desired place.
-
- This also allows us not to follow transitions that have already
- been eliminated, in the merged automaton, via resolution of
- shift/reduce conflicts. Whenever we follow a transition in the
- canonical LR(1) automaton, we check that the corresponding
- transition is legal in the merged LR(1) automaton.
-
- The automaton is explored breadth-first and shortest paths from
- every node to one of the start nodes are recorded. *)
-
- type node = {
- state: Lr0.lr1state;
- ancestor: (Symbol.t * node) option;
- shadow: Lr1.node;
- }
-
- (* A queue of pending nodes, whose successors should be explored. *)
-
- let queue : node Queue.t =
- Queue.create()
-
- (* Mapping of LR(0) state numbers to lists of nodes. *)
-
- let map : node list array =
- Array.create Lr0.n []
-
- (* Exploring a state. This creates a new node, if necessary, and
- enqueues it for further exploration. *)
-
- exception Goal of node * Terminal.t
-
- let explore ancestor shadow (state : Lr0.lr1state) : unit =
-
- (* Find all existing nodes that share the same LR(0) core. *)
-
- let k = Lr0.core state in
- assert (k < Lr0.n);
- let similar = map.(k) in
-
- (* Check whether one of these nodes coincides with the candidate
- new node. If so, stop. This check requires comparing not only
- the states of the partial, canonical automaton, but also their
- shadows in the full, merged automaton. This is because a single
- state of the canonical automaton may be reached along several
- different paths, leading to distinct shadows in the merged
- automaton, and we must explore all of these paths in order to
- ensure that we eventually find a goal node. *)
-
- if not (List.exists (fun node ->
- Lr0.equal state node.state && shadow == node.shadow
- ) similar) then begin
-
- (* Otherwise, create a new node. *)
-
- let node = {
- state = state;
- ancestor = ancestor;
- shadow = shadow;
- } in
-
- map.(k) <- node :: similar;
- Queue.add node queue;
-
- (* Check whether this is a goal node. A node [N] is a goal node
- if (i) [N] has a conflict involving one of the tokens of
- interest and (ii) [N] corresponds to the goal node, that is,
- the path that leads to [N] in the canonical LR(1) automaton
- leads to the goal node in the merged LR(1) automaton. Note
- that these conditions do not uniquely define [N]. *)
-
- if shadow == X.goal then
- let can_reduce =
- ref TerminalSet.empty in
- let reductions1 : Production.index list TerminalMap.t =
- Lr1.reductions shadow in
- List.iter (fun (toks, prod) ->
- TerminalSet.iter (fun tok ->
-
- (* We are looking at a [(tok, prod)] pair -- a reduction
- in the canonical automaton state. *)
-
- (* Check that this reduction, which exists in the canonical
- automaton state, also exists in the merged automaton --
- that is, it wasn't suppressed by conflict resolution. *)
-
- if List.mem prod (TerminalMap.lookup tok reductions1) then
-
- try
- let (_ : Lr1.node) =
- SymbolMap.find (Symbol.T tok) (Lr1.transitions shadow)
- in
- (* Shift/reduce conflict. *)
- raise (Goal (node, tok))
- with Not_found ->
- let toks = !can_reduce in
- (* We rely on the property that [TerminalSet.add tok toks]
- preserves physical equality when [tok] is a member of
- [toks]. *)
- let toks' = TerminalSet.add tok toks in
- if toks == toks' then
- (* Reduce/reduce conflict. *)
- raise (Goal (node, tok))
- else
- (* No conflict so far. *)
- can_reduce := toks'
-
- ) toks
- ) (Lr0.reductions state)
-
- end
-
- (* Populate the queue with the start nodes. Until we find a goal
- node, take a node out the queue, construct the nodes that
- correspond to its successors, and enqueue them. *)
-
- let goal, token =
- try
-
- ProductionMap.iter (fun (prod : Production.index) (k : Lr0.node) ->
- let shadow = try
- ProductionMap.find prod Lr1.entry
- with Not_found ->
- assert false
- in
- if relevant shadow then
- explore None shadow (restrict (Lr0.start k))
- ) Lr0.entry;
-
- Misc.qiter (fun node ->
- SymbolMap.iter (fun symbol state ->
- try
- let shadow =
- SymbolMap.find symbol (Lr1.transitions node.shadow) in
- if relevant shadow then
- explore (Some (symbol, node)) shadow (restrict state)
- with Not_found ->
- (* No shadow. This can happen if a shift/reduce conflict
- was resolved in favor in reduce. Ignore that transition. *)
- ()
- ) (Lr0.transitions node.state)
- ) queue;
-
- (* We didn't find a goal node. This shouldn't happen! If the
- goal node in the merged LR(1) automaton has a conflict,
- then there should exist a node with a conflict in the
- canonical automaton as well. Otherwise, Pager's construction
- is incorrect. *)
-
- begin
- Printf.fprintf stderr "** Internal failure (Pager's theorem).\n";
- Printf.fprintf stderr "** Tokens of interest: %s\n" (TerminalSet.print X.tokens);
- Printf.fprintf stderr "** Goal state: %d\n" (Lr1.number X.goal);
- Printf.fprintf stderr "** Please send your grammar to Menhir's developers.\n%!";
- exit 1
- end
-
- with Goal (node, tok) ->
- node, tok
-
- (* Query the goal node that was found about the shortest path from
- it to one of the entry nodes. *)
-
- let source, path =
-
- let rec follow path node =
- match node.ancestor with
- | None ->
- Lr1.start2item node.shadow, Array.of_list path
- | Some (symbol, node) ->
- follow (symbol :: path) node
- in
- follow [] goal
-
- let goal =
- Lr0.export goal.state
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-
-module Run (X : sig
-
- (* A restricted set of tokens of interest. *)
-
- val tokens: TerminalSet.t
-
- (* A state of the (merged) LR(1) automaton that we're trying to
- simulate. *)
-
- val goal: Lr1.node
-
-end) : sig
-
- (* What we are after is a path, in the canonical LR(1) automaton,
- that leads from some entry node to a node [N] such that (i)
- [N] has a conflict involving one of the tokens of interest
- and (ii) [N] corresponds to the goal node, that is, the path
- that leads to [N] in the canonical LR(1) automaton leads to
- the goal node in the merged LR(1) automaton. *)
-
- val source: Item.t
-
- val path: Symbol.t array
-
- val goal: Lr0.concretelr1state
-
- (* An (arbitrarily chosen) conflict token in the goal state. *)
-
- val token: Terminal.t
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(** This module implements a very simple notion of ``mark''. A mark is
- really a reference cell (without content). Creating a new mark
- requires allocating a new cell, and comparing marks requires
- comparing pointers. *)
-
-type t =
- unit ref
-
-let fresh =
- ref
-
-let same =
- (==)
-
-let none =
- fresh()
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(** This module implements a very simple notion of ``mark''. *)
-
-(** The type of marks. *)
-type t
-
-(** [fresh()] generates a fresh mark, that is, a mark that is guaranteed
- to be distinct from all existing marks. *)
-val fresh: unit -> t
-
-(** [same mark1 mark2] tells whether [mark1] and [mark2] are the same
- mark, that is, were created by the same call to [fresh]. *)
-val same: t -> t -> bool
-
-(** [none] is a distinguished mark, created via an initial call to
- [fresh()]. *)
-val none: t
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-let ( $$ ) x f = f x
-
-let unSome = function
- None -> assert false
- | Some x -> x
-
-let o2s o f =
- match o with
- | None ->
- ""
- | Some x ->
- f x
-
-let single = function
- | [ x ] ->
- x
- | _ ->
- assert false
-
-let rec mapd f = function
- | [] ->
- []
- | x :: xs ->
- let y1, y2 = f x in
- y1 :: y2 :: mapd f xs
-
-let tabulateb n f =
- let a = Array.init n f in
- Array.get a,
- Array.fold_left (fun count element ->
- if element then count + 1 else count
- ) 0 a
-
-let tabulateo number fold n f =
- let a = Array.create n None in
- let c = ref 0 in
- let () = fold (fun () element ->
- let image = f element in
- a.(number element) <- image;
- match image with
- | Some _ ->
- incr c
- | None ->
- ()
- ) () in
- let get element =
- a.(number element)
- in
- get, !c
-
-let rec truncate k xs =
- match k, xs with
- | 0, _ ->
- []
- | _, [] ->
- assert false
- | _, x :: xs ->
- x :: truncate (k-1) xs
-
-let truncate k xs =
- if List.length xs <= k then xs else truncate k xs
-
-module IntSet = Set.Make (struct
- type t = int
- let compare = ( - )
- end)
-
-let separated_list_to_string printer separator list =
-
- let rec loop x = function
- | [] ->
- printer x
- | y :: xs ->
- printer x
- ^ separator
- ^ loop y xs
- in
-
- match list with
- | [] ->
- ""
- | x :: xs ->
- loop x xs
-
-
-let index_map string_map =
- let n = StringMap.cardinal string_map in
- let a = Array.create n None in
- let conv, _ = StringMap.fold
- (fun k v (conv, idx) ->
- a.(idx) <- Some (k, v);
- StringMap.add k idx conv, idx + 1)
- string_map (StringMap.empty, 0)
- in
- ((fun n -> snd (unSome a.(n))),
- (fun k -> StringMap.find k conv),
- (fun n -> fst (unSome a.(n))))
-
-let support_assoc l x =
- try
- List.assoc x l
- with Not_found -> x
-
-let index (strings : string list) : int * string array * int StringMap.t =
- let name = Array.of_list strings
- and n, map = List.fold_left (fun (n, map) s ->
- n+1, StringMap.add s n map
- ) (0, StringMap.empty) strings in
- n, name, map
-
-(* Turning an implicit list, stored using pointers through a hash
- table, into an explicit list. The head of the implicit list is
- not included in the explicit list. *)
-
-let materialize (table : ('a, 'a option) Hashtbl.t) (x : 'a) : 'a list =
- let rec loop x =
- match Hashtbl.find table x with
- | None ->
- []
- | Some x ->
- x :: loop x
- in
- loop x
-
-(* [iteri] implements a [for] loop over integers, from 0 to
- [n-1]. *)
-
-let iteri n f =
- for i = 0 to n - 1 do
- f i
- done
-
-(* [foldi] implements a [for] loop over integers, from 0 to [n-1],
- with an accumulator. [foldij] implements a [for] loop over
- integers, from [start] to [n-1], with an accumulator. *)
-
-let foldij start n f accu =
- let rec loop i accu =
- if i = n then
- accu
- else
- loop (i+1) (f i accu)
- in
- loop start accu
-
-let foldi n f accu =
- foldij 0 n f accu
-
-(* [mapi n f] produces the list [ f 0; ... f (n-1) ]. *)
-
-let mapi n f =
- List.rev (
- foldi n (fun i accu ->
- f i :: accu
- ) []
- )
-
-(* [qfold f accu q] repeatedly takes an element [x] off the queue [q]
- and applies [f] to the accumulator and to [x], until [q] becomes
- empty. Of course, [f] can add elements to [q] as a side-effect.
-
- We allocate an option to ensure that [qfold] is tail-recursive. *)
-
-let rec qfold f accu q =
- match
- try
- Some (Queue.take q)
- with Queue.Empty ->
- None
- with
- | Some x ->
- qfold f (f accu x) q
- | None ->
- accu
-
-(* [qiter f q] repeatedly takes an element [x] off the queue [q] and
- applies [f] to [x], until [q] becomes empty. Of course, [f] can add
- elements to [q] as a side-effect. *)
-
-let qiter f q =
- try
- while true do
- f (Queue.take q)
- done
- with Queue.Empty ->
- ()
-
-let rec smap f = function
- | [] ->
- []
- | (x :: xs) as l ->
- let x' = f x
- and xs' = smap f xs in
- if x == x' && xs == xs' then
- l
- else
- x' :: xs'
-
-let rec smapa f accu = function
- | [] ->
- accu, []
- | (x :: xs) as l ->
- let accu, x' = f accu x in
- let accu, xs' = smapa f accu xs in
- accu,
- if x == x' && xs == xs' then
- l
- else
- x' :: xs'
-
-let normalize s =
- let s = String.copy s in
- let n = String.length s in
- for i = 0 to n - 1 do
- match s.[i] with
- | '('
- | ')'
- | ',' ->
- s.[i] <- '_'
- | _ ->
- ()
- done;
- s
-
-(* [postincrement r] increments [r] and returns its original value. *)
-
-let postincrement r =
- let x = !r in
- r := x + 1;
- x
-
-(* [gcp] returns the greatest common prefix of two strings. *)
-
-let gcp s1 s2 =
- let n1 = String.length s1
- and n2 = String.length s2 in
- let rec loop i =
- if (i < n1) && (i < n2) && (s1.[i] = s2.[i]) then
- loop (i+1)
- else
- String.sub s1 0 i
- in
- loop 0
-
-(* [gcps] returns the greatest common prefix of a nonempty list of strings. *)
-
-let rec gcps = function
- | [] ->
- assert false
- | s :: ss ->
- let rec loop accu = function
- | [] ->
- accu
- | s :: ss ->
- loop (gcp s accu) ss
- in
- loop s ss
-
-(* [array_forall p a] computes the conjunction of the predicate [p] over all
- elements of the array [a]. *)
-
-exception ArrayForall
-
-let _ArrayForall =
- ArrayForall
-
-let array_forall (p : 'a -> bool) (a : 'a array) : bool =
- try
- for i = 0 to Array.length a - 1 do
- let x = Array.get a i in
- if not (p x) then
- raise _ArrayForall
- done;
- true
- with ArrayForall ->
- false
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* TEMPORARY tidy up, comment, remove dead code *)
-
-(* Converting an option to a string, with [None] converted
- to the empty string. *)
-
-val o2s: 'a option -> ('a -> string) -> string
-
-(* Projection out of a singleton list. *)
-
-val single: 'a list -> 'a
-
-(* A variant of [List.map] where [f] returns a pair of elements,
- to be flattened into the new list. *)
-
-val mapd: ('a -> 'b * 'b) -> 'a list -> 'b list
-
-(* Tabulating a function using an internal array. [tabulateb n f]
- returns a function that is extensionally equal to [f], but relies
- on an internal array. Arguments to [f] are of type [int] and are
- supposed to lie in the range [0..n). The result type of [f] is
- assumed to be of type [bool]. [tabulateb] also returns the number
- of points where [f] is [true]. *)
-
-val tabulateb: int -> (int -> bool) -> (int -> bool) * int
-
-(* [tabulateo number fold n f] returns a function that is
- extensionally equal to [f], but relies on an internal
- array. Arguments to [f] are of type ['a] and are mapped by [number]
- into the range [0..n). [fold] allows folding over the domain of
- [f]. The result type of [f] is an option type, and [tabulateo] also
- returns the number of points where [f] is [Some _]. *)
-
-val tabulateo: ('a -> int) -> ((unit -> 'a -> unit) -> unit -> unit) -> int -> ('a -> 'b option) -> ('a -> 'b option) * int
-
-(* Truncature of a list. *)
-
-val truncate: int -> 'a list -> 'a list
-
-(* Reverse function application. *)
-
-val ( $$ ) : 'a -> ('a -> 'b) -> 'b
-
-(* Sets of strings and maps over strings. *)
-
-module IntSet : Set.S with type elt = int
-
-(* [separated_list_to_string printer sep l] converts [l] into a string
- representation built using [printer] on each element and [sep] as
- a separator. *)
-
-val separated_list_to_string: ('a -> string) -> string -> 'a list -> string
-
-(* [index_map f] returns a triple (indexed_f, domain_indexation, domain_array).
- [indexed_f] is a mapping from [0..n-1] to the elements of the map [f]
- ([n] being the size of the image of [f]).
- [domain_indexation] is a mapping from the domain of the map [f] to indexes.
- [domain_array] is a mapping from the indexes to the domain of [f].
- The indexation implements [f] ie:
- - forall x in domain(m), indexed_f (domain_indexation x) = f (x).
- - forall x in domain(m), domain_array (domain_indexation x) = x. *)
-
-val index_map
- : 'a StringMap.t -> (int -> 'a) * (string -> int) * (int -> string)
-
-(* [support_assoc l x] returns the second component of the first couple
- in [l] whose first component is [x]. If it does not exist, it returns
- [x]. *)
-
-val support_assoc : ('a * 'a) list -> 'a -> 'a
-
-(* [index] indexes a list of (distinct) strings, that is, assigns an
- integer index to each string and builds mappings both ways between
- strings and indices. *)
-
-val index: string list -> int * string array * int StringMap.t
-
-(* Turning an implicit list, stored using pointers through a hash
- table, into an explicit list. The head of the implicit list is
- not included in the explicit list. *)
-
-val materialize: ('a, 'a option) Hashtbl.t -> 'a -> 'a list
-
-(* [iteri] implements a [for] loop over integers, from 0 to
- [n-1]. *)
-
-val iteri: int -> (int -> unit) -> unit
-
-(* [foldi] implements a [for] loop over integers, from 0 to [n-1],
- with an accumulator. [foldij] implements a [for] loop over
- integers, from [start] to [n-1], with an accumulator. *)
-
-val foldi: int -> (int -> 'a -> 'a) -> 'a -> 'a
-val foldij: int -> int -> (int -> 'a -> 'a) -> 'a -> 'a
-
-(* [mapi n f] produces the list [ f 0; ... f (n-1) ]. *)
-
-val mapi: int -> (int -> 'a) -> 'a list
-
-(* [qfold f accu q] repeatedly takes an element [x] off the queue [q]
- and applies [f] to the accumulator and to [x], until [q] becomes
- empty. Of course, [f] can add elements to [q] as a side-effect. *)
-
-val qfold: ('a -> 'b -> 'a) -> 'a -> 'b Queue.t -> 'a
-
-(* [qiter f q] repeatedly takes an element [x] off the queue [q] and
- applies [f] to [x], until [q] becomes empty. Of course, [f] can add
- elements to [q] as a side-effect. *)
-
-val qiter: ('b -> unit) -> 'b Queue.t -> unit
-
-(* [smap] has the same semantics as [List.map], but attempts to
- physically return the input list when [f] is the identity. *)
-
-val smap: ('a -> 'a) -> 'a list -> 'a list
-
-(* [smapa] is a variant of [smap] that maintains an accumulator. *)
-
-val smapa: ('b -> 'a -> 'b * 'a) -> 'b -> 'a list -> 'b * 'a list
-
-(* [normalize s] returns a copy of [s] where parentheses and commas
- are replaced with underscores. *)
-
-val normalize: string -> string
-
-(* [postincrement r] increments [r] and returns its original value. *)
-
-val postincrement: int ref -> int
-
-(* [gcp] returns the greatest common prefix of two strings. *)
-
-val gcp: string -> string -> string
-
-(* [gcps] returns the greatest common prefix of a nonempty list of strings. *)
-
-val gcps : string list -> string
-
-(* [array_forall p a] computes the conjunction of the predicate [p] over all
- elements of the array [a]. *)
-
-val array_forall: ('a -> bool) -> 'a array -> bool
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: nonTerminalDefinitionInlining.ml,v 1.17 2006/06/26 09:41:33 regisgia Exp $ *)
-open UnparameterizedSyntax
-open ListMonad
-
-(* This exception will be raised when a branch does not need inlining. *)
-exception NoInlining
-
-(* Color are used to detect cycles. *)
-type 'a color =
- | BeingExpanded
- | Expanded of 'a
-
-(* Inline a grammar. The resulting grammar does not contain any definitions
- that can be inlined. *)
-let inline grammar =
-
- let names producers =
- List.fold_left (fun s -> function (_, Some x) -> StringSet.add x s | _ -> s)
- StringSet.empty producers
- in
-
- (* This function returns a fresh name beginning with [prefix] and
- that is not in the set of names [names]. *)
- let rec fresh ?(c=0) names prefix =
- let name = prefix^string_of_int c in
- if StringSet.mem name names then
- fresh ~c:(c+1) names prefix
- else
- name
- in
-
- let use_inline = ref false in
-
- (* This table associates a color to each non terminal that can be expanded. *)
- let expanded_non_terminals =
- Hashtbl.create 13
- in
-
- let expanded_state k =
- Hashtbl.find expanded_non_terminals k
- in
-
- let mark_as_being_expanded k =
- Hashtbl.add expanded_non_terminals k BeingExpanded
- in
-
- let mark_as_expanded k r =
- Hashtbl.replace expanded_non_terminals k (Expanded r);
- r
- in
-
- (* This function traverses the producers of the branch [b] and find
- the first non terminal that can be inlined. If it finds one, it
- inlines its branches into [b], that's why this function can return
- several branches. If it does not find one non terminal to be
- inlined, it raises [NoInlining]. *)
- let rec find_inline_producer b =
- let prefix, nt, p, psym, suffix =
- let rec chop_inline i (prefix, suffix) =
- match suffix with
- | [] ->
- raise NoInlining
-
- | ((nt, id) as x) :: xs ->
- try
- let r = StringMap.find nt grammar.rules in
- let id = match id with
- | None -> "_"^string_of_int i
- | Some id -> id
- in
- if r.inline_flag then
- (* We have to inline the rule [r] into [b] between
- [prefix] and [xs]. *)
- List.rev prefix, nt, r, id, xs
- else
- chop_inline (i + 1) (x :: prefix, xs)
- with Not_found ->
- chop_inline (i + 1) (x :: prefix, xs)
- in
- chop_inline 1 ([], b.producers)
- in
- prefix, expand_rule nt p, nt, psym, suffix
-
- (* We have to rename producers' names of the inlined production
- if they clashes with the producers' names of the branch into
- which we do the inlining. *)
- and rename_if_necessary b producers =
-
- (* First we compute the set of names already in use. *)
- let producers_names = names (b.producers @ producers) in
-
- (* Compute a renaming and the new inlined producers' names. *)
- let phi, producers' =
- List.fold_left (fun (phi, producers) -> function (p, Some x) ->
- if StringSet.mem x producers_names then
- let x' = fresh producers_names x in
- ((x, x') :: phi, (p, Some x') :: producers)
- else
- (phi, (p, Some x) :: producers)
- | p -> phi, p :: producers) ([], []) producers
- in
- phi, List.rev producers'
-
- (* Inline the non terminals that can be inlined in [b]. We use the
- ListMonad to combine the results. *)
- and expand_branch (b : branch) : branch ListMonad.m =
- try
- let prefix, p, nt, psym, suffix = find_inline_producer b in
- use_inline := true;
- if Action.use_dollar b.action then
- Error.error [ b.branch_position ]
- (Printf.sprintf
- "You cannot use %s and the $i syntax in this branch since the \
- definition of %s has to be inlined."
- nt nt)
- else
- (* Inline a branch of [nt] at position [prefix] ... [suffix] in
- the branch [b]. *)
- let inline_branch pb =
- (* Rename the producers of this branch is they conflict with
- the name of the host's producers. *)
- let phi, inlined_producers = rename_if_necessary b pb.producers in
-
- (* Define the renaming environment given the shape of the branch. *)
- let renaming_env, prefix', suffix' =
-
- let start_position, prefix' =
- match List.rev prefix with
-
- (* If the prefix is empty, the start position is the rule
- start position. *)
- | [] -> (Keyword.Left, Keyword.WhereStart), prefix
-
- (* If the last producer of prefix is unnamed, we cannot refer to
- its position. We give it a name. *)
- | (p, None) :: ps ->
- let x = fresh (names (inlined_producers @ prefix @ suffix)) (CodeBits.prefix "p") in
- (Keyword.RightNamed x, Keyword.WhereEnd), List.rev ((p, Some x) :: ps)
-
- (* The last producer of prefix is named [x],
- $startpos in the inlined rule will be changed to $endpos(x). *)
- | (_, Some x) :: _ -> (Keyword.RightNamed x, Keyword.WhereEnd), prefix
-
- in
- (* Same thing for the suffix. *)
- let end_position, suffix' =
- match suffix with
- | [] -> (Keyword.Left, Keyword.WhereEnd), suffix
- | (p, None) :: ps ->
- let x = fresh (names (inlined_producers @ prefix' @ suffix)) (CodeBits.prefix "p") in
- ((Keyword.RightNamed x, Keyword.WhereStart), (p, Some x) :: ps)
- | (_, Some x) :: _ -> (Keyword.RightNamed x, Keyword.WhereStart), suffix
- in
- (psym, start_position, end_position), prefix', suffix'
- in
- (* Rename the host semantic action.
- Each reference of the inlined non terminal [psym] must be taken into
- account. $startpos(psym) is changed to $startpos(x) where [x] is
- the first producer of the inlined branch if it is not empty or
- the preceding producer found in the prefix. *)
- let outer_action, (used1, used2) =
- Action.rename_inlined_psym renaming_env [] b.action
- in
- let action', (used1', used2') =
- Action.rename renaming_env phi pb.action
- in
- let prefix = if used1 || used1' then prefix' else prefix in
- let suffix = if used2 || used2' then suffix' else suffix in
-
- { b with
- producers = prefix @ inlined_producers @ suffix;
- action = Action.compose psym action' outer_action
- }
- in
- List.map inline_branch p.branches >>= expand_branch
-
- with NoInlining ->
- return b
-
- (* Expand a rule if necessary. *)
- and expand_rule k r =
- try
- (match expanded_state k with
- | BeingExpanded ->
- Error.error
- r.positions
- (Printf.sprintf "there is a cycle in the definition of %s." k)
- | Expanded r ->
- r)
- with Not_found ->
- mark_as_being_expanded k;
- mark_as_expanded k { r with branches = r.branches >>= expand_branch }
- in
-
- (* We check that the %inline rules do not use $i syntax since
- expansion of $i is impossible. *)
- let _ =
- StringMap.iter
- (fun _ r ->
- if r.inline_flag
- && List.exists (fun b -> Action.use_dollar b.action) r.branches then
- Error.error r.positions
- (Printf.sprintf
- "You cannot use $i syntax in this branch since its \
- definition will be inlined."))
- grammar.rules
- in
-
- (* If we are in Coq mode, %inline is forbidden. *)
- let _ =
- if Settings.coq then
- StringMap.iter
- (fun _ r ->
- if r.inline_flag then
- Error.error r.positions
- (Printf.sprintf "%%inline is not supported by the coq back-end"))
- grammar.rules
- in
-
- (* To expand a grammar, we expand all its rules and remove
- the %inline rules. *)
- let expanded_rules =
- StringMap.mapi expand_rule grammar.rules
- and useful_types =
- StringMap.filter
- (fun k _ -> try not (StringMap.find k grammar.rules).inline_flag
- with Not_found -> true)
- grammar.types
- in
-
- { grammar with
- rules = StringMap.filter (fun _ r -> not r.inline_flag) expanded_rules;
- types = useful_types
- }, !use_inline
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: nonTerminalDefinitionInlining.mli,v 1.5 2005/12/01 16:20:06 regisgia Exp $ *)
-
-(** [inline g] traverses the rules of [g] and inlines the non terminal
- definitions that are marked with [%inline]. It returns a pair of the transformed
- grammar and a flag that tells whether any inlining was actually done. *)
-val inline: UnparameterizedSyntax.grammar -> UnparameterizedSyntax.grammar * bool
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module uses Floyd and Warshall's algorithm to detect whether a graph
- with integer-weighted edges contains a simple cycle of negative weight. *)
-
-(* The algorithm runs in cubic time in the number of vertices. It may be
- worthwhile to first use Tarjan's algorithm to obtain the graph's strongly
- connected components, and use Floyd and Warshall's algorithm only on each
- component. *)
-
-module Run (G : sig
-
- type node
-
- (* We assume each node has a unique index. Indices must range from
- $0$ to $n-1$, where $n$ is the number of nodes in the graph. *)
-
- val n: int
- val index: node -> int
-
- (* Iterating over a node's immediate successors. Edges are weighted. *)
-
- val successors: (int -> node -> unit) -> node -> unit
-
- (* Iterating over all nodes. *)
-
- val iter: (node -> unit) -> unit
-
-end) = struct
-
- open G
-
- (* Integers with infinity. *)
-
- type distance =
- | Infinity
- | Finite of int
-
- let add d1 d2 =
- match d1, d2 with
- | Infinity, _
- | _, Infinity ->
- Infinity
- | Finite i1, Finite i2 ->
- Finite (i1 + i2)
-
- let min d1 d2 =
- match d1, d2 with
- | Infinity, d
- | d, Infinity ->
- d
- | Finite i1, Finite i2 ->
- Finite (min i1 i2)
-
- let le d1 d2 =
- match d1, d2 with
- | Infinity, Infinity ->
- true
- | Infinity, Finite _ ->
- false
- | Finite _, Infinity ->
- true
- | Finite i1, Finite i2 ->
- i1 <= i2
-
- (* Allocate and initialize a distance matrix. At allocation time, every entry
- is initialized to infinity. Then, we iterate over all edges, and copy them
- into the distance matrix. *)
-
- (* Note that, by default, [d.(i).(i)] is not initialized to zero: it is
- initialized to infinity. This is because we are looking for paths of
- non-zero length. In other words, we are computing a transitive closure,
- not a reflexive, transitive closure. *)
-
- let d =
- Array.init n (fun i ->
- Array.init n (fun j ->
- Infinity
- )
- )
-
- let () =
- iter (fun source ->
- successors (fun weight target ->
- (* We use a min operation, so the graph may be a multi-graph, that is,
- multiple edges between two nodes are permitted. *)
- let i = index source
- and j = index target in
- d.(i).(j) <- min (Finite weight) d.(i).(j)
- ) source
- )
-
- (* The algorithm. *)
-
- (* Stefan Hougardy notes that, in the presence of negative cycles, distances
- can grow exponentially fast (towards minus infinity), so there is a risk
- of overflow. To avoid this, one must check for negative cycles during the
- computation -- as opposed to waiting until the end. *)
-
- exception Detection
-
- let graph_has_nonpositive_simple_cycle : bool =
- try
- for k = 0 to n-1 do
- for i = 0 to n-1 do
- for j = 0 to n-1 do
- d.(i).(j) <- min d.(i).(j) (add d.(i).(k) d.(k).(j));
- if i = j && le d.(i).(j) (Finite 0) then
- raise Detection
- done
- done
- done;
- false
- with Detection ->
- true
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module uses Floyd and Warshall's algorithm to detect whether a graph
- with integer-weighted edges contains a simple cycle of negative weight. *)
-
-(* The algorithm runs in cubic time in the number of vertices. It may be
- worthwhile to first use Tarjan's algorithm to obtain the graph's strongly
- connected components, and use Floyd and Warshall's algorithm only on each
- component. *)
-
-module Run (G : sig
-
- type node
-
- (* We assume each node has a unique index. Indices must range from
- $0$ to $n-1$, where $n$ is the number of nodes in the graph. *)
-
- val n: int
- val index: node -> int
-
- (* Iterating over a node's immediate successors. Edges are weighted. *)
-
- val successors: (int -> node -> unit) -> node -> unit
-
- (* Iterating over all nodes. *)
-
- val iter: (node -> unit) -> unit
-
-end) : sig
-
- val graph_has_nonpositive_simple_cycle : bool
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-let map f = function
- | None ->
- None
- | Some x ->
- Some (f x)
-
-let iter f o =
- match o with
- | None ->
- ()
- | Some x ->
- f x
-
-let fold f o accu =
- match o with
- | None ->
- accu
- | Some x ->
- f x accu
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-val map: ('a -> 'b) -> 'a option -> 'b option
-val iter: ('a -> unit) -> 'a option -> unit
-val fold: ('a -> 'b -> 'b) -> 'a option -> 'b -> 'b
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* A packed integer array is represented as a pair of an integer [k] and
- a string [s]. The integer [k] is the number of bits per integer that we
- use. The string [s] is just an array of bits, which is read in 8-bit
- chunks. *)
-
-(* The ocaml programming language treats string literals and array literals
- in slightly different ways: the former are statically allocated, while
- the latter are dynamically allocated. (This is rather arbitrary.) In the
- context of Menhir's table-based back-end, where compact, immutable
- integer arrays are needed, ocaml strings are preferable to ocaml arrays. *)
-
-type t =
- int * string
-
-(* The magnitude [k] of an integer [v] is the number of bits required
- to represent [v]. It is rounded up to the nearest power of two, so
- that [k] divides [Sys.word_size]. *)
-
-let magnitude (v : int) =
- if v < 0 then
- Sys.word_size
- else
- let rec check k max = (* [max] equals [2^k] *)
- if (max <= 0) || (v < max) then
- k
- (* if [max] just overflew, then [v] requires a full ocaml
- integer, and [k] is the number of bits in an ocaml integer
- plus one, that is, [Sys.word_size]. *)
- else
- check (2 * k) (max * max)
- in
- check 1 2
-
-(* [pack a] turns an array of integers into a packed integer array. *)
-
-(* Because the sign bit is the most significant bit, the magnitude of
- any negative number is the word size. In other words, [pack] does
- not achieve any space savings as soon as [a] contains any negative
- numbers, even if they are ``small''. *)
-
-let pack (a : int array) : t =
-
- let m = Array.length a in
-
- (* Compute the maximum magnitude of the array elements. This tells
- us how many bits per element we are going to use. *)
-
- let k =
- Array.fold_left (fun k v ->
- max k (magnitude v)
- ) 1 a
- in
-
- (* Because access to ocaml strings is performed on an 8-bit basis,
- two cases arise. If [k] is less than 8, then we can pack multiple
- array entries into a single character. If [k] is greater than 8,
- then we must use multiple characters to represent a single array
- entry. *)
-
- if k <= 8 then begin
-
- (* [w] is the number of array entries that we pack in a character. *)
-
- assert (8 mod k = 0);
- let w = 8 / k in
-
- (* [n] is the length of the string that we allocate. *)
-
- let n =
- if m mod w = 0 then
- m / w
- else
- m / w + 1
- in
-
- let s =
- String.create n
- in
-
- (* Define a reader for the source array. The reader might run off
- the end if [w] does not divide [m]. *)
-
- let i = ref 0 in
- let next () =
- let ii = !i in
- if ii = m then
- 0 (* ran off the end, pad with zeroes *)
- else
- let v = a.(ii) in
- i := ii + 1;
- v
- in
-
- (* Fill up the string. *)
-
- for j = 0 to n - 1 do
- let c = ref 0 in
- for x = 1 to w do
- c := (!c lsl k) lor next()
- done;
- s.[j] <- Char.chr !c
- done;
-
- (* Done. *)
-
- k, s
-
- end
- else begin (* k > 8 *)
-
- (* [w] is the number of characters that we use to encode an array entry. *)
-
- assert (k mod 8 = 0);
- let w = k / 8 in
-
- (* [n] is the length of the string that we allocate. *)
-
- let n =
- m * w
- in
-
- let s =
- String.create n
- in
-
- (* Fill up the string. *)
-
- for i = 0 to m - 1 do
- let v = ref a.(i) in
- for x = 1 to w do
- s.[(i + 1) * w - x] <- Char.chr (!v land 255);
- v := !v lsr 8
- done
- done;
-
- (* Done. *)
-
- k, s
-
- end
-
-(* Access to a string. *)
-
-let read (s : string) (i : int) : int =
- Char.code (String.unsafe_get s i)
-
-(* [get1 t i] returns the integer stored in the packed array [t] at index [i].
- It assumes (and does not check) that the array's bit width is [1]. The
- parameter [t] is just a string. *)
-
-let get1 (s : string) (i : int) : int =
- let c = read s (i lsr 3) in
- let c = c lsr ((lnot i) land 0b111) in
- let c = c land 0b1 in
- c
-
-(* [get t i] returns the integer stored in the packed array [t] at index [i]. *)
-
-(* Together, [pack] and [get] satisfy the following property: if the index [i]
- is within bounds, then [get (pack a) i] equals [a.(i)]. *)
-
-let get ((k, s) : t) (i : int) : int =
- match k with
- | 1 ->
- get1 s i
- | 2 ->
- let c = read s (i lsr 2) in
- let c = c lsr (2 * ((lnot i) land 0b11)) in
- let c = c land 0b11 in
- c
- | 4 ->
- let c = read s (i lsr 1) in
- let c = c lsr (4 * ((lnot i) land 0b1)) in
- let c = c land 0b1111 in
- c
- | 8 ->
- read s i
- | 16 ->
- let j = 2 * i in
- (read s j) lsl 8 + read s (j + 1)
- | _ ->
- assert (k = 32); (* 64 bits unlikely, not supported *)
- let j = 4 * i in
- (((read s j lsl 8) + read s (j + 1)) lsl 8 + read s (j + 2)) lsl 8 + read s (j + 3)
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* A packed integer array is represented as a pair of an integer [k] and
- a string [s]. The integer [k] is the number of bits per integer that we
- use. The string [s] is just an array of bits, which is read in 8-bit
- chunks. *)
-
-(* The ocaml programming language treats string literals and array literals
- in slightly different ways: the former are statically allocated, while
- the latter are dynamically allocated. (This is rather arbitrary.) In the
- context of Menhir's table-based back-end, where compact, immutable
- integer arrays are needed, ocaml strings are preferable to ocaml arrays. *)
-
-type t =
- int * string
-
-(* [pack a] turns an array of integers into a packed integer array. *)
-
-(* Because the sign bit is the most significant bit, the magnitude of
- any negative number is the word size. In other words, [pack] does
- not achieve any space savings as soon as [a] contains any negative
- numbers, even if they are ``small''. *)
-
-val pack: int array -> t
-
-(* [get t i] returns the integer stored in the packed array [t] at index [i]. *)
-
-(* Together, [pack] and [get] satisfy the following property: if the index [i]
- is within bounds, then [get (pack a) i] equals [a.(i)]. *)
-
-val get: t -> int -> int
-
-(* [get1 t i] returns the integer stored in the packed array [t] at index [i].
- It assumes (and does not check) that the array's bit width is [1]. The
- parameter [t] is just a string. *)
-
-val get1: string -> int -> int
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Positions
-open Syntax
-open UnparameterizedSyntax
-open InternalSyntax
-open Misc
-
-(* Inference for non terminals. *)
-
-(* Unification variables convey [variable_info] to describe
- the multi-equation they take part of. *)
-type variable_info =
- {
- mutable structure : nt_type option;
- mutable name : string option;
- mutable mark : Mark.t
- }
-
-(* [UnionFind] is used to improve the union and the equality test
- between multi-equations. *)
-and variable = variable_info UnionFind.point
-
-(* Types are simple types.
- [star] denotes the type of ground symbol (non terminal or terminal).
- [Arrow] describes the type of a parameterized non terminal. *)
-and nt_type =
- Arrow of variable list
-
-let star =
- Arrow []
-
-(* [var_name] is a name generator for unification variables. *)
-let var_name =
- let name_counter = ref (-1) in
- let next_name () =
- incr name_counter;
- String.make 1 (char_of_int (97 + !name_counter mod 26))
- ^ let d = !name_counter / 26 in if d = 0 then "" else string_of_int d
- in
- fun v ->
- let repr = UnionFind.find v in
- match repr.name with
- None -> let name = next_name () in repr.name <- Some name; name
- | Some x -> x
-
-(* [string_of_nt_type] is a simple pretty printer for types (they can be
- recursive). *)
-
-(* 2011/04/05: types can no longer be recursive, but I won't touch the printer -fpottier *)
-
-let string_of paren_fun ?paren ?colors t : string =
- let colors =
- match colors with
- None -> (Mark.fresh (), Mark.fresh ())
- | Some cs -> cs
- in
- let s, p = paren_fun colors t in
- if paren <> None && p = true then
- "("^ s ^")"
- else s
-
-let rec paren_nt_type ((white, black) as colors) = function
-
- Arrow [] ->
- "*", false
-
- | Arrow ins ->
- let args = separated_list_to_string
- (string_of paren_var ~paren:true ~colors) ", " ins
- in
- let args =
- if List.length ins > 1 then
- "("^ args ^ ")"
- else
- args
- in
- args^" -> *", true
-
-and paren_var (white, black) x =
- let descr = UnionFind.find x in
- if Mark.same descr.mark white then begin
- descr.mark <- black;
- var_name x, false
- end
- else begin
- descr.mark <- white;
- let s, p = match descr.structure with
- None -> var_name x, false
- | Some t -> paren_nt_type (white, black) t
- in
- if Mark.same descr.mark black then
- (var_name x ^ " = " ^ s, true)
- else
- (s, p)
- end
-
-let string_of_nt_type ?paren ?colors t =
- string_of ?colors paren_nt_type t
-
-let string_of_var ?paren ?colors v =
- string_of ?colors paren_var v
-
-(* [print_env env] returns a string description of the typing environment. *)
-let print_env =
- List.iter (fun (k, (_, v)) ->
- Printf.eprintf "%s: %s\n" k (string_of_var v))
-
-(* [occurs_check x y] checks that [x] does not occur within [y]. *)
-
-let dfs action x =
-
- let black = Mark.fresh () in
-
- let rec visit_var x =
- let descr = UnionFind.find x in
- if not (Mark.same descr.mark black) then begin
- descr.mark <- black;
- action x;
- match descr.structure with
- | None ->
- ()
- | Some t ->
- visit_term t
- end
-
- and visit_term (Arrow ins) =
- List.iter visit_var ins
-
- in
- visit_var x
-
-exception OccursError of variable * variable
-
-let occurs_check x y =
- dfs (fun z -> if UnionFind.equivalent x z then raise (OccursError (x, y))) y
-
-(* First order unification. *)
-
-(* 2011/04/05: perform an eager occurs check and prevent the construction
- of any cycles. *)
-
-let fresh_flexible_variable () =
- UnionFind.fresh { structure = None; name = None; mark = Mark.none }
-
-let fresh_structured_variable t =
- UnionFind.fresh { structure = Some t; name = None; mark = Mark.none }
-
-let star_variable =
- fresh_structured_variable star
-
-exception UnificationError of nt_type * nt_type
-exception BadArityError of int * int
-
-let rec unify_var toplevel x y =
- if not (UnionFind.equivalent x y) then
- let reprx, repry = UnionFind.find x, UnionFind.find y in
- match reprx.structure, repry.structure with
- None, Some t -> occurs_check x y; UnionFind.union x y
- | Some t, None -> occurs_check y x; UnionFind.union y x
- | None, None -> UnionFind.union x y
- | Some t, Some t' -> unify toplevel t t'; UnionFind.union x y
-
-and unify toplevel t1 t2 =
- match t1, t2 with
-
- | Arrow ins, Arrow ins' ->
- let n1, n2 = List.length ins, List.length ins' in
- if n1 <> n2 then
- if n1 = 0 || n2 = 0 || not toplevel then
- raise (UnificationError (t1, t2))
- else
- (* the flag [toplevel] is used only here and influences which
- exception is raised; BadArityError is raised only at toplevel *)
- raise (BadArityError (n1, n2));
- List.iter2 (unify_var false) ins ins'
-
-let unify_var x y =
- unify_var true x y
-
-(* Typing environment. *)
-type environment =
- (string * (Positions.t list * variable)) list
-
-(* [lookup x env] returns the type related to [x] in the typing environment
- [env].
- By convention, identifiers that are not in [env] are terminals. They are
- given the type [Star]. *)
-let lookup x (env: environment) =
- try
- snd (List.assoc x env)
- with Not_found -> star_variable
-
-(* This function checks that the symbol [k] has the type [expected_type]. *)
-let check positions env k expected_type =
- let inference_var = lookup k env in
- let checking_var = fresh_structured_variable expected_type in
- try
- unify_var inference_var checking_var
- with
- UnificationError (t1, t2) ->
- Error.error
- positions
- (Printf.sprintf
- "How is this symbol parameterized?\n\
- It is used at sorts %s and %s.\n\
- The sort %s is not compatible with the sort %s."
- (string_of_var inference_var) (string_of_var checking_var)
- (string_of_nt_type t1) (string_of_nt_type t2))
-
- | BadArityError (n1, n2) ->
- Error.error
- positions
- (Printf.sprintf
- "does this symbol expect %d or %d arguments?"
- (min n1 n2) (max n1 n2))
-
- | OccursError (x, y) ->
- Error.error
- positions
- (Printf.sprintf
- "How is this symbol parameterized?\n\
- It is used at sorts %s and %s.\n\
- The sort %s cannot be unified with the sort %s."
- (string_of_var inference_var) (string_of_var checking_var)
- (string_of_var x) (string_of_var y))
-
-
-
-(* An identifier can be used either in a total application or as a
- higher-order non terminal (no partial application is allowed). *)
-let rec parameter_type env = function
- | ParameterVar x ->
- lookup x.value env
-
- | ParameterApp (x, args) ->
- assert (args <> []);
- let expected_type =
- (* [x] is applied, it must be to the exact number
- of arguments. *)
- Arrow (List.map (parameter_type env) args)
- in
- (* Check the well-formedness of the application. *)
- check [x.position] env x.value expected_type;
-
- (* Similarly, if it was a total application the result is
- [Star] otherwise it is the flexible variable. *)
- star_variable
-
-let check_grammar p_grammar =
- (* [n] is the grammar size. *)
- let n = StringMap.cardinal p_grammar.p_rules in
-
- (* The successors of the non terminal [N] are its producers. It
- induce a graph over the non terminals and its successor function
- is implemented by [successors]. Non terminals are indexed using
- [nt].
- *)
- let nt, conv, iconv = index_map p_grammar.p_rules in
- let parameters, name, branches, positions =
- (fun n -> (nt n).pr_parameters), (fun n -> (nt n).pr_nt),
- (fun n -> (nt n).pr_branches), (fun n -> (nt n).pr_positions)
- in
-
- (* The successors function is implemented as an array using the
- indexing previously created. *)
- let successors =
- Array.init n (fun node ->
- (* We only are interested by parameterized non terminals. *)
- if parameters node <> [] then
- List.fold_left (fun succs { pr_producers = symbols } ->
- List.fold_left (fun succs -> function (_, p) ->
- let symbol, _ = Parameters.unapp p in
- try
- let symbol_node = conv symbol.value in
- (* [symbol] is a parameterized non terminal, we add it
- to the successors set. *)
- if parameters symbol_node <> [] then
- IntSet.add symbol_node succs
- else
- succs
- with Not_found ->
- (* [symbol] is a token, it is not interesting for type inference
- purpose. *)
- succs
- ) succs symbols
- ) IntSet.empty (branches node)
- else
- Misc.IntSet.empty
- )
- in
-
- (* The successors function and the indexing induce the following graph
- module. *)
- let module RulesGraph =
- struct
-
- type node = int
-
- let n = n
-
- let index node =
- node
-
- let successors f node =
- IntSet.iter f successors.(node)
-
- let iter f =
- for i = 0 to n - 1 do
- f i
- done
-
- end
- in
- let module ConnectedComponents = Tarjan.Run (RulesGraph) in
- (* We check that:
- - all the parameterized definitions of a particular component
- have the same number of parameters.
- - every parameterized non terminal definition always uses
- parameterized definitions of the same component with its
- formal parameters.
-
- Components are marked during the traversal:
- -1 means unvisited
- n with n > 0 is the number of parameters of the clique.
- *)
- let unseen = -1 in
- let marked_components = Array.create n unseen in
-
- let flexible_arrow args =
- let ty = Arrow (List.map (fun _ -> fresh_flexible_variable ()) args) in
- fresh_structured_variable ty
- in
-
- (* [nt_type i] is the type of the i-th non terminal. *)
- let nt_type i =
- match parameters i with
- | [] ->
- star_variable
-
- | x ->
- flexible_arrow x
- in
-
- (* [actual_parameters_as_formal] is the well-formedness checker for
- parameterized non terminal application. *)
- let actual_parameters_as_formal actual_parameters formal_parameters =
- List.for_all2 (fun y -> (function ParameterVar x -> x.value = y
- | _ -> false))
- formal_parameters actual_parameters
- in
-
- (* The environment is initialized. *)
- let env : environment = StringMap.fold
- (fun k r acu ->
- (k, (r.pr_positions, nt_type (conv k)))
- :: acu)
- p_grammar.p_rules []
- in
-
- (* We traverse the graph checking each parameterized non terminal
- definition is well-formed. *)
- RulesGraph.iter
- (fun i ->
- let params = parameters i
- and iname = name i
- and repr = ConnectedComponents.representative i
- and positions = positions i
- in
-
- (* The environment is augmented with the parameters whose types are
- unknown. *)
- let env' = List.map
- (fun k -> (k, (positions, fresh_flexible_variable ()))) params
- in
- let env = env' @ env in
-
- (* The type of the parameterized non terminal is constrained to be
- [expected_ty]. *)
- let check_type () =
- check positions env iname (Arrow (List.map (fun (_, (_, t)) -> t) env'))
- in
-
- (* We check the number of parameters. *)
- let check_parameters () =
- let parameters_len = List.length params in
- (* The component is visited for the first time. *)
- if marked_components.(repr) = unseen then
- marked_components.(repr) <- parameters_len
- else (* Otherwise, we check that the arity is homogeneous
- in the component. *)
- if marked_components.(repr) <> parameters_len then
- Error.error positions
- (Printf.sprintf
- "Mutually recursive definitions must have the same parameters.\n\
- This is not the case for %s and %s."
- (name repr) iname)
- in
-
- (* In each production rule, the parameterized non terminal
- of the same component must be instantiated with the same
- formal arguments. *)
- let check_producers () =
- List.iter
- (fun { pr_producers = symbols } -> List.iter
- (function (_, p) ->
- let symbol, actuals = Parameters.unapp p in
- (* We take the use of each symbol into account. *)
- check [ symbol.position ] env symbol.value
- (if actuals = [] then star else
- Arrow (List.map (parameter_type env) actuals));
- (* If it is in the same component, check in addition that
- the arguments are the formal arguments. *)
- try
- let idx = conv symbol.value in
- if ConnectedComponents.representative idx = repr then
- if not (actual_parameters_as_formal actuals params)
- then
- Error.error [ symbol.position ]
- (Printf.sprintf
- "Mutually recursive definitions must have the same \
- parameters.\n\
- This is not the case for %s."
- (let name1, name2 = (name idx), (name i) in
- if name1 <> name2 then name1 ^ " and "^ name2
- else name1))
- with _ -> ())
- symbols) (branches i)
- in
- check_type ();
- check_parameters ();
- check_producers ())
-
-
-let rec subst_parameter subst = function
- | ParameterVar x ->
- (try
- List.assoc x.value subst
- with Not_found ->
- ParameterVar x)
-
- | ParameterApp (x, ps) ->
- (try
- match List.assoc x.value subst with
- | ParameterVar y ->
- ParameterApp (y, List.map (subst_parameter subst) ps)
-
- | ParameterApp _ ->
- (* Type-checking ensures that we cannot do partial
- application. Consequently, if an higher-order non terminal
- is an actual argument, it cannot be the result of a
- partial application. *)
- assert false
-
- with Not_found ->
- ParameterApp (x, List.map (subst_parameter subst) ps))
-
-let subst_parameters subst =
- List.map (subst_parameter subst)
-
-let names_of_p_grammar p_grammar =
- StringMap.fold (fun tok _ acu -> StringSet.add tok acu)
- p_grammar.p_tokens StringSet.empty
- $$ (StringMap.fold (fun nt _ acu -> StringSet.add nt acu)
- p_grammar.p_rules)
-
-let expand p_grammar =
- (* Check that it is safe to expand this parameterized grammar. *)
- check_grammar p_grammar;
-
- (* Set up a mechanism that ensures that names are unique -- and, in
- fact, ensures the stronger condition that normalized names are
- unique. *)
-
- let names =
- ref (StringSet.empty)
- in
- let ensure_fresh name =
- let normalized_name = Misc.normalize name in
- if StringSet.mem normalized_name !names then
- Error.error []
- (Printf.sprintf "internal name clash over %s" normalized_name);
- names := StringSet.add normalized_name !names;
- name
- in
- let expanded_rules =
- Hashtbl.create 13
- in
- let module InstanceTable =
- Hashtbl.Make (Parameters)
- in
- let rule_names =
- InstanceTable.create 13
- in
-
- (* [mangle p] chooses a name for the new nonterminal symbol that corresponds
- to the parameter [p]. *)
-
- let rec mangle = function
- | ParameterVar x
- | ParameterApp (x, []) ->
- Positions.value x
- | ParameterApp (x, ps) ->
-
- (* We include parentheses and commas in the names that we
- assign to expanded nonterminals, because that is more
- readable and acceptable in many situations. We replace them
- with underscores in situations where these characters are
- not valid. *)
-
- Printf.sprintf "%s(%s)"
- (Positions.value x)
- (separated_list_to_string mangle "," ps)
-
- in
- let name_of symbol parameters =
- let param = ParameterApp (symbol, parameters) in
- try
- InstanceTable.find rule_names param
- with Not_found ->
- let name = ensure_fresh (mangle param) in
- InstanceTable.add rule_names param name;
- name
- in
- (* Given the substitution [subst] from parameters to non terminal, we
- instantiate the parameterized branch. *)
- let rec expand_branch subst pbranch =
- let new_producers = List.map
- (function (ido, p) ->
- let sym, actual_parameters =
- Parameters.unapp p in
- let sym, actual_parameters =
- try
- match List.assoc sym.value subst with
- | ParameterVar x ->
- x, subst_parameters subst actual_parameters
-
- | ParameterApp (x, ps) ->
- assert (actual_parameters = []);
- x, ps
-
- with Not_found ->
- sym, subst_parameters subst actual_parameters
- in
- (* Instantiate the definition of the producer. *)
- (expand_branches subst sym actual_parameters, Option.map Positions.value ido))
- pbranch.pr_producers
- in
- {
- branch_position = pbranch.pr_branch_position;
- producers = new_producers;
- action = pbranch.pr_action;
- branch_shift_precedence = pbranch.pr_branch_shift_precedence;
- branch_reduce_precedence = pbranch.pr_branch_reduce_precedence;
- }
-
- (* Instantiate the branches of sym for a particular set of actual
- parameters. *)
- and expand_branches subst sym actual_parameters =
- let nsym = name_of sym actual_parameters in
- try
- if not (Hashtbl.mem expanded_rules nsym) then begin
- let prule = StringMap.find (Positions.value sym) p_grammar.p_rules in
- let subst =
- (* Type checking ensures that parameterized non terminal
- instantiations are well defined. *)
- assert (List.length prule.pr_parameters
- = List.length actual_parameters);
- List.combine prule.pr_parameters actual_parameters @ subst in
- Hashtbl.add expanded_rules nsym
- { branches = []; positions = []; inline_flag = false };
- let rules = List.map (expand_branch subst) prule.pr_branches in
- Hashtbl.replace expanded_rules nsym
- {
- branches = rules;
- positions = prule.pr_positions;
- inline_flag = prule.pr_inline_flag;
- }
- end;
- nsym
- (* If [sym] is a terminal, then it is not in [p_grammar.p_rules].
- Expansion is not needed. *)
- with Not_found -> Positions.value sym
- in
- let rec types_from_list = function
- | [] -> StringMap.empty
- | (nt, ty)::q ->
- let accu = types_from_list q in
- let mangled = mangle nt in
- if StringMap.mem mangled accu then
- Error.error [Positions.position (Parameters.with_pos nt)]
- (Printf.sprintf
- "There are multiple %%type definitions for nonterminal %s."
- mangled);
- StringMap.add mangled (Positions.value ty) accu
- in
-
- let start_symbols = StringMap.domain (p_grammar.p_start_symbols) in
- {
- preludes = p_grammar.p_preludes;
- postludes = p_grammar.p_postludes;
- parameters = p_grammar.p_parameters;
- start_symbols = start_symbols;
- types = types_from_list p_grammar.p_types;
- tokens = p_grammar.p_tokens;
- rules =
- let closed_rules = StringMap.fold
- (fun k prule rules ->
- (* If [k] is a start symbol then it cannot be parameterized. *)
- if prule.pr_parameters <> [] && StringSet.mem k start_symbols then
- Error.error []
- (Printf.sprintf "The start symbol `%s' cannot be parameterized."
- k);
-
- (* Entry points are the closed non terminals. *)
- if prule.pr_parameters = [] then
- StringMap.add k {
- branches = List.map (expand_branch []) prule.pr_branches;
- positions = prule.pr_positions;
- inline_flag = prule.pr_inline_flag;
- } rules
- else rules)
- p_grammar.p_rules
- StringMap.empty
- in
- Hashtbl.fold StringMap.add expanded_rules closed_rules
- }
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: parameterizedGrammar.mli,v 1.6 2005/12/01 16:20:06 regisgia Exp $ *)
-
-(* This turns a grammar where nonterminal symbols can be parameterized
- into a grammar where nonterminal symbols are not parameterized. The
- transformation is a textual expansion process, whose termination is
- guaranteed by a simple type system.
-
- Expansion creates new nonterminal symbols whose names contain
- parentheses and commas. These names can be printed directly in
- informational messages (error messages, conflict reports,
- descriptions of the automaton, etc.). However, they must be
- sanitized via [Misc.normalize] when printed in a context where a
- valid identifier is expected. *)
-
-val expand : InternalSyntax.grammar -> UnparameterizedSyntax.grammar
-
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: parameters.ml,v 1.12 2005/12/02 16:16:22 regisgia Exp $ *)
-
-(* TEMPORARY clean up and write an .mli file *)
-
-open Syntax
-open Misc
-open Positions
-
-let app p ps =
- match ps with
- | [] ->
- ParameterVar p
- | _ ->
- ParameterApp (p, ps)
-
-let oapp1 o p =
- match o with
- | None ->
- p
- | Some var ->
- ParameterApp (var, [ p ])
-
-let unapp = function
- | ParameterVar x ->
- (x, [])
-
- | ParameterApp (p, ps) ->
- (p, ps)
-
-let rec map f = function
- | ParameterVar x ->
- ParameterVar (f x)
-
- | ParameterApp (p, ps) ->
- ParameterApp (f p, List.map (map f) ps)
-
-
-let rec fold f init = function
- | ParameterVar x ->
- f init x
-
- | ParameterApp (p, ps) ->
- f (List.fold_left (fold f) init ps) p
-
-let identifiers m p =
- fold (fun acu x -> StringMap.add x.value x.position acu) m p
-
-type t = parameter
-
-let rec equal x y =
- match x, y with
- | ParameterVar x, ParameterVar y when x.value = y.value ->
- true
- | ParameterApp (p1, p2), ParameterApp (p1', p2') ->
- p1.value = p1'.value && List.for_all2 equal p2 p2'
- | _ -> false
-
-let hash = function
- | ParameterVar x
- | ParameterApp (x, _) ->
- Hashtbl.hash (Positions.value x)
-
-let position = function
- | ParameterVar x
- | ParameterApp (x, _) ->
- Positions.position x
-
-let with_pos p =
- Positions.with_pos (position p) p
+++ /dev/null
-/**************************************************************************/
-/* */
-/* Menhir */
-/* */
-/* François Pottier, INRIA Rocquencourt */
-/* Yann Régis-Gianas, PPS, Université Paris Diderot */
-/* */
-/* Copyright 2005-2008 Institut National de Recherche en Informatique */
-/* et en Automatique. All rights reserved. This file is distributed */
-/* under the terms of the Q Public License version 1.0, with the change */
-/* described in file LICENSE. */
-/* */
-/**************************************************************************/
-
-/* This is the crude version of the parser. It is meant to be processed
- by ocamlyacc. Its existence is necessary for bootstrapping. It is kept
- in sync with [fancy-parser]. The two parsers accept the same language,
- but [fancy-parser] performs more refined error recovery. */
-
-%{
-
-open Keyword
-open ConcreteSyntax
-open Syntax
-open Positions
-
-%}
-
-%token TOKEN TYPE LEFT RIGHT NONASSOC START PREC PUBLIC COLON BAR EOF EQUAL
-%token INLINE LPAREN RPAREN COMMA QUESTION STAR PLUS PARAMETER
-%token <string Positions.located> LID UID
-%token <Stretch.t> HEADER
-%token <Stretch.ocamltype> OCAMLTYPE
-%token <string Lazy.t> PERCENTPERCENT
-%token <Syntax.action> ACTION
-%start grammar
-%type <ConcreteSyntax.grammar> grammar
-
-/* These declarations solve a shift-reduce conflict in favor of
- shifting: when the declaration of a non-terminal symbol begins with
- a leading bar, it is understood as an (insignificant) leading
- optional bar, *not* as an empty right-hand side followed by a bar.
- This ambiguity arises due to the existence of a new notation for
- letting several productions share a single semantic action. */
-
-%nonassoc no_optional_bar
-%nonassoc BAR
-
-%%
-
-/* ------------------------------------------------------------------------- */
-/* A grammar consists of declarations and rules, followed by an optional
- trailer, which we do not parse. */
-
-grammar:
- declarations PERCENTPERCENT rules trailer
- {
- {
- pg_filename = ""; (* filled in by the caller *)
- pg_declarations = List.rev $1;
- pg_rules = $3;
- pg_trailer = $4
- }
- }
-
-trailer:
- EOF
- { None }
-| PERCENTPERCENT /* followed by actual trailer */
- { Some (Lazy.force $1) }
-
-/* ------------------------------------------------------------------------- */
-/* A declaration is an %{ Objective Caml header %}, or a %token, %start,
- %type, %left, %right, or %nonassoc declaration. */
-
-declarations:
- /* epsilon */
- { [] }
-| declarations declaration
- { $2 @ $1 }
-
-declaration:
-| HEADER /* lexically delimited by %{ ... %} */
- { [ unknown_pos (DCode $1) ] }
-
-| TOKEN optional_ocamltype terminals
- { List.map (Positions.map (fun terminal -> DToken ($2, terminal))) $3 }
-
-| START nonterminals
- { List.map (Positions.map (fun nonterminal -> DStart nonterminal)) $2 }
-
-| TYPE OCAMLTYPE actual_parameters
- { List.map (Positions.map (fun nt -> DType ($2, nt)))
- (List.map Parameters.with_pos $3) }
-
-| START OCAMLTYPE nonterminals
- /* %start <ocamltype> foo is syntactic sugar for %start foo %type <ocamltype> foo */
- { Misc.mapd (fun ntloc ->
- Positions.mapd (fun nt -> DStart nt, DType ($2, ParameterVar ntloc)) ntloc) $3 }
-
-| priority_keyword symbols
- { let prec = ParserAux.current_token_precedence (rhs_start_pos 1) (rhs_end_pos 1) in
- List.map (Positions.map (fun symbol -> DTokenProperties (symbol, $1, prec))) $2 }
-
-| PARAMETER OCAMLTYPE
- { [ unknown_pos (DParameter $2) ] }
-
-optional_ocamltype:
- /* epsilon */
- { None }
-| OCAMLTYPE /* lexically delimited by angle brackets */
- { Some $1 }
-
-priority_keyword:
- LEFT
- { LeftAssoc }
-| RIGHT
- { RightAssoc }
-| NONASSOC
- { NonAssoc }
-
-/* ------------------------------------------------------------------------- */
-/* A symbol is a terminal or nonterminal symbol. One would like to
- require nonterminal symbols to begin with a lowercase letter, so as
- to lexically distinguish them from terminal symbols, which must
- begin with an uppercase letter. However, for compatibility with
- ocamlyacc, this is impossible. It can be required only for
- nonterminal symbols that are also start symbols. */
-
-symbols:
- /* epsilon */
- { [] }
-| symbols optional_comma symbol
- { $3 :: $1 }
-
-symbol:
- LID
- { $1 }
-| UID
- { $1 }
-
-optional_comma:
- /* epsilon */
- { () }
-| COMMA
- { () }
-
-/* ------------------------------------------------------------------------- */
-/* Terminals must begin with an uppercase letter. Nonterminals that are
- declared to be start symbols must begin with a lowercase letter. */
-
-terminals:
- /* epsilon */
- { [] }
-| terminals optional_comma UID
- { $3 :: $1 }
-
-nonterminals:
- /* epsilon */
- { [] }
-| nonterminals LID
- { $2 :: $1 }
-
-/* ------------------------------------------------------------------------- */
-/* A rule defines a symbol. It is optionally declared %public, and optionally
- carries a number of formal parameters. The right-hand side of the definition
- consists of a list of production groups. */
-
-rules:
- /* epsilon */
- { [] }
-| rules rule
- { $2 :: $1 }
-
-rule:
- flags
- symbol
- optional_formal_parameters
- COLON optional_bar
- production_group production_groups
- {
- let public, inline = $1 in
- { pr_public_flag = public;
- pr_inline_flag = inline;
- pr_nt = Positions.value $2;
- pr_positions = [ Positions.position $2 ];
- pr_parameters = $3;
- pr_branches = List.flatten ($6 :: List.rev $7)
- }
- }
-
-flags:
- /* epsilon */
- { false, false }
-| PUBLIC
- { true, false }
-| INLINE
- { false, true }
-| PUBLIC INLINE
- { true, true }
-| INLINE PUBLIC
- { true, true }
-
-/* ------------------------------------------------------------------------- */
-/* Parameters are surroundered with parentheses and delimited by commas.
- The syntax of actual parameters allows applications, whereas the syntax
- of formal parameters does not. It also allows use of the "?", "+", and
- "*" shortcuts. */
-
-optional_formal_parameters:
- /* epsilon */
- { [] }
-| LPAREN formal_parameters RPAREN
- { $2 }
-
-formal_parameters:
- symbol
- { [ Positions.value $1 ] }
-| symbol COMMA formal_parameters
- { Positions.value $1 :: $3 }
-
-optional_actual_parameters:
- /* epsilon */
- { [] }
-| LPAREN actual_parameters_comma RPAREN
- { $2 }
-
-actual_parameters_comma:
- actual_parameter
- { [ $1 ] }
-| actual_parameter COMMA actual_parameters_comma
- { $1 :: $3 }
-
-actual_parameter:
- symbol optional_actual_parameters optional_modifier
- { Parameters.oapp1 $3 (Parameters.app $1 $2) }
-
-actual_parameters:
- /* epsilon */
- { [] }
-| actual_parameters optional_comma actual_parameter
- { $3::$1 }
-
-optional_bar:
- /* epsilon */ %prec no_optional_bar
- { () }
-| BAR
- { () }
-
-/* ------------------------------------------------------------------------- */
-/* The "?", "+", and "*" modifiers are short-hands for applications of
- certain parameterized nonterminals, defined in the standard library. */
-
-optional_modifier:
- /* epsilon */
- { None }
-| modifier
- { Some $1 }
-
-modifier:
- QUESTION
- { unknown_pos "option" }
-| PLUS
- { unknown_pos "nonempty_list" }
-| STAR
- { unknown_pos "list" }
-
-/* ------------------------------------------------------------------------- */
-/* A production group consists of a list of productions, followed by a
- semantic action and an optional precedence specification. */
-
-production_groups:
- /* epsilon */
- { [] }
-| production_groups BAR production_group
- { $3 :: $1 }
-
-production_group:
- productions ACTION /* action is lexically delimited by braces */ optional_precedence
- {
- let productions, action, oprec2 = $1, $2, $3 in
-
- ParserAux.check_production_group
- productions
- (rhs_start_pos 2) (rhs_end_pos 2) action;
-
- List.map (fun (producers, oprec1, rprec, pos) -> {
- pr_producers = producers;
- pr_action = action;
- pr_branch_shift_precedence = ParserAux.override pos oprec1 oprec2;
- pr_branch_reduce_precedence = rprec;
- pr_branch_position = pos
- }) productions
- }
-
-optional_precedence:
- /* epsilon */
- { None }
-| PREC symbol
- { Some $2 }
-
-/* ------------------------------------------------------------------------- */
-/* A production is a list of producers, optionally followed by a
- precedence declaration. Lists of productions are nonempty and
- separated with bars. */
-
-productions:
- production
- { [ $1 ] }
-| production bar_productions
- { $1 :: $2 }
-
-bar_productions:
- BAR production
- { [ $2 ] }
-| BAR production bar_productions
- { $2 :: $3 }
-
-production:
- producers optional_precedence
- { List.rev $1,
- $2,
- ParserAux.current_reduce_precedence(),
- Positions.lex_join (symbol_start_pos()) (symbol_end_pos())
- }
-
-producers:
- /* epsilon */
- { [] }
-| producers producer
- { $2 :: $1 }
-
-/* ------------------------------------------------------------------------- */
-/* A producer is an actual parameter, possibly preceded by a
- binding. */
-
-producer:
-| actual_parameter
- { None, $1 }
-| LID EQUAL actual_parameter
- { Some $1, $3 }
-
-%%
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Positions
-open Syntax
-
-let current_token_precedence =
- let c = ref 0 in
- fun pos1 pos2 ->
- incr c;
- PrecedenceLevel (Error.get_filemark (), !c, pos1, pos2)
-
-let current_reduce_precedence =
- let c = ref 0 in
- fun () ->
- incr c;
- PrecedenceLevel (Error.get_filemark (), !c, Lexing.dummy_pos, Lexing.dummy_pos)
-
-module IdSet = Set.Make (struct
- type t = identifier located
- let compare id1 id2 =
- compare (value id1) (value id2)
-end)
-
-let defined_identifiers ((ido, _) : producer) accu =
- Option.fold IdSet.add ido accu
-
-let defined_identifiers (producers : producer list) =
- List.fold_right defined_identifiers producers IdSet.empty
-
-let check_production_group right_hand_sides pos1 pos2 action =
-
- begin
- match right_hand_sides with
- | [] ->
- assert false
- | ((producers : producer list), _, _, _) :: right_hand_sides ->
- let ids = defined_identifiers producers in
- List.iter (fun (producers, _, _, _) ->
- let ids' = defined_identifiers producers in
- try
- let id =
- IdSet.choose (IdSet.union
- (IdSet.diff ids ids')
- (IdSet.diff ids' ids))
- in
- Error.error [Positions.position id]
- "Two productions that share a semantic action must define\n\
- exactly the same identifiers."
- with Not_found ->
- ()
- ) right_hand_sides
- end;
- begin
- if List.length right_hand_sides > 1 && Action.use_dollar action then
- Error.signal (Positions.two pos1 pos2)
- "A semantic action that is shared between several productions must\n\
- not use the $i notation -- semantic values must be named instead."
- end
-
-let override pos o1 o2 =
- match o1, o2 with
- | Some _, Some _ ->
- Error.signal [ pos ] "This production carries two %prec declarations.";
- o2
- | None, Some _ ->
- o2
- | _, None ->
- o1
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module provides utilities that are shared by the two versions
- of the parser. *)
-
-open Syntax
-
-(* TEMPORARY document *)
-
-val current_token_precedence: Lexing.position -> Lexing.position -> precedence_level
-val current_reduce_precedence: unit -> precedence_level
-
-(* [check_disjunctive_production] accepts production group and checks
- that they all productions in the group define the same set of
- identifiers. It also checks that the semantic action does not use
- any [$i] keyword. *)
-
-val check_production_group:
- (producer list * 'a * 'b * 'c) list ->
- Lexing.position -> Lexing.position -> Action.t -> unit
-
-(* [override pos oprec1 oprec2] decides which of the two optional
- %prec declarations [oprec1] and [oprec2] applies to a
- production. It signals an error if the two are present. *)
-
-val override: Positions.t -> 'a option -> 'a option -> 'a option
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: partialGrammar.ml,v 1.63 2006/10/22 14:07:57 fpottier Exp $ *)
-open Misc
-open Syntax
-open Stretch
-open ConcreteSyntax
-open InternalSyntax
-open Positions
-open Keyword
-
-(* ------------------------------------------------------------------------- *)
-(* This adds one declaration [decl], as found in file [filename], to
- the grammar [grammar]. *)
-
-let join_declaration filename (grammar : grammar) decl =
- match decl.value with
-
- (* Preludes are stored in an arbitrary order. The order of
- preludes within a single source file is preserved. Same
- treatment for functor parameters. *)
-
- | DCode code ->
- { grammar with p_preludes = grammar.p_preludes @ [ code ] }
- | DParameter (Stretch.Declared stretch) ->
- { grammar with p_parameters = grammar.p_parameters @ [ stretch ] }
- | DParameter (Stretch.Inferred _) ->
- assert false
-
- (* Token declarations are recorded. Things are made somewhat
- difficult by the fact that %token and %left-%right-%nonassoc
- declarations are independent. *)
-
- | DToken (ocamltype, terminal) ->
- let token_property =
- try
-
- (* Retrieve any previous definition for this token. *)
-
- let token_property =
- StringMap.find terminal grammar.p_tokens
- in
-
- (* If the previous definition was actually a %token declaration
- (as opposed to a %left, %right, or %nonassoc specification),
- signal an error. *)
-
- if token_property.tk_is_declared then
- Error.errorp decl
- (Printf.sprintf "the token %s has multiple definitions." terminal)
-
- (* Otherwise, update the previous definition. *)
-
- else
- { token_property with
- tk_is_declared = true;
- tk_ocamltype = ocamltype;
- tk_filename = filename;
- tk_position = decl.position;
- }
-
- with Not_found ->
-
- (* If no previous definition exists, create one. *)
-
- {
- tk_filename = filename;
- tk_ocamltype = ocamltype;
- tk_associativity = UndefinedAssoc;
- tk_priority = UndefinedPrecedence;
- tk_position = decl.position;
- tk_is_declared = true
- }
-
- in
- { grammar with
- p_tokens = StringMap.add terminal token_property grammar.p_tokens }
-
- (* Start symbols. *)
-
- | DStart nonterminal ->
- { grammar with
- p_start_symbols = StringMap.add nonterminal decl.position grammar.p_start_symbols }
-
- (* Type declarations for nonterminals. *)
-
- | DType (ocamltype, nonterminal) ->
- { grammar with
- p_types = (nonterminal, with_pos (position decl) ocamltype)::grammar.p_types }
-
- (* Token associativity and precedence. *)
-
- | DTokenProperties (terminal, assoc, prec) ->
-
- (* Retrieve the property record for this token, creating one
- if none existed (but without deeming the token to have been
- declared). *)
-
- let token_properties, grammar =
- try
- StringMap.find terminal grammar.p_tokens, grammar
- with Not_found ->
- let p = {
- tk_filename = filename;
- tk_ocamltype = None;
- tk_associativity = UndefinedAssoc;
- tk_priority = prec;
- tk_is_declared = false;
- (* Will be updated later. *)
- tk_position = decl.position;
- } in
- p, { grammar with
- p_tokens = StringMap.add terminal p grammar.p_tokens }
- in
-
- (* Reject duplicate precedence declarations. *)
-
- if token_properties.tk_associativity <> UndefinedAssoc then
- Error.error
- [ decl.position; token_properties.tk_position ]
- (Printf.sprintf "there are multiple precedence declarations for token %s." terminal);
-
- (* Record the new declaration. *)
-
- token_properties.tk_priority <- prec;
- token_properties.tk_associativity <- assoc;
- grammar
-
-(* ------------------------------------------------------------------------- *)
-(* This stores an optional trailer into a grammar.
- Trailers are stored in an arbitrary order. *)
-
-let join_trailer trailer grammar =
- match trailer with
- | None ->
- grammar
- | Some trailer ->
- { grammar with p_postludes = trailer :: grammar.p_postludes }
-
-(* ------------------------------------------------------------------------- *)
-(* We rewrite definitions when nonterminals are renamed. The
- renaming [phi] is an association list of names to names. *)
-
-type renaming =
- (nonterminal * nonterminal) list
-
-let identity_renaming =
- []
-
-let rewrite_nonterminal (phi : renaming) nonterminal =
- Misc.support_assoc phi nonterminal
-
-let rewrite_parameter phi parameter =
- Parameters.map (Positions.map (Misc.support_assoc phi)) parameter
-
-let rewrite_element phi (ido, parameter) =
- ido, rewrite_parameter phi parameter
-
-let rewrite_branch phi ({ pr_producers = producers } as branch) =
- { branch with pr_producers = List.map (rewrite_element phi) producers }
-
-let rewrite_branches phi branches =
- match phi with
- | [] ->
- branches
- | _ ->
- List.map (rewrite_branch phi) branches
-
-let fresh_counter = ref 0
-
-let names = ref StringSet.empty
-
-let use_name name =
- names := StringSet.add name !names
-
-let used_name name =
- StringSet.mem name !names
-
-let rec fresh ?(hint = "v") () =
- let name =
- incr fresh_counter;
- hint ^ string_of_int !fresh_counter
- in
- if used_name name then
- fresh ~hint ()
- else (
- use_name name;
- name
- )
-
-(* Alpha conversion of [prule]. We rename bound parameters using
- fresh names. *)
-let alphaconvert_rule parameters prule =
- let phi =
- List.combine parameters (List.map (fun x -> fresh ~hint:x ()) parameters)
- in
- { prule with
- pr_parameters = List.map (Misc.support_assoc phi) prule.pr_parameters;
- pr_branches = rewrite_branches phi prule.pr_branches
- }
-
-(* Rewrite a rule taking bounded names into account. We rename parameters
- to avoid capture. *)
-let rewrite_rule phi prule =
- let ids =
- List.fold_left (fun acu (f, d) -> StringSet.add f (StringSet.add d acu))
- StringSet.empty phi
- in
- let captured_parameters =
- List.filter (fun p -> StringSet.mem p ids) prule.pr_parameters
- in
- let prule =
- alphaconvert_rule captured_parameters prule
- in
- { prule with
- pr_nt = rewrite_nonterminal phi prule.pr_nt;
- pr_branches = rewrite_branches phi prule.pr_branches }
-
-let rewrite_rules phi rules =
- List.map (rewrite_rule phi) rules
-
-let rewrite_grammar phi grammar =
- (* We assume that [phi] affects only private symbols, so it does
- not affect the start symbols. *)
- if phi = identity_renaming then
- grammar
- else
- { grammar with pg_rules = rewrite_rules phi grammar.pg_rules }
-
-(* ------------------------------------------------------------------------- *)
-(* To rename (internalize) a nonterminal, we prefix it with its filename.
- This guarantees that names are unique. *)
-
-let is_valid_nonterminal_character = function
- | 'A' .. 'Z'
- | 'a' .. 'z'
- | '_'
- | '\192' .. '\214'
- | '\216' .. '\246'
- | '\248' .. '\255'
- | '0' .. '9' ->
- true
- | _ ->
- false
-
-let restrict filename =
- let m = String.copy (Filename.chop_suffix filename (if Settings.coq then ".vy" else ".mly")) in
- for i = 0 to String.length m - 1 do
- if not (is_valid_nonterminal_character m.[i]) then
- m.[i] <- '_'
- done;
- m
-
-let rename nonterminal filename =
- let name = restrict filename ^ "_" ^ nonterminal in
- if used_name name then
- fresh ~hint:name ()
- else
- (use_name name; name)
-
-(* ------------------------------------------------------------------------- *)
-(* A nonterminal is considered public if it is declared using %public
- or %start. *)
-
-let is_public grammar prule =
- prule.pr_public_flag || StringMap.mem prule.pr_nt grammar.p_start_symbols
-
-(* ------------------------------------------------------------------------- *)
-type symbol_kind =
-
- (* The nonterminal is declared public at a particular position. *)
- | PublicNonTerminal of Positions.t
-
- (* The nonterminal is not declared public at a particular position. *)
- | PrivateNonTerminal of Positions.t
-
- (* The symbol is a token. *)
- | Token of token_properties
-
- (* We do not know yet what does the symbol means.
- This is defined in the sequel or it is free in the partial grammar. *)
- | DontKnow of Positions.t
-
-type symbol_table =
- (symbol, symbol_kind) Hashtbl.t
-
-let find_symbol symbols symbol =
- Hashtbl.find symbols symbol
-
-let add_in_symbol_table symbols symbol kind =
- use_name symbol;
- Hashtbl.add symbols symbol kind;
- symbols
-
-let replace_in_symbol_table symbols symbol kind =
- Hashtbl.replace symbols symbol kind;
- symbols
-
-let empty_symbol_table () =
- Hashtbl.create 13
-
-let store_symbol symbols symbol kind =
- try
- let sym_info = find_symbol symbols symbol in
- match sym_info, kind with
-
- (* There are two definitions of the same symbol in one
- particular unit. This is forbidden. *)
- | (PublicNonTerminal p | PrivateNonTerminal p),
- (PublicNonTerminal p' | PrivateNonTerminal p') ->
- Error.error [ p; p']
- (Printf.sprintf
- "the nonterminal symbol %s is multiply defined."
- symbol)
-
- (* The symbol is known to be a token but declared as a non terminal.*)
- | (Token tkp, (PrivateNonTerminal p | PublicNonTerminal p))
- | ((PrivateNonTerminal p | PublicNonTerminal p), Token tkp) ->
- Error.error [ p; tkp.tk_position ]
- (Printf.sprintf
- "The identifier %s is a reference to a token."
- symbol)
-
- (* We do not gain any piece of information. *)
- | _, DontKnow _ | Token _, Token _ ->
- symbols
-
- (* We learn that the symbol is a non terminal or a token. *)
- | DontKnow _, _ ->
- replace_in_symbol_table symbols symbol kind
-
- with Not_found ->
- add_in_symbol_table symbols symbol kind
-
-let store_used_symbol position tokens symbols symbol =
- try
- store_symbol symbols symbol (Token (StringMap.find symbol tokens))
- with Not_found ->
- store_symbol symbols symbol (DontKnow position)
-
-let non_terminal_is_not_reserved symbol positions =
- if symbol = "error" then
- Error.error positions
- (Printf.sprintf "%s is reserved and thus cannot be used \
- as a non-terminal symbol." symbol)
-
-let non_terminal_is_not_a_token tokens symbol positions =
- try
- let tkp = StringMap.find symbol tokens in
- Error.error (positions @ [ tkp.tk_position ])
- (Printf.sprintf
- "The identifier %s is a reference to a token."
- symbol)
- with Not_found -> ()
-
-let store_public_nonterminal tokens symbols symbol positions =
- non_terminal_is_not_reserved symbol positions;
- non_terminal_is_not_a_token tokens symbol positions;
- store_symbol symbols symbol (PublicNonTerminal (List.hd positions))
-
-let store_private_nonterminal tokens symbols symbol positions =
- non_terminal_is_not_reserved symbol positions;
- non_terminal_is_not_a_token tokens symbol positions;
- store_symbol symbols symbol (PrivateNonTerminal (List.hd positions))
-
-let string_of_kind = function
- | PublicNonTerminal p ->
- Printf.sprintf "public (%s)" (Positions.string_of_pos p)
-
- | PrivateNonTerminal p ->
- Printf.sprintf "private (%s)" (Positions.string_of_pos p)
-
- | Token tk ->
- Printf.sprintf "token (%s)" tk.tk_filename
-
- | DontKnow p ->
- Printf.sprintf "only used at (%s)" (Positions.string_of_pos p)
-
-let string_of_symbol_table t =
- let b = Buffer.create 13 in
- let m = 1 + Hashtbl.fold (fun k v acu -> max (String.length k) acu) t 0 in
- let fill_blank s =
- let s' = String.make m ' ' in
- String.blit s 0 s' 0 (String.length s);
- s'
- in
- Hashtbl.iter (fun k v -> Buffer.add_string b
- (Printf.sprintf "%s: %s\n"
- (fill_blank k) (string_of_kind v))) t;
- Buffer.contents b
-
-let is_private_symbol t x =
- try
- match Hashtbl.find t x with
- | PrivateNonTerminal _ ->
- true
-
- | _ ->
- false
- with Not_found ->
- false
-
-let is_public_symbol t x =
- try
- match Hashtbl.find t x with
- | PublicNonTerminal _ ->
- true
-
- | _ ->
- false
- with Not_found ->
- false
-
-let fold_on_private_symbols f init t =
- Hashtbl.fold
- (fun k -> function PrivateNonTerminal _ -> (fun acu -> f acu k)
- | _ -> (fun acu -> acu))
- t init
-
-let fold_on_public_symbols f init t =
- Hashtbl.fold
- (fun k -> function PublicNonTerminal _ -> (fun acu -> f acu k)
- | _ -> (fun acu -> acu))
- t init
-
-let iter_on_only_used_symbols f t =
- Hashtbl.iter
- (fun k -> function DontKnow pos -> f k pos
- | _ -> ())
- t
-
-let symbols_of grammar (pgrammar : ConcreteSyntax.grammar) =
- let tokens = grammar.p_tokens in
- let symbols_of_rule symbols prule =
- let rec store_except_rule_parameters =
- fun symbols (symbol, parameters) ->
- (* Rule parameters are bound locally, so they are not taken into
- account. *)
- if List.mem symbol.value prule.pr_parameters then
- symbols
- else
- (* Otherwise, mark this symbol as being used and analyse its
- parameters. *)
- List.fold_left
- (fun symbols -> function
- | ParameterApp (symbol, parameters) ->
- store_except_rule_parameters symbols (symbol, parameters)
- | ParameterVar symbol ->
- store_except_rule_parameters symbols (symbol, [])
- )
- (store_used_symbol symbol.position tokens symbols symbol.value) parameters
- in
-
- (* Analyse each branch. *)
- let symbols = List.fold_left (fun symbols branch ->
- List.fold_left (fun symbols (_, p) ->
- let symbol, parameters = Parameters.unapp p in
- store_except_rule_parameters symbols (symbol, parameters)
- ) symbols branch.pr_producers
- ) symbols prule.pr_branches
- in
- (* Store the symbol declaration. *)
- if prule.pr_public_flag
- || StringMap.mem prule.pr_nt grammar.p_start_symbols then
- store_public_nonterminal tokens symbols prule.pr_nt prule.pr_positions
- else
- store_private_nonterminal tokens symbols prule.pr_nt prule.pr_positions
- in
- List.fold_left symbols_of_rule (empty_symbol_table ()) pgrammar.pg_rules
-
-let merge_rules tokens symbols pgs =
-
- (* Retrieve all the public symbols. *)
- let public_symbols =
- List.fold_left (fold_on_public_symbols (fun s k -> StringSet.add k s))
- (StringSet.singleton "error")
- symbols
- in
-
- (* We check the references in each grammar can be bound to
- a public symbol. *)
- let _ =
- List.iter
- (iter_on_only_used_symbols
- (fun k pos -> if not (StringSet.mem k public_symbols) then
- Error.error [ pos ]
- (Printf.sprintf "%s is undefined." k)))
- symbols
- in
- (* Detect private symbol clashes and rename them if necessary. *)
- let detect_private_symbol_clashes =
- fold_on_private_symbols
- (fun (defined, clashes) symbol ->
- if StringSet.mem symbol defined
- || StringSet.mem symbol public_symbols then
- (defined, StringSet.add symbol clashes)
- else
- (StringSet.add symbol defined, clashes))
- in
- let private_symbols, clashes =
- List.fold_left detect_private_symbol_clashes (StringSet.empty, StringSet.empty) symbols
- in
- let rpgs = List.map
- (fun (symbol_table, pg) ->
- let renaming =
- StringSet.fold
- (fun x phi ->
- if is_private_symbol symbol_table x then begin
- let x' = rename x pg.pg_filename in
- Printf.fprintf stderr
- "Note: the nonterminal symbol %s (from %s) is renamed %s.\n"
- x pg.pg_filename x';
- (x, x') :: phi
- end
- else phi)
- clashes []
- in
- rewrite_grammar renaming pg)
- pgs
- in
-
- (* Merge public nonterminal definitions
- and copy private nonterminal definitions. Since the clash between
- private symbols have already been resolved, these copies are safe. *)
- List.fold_left
- (fun rules rpg -> List.fold_left
- (fun rules r ->
- let r =
- try
- let r' = StringMap.find r.pr_nt rules in
- let positions = r.pr_positions @ r'.pr_positions in
- let ra, ra' =
- List.length r.pr_parameters,
- List.length r'.pr_parameters
- in
- (* The arity of the parameterized symbols must be constant.*)
- if ra <> ra' then
- Error.error positions
- (Printf.sprintf "symbol %s is defined with arities %d and %d."
- r.pr_nt ra ra')
- else if r.pr_inline_flag <> r'.pr_inline_flag then
- Error.error positions
- (Printf.sprintf
- "not all definitions of %s are marked %%inline." r.pr_nt)
- else
- (* We combine the different branches. The parameters
- could have different names, we rename them with
- the fresh names assigned earlier (see the next
- comment). *)
- let phi = List.combine r.pr_parameters r'.pr_parameters in
- let rbr = rewrite_branches phi r.pr_branches in
- { r' with
- pr_positions = positions;
- pr_branches = rbr @ r'.pr_branches
- }
- with Not_found ->
- (* We alphaconvert the rule in order to avoid the capture of
- private symbols coming from another unit. *)
- alphaconvert_rule r.pr_parameters r
- in
- StringMap.add r.pr_nt r rules) rules rpg.pg_rules)
- StringMap.empty rpgs
-
-let empty_grammar =
- {
- p_preludes = [];
- p_postludes = [];
- p_parameters = [];
- p_start_symbols = StringMap.empty;
- p_types = [];
- p_tokens = StringMap.empty;
- p_rules = StringMap.empty
- }
-
-let join grammar pgrammar =
- let filename = pgrammar.pg_filename in
- List.fold_left (join_declaration filename) grammar pgrammar.pg_declarations
- $$ join_trailer pgrammar.pg_trailer
-
-(* Check that the $i's are consistent, that is, that they are within
- bounds and that they are not used when symbols are explicitly
- named. Check also that no two symbols carry the same name. *)
-
-let check_keywords grammar producers action =
- let length = List.length producers in
- List.iter
- (function keyword ->
- match Positions.value keyword with
- | Dollar i
- | Position (RightDollar i, _, _) ->
- if i < 1 || i > length then
- Error.errorp keyword
- (Printf.sprintf "$%d refers to a nonexistent symbol." i);
- let ido, param = List.nth producers (i - 1) in
- begin
- match ido with
- | Some { value = id } ->
- Error.errorp keyword
- (Printf.sprintf
- "please do not say: $%d. Instead, say: %s." i id)
- | None ->
- ()
- end
- | Position (RightNamed id, _, _) ->
- let found =
- ref false
- in
- List.iter (fun (ido, param) ->
- match ido with
- | Some { value = id' } when id = id' ->
- found := true
- | _ ->
- ()
- ) producers;
- if not !found then
- Error.errorp keyword
- (Printf.sprintf "%s refers to a nonexistent symbol." id)
- | Position (Left, _, _)
- | PreviousError
- | SyntaxError ->
- ()
- ) (Action.pkeywords action)
-
-let check_parameterized_grammar_is_well_defined grammar =
-
- (* Every start symbol is defined and has a %type declaration. *)
- StringMap.iter
- (fun nonterminal p ->
- if not (StringMap.mem nonterminal grammar.p_rules) then
- Error.error [p] (Printf.sprintf "the start symbol %s is undefined."
- nonterminal);
- if not (List.exists (function
- | ParameterVar { value = id }, _ -> id = nonterminal
- | _ -> false) grammar.p_types) then
- Error.error [p]
- (Printf.sprintf
- "the type of the start symbol %s is unspecified." nonterminal);
- ) grammar.p_start_symbols;
-
- let rec parameter_head_symb = function
- | ParameterVar id -> id
- | ParameterApp (id, _) -> id
- in
-
- List.iter (fun (symbol, _) ->
- let head_symb = parameter_head_symb symbol in
- if not (StringMap.mem (value head_symb) grammar.p_rules) then
- Error.errorp (Parameters.with_pos symbol)
- (Printf.sprintf
- "this is a terminal symbol.\n\
- %%type declarations are applicable only to nonterminal symbols."))
- grammar.p_types;
-
- (* Every reference to a symbol is well defined. *)
- let reserved = [ "error" ] in
- let used_tokens = ref StringSet.empty in
- let mark_token_as_used token =
- used_tokens := StringSet.add token !used_tokens
- in
- let check_identifier_reference grammar prule s p =
- (* Mark the symbol as a used token if this is a token. *)
- if StringMap.mem s grammar.p_tokens then
- mark_token_as_used s;
-
- if not (StringMap.mem s grammar.p_rules
- || StringMap.mem s grammar.p_tokens
- || List.mem s prule.pr_parameters
- || List.mem s reserved) then
- Error.error [ p ] (Printf.sprintf "%s is undefined." s)
- in
- StringMap.iter
- (fun k prule -> List.iter
-
- (* Check each branch. *)
- (fun { pr_producers = producers;
- pr_branch_shift_precedence = sprec;
- pr_action = action
- } -> ignore (List.fold_left
-
- (* Check the producers. *)
- (fun already_seen (id, p) ->
- let symbol, parameters = Parameters.unapp p in
- let s = symbol.value and p = symbol.position in
- let already_seen =
- match id with
- None -> already_seen
- | Some id ->
- (* Check the producer id is unique. *)
- if StringSet.mem id.value already_seen then
- Error.error [ id.position ]
- (Printf.sprintf
- "there are multiple producers named %s in this sequence."
- id.value);
- StringSet.add id.value already_seen
- in
-
- (* Check that the producer is defined somewhere. *)
- check_identifier_reference grammar prule s p;
- StringMap.iter (check_identifier_reference grammar prule)
- (List.fold_left Parameters.identifiers StringMap.empty parameters);
-
- (* Check the %prec is a valid reference to a token. *)
- (try
- if not ((StringMap.find s grammar.p_tokens).tk_is_declared
- || List.mem s reserved) then
- Error.errorp symbol
- (Printf.sprintf "%s has not been declared as a token." s)
- with Not_found -> ());
- already_seen
-
- ) StringSet.empty producers);
-
- check_keywords grammar producers action;
-
- match sprec with
-
- | None -> ()
-
- | Some terminal ->
- check_identifier_reference grammar prule
- terminal.value terminal.position;
-
- (* It is forbidden to use the %prec directive with %inline. *)
- if prule.pr_inline_flag then
- Error.errorp terminal
- "use of %prec is forbidden in an %inlined nonterminal definition.";
-
- (* Furthermore, the symbol following %prec must be a valid
- token identifier. *)
- if not (StringMap.mem terminal.value grammar.p_tokens) then
- Error.errorp terminal
- (Printf.sprintf "%s is undefined." terminal.value))
-
- prule.pr_branches;
-
- (* It is forbidden to use %inline on a %start symbol. *)
- if (prule.pr_inline_flag
- && StringMap.mem k grammar.p_start_symbols) then
- Error.error prule.pr_positions
- (Printf.sprintf
- "%s cannot be both a start symbol and inlined." k);
-
- ) grammar.p_rules;
-
- (* Check that every token is used. *)
- begin match Settings.token_type_mode with
- | Settings.TokenTypeOnly ->
- ()
- | Settings.TokenTypeAndCode
- | Settings.CodeOnly _ ->
- StringMap.iter (fun token { tk_position = p } ->
- if not (StringSet.mem token !used_tokens) then
- Error.warning [p]
- (Printf.sprintf "the token %s is unused." token)
- ) grammar.p_tokens
- end;
-
- grammar
-
-let join_partial_grammars pgs =
- let grammar = List.fold_left join empty_grammar pgs in
- let symbols = List.map (symbols_of grammar) pgs in
- let tpgs = List.combine symbols pgs in
- let rules = merge_rules grammar.p_tokens symbols tpgs in
- check_parameterized_grammar_is_well_defined { grammar with p_rules = rules }
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: partialGrammar.mli,v 1.4 2005/12/01 16:20:07 regisgia Exp $ *)
-
-val join_partial_grammars :
- ConcreteSyntax.grammar list -> InternalSyntax.grammar
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This is an implementation of Patricia trees, following Chris Okasaki's paper at the 1998 ML Workshop in Baltimore.
- Both big-endian and little-endian trees are provided. Both sets and maps are implemented on top of Patricia
- trees. *)
-
-(*i --------------------------------------------------------------------------------------------------------------- i*)
-(*s \mysection{Little-endian vs big-endian trees} *)
-
- (* A tree is little-endian if it expects the key's least significant bits to be tested first during a search. It is
- big-endian if it expects the key's most significant bits to be tested first.
-
- Most of the code is independent of this design choice, so it is written as a functor, parameterized by a small
- structure which defines endianness. Here is the interface which must be adhered to by such a structure. *)
-
-module Endianness = struct
-
- module type S = sig
-
- (* A mask is an integer with a single one bit (i.e. a power of 2). *)
-
- type mask = int
-
- (* [branching_bit] accepts two distinct integers and returns a mask which identifies the first bit where they
- differ. The meaning of ``first'' varies according to the endianness being implemented. *)
-
- val branching_bit: int -> int -> mask
-
- (* [mask i m] returns an integer [i'], where all bits which [m] says are relevant are identical to those in [i],
- and all others are set to some unspecified, but fixed value. Which bits are ``relevant'' according to a given
- mask varies according to the endianness being implemented. *)
-
- val mask: int -> mask -> int
-
- (* [shorter m1 m2] returns [true] if and only if [m1] describes a shorter prefix than [m2], i.e. if it makes fewer
- bits relevant. Which bits are ``relevant'' according to a given mask varies according to the endianness being
- implemented. *)
-
- val shorter: mask -> mask -> bool
-
- end
-
- (* Now, let us define [Little] and [Big], two possible [Endiannness] choices. *)
-
- module Little = struct
-
- type mask = int
-
- let lowest_bit x =
- x land (-x)
-
- (* Performing a logical ``xor'' of [i0] and [i1] yields a bit field where all differences between [i0] and [i1]
- show up as one bits. (There must be at least one, since [i0] and [i1] are distinct.) The ``first'' one is
- the lowest bit in this bit field, since we are checking least significant bits first. *)
-
- let branching_bit i0 i1 =
- lowest_bit (i0 lxor i1)
-
- (* The ``relevant'' bits in an integer [i] are those which are found (strictly) to the right of the single one bit
- in the mask [m]. We keep these bits, and set all others to 0. *)
-
- let mask i m =
- i land (m-1)
-
- (* The smaller [m] is, the fewer bits are relevant. *)
-
- let shorter =
- (<)
-
- end
-
- module Big = struct
-
- type mask = int
-
- let lowest_bit x =
- x land (-x)
-
- let rec highest_bit x =
- let m = lowest_bit x in
- if x = m then
- m
- else
- highest_bit (x - m)
-
- (* Performing a logical ``xor'' of [i0] and [i1] yields a bit field where all differences between [i0] and [i1]
- show up as one bits. (There must be at least one, since [i0] and [i1] are distinct.) The ``first'' one is
- the highest bit in this bit field, since we are checking most significant bits first.
-
- In Okasaki's paper, this loop is sped up by computing a conservative initial guess. Indeed, the bit at which
- the two prefixes disagree must be somewhere within the shorter prefix, so we can begin searching at the
- least-significant valid bit in the shorter prefix. Unfortunately, to allow computing the initial guess, the
- main code has to pass in additional parameters, e.g. a mask which describes the length of each prefix. This
- ``pollutes'' the endianness-independent code. For this reason, this optimization isn't implemented here. *)
-
- let branching_bit i0 i1 =
- highest_bit (i0 lxor i1)
-
- (* The ``relevant'' bits in an integer [i] are those which are found (strictly) to the left of the single one bit
- in the mask [m]. We keep these bits, and set all others to 0. Okasaki uses a different convention, which allows
- big-endian Patricia trees to masquerade as binary search trees. This feature does not seem to be useful here. *)
-
- let mask i m =
- i land (lnot (2*m-1))
-
- (* The smaller [m] is, the more bits are relevant. *)
-
- let shorter =
- (>)
-
- end
-
-end
-
-(*i --------------------------------------------------------------------------------------------------------------- i*)
-(*s \mysection{Patricia-tree-based maps} *)
-
-module Make (X : Endianness.S) = struct
-
- (* Patricia trees are maps whose keys are integers. *)
-
- type key = int
-
- (* A tree is either empty, or a leaf node, containing both the integer key and a piece of data, or a binary node.
- Each binary node carries two integers. The first one is the longest common prefix of all keys in this
- sub-tree. The second integer is the branching bit. It is an integer with a single one bit (i.e. a power of 2),
- which describes the bit being tested at this node. *)
-
- type 'a t =
- | Empty
- | Leaf of int * 'a
- | Branch of int * X.mask * 'a t * 'a t
-
- (* The empty map. *)
-
- let empty =
- Empty
-
- (* [choose m] returns an arbitrarily chosen binding in [m], if [m]
- is nonempty, and raises [Not_found] otherwise. *)
-
- let rec choose = function
- | Empty ->
- raise Not_found
- | Leaf (key, data) ->
- key, data
- | Branch (_, _, tree0, _) ->
- choose tree0
-
- (* [lookup k m] looks up the value associated to the key [k] in the map [m], and raises [Not_found] if no value is
- bound to [k].
-
- This implementation takes branches \emph{without} checking whether the key matches the prefix found at the
- current node. This means that a query for a non-existent key shall be detected only when finally reaching
- a leaf, rather than higher up in the tree. This strategy is better when (most) queries are expected to be
- successful. *)
-
- let rec lookup key = function
- | Empty ->
- raise Not_found
- | Leaf (key', data) ->
- if key = key' then
- data
- else
- raise Not_found
- | Branch (_, mask, tree0, tree1) ->
- lookup key (if (key land mask) = 0 then tree0 else tree1)
-
- let find =
- lookup
-
- (* [mem k m] tells whether the key [k] appears in the domain of the
- map [m]. *)
-
- let mem k m =
- try
- let _ = lookup k m in
- true
- with Not_found ->
- false
-
- (* The auxiliary function [join] merges two trees in the simple case where their prefixes disagree.
-
- Assume $t_0$ and $t_1$ are non-empty trees, with longest common prefixes $p_0$ and $p_1$, respectively. Further,
- suppose that $p_0$ and $p_1$ disagree, that is, neither prefix is contained in the other. Then, no matter how
- large $t_0$ and $t_1$ are, we can merge them simply by creating a new [Branch] node that has $t_0$ and $t_1$
- as children! *)
-
- let join p0 t0 p1 t1 =
- let m = X.branching_bit p0 p1 in
- let p = X.mask p0 (* for instance *) m in
- if (p0 land m) = 0 then
- Branch(p, m, t0, t1)
- else
- Branch(p, m, t1, t0)
-
- (* The auxiliary function [match_prefix] tells whether a given key has a given prefix. More specifically,
- [match_prefix k p m] returns [true] if and only if the key [k] has prefix [p] up to bit [m].
-
- Throughout our implementation of Patricia trees, prefixes are assumed to be in normal form, i.e. their
- irrelevant bits are set to some predictable value. Formally, we assume [X.mask p m] equals [p] whenever [p]
- is a prefix with [m] relevant bits. This allows implementing [match_prefix] using only one call to
- [X.mask]. On the other hand, this requires normalizing prefixes, as done e.g. in [join] above, where
- [X.mask p0 m] has to be used instead of [p0]. *)
-
- let match_prefix k p m =
- X.mask k m = p
-
- (* [fine_add decide k d m] returns a map whose bindings are all bindings in [m], plus a binding of the key [k] to
- the datum [d]. If a binding from [k] to [d0] already exists, then the resulting map contains a binding from
- [k] to [decide d0 d]. *)
-
- type 'a decision = 'a -> 'a -> 'a
-
- exception Unchanged
-
- let basic_add decide k d m =
-
- let rec add t =
- match t with
- | Empty ->
- Leaf (k, d)
- | Leaf (k0, d0) ->
- if k = k0 then
- let d' = decide d0 d in
- if d' == d0 then
- raise Unchanged
- else
- Leaf (k, d')
- else
- join k (Leaf (k, d)) k0 t
- | Branch (p, m, t0, t1) ->
- if match_prefix k p m then
- if (k land m) = 0 then Branch (p, m, add t0, t1)
- else Branch (p, m, t0, add t1)
- else
- join k (Leaf (k, d)) p t in
-
- add m
-
- let strict_add k d m =
- basic_add (fun _ _ -> raise Unchanged) k d m
-
- let fine_add decide k d m =
- try
- basic_add decide k d m
- with Unchanged ->
- m
-
- (* [add k d m] returns a map whose bindings are all bindings in [m], plus a binding of the key [k] to the datum
- [d]. If a binding already exists for [k], it is overridden. *)
-
- let add k d m =
- fine_add (fun old_binding new_binding -> new_binding) k d m
-
- (* [singleton k d] returns a map whose only binding is from [k] to [d]. *)
-
- let singleton k d =
- Leaf (k, d)
-
- (* [is_singleton m] returns [Some (k, d)] if [m] is a singleton map
- that maps [k] to [d]. Otherwise, it returns [None]. *)
-
- let is_singleton = function
- | Leaf (k, d) ->
- Some (k, d)
- | Empty
- | Branch _ ->
- None
-
- (* [is_empty m] returns [true] if and only if the map [m] defines no bindings at all. *)
-
- let is_empty = function
- | Empty ->
- true
- | Leaf _
- | Branch _ ->
- false
-
- (* [cardinal m] returns [m]'s cardinal, that is, the number of keys it binds, or, in other words, its domain's
- cardinal. *)
-
- let rec cardinal = function
- | Empty ->
- 0
- | Leaf _ ->
- 1
- | Branch (_, _, t0, t1) ->
- cardinal t0 + cardinal t1
-
- (* [remove k m] returns the map [m] deprived from any binding involving [k]. *)
-
- let remove key m =
-
- let rec remove = function
- | Empty ->
- raise Not_found
- | Leaf (key', _) ->
- if key = key' then
- Empty
- else
- raise Not_found
- | Branch (prefix, mask, tree0, tree1) ->
- if (key land mask) = 0 then
- match remove tree0 with
- | Empty ->
- tree1
- | tree0 ->
- Branch (prefix, mask, tree0, tree1)
- else
- match remove tree1 with
- | Empty ->
- tree0
- | tree1 ->
- Branch (prefix, mask, tree0, tree1) in
-
- try
- remove m
- with Not_found ->
- m
-
- (* [lookup_and_remove k m] looks up the value [v] associated to the key [k] in the map [m], and raises [Not_found]
- if no value is bound to [k]. The call returns the value [v], together with the map [m] deprived from the binding
- from [k] to [v]. *)
-
- let rec lookup_and_remove key = function
- | Empty ->
- raise Not_found
- | Leaf (key', data) ->
- if key = key' then
- data, Empty
- else
- raise Not_found
- | Branch (prefix, mask, tree0, tree1) ->
- if (key land mask) = 0 then
- match lookup_and_remove key tree0 with
- | data, Empty ->
- data, tree1
- | data, tree0 ->
- data, Branch (prefix, mask, tree0, tree1)
- else
- match lookup_and_remove key tree1 with
- | data, Empty ->
- data, tree0
- | data, tree1 ->
- data, Branch (prefix, mask, tree0, tree1)
-
- let find_and_remove =
- lookup_and_remove
-
- (* [fine_union decide m1 m2] returns the union of the maps [m1] and
- [m2]. If a key [k] is bound to [x1] (resp. [x2]) within [m1]
- (resp. [m2]), then [decide] is called. It is passed [x1] and
- [x2], and must return the value which shall be bound to [k] in
- the final map. The operation returns [m2] itself (as opposed to a
- copy of it) when its result is equal to [m2]. *)
-
- let reverse decision elem1 elem2 =
- decision elem2 elem1
-
- let fine_union decide m1 m2 =
-
- let rec union s t =
- match s, t with
-
- | Empty, _ ->
- t
- | (Leaf _ | Branch _), Empty ->
- s
-
- | Leaf(key, value), _ ->
- fine_add (reverse decide) key value t
- | Branch _, Leaf(key, value) ->
- fine_add decide key value s
-
- | Branch(p, m, s0, s1), Branch(q, n, t0, t1) ->
- if (p = q) & (m = n) then
-
- (* The trees have the same prefix. Merge their sub-trees. *)
-
- let u0 = union s0 t0
- and u1 = union s1 t1 in
- if t0 == u0 && t1 == u1 then t
- else Branch(p, m, u0, u1)
-
- else if (X.shorter m n) & (match_prefix q p m) then
-
- (* [q] contains [p]. Merge [t] with a sub-tree of [s]. *)
-
- if (q land m) = 0 then
- Branch(p, m, union s0 t, s1)
- else
- Branch(p, m, s0, union s1 t)
-
- else if (X.shorter n m) & (match_prefix p q n) then
-
- (* [p] contains [q]. Merge [s] with a sub-tree of [t]. *)
-
- if (p land n) = 0 then
- let u0 = union s t0 in
- if t0 == u0 then t
- else Branch(q, n, u0, t1)
- else
- let u1 = union s t1 in
- if t1 == u1 then t
- else Branch(q, n, t0, u1)
-
- else
-
- (* The prefixes disagree. *)
-
- join p s q t in
-
- union m1 m2
-
- (* [union m1 m2] returns the union of the maps [m1] and
- [m2]. Bindings in [m2] take precedence over those in [m1]. *)
-
- let union m1 m2 =
- fine_union (fun d d' -> d') m1 m2
-
- (* [iter f m] invokes [f k x], in turn, for each binding from key [k] to element [x] in the map [m]. Keys are
- presented to [f] according to some unspecified, but fixed, order. *)
-
- let rec iter f = function
- | Empty ->
- ()
- | Leaf (key, data) ->
- f key data
- | Branch (_, _, tree0, tree1) ->
- iter f tree0;
- iter f tree1
-
- (* [fold f m seed] invokes [f k d accu], in turn, for each binding from key [k] to datum [d] in the map
- [m]. Keys are presented to [f] in increasing order according to the map's ordering. The initial value of
- [accu] is [seed]; then, at each new call, its value is the value returned by the previous invocation of [f]. The
- value returned by [fold] is the final value of [accu]. *)
-
- let rec fold f m accu =
- match m with
- | Empty ->
- accu
- | Leaf (key, data) ->
- f key data accu
- | Branch (_, _, tree0, tree1) ->
- fold f tree1 (fold f tree0 accu)
-
- (* [fold_rev] performs exactly the same job as [fold], but presents keys to [f] in the opposite order. *)
-
- let rec fold_rev f m accu =
- match m with
- | Empty ->
- accu
- | Leaf (key, data) ->
- f key data accu
- | Branch (_, _, tree0, tree1) ->
- fold_rev f tree0 (fold_rev f tree1 accu)
-
- (* It is valid to evaluate [iter2 f m1 m2] if and only if [m1] and [m2] have the same domain. Doing so invokes
- [f k x1 x2], in turn, for each key [k] bound to [x1] in [m1] and to [x2] in [m2]. Bindings are presented to [f]
- according to some unspecified, but fixed, order. *)
-
- let rec iter2 f t1 t2 =
- match t1, t2 with
- | Empty, Empty ->
- ()
- | Leaf (key1, data1), Leaf (key2, data2) ->
- assert (key1 = key2);
- f key1 (* for instance *) data1 data2
- | Branch (p1, m1, left1, right1), Branch (p2, m2, left2, right2) ->
- assert (p1 = p2);
- assert (m1 = m2);
- iter2 f left1 left2;
- iter2 f right1 right2
- | _, _ ->
- assert false
-
- (* [map f m] returns the map obtained by composing the map [m] with the function [f]; that is, the map
- $k\mapsto f(m(k))$. *)
-
- let rec map f = function
- | Empty ->
- Empty
- | Leaf (key, data) ->
- Leaf(key, f data)
- | Branch (p, m, tree0, tree1) ->
- Branch (p, m, map f tree0, map f tree1)
-
- (* [endo_map] is similar to [map], but attempts to physically share its result with its input. This saves
- memory when [f] is the identity function. *)
-
- let rec endo_map f tree =
- match tree with
- | Empty ->
- tree
- | Leaf (key, data) ->
- let data' = f data in
- if data == data' then
- tree
- else
- Leaf(key, data')
- | Branch (p, m, tree0, tree1) ->
- let tree0' = endo_map f tree0 in
- let tree1' = endo_map f tree1 in
- if (tree0' == tree0) & (tree1' == tree1) then
- tree
- else
- Branch (p, m, tree0', tree1')
-
- (* [iterator m] returns a stateful iterator over the map [m]. *)
-
- (* TEMPORARY performance could be improved, see JCF's paper *)
-
- let iterator m =
-
- let remainder = ref [ m ] in
-
- let rec next () =
- match !remainder with
- | [] ->
- None
- | Empty :: parent ->
- remainder := parent;
- next()
- | (Leaf (key, data)) :: parent ->
- remainder := parent;
- Some (key, data)
- | (Branch(_, _, s0, s1)) :: parent ->
- remainder := s0 :: s1 :: parent;
- next () in
-
- next
-
- (* If [dcompare] is an ordering over data, then [compare dcompare]
- is an ordering over maps. *)
-
- exception Got of int
-
- let compare dcompare m1 m2 =
- let iterator2 = iterator m2 in
- try
- iter (fun key1 data1 ->
- match iterator2() with
- | None ->
- raise (Got 1)
- | Some (key2, data2) ->
- let c = Pervasives.compare key1 key2 in
- if c <> 0 then
- raise (Got c)
- else
- let c = dcompare data1 data2 in
- if c <> 0 then
- raise (Got c)
- ) m1;
- match iterator2() with
- | None ->
- 0
- | Some _ ->
- -1
- with Got c ->
- c
-
-(*i --------------------------------------------------------------------------------------------------------------- i*)
-(*s \mysection{Patricia-tree-based sets} *)
-
-(* To enhance code sharing, it would be possible to implement maps as sets of pairs, or (vice-versa) to implement
- sets as maps to the unit element. However, both possibilities introduce some space and time inefficiency. To
- avoid it, we define each structure separately. *)
-
-module Domain = struct
-
- type element = int
-
- type t =
- | Empty
- | Leaf of int
- | Branch of int * X.mask * t * t
-
- (* The empty set. *)
-
- let empty =
- Empty
-
- (* [is_empty s] returns [true] if and only if the set [s] is empty. *)
-
- let is_empty = function
- | Empty ->
- true
- | Leaf _
- | Branch _ ->
- false
-
- (* [singleton x] returns a set whose only element is [x]. *)
-
- let singleton x =
- Leaf x
-
- (* [is_singleton s] returns [Some x] if [s] is a singleton
- containing [x] as its only element; otherwise, it returns
- [None]. *)
-
- let is_singleton = function
- | Leaf x ->
- Some x
- | Empty
- | Branch _ ->
- None
-
- (* [choose s] returns an arbitrarily chosen element of [s], if [s]
- is nonempty, and raises [Not_found] otherwise. *)
-
- let rec choose = function
- | Empty ->
- raise Not_found
- | Leaf x ->
- x
- | Branch (_, _, tree0, _) ->
- choose tree0
-
- (* [cardinal s] returns [s]'s cardinal. *)
-
- let rec cardinal = function
- | Empty ->
- 0
- | Leaf _ ->
- 1
- | Branch (_, _, t0, t1) ->
- cardinal t0 + cardinal t1
-
- (* [mem x s] returns [true] if and only if [x] appears in the set [s]. *)
-
- let rec mem x = function
- | Empty ->
- false
- | Leaf x' ->
- x = x'
- | Branch (_, mask, tree0, tree1) ->
- mem x (if (x land mask) = 0 then tree0 else tree1)
-
- (* The auxiliary function [join] merges two trees in the simple case where their prefixes disagree. *)
-
- let join p0 t0 p1 t1 =
- let m = X.branching_bit p0 p1 in
- let p = X.mask p0 (* for instance *) m in
- if (p0 land m) = 0 then
- Branch(p, m, t0, t1)
- else
- Branch(p, m, t1, t0)
-
- (* [add x s] returns a set whose elements are all elements of [s], plus [x]. *)
-
- exception Unchanged
-
- let rec strict_add x t =
- match t with
- | Empty ->
- Leaf x
- | Leaf x0 ->
- if x = x0 then
- raise Unchanged
- else
- join x (Leaf x) x0 t
- | Branch (p, m, t0, t1) ->
- if match_prefix x p m then
- if (x land m) = 0 then Branch (p, m, strict_add x t0, t1)
- else Branch (p, m, t0, strict_add x t1)
- else
- join x (Leaf x) p t
-
- let add x s =
- try
- strict_add x s
- with Unchanged ->
- s
-
- (* [make2 x y] creates a set whose elements are [x] and [y]. [x] and [y] need not be distinct. *)
-
- let make2 x y =
- add x (Leaf y)
-
- (* [fine_add] does not make much sense for sets of integers. Better warn the user. *)
-
- type decision = int -> int -> int
-
- let fine_add decision x s =
- assert false
-
- (* [remove x s] returns a set whose elements are all elements of [s], except [x]. *)
-
- let remove x s =
-
- let rec strict_remove = function
- | Empty ->
- raise Not_found
- | Leaf x' ->
- if x = x' then
- Empty
- else
- raise Not_found
- | Branch (prefix, mask, tree0, tree1) ->
- if (x land mask) = 0 then
- match strict_remove tree0 with
- | Empty ->
- tree1
- | tree0 ->
- Branch (prefix, mask, tree0, tree1)
- else
- match strict_remove tree1 with
- | Empty ->
- tree0
- | tree1 ->
- Branch (prefix, mask, tree0, tree1) in
-
- try
- strict_remove s
- with Not_found ->
- s
-
- (* [union s1 s2] returns the union of the sets [s1] and [s2]. *)
-
- let rec union s t =
- match s, t with
-
- | Empty, _ ->
- t
- | _, Empty ->
- s
-
- | Leaf x, _ ->
- add x t
- | _, Leaf x ->
- add x s
-
- | Branch(p, m, s0, s1), Branch(q, n, t0, t1) ->
- if (p = q) & (m = n) then
-
- (* The trees have the same prefix. Merge their sub-trees. *)
-
- let u0 = union s0 t0
- and u1 = union s1 t1 in
- if t0 == u0 && t1 == u1 then t
- else Branch(p, m, u0, u1)
-
- else if (X.shorter m n) & (match_prefix q p m) then
-
- (* [q] contains [p]. Merge [t] with a sub-tree of [s]. *)
-
- if (q land m) = 0 then
- Branch(p, m, union s0 t, s1)
- else
- Branch(p, m, s0, union s1 t)
-
- else if (X.shorter n m) & (match_prefix p q n) then
-
- (* [p] contains [q]. Merge [s] with a sub-tree of [t]. *)
-
- if (p land n) = 0 then
- let u0 = union s t0 in
- if t0 == u0 then t
- else Branch(q, n, u0, t1)
- else
- let u1 = union s t1 in
- if t1 == u1 then t
- else Branch(q, n, t0, u1)
-
- else
-
- (* The prefixes disagree. *)
-
- join p s q t
-
- (* [fine_union] does not make much sense for sets of integers. Better warn the user. *)
-
- let fine_union decision s1 s2 =
- assert false
-
- (* [build] is a ``smart constructor''. It builds a [Branch] node with the specified arguments, but ensures
- that the newly created node does not have an [Empty] child. *)
-
- let build p m t0 t1 =
- match t0, t1 with
- | Empty, Empty ->
- Empty
- | Empty, _ ->
- t1
- | _, Empty ->
- t0
- | _, _ ->
- Branch(p, m, t0, t1)
-
- (* [diff s t] returns the set difference of [s] and [t], that is, $s\setminus t$. *)
-
- let rec diff s t =
- match s, t with
-
- | Empty, _
- | _, Empty ->
- s
-
- | Leaf x, _ ->
- if mem x t then Empty else s
- | _, Leaf x ->
- remove x s
-
- | Branch(p, m, s0, s1), Branch(q, n, t0, t1) ->
- if (p = q) & (m = n) then
-
- (* The trees have the same prefix. Compute the differences of their sub-trees. *)
-
- build p m (diff s0 t0) (diff s1 t1)
-
- else if (X.shorter m n) & (match_prefix q p m) then
-
- (* [q] contains [p]. Subtract [t] off a sub-tree of [s]. *)
-
- if (q land m) = 0 then
- build p m (diff s0 t) s1
- else
- build p m s0 (diff s1 t)
-
- else if (X.shorter n m) & (match_prefix p q n) then
-
- (* [p] contains [q]. Subtract a sub-tree of [t] off [s]. *)
-
- diff s (if (p land n) = 0 then t0 else t1)
-
- else
-
- (* The prefixes disagree. *)
-
- s
-
- (* [inter s t] returns the set intersection of [s] and [t], that is, $s\cap t$. *)
-
- let rec inter s t =
- match s, t with
-
- | Empty, _
- | _, Empty ->
- Empty
-
- | (Leaf x as s), t
- | t, (Leaf x as s) ->
- if mem x t then s else Empty
-
- | Branch(p, m, s0, s1), Branch(q, n, t0, t1) ->
- if (p = q) & (m = n) then
-
- (* The trees have the same prefix. Compute the intersections of their sub-trees. *)
-
- build p m (inter s0 t0) (inter s1 t1)
-
- else if (X.shorter m n) & (match_prefix q p m) then
-
- (* [q] contains [p]. Intersect [t] with a sub-tree of [s]. *)
-
- inter (if (q land m) = 0 then s0 else s1) t
-
- else if (X.shorter n m) & (match_prefix p q n) then
-
- (* [p] contains [q]. Intersect [s] with a sub-tree of [t]. *)
-
- inter s (if (p land n) = 0 then t0 else t1)
-
- else
-
- (* The prefixes disagree. *)
-
- Empty
-
- (* [disjoint s1 s2] returns [true] if and only if the sets [s1] and [s2] are disjoint, i.e. iff their intersection
- is empty. It is a specialized version of [inter], which uses less space. *)
-
- exception NotDisjoint
-
- let disjoint s t =
-
- let rec inter s t =
- match s, t with
-
- | Empty, _
- | _, Empty ->
- ()
-
- | Leaf x, _ ->
- if mem x t then
- raise NotDisjoint
- | _, Leaf x ->
- if mem x s then
- raise NotDisjoint
-
- | Branch(p, m, s0, s1), Branch(q, n, t0, t1) ->
- if (p = q) & (m = n) then begin
- inter s0 t0;
- inter s1 t1
- end
- else if (X.shorter m n) & (match_prefix q p m) then
- inter (if (q land m) = 0 then s0 else s1) t
- else if (X.shorter n m) & (match_prefix p q n) then
- inter s (if (p land n) = 0 then t0 else t1)
- else
- () in
-
- try
- inter s t;
- true
- with NotDisjoint ->
- false
-
- (* [iter f s] invokes [f x], in turn, for each element [x] of the set [s]. Elements are presented to [f] according
- to some unspecified, but fixed, order. *)
-
- let rec iter f = function
- | Empty ->
- ()
- | Leaf x ->
- f x
- | Branch (_, _, tree0, tree1) ->
- iter f tree0;
- iter f tree1
-
- (* [fold f s seed] invokes [f x accu], in turn, for each element [x] of the set [s]. Elements are presented to [f]
- according to some unspecified, but fixed, order. The initial value of [accu] is [seed]; then, at each new call,
- its value is the value returned by the previous invocation of [f]. The value returned by [fold] is the final
- value of [accu]. In other words, if $s = \{ x_1, x_2, \ldots, x_n \}$, where $x_1 < x_2 < \ldots < x_n$, then
- [fold f s seed] computes $([f]\,x_n\,\ldots\,([f]\,x_2\,([f]\,x_1\,[seed]))\ldots)$. *)
-
- let rec fold f s accu =
- match s with
- | Empty ->
- accu
- | Leaf x ->
- f x accu
- | Branch (_, _, s0, s1) ->
- fold f s1 (fold f s0 accu)
-
- (* [elements s] is a list of all elements in the set [s]. *)
-
- let elements s =
- fold (fun tl hd -> tl :: hd) s []
-
- (* [fold_rev] performs exactly the same job as [fold], but presents elements to [f] in the opposite order. *)
-
- let rec fold_rev f s accu =
- match s with
- | Empty ->
- accu
- | Leaf x ->
- f x accu
- | Branch (_, _, s0, s1) ->
- fold_rev f s0 (fold_rev f s1 accu)
-
- (* [iter2] does not make much sense for sets of integers. Better warn the user. *)
-
- let rec iter2 f t1 t2 =
- assert false
-
- (* [iterator s] returns a stateful iterator over the set [s]. That is, if $s = \{ x_1, x_2, \ldots, x_n \}$, where
- $x_1 < x_2 < \ldots < x_n$, then [iterator s] is a function which, when invoked for the $k^{\text{th}}$ time,
- returns [Some]$x_k$, if $k\leq n$, and [None] otherwise. Such a function can be useful when one wishes to
- iterate over a set's elements, without being restricted by the call stack's discipline.
-
- For more comments about this algorithm, please see module [Baltree], which defines a similar one. *)
-
- let iterator s =
-
- let remainder = ref [ s ] in
-
- let rec next () =
- match !remainder with
- | [] ->
- None
- | Empty :: parent ->
- remainder := parent;
- next()
- | (Leaf x) :: parent ->
- remainder := parent;
- Some x
- | (Branch(_, _, s0, s1)) :: parent ->
- remainder := s0 :: s1 :: parent;
- next () in
-
- next
-
- (* [exists p s] returns [true] if and only if some element of [s] matches the predicate [p]. *)
-
- exception Exists
-
- let exists p s =
- try
- iter (fun x ->
- if p x then
- raise Exists
- ) s;
- false
- with Exists ->
- true
-
- (* [compare] is an ordering over sets. *)
-
- exception Got of int
-
- let compare s1 s2 =
- let iterator2 = iterator s2 in
- try
- iter (fun x1 ->
- match iterator2() with
- | None ->
- raise (Got 1)
- | Some x2 ->
- let c = Pervasives.compare x1 x2 in
- if c <> 0 then
- raise (Got c)
- ) s1;
- match iterator2() with
- | None ->
- 0
- | Some _ ->
- -1
- with Got c ->
- c
-
- (* [equal] implements equality over sets. *)
-
- let equal s1 s2 =
- compare s1 s2 = 0
-
- (* [subset] implements the subset predicate over sets. In other words, [subset s t] returns [true] if and only if
- $s\subseteq t$. It is a specialized version of [diff]. *)
-
- exception NotSubset
-
- let subset s t =
-
- let rec diff s t =
- match s, t with
-
- | Empty, _ ->
- ()
- | _, Empty
-
- | Branch _, Leaf _ ->
- raise NotSubset
- | Leaf x, _ ->
- if not (mem x t) then
- raise NotSubset
-
- | Branch(p, m, s0, s1), Branch(q, n, t0, t1) ->
-
- if (p = q) & (m = n) then begin
-
- diff s0 t0;
- diff s1 t1
-
- end
- else if (X.shorter n m) & (match_prefix p q n) then
-
- diff s (if (p land n) = 0 then t0 else t1)
-
- else
-
- (* Either [q] contains [p], which means at least one of [s]'s sub-trees is not contained within [t],
- or the prefixes disagree. In either case, the subset relationship cannot possibly hold. *)
-
- raise NotSubset in
-
- try
- diff s t;
- true
- with NotSubset ->
- false
-
- (* [filter p s] returns the subset of [s] formed by all elements which satisfy the predicate [p]. *)
-
- let filter predicate s =
- let modified = ref false in
-
- let subset = fold (fun element subset ->
- if predicate element then
- add element subset
- else begin
- modified := true;
- subset
- end
- ) s Empty in
-
- if !modified then
- subset
- else
- s
-
- (* [map f s] computes the image of [s] through [f]. *)
-
- let map f s =
- fold (fun element accu ->
- add (f element) accu
- ) s Empty
-
- (* [monotone_map] and [endo_map] do not make much sense for sets of integers. Better warn the user. *)
-
- let monotone_map f s =
- assert false
-
- let endo_map f s =
- assert false
-
-end
-
-(*i --------------------------------------------------------------------------------------------------------------- i*)
-(*s \mysection{Relating sets and maps} *)
-
- (* Back to the world of maps. Let us now describe the relationship which exists between maps and their domains. *)
-
- (* [domain m] returns [m]'s domain. *)
-
- let rec domain = function
- | Empty ->
- Domain.Empty
- | Leaf (k, _) ->
- Domain.Leaf k
- | Branch (p, m, t0, t1) ->
- Domain.Branch (p, m, domain t0, domain t1)
-
- (* [lift f s] returns the map $k\mapsto f(k)$, where $k$ ranges over a set of keys [s]. *)
-
- let rec lift f = function
- | Domain.Empty ->
- Empty
- | Domain.Leaf k ->
- Leaf (k, f k)
- | Domain.Branch (p, m, t0, t1) ->
- Branch(p, m, lift f t0, lift f t1)
-
- (* [build] is a ``smart constructor''. It builds a [Branch] node with the specified arguments, but ensures
- that the newly created node does not have an [Empty] child. *)
-
- let build p m t0 t1 =
- match t0, t1 with
- | Empty, Empty ->
- Empty
- | Empty, _ ->
- t1
- | _, Empty ->
- t0
- | _, _ ->
- Branch(p, m, t0, t1)
-
- (* [corestrict m d] performs a co-restriction of the map [m] to the domain [d]. That is, it returns the map
- $k\mapsto m(k)$, where $k$ ranges over all keys bound in [m] but \emph{not} present in [d]. Its code resembles
- [diff]'s. *)
-
- let rec corestrict s t =
- match s, t with
-
- | Empty, _
- | _, Domain.Empty ->
- s
-
- | Leaf (k, _), _ ->
- if Domain.mem k t then Empty else s
- | _, Domain.Leaf k ->
- remove k s
-
- | Branch(p, m, s0, s1), Domain.Branch(q, n, t0, t1) ->
- if (p = q) & (m = n) then
-
- build p m (corestrict s0 t0) (corestrict s1 t1)
-
- else if (X.shorter m n) & (match_prefix q p m) then
-
- if (q land m) = 0 then
- build p m (corestrict s0 t) s1
- else
- build p m s0 (corestrict s1 t)
-
- else if (X.shorter n m) & (match_prefix p q n) then
-
- corestrict s (if (p land n) = 0 then t0 else t1)
-
- else
-
- s
-
-end
-
-(*i --------------------------------------------------------------------------------------------------------------- i*)
-(*s \mysection{Instantiating the functor} *)
-
-module Little = Make(Endianness.Little)
-
-module Big = Make(Endianness.Big)
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This is an implementation of Patricia trees, following Chris Okasaki's paper at the 1998 ML Workshop in Baltimore.
- Both big-endian and little-endian trees are provided. Both sets and maps are implemented on top of Patricia
- trees. *)
-
-module Little : GMap.S with type key = int
-
-module Big : GMap.S with type key = int
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: positions.ml,v 1.9 2005/12/01 16:20:07 regisgia Exp $ *)
-
-(* TEMPORARY vérifier que ces fonctions sont utilisées partout et
- de façon cohérente; interaction avec [Error]? *)
-
-open Lexing
-
-type t =
- {
- start_p : Lexing.position;
- end_p : Lexing.position
- }
-
-type 'a located =
- {
- value : 'a;
- position : t;
- }
-
-let value { value = v } =
- v
-
-let position { position = p } =
- p
-
-let with_pos p v =
- {
- value = v;
- position = p;
- }
-
-let with_poss p1 p2 v =
- with_pos { start_p = p1; end_p = p2 } v
-
-let map f v =
- {
- value = f v.value;
- position = v.position;
- }
-
-let iter f { value = v } =
- f v
-
-let mapd f v =
- let w1, w2 = f v.value in
- let pos = v.position in
- { value = w1; position = pos },
- { value = w2; position = pos }
-
-let dummy =
- {
- start_p = Lexing.dummy_pos;
- end_p = Lexing.dummy_pos
- }
-
-let unknown_pos v =
- {
- value = v;
- position = dummy
- }
-
-let start_of_position p = p.start_p
-
-let end_of_position p = p.end_p
-
-let filename_of_position p =
- p.start_p.Lexing.pos_fname
-
-let line p =
- p.pos_lnum
-
-let column p =
- p.pos_cnum - p.pos_bol
-
-let characters p1 p2 =
- (column p1, p2.pos_cnum - p1.pos_bol) (* intentionally [p1.pos_bol] *)
-
-let join x1 x2 =
-{
- start_p = if x1 = dummy then x2.start_p else x1.start_p;
- end_p = if x2 = dummy then x1.end_p else x2.end_p
-}
-
-let lex_join x1 x2 =
-{
- start_p = x1;
- end_p = x2
-}
-
-let join_located l1 l2 f =
- {
- value = f l1.value l2.value;
- position = join l1.position l2.position;
- }
-
-let string_of_lex_pos p =
- let c = p.pos_cnum - p.pos_bol in
- (string_of_int p.pos_lnum)^":"^(string_of_int c)
-
-let string_of_pos p =
- let filename = filename_of_position p in
- assert (filename <> "");
- let l = line p.start_p in
- let c1, c2 = characters p.start_p p.end_p in
- Printf.sprintf "File \"%s\", line %d, characters %d-%d" filename l c1 c2
-
-let pos_or_undef = function
- | None -> dummy
- | Some x -> x
-
-let cpos lexbuf =
- {
- start_p = Lexing.lexeme_start_p lexbuf;
- end_p = Lexing.lexeme_end_p lexbuf;
- }
-
-let with_cpos lexbuf v =
- with_pos (cpos lexbuf) v
-
-let string_of_cpos lexbuf =
- string_of_pos (cpos lexbuf)
-
-let joinf f t1 t2 =
- join (f t1) (f t2)
-
-let ljoinf f =
- List.fold_left (fun p t -> join p (f t)) dummy
-
-let join_located_list ls f =
- {
- value = f (List.map (fun l -> l.value) ls);
- position = ljoinf (fun x -> x.position) ls
- }
-
-(* The functions that print error messages and warnings require a list of
- positions. The following auxiliary functions help build such lists. *)
-
-type positions =
- t list
-
-let one (pos : Lexing.position) : positions =
- [ { start_p = pos; end_p = pos } ] (* or: lex_join pos pos *)
-
-let two (pos1 : Lexing.position) (pos2 : Lexing.position) : positions =
- [ lex_join pos1 pos2 ]
-
-let lexbuf (lexbuf : Lexing.lexbuf) : positions =
- [ lex_join lexbuf.Lexing.lex_start_p lexbuf.Lexing.lex_curr_p ]
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: positions.mli,v 1.10 2005/12/01 16:20:07 regisgia Exp $ *)
-
-(* TEMPORARY faire un peu le ménage dans cette interface pléthorique? *)
-
-(** Extension of standard library's positions. *)
-
-(** {2 Extended lexing positions} *)
-
-(** Abstract type for pairs of positions in the lexing stream. *)
-type t
-
-(** Decoration of a value with a position. *)
-type 'a located =
- {
- value : 'a;
- position : t;
- }
-
-(** [value dv] returns the raw value that underlies the
- decorated value [dv]. *)
-val value: 'a located -> 'a
-
-(** [position dv] returns the position that decorates the
- decorated value [dv]. *)
-val position: 'a located -> t
-
-(** [with_pos p v] decorates [v] with a position [p]. *)
-val with_pos : t -> 'a -> 'a located
-val with_cpos: Lexing.lexbuf -> 'a -> 'a located
-val with_poss : Lexing.position -> Lexing.position -> 'a -> 'a located
-
-val unknown_pos : 'a -> 'a located
-
-(** [map f v] extends the decoration from [v] to [f v]. *)
-val map: ('a -> 'b) -> 'a located -> 'b located
-
-(** [iter f dv] applies [f] to the value inside [dv]. *)
-val iter: ('a -> unit) -> 'a located -> unit
-
-(** [mapd f v] extends the decoration from [v] to both members of the pair [f v]. *)
-val mapd: ('a -> 'b1 * 'b2) -> 'a located -> 'b1 located * 'b2 located
-
-(** This value is used when an object does not from
- a particular input location. *)
-val dummy: t
-
-(** {2 Accessors} *)
-
-(** [column p] returns the number of characters from the
- beginning of the line of the Lexing.position [p]. *)
-val column : Lexing.position -> int
-
-(** [column p] returns the line number of to the Lexing.position [p]. *)
-val line : Lexing.position -> int
-
-(** [characters p1 p2] returns the character interval
- between [p1] and [p2] assuming they are located in the same
- line.
-*)
-val characters : Lexing.position -> Lexing.position -> int * int
-
-val start_of_position: t -> Lexing.position
-
-val end_of_position: t -> Lexing.position
-
-val filename_of_position: t -> string
-
-(** {2 Position handling} *)
-
-(** [join p1 p2] returns a position that starts where [p1]
- starts and stops where [p2] stops. *)
-val join : t -> t -> t
-
-val lex_join : Lexing.position -> Lexing.position -> t
-
-val ljoinf : ('a -> t) -> 'a list -> t
-
-val joinf : ('a -> t) -> 'a -> 'a -> t
-
-val join_located : 'a located -> 'b located -> ('a -> 'b -> 'c) -> 'c located
-
-val join_located_list :
- ('a located) list -> ('a list -> 'b list) -> ('b list) located
-
-
-(** [string_of_lex_pos p] returns a string representation for
- the lexing position [p]. *)
-val string_of_lex_pos : Lexing.position -> string
-
-(** [string_of_pos p] returns the standard (Emacs-like) representation
- of the position [p]. *)
-val string_of_pos : t -> string
-
-(** [pos_or_undef po] is the identity function except if po = None,
- in that case, it returns [undefined_position]. *)
-val pos_or_undef : t option -> t
-
-(** {2 Interaction with the lexer runtime} *)
-
-(** [cpos lexbuf] returns the current position of the lexer. *)
-val cpos : Lexing.lexbuf -> t
-
-(** [string_of_cpos p] returns a string representation of
- the lexer's current position. *)
-val string_of_cpos : Lexing.lexbuf -> string
-
-(* The functions that print error messages and warnings require a list of
- positions. The following auxiliary functions help build such lists. *)
-
-type positions =
- t list
-
-val one: Lexing.position -> positions
-
-val two: Lexing.position -> Lexing.position -> positions
-
-val lexbuf: Lexing.lexbuf -> positions
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This is an adaptation of Daan Leijen's [PPrint] library, which itself is
- based on the ideas developed by Philip Wadler in ``A Prettier Printer''.
- For more information, see:
-
- http://www.cs.uu.nl/~daan/pprint.html
- http://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf *)
-
-(* ------------------------------------------------------------------------- *)
-
-(* A uniform interface for output channels. *)
-
-module type OUTPUT = sig
- type channel
- val char: channel -> char -> unit
- val substring: channel -> string -> int (* offset *) -> int (* length *) -> unit
-end
-
-(* ------------------------------------------------------------------------- *)
-
-(* Two implementations of the above interface, respectively based on
- output channels and memory buffers. This compensates for the fact
- that ocaml's standard library does not allow creating an output
- channel out of a memory buffer (a regrettable omission). *)
-
-module ChannelOutput : OUTPUT with type channel = out_channel = struct
- type channel = out_channel
- let char = output_char
- let substring = output
-end
-
-module BufferOutput : OUTPUT with type channel = Buffer.t = struct
- type channel = Buffer.t
- let char = Buffer.add_char
- let substring = Buffer.add_substring
-end
-
-(* ------------------------------------------------------------------------- *)
-
-(* Here is the algebraic data type of documents. It is analogous to Daan
- Leijen's version, but the binary constructor [Union] is replaced with
- the unary constructor [Group], and the constant [Line] is replaced with
- more general constructions, namely [IfFlat], which provides alternative
- forms depending on the current flattening mode, and [HardLine], which
- represents a newline character, and is invalid in flattening mode. *)
-
-type document =
-
- (* [Empty] is the empty document. *)
-
- | Empty
-
- (* [Char c] is a document that consists of the single character [c]. We
- enforce the invariant that [c] is not a newline character. *)
-
- | Char of char
-
- (* [String (s, ofs, len)] is a document that consists of the portion of
- the string [s] delimited by the offset [ofs] and the length [len]. We
- assume, but do not check, that this portion does not contain a newline
- character. *)
-
- | String of string * int * int
-
- (* [Blank n] is a document that consists of [n] blank characters. *)
-
- | Blank of int
-
- (* When in flattening mode, [IfFlat (d1, d2)] turns into the document
- [d1]. When not in flattening mode, it turns into the document [d2]. *)
-
- | IfFlat of document * document
-
- (* When in flattening mode, [HardLine] is illegal. When not in flattening
- mode, it represents a newline character, followed with an appropriate
- number of indentation. A safe way of using [HardLine] is to only use it
- directly within the right branch of an [IfFlat] construct. *)
-
- | HardLine
-
- (* [Cat doc1 doc2] is the concatenation of the documents [doc1] and
- [doc2]. *)
-
- | Cat of document * document
-
- (* [Nest (j, doc)] is the document [doc], in which the indentation level
- has been increased by [j], that is, in which [j] blanks have been
- inserted after every newline character. *)
-
- | Nest of int * document
-
- (* [Group doc] represents an alternative: it is either a flattened form of
- [doc], in which occurrences of [Group] disappear and occurrences of
- [IfFlat] resolve to their left branch, or [doc] itself. *)
-
- | Group of document
-
- (* [Column f] is the document obtained by applying [f] to the current
- column number. *)
-
- | Column of (int -> document)
-
- (* [Nesting f] is the document obtained by applying [f] to the current
- indentation level, that is, the number of blanks that were printed
- at the beginning of the current line. *)
-
- | Nesting of (int -> document)
-
-(* ------------------------------------------------------------------------- *)
-
-(* A signature for document renderers. *)
-
-module type RENDERER = sig
-
- (* Output channels. *)
-
- type channel
-
- (* [pretty rfrac width channel document] pretty-prints the document
- [document] to the output channel [channel]. The parameter [width] is the
- maximum number of characters per line. The parameter [rfrac] is the
- ribbon width, a fraction relative to [width]. The ribbon width is the
- maximum number of non-indentation characters per line. *)
-
- val pretty: float -> int -> channel -> document -> unit
-
- (* [compact channel document] prints the document [document] to the output
- channel [channel]. No indentation is used. All newline instructions are
- respected, that is, no groups are flattened. *)
-
- val compact: channel -> document -> unit
-
-end
-
-(* ------------------------------------------------------------------------- *)
-
-(* The pretty rendering algorithm: preliminary declarations. *)
-
-(* The renderer is supposed to behave exactly like Daan Leijen's, although its
- implementation is quite radically different. Instead of relying on
- Haskell's lazy evaluation mechanism, we implement an abstract machine with
- mutable current state, forking, backtracking (via an explicit stack of
- choice points), and cut (disposal of earlier choice points). *)
-
-(* The renderer's input consists of an ordered sequence of documents. Each
- document carries an extra indentation level, akin to an implicit [Nest]
- constructor, and a ``flattening'' flag, which, if set, means that this
- document should be printed in flattening mode. *)
-
-(* An alternative coding style would be to avoid decorating each input
- document with an indentation level and a flattening mode, and allow
- the input sequence to contain instructions that set the current
- nesting level or reset the flattening mode. That would perhaps be
- slightly more readable, and slightly less efficient. *)
-
-type input =
- | INil
- | ICons of int * bool * document * input
-
-(* When possible (that is, when the stack is empty), the renderer writes
- directly to the output channel. Otherwise, output is buffered until either
- a failure point is reached (then, the buffered output is discarded) or a
- cut is reached (then, all buffered output is committed to the output
- channel). At all times, the length of the buffered output is at most one
- line. *)
-
-(* The buffered output consists of a list of characters and strings. It is
- stored in reverse order (the head of the list should be printed last). *)
-
-type output =
- | OEmpty
- | OChar of char * output
- | OString of string * int * int * output
- | OBlank of int * output
-
-(* The renderer maintains the following state record. For efficiency, the
- record is mutable; it is copied when the renderer forks, that is, at
- choice points. *)
-
-type 'channel state = {
-
- (* The line width and ribbon width. *)
-
- width: int;
- ribbon: int;
-
- (* The output channel. *)
-
- channel: 'channel;
-
- (* The current indentation level. This is the number of blanks that
- were printed at the beginning of the current line. *)
-
- mutable indentation: int;
-
- (* The current column. *)
-
- mutable column: int;
-
- (* The renderer's input. For efficiency, the input is assumed to never be
- empty, and the leading [ICons] constructor is inlined within the state
- record. In other words, the fields [nest1], [flatten1], and [input1]
- concern the first input document, and the field [input] contains the
- rest of the input sequence. *)
-
- mutable indent1: int;
- mutable flatten1: bool;
- mutable input1: document;
- mutable input: input;
-
- (* The renderer's buffer output. *)
-
- mutable output: output;
-
- }
-
-(* The renderer maintains a stack of resumptions, that is, states in which
- execution should be resumed if the current thread of execution fails by
- lack of space on the current line. *)
-
-(* It is not difficult to prove that the stack is empty if and only if
- flattening mode is off. Furthermore, when flattening mode is on,
- all groups are ignored, so no new choice points are pushed onto the
- stack. As a result, the stack has height one at most at all times,
- so that the stack height is zero when flattening mode is off and
- one when flattening mode is on. *)
-
-type 'channel stack =
- 'channel state list
-
-(* ------------------------------------------------------------------------- *)
-
-(* The pretty rendering algorithm: code. *)
-
-(* The renderer is parameterized over an implementation of output channels. *)
-
-module Renderer (Output : OUTPUT) = struct
-
- type channel =
- Output.channel
-
- (* Printing blank space (indentation characters). *)
-
- let blank_length =
- 80
-
- let blank_buffer =
- String.make blank_length ' '
-
- let rec blanks channel n =
- if n <= 0 then
- ()
- else if n <= blank_length then
- Output.substring channel blank_buffer 0 n
- else begin
- Output.substring channel blank_buffer 0 blank_length;
- blanks channel (n - blank_length)
- end
-
- (* Committing buffered output to the output channel. The list is printed in
- reverse order. The code is not tail recursive, but there is no risk of
- stack overflow, since the length of the buffered output cannot exceed one
- line. *)
-
- let rec commit channel = function
- | OEmpty ->
- ()
- | OChar (c, output) ->
- commit channel output;
- Output.char channel c
- | OString (s, ofs, len, output) ->
- commit channel output;
- Output.substring channel s ofs len
- | OBlank (n, output) ->
- commit channel output;
- blanks channel n
-
- (* The renderer's abstract machine. *)
-
- (* The procedures [run], [shift], [emit_char], [emit_string], and
- [emit_blanks] are mutually recursive, and are tail recursive. They
- maintain a stack and a current state. The states in the stack, and the
- current state, are pairwise distinct, so that the current state can be
- mutated without affecting the contents of the stack. *)
-
- (* An invariant is: the buffered output is nonempty only when the stack is
- nonempty. The contrapositive is: if the stack is empty, then the buffered
- output is empty. Indeed, the fact that the stack is empty means that no
- choices were made, so we are not in a speculative mode of execution: as a
- result, all output can be sent directly to the output channel. On the
- contrary, when the stack is nonempty, there is a possibility that we
- might backtrack in the future, so all output should be held in a
- buffer. *)
-
- (* [run] is allowed to call itself recursively only when no material is
- printed. In that case, the check for failure is skipped -- indeed,
- this test is performed only within [shift]. *)
-
- let rec run (stack : channel stack) (state : channel state) : unit =
-
- (* Examine the first piece of input, as well as (in some cases) the
- current flattening mode. *)
-
- match state.input1, state.flatten1 with
-
- (* The first piece of input is an empty document. Discard it
- and continue. *)
-
- | Empty, _ ->
- shift stack state
-
- (* The first piece of input is a character. Emit it and continue. *)
-
- | Char c, _ ->
- emit_char stack state c
-
- (* The first piece of input is a string. Emit it and continue. *)
-
- | String (s, ofs, len), _ ->
- emit_string stack state s ofs len
- | Blank n, _ ->
- emit_blanks stack state n
-
- (* The first piece of input is a hard newline instruction. Such an
- instruction is valid only when flattening mode is off. *)
-
- (* We emit a newline character, followed by the prescribed amount of
- indentation. We update the current state to record how many
- indentation characters were printed and to to reflect the new
- column number. Then, we discard the current piece of input and
- continue. *)
-
- | HardLine, flattening ->
- assert (not flattening); (* flattening mode must be off. *)
- assert (stack = []); (* since flattening mode is off, the stack must be empty. *)
- Output.char state.channel '\n';
- let i = state.indent1 in
- blanks state.channel i;
- state.column <- i;
- state.indentation <- i;
- shift stack state
-
- (* The first piece of input is an [IfFlat] conditional instruction. *)
-
- | IfFlat (doc, _), true
- | IfFlat (_, doc), false ->
- state.input1 <- doc;
- run stack state
-
- (* The first piece of input is a concatenation operator. We take it
- apart and queue both documents in the input sequence. *)
-
- | Cat (doc1, doc2), _ ->
- state.input1 <- doc1;
- state.input <- ICons (state.indent1, state.flatten1, doc2, state.input);
- run stack state
-
- (* The first piece of input is a [Nest] operator. We increase the amount
- of indentation to be applied to the first input document. *)
-
- | Nest (j, doc), _ ->
- state.indent1 <- state.indent1 + j;
- state.input1 <- doc;
- run stack state
-
- (* The first piece of input is a [Group] operator, and flattening mode
- is currently off. This introduces a choice point: either we flatten
- this whole group, or we don't. We try the former possibility first:
- this is done by enabling flattening mode. Should this avenue fail,
- we push the current state, in which flattening mode is disabled,
- onto the stack. *)
-
- (* Note that the current state is copied before continuing, so that
- the state that is pushed on the stack is not affected by future
- modifications. This is a fork. *)
-
- | Group doc, false ->
- state.input1 <- doc;
- run (state :: stack) { state with flatten1 = true }
-
- (* The first piece of input is a [Group] operator, and flattening mode
- is currently on. The operator is ignored. *)
-
- | Group doc, true ->
- state.input1 <- doc;
- run stack state
-
- (* The first piece of input is a [Column] operator. The current column
- is fed into it, so as to produce a document, with which we continue. *)
-
- | Column f, _ ->
- state.input1 <- f state.column;
- run stack state
-
- (* The first piece of input is a [Column] operator. The current
- indentation level is fed into it, so as to produce a document, with
- which we continue. *)
-
- | Nesting f, _ ->
- state.input1 <- f state.indentation;
- run stack state
-
- (* [shift] discards the first document in the input sequence, so that the
- second input document, if there is one, becomes first. The renderer stops
- if there is none. *)
-
- and shift stack state =
-
- assert (state.output = OEmpty || stack <> []);
- assert (state.flatten1 = (stack <> []));
-
- (* If the stack is nonempty and we have exceeded either the width or the
- ribbon width parameters, then fail. Backtracking is implemented by
- discarding the current state, popping a state off the stack, and making
- it the current state. *)
-
- match stack with
- | resumption :: stack
- when state.column > state.width
- || state.column - state.indentation > state.ribbon ->
- run stack resumption
- | _ ->
-
- match state.input with
- | INil ->
-
- (* End of input. Commit any buffered output and stop. *)
-
- commit state.channel state.output
-
- | ICons (indent, flatten, head, tail) ->
-
- (* There is an input document. Move it one slot ahead and
- check if we are leaving flattening mode. *)
-
- state.indent1 <- indent;
- state.input1 <- head;
- state.input <- tail;
- if state.flatten1 && not flatten then begin
-
- (* Leaving flattening mode means success: we have flattened
- a certain group, and fitted it all on a line, without
- reaching a failure point. We would now like to commit our
- decision to flatten this group. This is a Prolog cut. We
- discard the stack of choice points, replacing it with an
- empty stack, and commit all buffered output. *)
-
- state.flatten1 <- flatten; (* false *)
- commit state.channel state.output;
- state.output <- OEmpty;
- run [] state
-
- end
- else
- run stack state
-
- (* [emit_char] prints a character (either to the output channel or to the
- output buffer), increments the current column, discards the first piece
- of input, and continues. *)
-
- and emit_char stack state c =
- begin match stack with
- | [] ->
- Output.char state.channel c
- | _ ->
- state.output <- OChar (c, state.output)
- end;
- state.column <- state.column + 1;
- shift stack state
-
- (* [emit_string] prints a string (either to the output channel or to the
- output buffer), updates the current column, discards the first piece of
- input, and continues. *)
-
- and emit_string stack state s ofs len =
- begin match stack with
- | [] ->
- Output.substring state.channel s ofs len
- | _ ->
- state.output <- OString (s, ofs, len, state.output)
- end;
- state.column <- state.column + len;
- shift stack state
-
- (* [emit_blanks] prints a blank string (either to the output channel or to
- the output buffer), updates the current column, discards the first piece
- of input, and continues. *)
-
- and emit_blanks stack state n =
- begin match stack with
- | [] ->
- blanks state.channel n
- | _ ->
- state.output <- OBlank (n, state.output)
- end;
- state.column <- state.column + n;
- shift stack state
-
- (* This is the renderer's main entry point. *)
-
- let pretty rfrac width channel document =
- run [] {
- width = width;
- ribbon = max 0 (min width (truncate (float_of_int width *. rfrac)));
- channel = channel;
- indentation = 0;
- column = 0;
- indent1 = 0;
- flatten1 = false;
- input1 = document;
- input = INil;
- output = OEmpty;
- }
-
-(* ------------------------------------------------------------------------- *)
-
-(* The compact rendering algorithm. *)
-
- let compact channel document =
-
- let column =
- ref 0
- in
-
- let rec scan = function
- | Empty ->
- ()
- | Char c ->
- Output.char channel c;
- column := !column + 1
- | String (s, ofs, len) ->
- Output.substring channel s ofs len;
- column := !column + len
- | Blank n ->
- blanks channel n;
- column := !column + n
- | HardLine ->
- Output.char channel '\n';
- column := 0
- | Cat (doc1, doc2) ->
- scan doc1;
- scan doc2
- | IfFlat (doc, _)
- | Nest (_, doc)
- | Group doc ->
- scan doc
- | Column f ->
- scan (f !column)
- | Nesting f ->
- scan (f 0)
- in
-
- scan document
-
-end
-
-(* ------------------------------------------------------------------------- *)
-
-(* Instantiating the renderers for the two kinds of output channels. *)
-
-module Channel =
- Renderer(ChannelOutput)
-
-module Buffer =
- Renderer(BufferOutput)
-
-(* ------------------------------------------------------------------------- *)
-
-(* Constructors. *)
-
-let empty =
- Empty
-
-let (^^) x y =
- match x, y with
- | Empty, x
- | x, Empty ->
- x
- | _, _ ->
- Cat (x, y)
-
-let ifflat doc1 doc2 =
- IfFlat (doc1, doc2)
-
-let hardline =
- HardLine
-
-let char c =
- assert (c <> '\n');
- Char c
-
-let substring s ofs len =
- if len = 0 then
- Empty
- else
- String (s, ofs, len)
-
-let text s =
- substring s 0 (String.length s)
-
-let blank n =
- if n = 0 then
- Empty
- else
- Blank n
-
-let nest i x =
- assert (i >= 0);
- Nest (i, x)
-
-let column f =
- Column f
-
-let nesting f =
- Nesting f
-
-let group x =
- Group x
-
-(* ------------------------------------------------------------------------- *)
-
-(* Low-level combinators for alignment and indentation. *)
-
-let align d =
- column (fun k ->
- nesting (fun i ->
- nest (k - i) d
- )
- )
-
-let hang i d =
- align (nest i d)
-
-let indent i d =
- hang i (blank i ^^ d)
-
-(* ------------------------------------------------------------------------- *)
-
-(* High-level combinators. *)
-
-let lparen = char '('
-let rparen = char ')'
-let langle = char '<'
-let rangle = char '>'
-let lbrace = char '{'
-let rbrace = char '}'
-let lbracket = char '['
-let rbracket = char ']'
-let squote = char '\''
-let dquote = char '"'
-let bquote = char '`'
-let semi = char ';'
-let colon = char ':'
-let comma = char ','
-let space = char ' '
-let dot = char '.'
-let sharp = char '#'
-let backslash = char '\\'
-let equals = char '='
-let qmark = char '?'
-let tilde = char '~'
-let at = char '@'
-let percent = char '%'
-let dollar = char '$'
-let caret = char '^'
-let ampersand = char '&'
-let star = char '*'
-let plus = char '+'
-let minus = char '-'
-let underscore = char '_'
-let bang = char '!'
-let bar = char '|'
-
-let break i = ifflat (text (String.make i ' ')) hardline
-let break0 = ifflat empty hardline
-let break1 = ifflat space hardline
-
-let string s =
- let n = String.length s in
- let rec chop i =
- try
- let j = String.index_from s i '\n' in
- substring s i (j - i) ^^ break1 ^^ chop (j + 1)
- with Not_found ->
- substring s i (n - i)
- in
- chop 0
-
-let group_break1 = group break1
-
-let words s =
- let n = String.length s in
- let rec blank accu i = (* we have skipped over at least one blank character *)
- if i = n then
- accu ^^ group_break1
- else match s.[i] with
- | ' '
- | '\t'
- | '\n'
- | '\r' ->
- blank accu (i + 1)
- | _ ->
- word break1 accu i (i + 1)
- and word prefix accu i j = (* we have skipped over at least one non-blank character *)
- if j = n then
- accu ^^ group (prefix ^^ substring s i (j - i))
- else match s.[j] with
- | ' '
- | '\t'
- | '\n'
- | '\r' ->
- blank (accu ^^ group (prefix ^^ substring s i (j - i))) (j + 1)
- | _ ->
- word prefix accu i (j + 1)
- in
- if n = 0 then
- empty
- else
- match s.[0] with
- | ' '
- | '\t'
- | '\n'
- | '\r' ->
- blank empty 1
- | _ ->
- word empty empty 0 1
-
-let enclose l r x = l ^^ x ^^ r
-
-let squotes = enclose squote squote
-let dquotes = enclose dquote dquote
-let bquotes = enclose bquote bquote
-let braces = enclose lbrace rbrace
-let parens = enclose lparen rparen
-let angles = enclose langle rangle
-let brackets = enclose lbracket rbracket
-
-let fold f docs = List.fold_right f docs empty
-
-let rec fold1 f docs =
- match docs with
- | [] ->
- empty
- | [ doc ] ->
- doc
- | doc :: docs ->
- f doc (fold1 f docs)
-
-let rec fold1map f g docs =
- match docs with
- | [] ->
- empty
- | [ doc ] ->
- g doc
- | doc :: docs ->
- let doc = g doc in (* force left-to-right evaluation *)
- f doc (fold1map f g docs)
-
-let sepmap sep g docs =
- fold1map (fun x y -> x ^^ sep ^^ y) g docs
-
-let optional f = function
- | None ->
- empty
- | Some x ->
- f x
-
-let group1 d = group (nest 1 d)
-let group2 d = group (nest 2 d)
-
-module Operators = struct
- let ( !^ ) = text
- let ( ^^ ) = ( ^^ )
- let ( ^/^ ) x y = x ^^ break1 ^^ y
- let ( ^//^ ) x y = group (x ^^ nest 2 (break1 ^^ y))
- let ( ^@^ ) x y = group (x ^^ break1 ^^ y)
- let ( ^@@^ ) x y = group2 (x ^^ break1 ^^ y)
-end
-
-open Operators
-let prefix op x = !^op ^//^ x
-let infix op x y = (x ^^ space ^^ !^op) ^//^ y
-let infix_dot op x y = group2 ((x ^^ !^op) ^^ break0 ^^ y)
-let infix_com op x y = x ^^ !^op ^^ group_break1 ^^ y
-let surround n sep open_doc contents close_doc =
- group (open_doc ^^ nest n (sep ^^ contents) ^^ sep ^^ close_doc)
-let surround1 open_txt contents close_txt =
- surround 1 break0 !^open_txt contents !^close_txt
-let surround2 open_txt contents close_txt =
- surround 2 break1 !^open_txt contents !^close_txt
-
-let soft_surround n sep open_doc contents close_doc =
- group (open_doc ^^ nest n (group sep ^^ contents) ^^
- group (sep ^^ close_doc))
-
-let seq indent break empty_seq open_seq sep_seq close_seq = function
- | [] -> empty_seq
- | xs ->
- surround indent break
- open_seq (fold1 (fun x xs -> x ^^ sep_seq ^^ xs) xs) close_seq
-let seq1 open_txt sep_txt close_txt =
- seq 1 break0 !^(open_txt ^ close_txt) !^open_txt (!^sep_txt ^^ break1) !^close_txt
-let seq2 open_txt sep_txt close_txt =
- seq 2 break1 !^(open_txt ^ close_txt) !^open_txt (!^sep_txt ^^ break1) !^close_txt
-
-let sprintf fmt = Printf.ksprintf string fmt
-
-(* A signature for value representations.
- This is compatible with the associated Camlp4 generator:
- SwitchValueRepresentation *)
-
-module type VALUE_REPRESENTATION = sig
- (* The type of value representation *)
- type t
-
- (* [variant type_name data_constructor_name tag arguments]
- Given information about the variant and its arguments,
- this function produces a new value representation. *)
- val variant : string -> string -> int -> t list -> t
-
- (* [record type_name fields]
- Given a type name and a list of record fields, this function
- produces the value representation of a record. *)
- val record : string -> (string * t) list -> t
-
- (* [tuple arguments]
- Given a list of value representation this function produces
- a new value representation. *)
- val tuple : t list -> t
-
- (* ------------------------------------------------------------------------- *)
-
- (* Value representation for primitive types. *)
-
- val string : string -> t
- val int : int -> t
- val int32 : int32 -> t
- val int64 : int64 -> t
- val nativeint : nativeint -> t
- val float : float -> t
- val char : char -> t
- val bool : bool -> t
- val option : ('a -> t) -> 'a option -> t
- val list : ('a -> t) -> 'a list -> t
- val array : ('a -> t) -> 'a array -> t
- val ref : ('a -> t) -> 'a ref -> t
-
- (* Value representation for any other value. *)
- val unknown : string -> 'a -> t
-end
-
-module type DOCUMENT_VALUE_REPRESENTATION =
- VALUE_REPRESENTATION with type t = document
-
-(* please remove as soon as this will be available in ocaml *)
-module MissingFloatRepr = struct
- let valid_float_lexeme s =
- let l = String.length s in
- let rec loop i =
- if i >= l then s ^ "." else
- match s.[i] with
- | '0' .. '9' | '-' -> loop (i+1)
- | _ -> s
- in loop 0
-
- let float_repres f =
- match classify_float f with
- FP_nan -> "nan"
- | FP_infinite ->
- if f < 0.0 then "neg_infinity" else "infinity"
- | _ ->
- let s1 = Printf.sprintf "%.12g" f in
- if f = float_of_string s1 then valid_float_lexeme s1 else
- let s2 = Printf.sprintf "%.15g" f in
- if f = float_of_string s2 then valid_float_lexeme s2 else
- Printf.sprintf "%.18g" f
-end
-
-module ML = struct
- type t = document
- let tuple = seq1 "(" "," ")"
- let variant _ cons _ args =
- if args = [] then !^cons else !^cons ^^ tuple args
- let record _ fields =
- seq2 "{" ";" "}" (List.map (fun (k, v) -> infix ":" !^k v) fields)
- let option f = function
- | Some x -> !^"Some" ^^ tuple [f x]
- | None -> !^"None"
- let list f xs = seq2 "[" ";" "]" (List.map f xs)
- let array f xs = seq2 "[|" ";" "|]" (Array.to_list (Array.map f xs))
- let ref f x = record "ref" ["contents", f !x]
- let float f = string (MissingFloatRepr.float_repres f)
- let int = sprintf "%d"
- let int32 = sprintf "%ld"
- let int64 = sprintf "%Ld"
- let nativeint = sprintf "%nd"
- let char = sprintf "%C"
- let bool = sprintf "%B"
- let string = sprintf "%S"
- let unknown tyname _ = sprintf "<abstr:%s>" tyname
-end
-
-(* Deprecated *)
-let line = ifflat space hardline
-let linebreak = ifflat empty hardline
-let softline = group line
-let softbreak = group linebreak
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* ------------------------------------------------------------------------- *)
-
-(* Basic combinators for building documents. *)
-
-type document
-
-val empty: document
-val hardline: document
-val char: char -> document
-val substring: string -> int -> int -> document
-val text: string -> document
-val blank: int -> document
-val (^^): document -> document -> document
-val nest: int -> document -> document
-val column: (int -> document) -> document
-val nesting: (int -> document) -> document
-val group: document -> document
-val ifflat: document -> document -> document
-
-(* ------------------------------------------------------------------------- *)
-
-(* Low-level combinators for alignment and indentation. *)
-
-val align: document -> document
-val hang: int -> document -> document
-val indent: int -> document -> document
-
-(* ------------------------------------------------------------------------- *)
-
-(* High-level combinators for building documents. *)
-
-(* [break n] Puts [n] spaces in flat mode and a new line otherwise.
- Equivalent to: [ifflat (String.make n ' ') hardline] *)
-val break: int -> document
-
-(* [break0] equivalent to [break 0] *)
-val break0: document
-
-(* [break1] equivalent to [break 1] *)
-val break1: document
-
-val string: string -> document
-val words: string -> document
-
-val lparen: document
-val rparen: document
-val langle: document
-val rangle: document
-val lbrace: document
-val rbrace: document
-val lbracket: document
-val rbracket: document
-val squote: document
-val dquote: document
-val bquote: document
-val semi: document
-val colon: document
-val comma: document
-val space: document
-val dot: document
-val sharp: document
-val backslash: document
-val equals: document
-val qmark: document
-val tilde: document
-val at: document
-val percent: document
-val dollar: document
-val caret: document
-val ampersand: document
-val star: document
-val plus: document
-val minus: document
-val underscore: document
-val bang: document
-val bar: document
-
-val squotes: document -> document
-val dquotes: document -> document
-val bquotes: document -> document
-val braces: document -> document
-val parens: document -> document
-val angles: document -> document
-val brackets: document -> document
-
-val fold: (document -> document -> document) -> document list -> document
-val fold1: (document -> document -> document) -> document list -> document
-val fold1map: (document -> document -> document) -> ('a -> document) -> 'a list -> document
-val sepmap: document -> ('a -> document) -> 'a list -> document
-
-val optional: ('a -> document) -> 'a option -> document
-
-(* [prefix left right]
- Flat layout: [left] [right]
- Otherwise: [left]
- [right]
- *)
-val prefix: string -> document -> document
-
-(* [infix middle left right]
- Flat layout: [left] [middle] [right]
- Otherwise: [left] [middle]
- [right]
- *)
-val infix: string -> document -> document -> document
-
-(* [infix_com middle left right]
- Flat layout: [left][middle] [right]
- Otherwise: [left][middle]
- [right]
- *)
-val infix_com: string -> document -> document -> document
-
-(* [infix_dot middle left right]
- Flat layout: [left][middle][right]
- Otherwise: [left][middle]
- [right]
- *)
-val infix_dot: string -> document -> document -> document
-
-(* [surround nesting break open_doc contents close_doc] *)
-val surround: int -> document -> document -> document -> document -> document
-
-(* [surround1 open_txt contents close_txt]
- Flat: [open_txt][contents][close_txt]
- Otherwise: [open_txt]
- [contents]
- [close_txt]
- *)
-val surround1: string -> document -> string -> document
-
-(* [surround2 open_txt contents close_txt]
- Flat: [open_txt] [contents] [close_txt]
- Otherwise: [open_txt]
- [contents]
- [close_txt]
- *)
-val surround2: string -> document -> string -> document
-
-(* [soft_surround nesting break open_doc contents close_doc] *)
-val soft_surround: int -> document -> document -> document -> document -> document
-
-(* [seq indent break empty_seq open_seq sep_seq close_seq contents] *)
-val seq: int -> document -> document -> document -> document -> document ->
- document list -> document
-
-(* [seq1 open_seq sep_seq close_seq contents]
- Flat layout: [open_seq][contents][sep_seq]...[sep_seq][contents][close_seq]
- Otherwise: [open_seq]
- [contents][sep_seq]...[sep_seq][contents]
- [close_seq]
- *)
-val seq1: string -> string -> string -> document list -> document
-
-(* [seq2 open_seq sep_seq close_seq contents]
- Flat layout: [open_seq] [contents][sep_seq]...[sep_seq][contents] [close_seq]
- Otherwise: [open_seq]
- [contents][sep_seq]...[sep_seq][contents]
- [close_seq]
- *)
-val seq2: string -> string -> string -> document list -> document
-
-(* [group1 d] equivalent to [group (nest 1 d)] *)
-val group1: document -> document
-
-(* [group2 d] equivalent to [group (nest 2 d)] *)
-val group2: document -> document
-
-module Operators : sig
- val ( ^^ ) : document -> document -> document
- val ( !^ ) : string -> document
- val ( ^/^ ) : document -> document -> document
- val ( ^//^ ) : document -> document -> document
- val ( ^@^ ) : document -> document -> document
- val ( ^@@^ ) : document -> document -> document
-end
-
-(* ------------------------------------------------------------------------- *)
-
-(* A signature for document renderers. *)
-
-module type RENDERER = sig
-
- (* Output channels. *)
-
- type channel
-
- (* [pretty rfrac width channel document] pretty-prints the document
- [document] to the output channel [channel]. The parameter [width] is the
- maximum number of characters per line. The parameter [rfrac] is the
- ribbon width, a fraction relative to [width]. The ribbon width is the
- maximum number of non-indentation characters per line. *)
-
- val pretty: float -> int -> channel -> document -> unit
-
- (* [compact channel document] prints the document [document] to the output
- channel [channel]. No indentation is used. All newline instructions are
- respected, that is, no groups are flattened. *)
-
- val compact: channel -> document -> unit
-
-end
-
-(* ------------------------------------------------------------------------- *)
-
-(* Renderers to output channels and to memory buffers. *)
-
-module Channel : RENDERER with type channel = out_channel
-
-module Buffer : RENDERER with type channel = Buffer.t
-
-(* ------------------------------------------------------------------------- *)
-
-(* A signature for value representations.
- This is compatible with the associated Camlp4 generator:
- SwitchValueRepresentation *)
-
-module type VALUE_REPRESENTATION = sig
- (* The type of value representation *)
- type t
-
- (* [variant type_name data_constructor_name tag arguments]
- Given information about the variant and its arguments,
- this function produces a new value representation. *)
- val variant : string -> string -> int -> t list -> t
-
- (* [record type_name fields]
- Given a type name and a list of record fields, this function
- produces the value representation of a record. *)
- val record : string -> (string * t) list -> t
-
- (* [tuple arguments]
- Given a list of value representation this function produces
- a new value representation. *)
- val tuple : t list -> t
-
- (* ------------------------------------------------------------------------- *)
-
- (* Value representation for primitive types. *)
-
- val string : string -> t
- val int : int -> t
- val int32 : int32 -> t
- val int64 : int64 -> t
- val nativeint : nativeint -> t
- val float : float -> t
- val char : char -> t
- val bool : bool -> t
- val option : ('a -> t) -> 'a option -> t
- val list : ('a -> t) -> 'a list -> t
- val array : ('a -> t) -> 'a array -> t
- val ref : ('a -> t) -> 'a ref -> t
-
- (* Value representation for any other value. *)
- val unknown : string -> 'a -> t
-end
-
-(* A signature for source printers. *)
-
-module type DOCUMENT_VALUE_REPRESENTATION =
- VALUE_REPRESENTATION with type t = document
-
-module ML : DOCUMENT_VALUE_REPRESENTATION
-
-(* Deprecated *)
-val line: document
-val linebreak: document
-val softline: document
-val softbreak: document
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Printf
-open Syntax
-
-let read_whole_file filename =
-
- (* Open the file in text mode, so that (under Windows) CRLF is converted to LF.
- This guarantees that one byte is one character and seems to be required in
- order to report accurate positions. *)
-
- let channel = open_in filename in
-
- (* The standard library functions [pos_in] and [seek_in] do not work correctly
- when CRLF conversion is being performed, so we abandon their use. (They were
- used to go and extract the text of semantic actions.) Instead we load the
- entire file into memory up front, and work with a string. *)
-
- (* The standard library function [in_channel_length] does not work correctly
- when CRLF conversion is being performed, so we do not use it to read the
- whole file. And the standard library function [Buffer.add_channel] uses
- [really_input] internally, so we cannot use it either. Bummer. *)
-
- let block_size = 16384 in
- let b = Buffer.create block_size in
- let s = String.create block_size in
-
- let rec loop () =
- let read = input channel s 0 block_size in
- if read > 0 then begin
- Buffer.add_substring b s 0 read;
- loop()
- end
- in
-
- loop();
- close_in channel;
- Buffer.contents b
-
-let load_partial_grammar filename =
- if Filename.check_suffix filename (if Settings.coq then ".vy" else ".mly") then
- Error.set_filename filename
- else
- Error.error [] (sprintf "argument file names should end in .mly. \"%s\" is not accepted." filename);
- try
-
- let contents = read_whole_file filename in
- Error.file_contents := Some contents;
- let lexbuf = Lexing.from_string contents in
- lexbuf.Lexing.lex_curr_p <-
- {
- Lexing.pos_fname = filename;
- Lexing.pos_lnum = 1;
- Lexing.pos_bol = 0;
- Lexing.pos_cnum = 0
- };
- let grammar =
- { (Parser.grammar Lexer.main lexbuf) with ConcreteSyntax.pg_filename = filename }
- in
- Error.file_contents := None;
-
- (* If there were errors during parsing, stop. This has to be done
- explicitly here because the parser performs error recovery and
- does not die at the first error. One could even go further and
- attempt to work with the grammar in spite of the parse errors,
- but we choose not to. *)
-
- if Error.errors () then
- exit 1
- else
- grammar
-
- with Sys_error msg ->
- Error.error [] msg
-
-let partial_grammars =
- List.map load_partial_grammar Settings.filenames
-
-let () =
- Time.tick "Lexing and parsing"
-
-let parameterized_grammar =
- PartialGrammar.join_partial_grammars partial_grammars
-
-let grammar =
- ParameterizedGrammar.expand parameterized_grammar
-
-let () =
- Time.tick "Joining and expanding"
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module drives the first half of the front-end. It opens and
- parses the input files, which yields a number of partial
- grammars. It joins these grammars, expands them to get rid of
- parameterized nonterminals, and performs reachability
- analysis. This yields a single unified grammar.
-
- More transformations over this grammar are performed in the second
- half of the front-end, which is driven by [Front]. The modules
- [PreFront] and [Front] are separated because it is convenient to
- insert auxiliary modules, such as [TokenType] and [Infer], in
- between the two. *)
-
-val grammar: UnparameterizedSyntax.grammar
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* A pretty-printer for [IL]. *)
-
-open IL
-open Printf
-
-module Make (X : sig
-
- (* This is the channel that is being written to. *)
-
- val f: out_channel
-
- (* If [raw_stretch_action] is set, then we print the semantic actions
- as they are found into the original source code. *)
- val raw_stretch_action: bool
-
- (* This controls the way we print Objective Caml stretches (types and
- semantic actions). We either surround them with #line directives
- (for better error reports if the generated code is ill - typed) or
- don't (for better readability). The value is either [None] -- do
- not provide #line directives -- or [Some filename] -- do provide
- them. [filename] is the name of the file that is being written
- to. *)
-
- val locate_stretches: string option
-
-end) = struct
-
-(* ------------------------------------------------------------------------- *)
-(* Dealing with newlines and indentation. *)
-
-let maxindent =
- 120
-
-let whitespace =
- String.make maxindent ' '
-
-let indentation =
- ref 0
-
-let line =
- ref 1
-
-(* [rawnl] is, in principle, the only place where writing a newline
- character to the output channel is permitted. This ensures that the
- line counter remains correct. But see also [stretch] and [typ0]. *)
-
-let rawnl f =
- incr line;
- output_char f '\n'
-
-let nl f =
- rawnl f;
- output f whitespace 0 !indentation
-
-let indent ofs producer f x =
- let old_indentation = !indentation in
- let new_indentation = old_indentation + ofs in
- if new_indentation <= maxindent then
- indentation := new_indentation;
- nl f;
- producer f x;
- indentation := old_indentation
-
-(* This produces a #line directive. *)
-
-let sharp f line file =
- fprintf f "%t# %d \"%s\"%t" rawnl line file rawnl
-
-(* ------------------------------------------------------------------------- *)
-(* Printers of atomic elements. *)
-
-let nothing f =
- ()
-
-let space f =
- output_char f ' '
-
-let comma f =
- output_string f ", "
-
-let seminl f =
- output_char f ';';
- nl f
-
-let times f =
- output_string f " * "
-
-let letrec f =
- output_string f "let rec "
-
-let letnonrec f =
- output_string f "let "
-
-let keytyp f =
- output_string f "type "
-
-let exc f =
- output_string f "exception "
-
-let et f =
- output_string f "and "
-
-let var f x =
- output_string f x
-
-let bar f =
- output_string f " | "
-
-(* ------------------------------------------------------------------------- *)
-(* List printers. *)
-
-let rec list elem sep f = function
- | [] ->
- ()
- | e :: es ->
- fprintf f "%t%a%a" sep elem e (list elem sep) es
-
-let rec typeparams p0 p1 f = function
- | [] ->
- ()
- | [ param ] ->
- fprintf f "%a " p0 param
- | param :: params ->
- fprintf f "(%a%a) " p1 param (list p1 comma) params
-
-(* ------------------------------------------------------------------------- *)
-(* Expression printer. *)
-
-(* We use symbolic constants that stand for subsets of the
- expression constructors. We do not use numeric levels
- to stand for subsets, because our subsets do not form
- a linear inclusion chain. *)
-
-type subset =
- | All
- | AllButSeq
- | AllButFunTryMatch
- | AllButFunTryMatchSeq
- | AllButLetFunTryMatch
- | AllButLetFunTryMatchSeq
- | AllButIfThen
- | AllButIfThenSeq
- | OnlyAppOrAtom
- | OnlyAtom
-
-(* This computes the intersection of a subset with the
- constraint "should not be a sequence". *)
-
-let andNotSeq = function
- | All
- | AllButSeq ->
- AllButSeq
- | AllButFunTryMatch
- | AllButFunTryMatchSeq ->
- AllButFunTryMatchSeq
- | AllButLetFunTryMatch
- | AllButLetFunTryMatchSeq ->
- AllButLetFunTryMatchSeq
- | AllButIfThen
- | AllButIfThenSeq ->
- AllButIfThenSeq
- | OnlyAppOrAtom ->
- OnlyAppOrAtom
- | OnlyAtom ->
- OnlyAtom
-
-(* This defines the semantics of subsets by relating
- expressions with subsets. *)
-
-let rec member e k =
- match e with
- | EComment _
- | EPatComment _ ->
- true
- | EFun _
- | ETry _
- | EMatch _ ->
- begin
- match k with
- | AllButFunTryMatch
- | AllButFunTryMatchSeq
- | AllButLetFunTryMatch
- | AllButLetFunTryMatchSeq
- | OnlyAppOrAtom
- | OnlyAtom ->
- false
- | _ ->
- true
- end
- | ELet ([], e) ->
- member e k
- | ELet ((PUnit, _) :: _, _) ->
- begin
- match k with
- | AllButSeq
- | AllButFunTryMatchSeq
- | AllButLetFunTryMatchSeq
- | AllButIfThenSeq
- | OnlyAppOrAtom
- | OnlyAtom ->
- false
- | _ ->
- true
- end
- | ELet (_ :: _, _) ->
- begin
- match k with
- | AllButLetFunTryMatch
- | AllButLetFunTryMatchSeq
- | OnlyAppOrAtom
- | OnlyAtom ->
- false
- | _ ->
- true
- end
- | EIfThen _ ->
- begin
- match k with
- | AllButIfThen
- | AllButIfThenSeq
- | OnlyAppOrAtom
- | OnlyAtom ->
- false
- | _ ->
- true
- end
- | EApp (_, _ :: _)
- | EData (_, _ :: _)
- | EMagic _
- | ERepr _
- | ERaise _ ->
- begin
- match k with
- | OnlyAtom ->
- false
- | _ ->
- true
- end
- | ERecordWrite _
- | EIfThenElse _ ->
- begin
- match k with
- | OnlyAppOrAtom
- | OnlyAtom ->
- false
- | _ ->
- true
- end
- | EVar _
- | ETextual _
- | EApp (_, [])
- | EData (_, [])
- | ETuple _
- | EAnnot _
- | ERecord _
- | ERecordAccess (_, _)
- | EIntConst _
- | EStringConst _
- | EUnit
- | EArray _
- | EArrayAccess (_, _) ->
- true
-
-
-let rec exprlet k pes f e2 =
- match pes with
- | [] ->
- exprk k f e2
- | (PUnit, e1) :: pes ->
- fprintf f "%a%t%a" (exprk AllButLetFunTryMatch) e1 seminl (exprlet k pes) e2
- | (PVar id1, EAnnot (e1, ts1)) :: pes ->
- (* TEMPORARY current ocaml does not support type schemes here; drop quantifiers, if any *)
- fprintf f "let %s : %a = %a in%t%a" id1 typ ts1.body (* scheme ts1 *) expr e1 nl (exprlet k pes) e2
- | (PVar id1, EFun (ps1, e1)) :: pes ->
- fprintf f "let %s%a = %a in%t%t%a"
- id1 (list pat0 space) ps1 (indent 2 expr) e1 nl nl (exprlet k pes) e2
- | (p1, (ELet _ as e1)) :: pes ->
- fprintf f "let %a =%a%tin%t%a" pat p1 (indent 2 expr) e1 nl nl (exprlet k pes) e2
- | (p1, e1) :: pes ->
- fprintf f "let %a = %a in%t%a" pat p1 expr e1 nl (exprlet k pes) e2
-
-and atom f e =
- exprk OnlyAtom f e
-
-and app f e =
- exprk OnlyAppOrAtom f e
-
-and expr f e =
- exprk All f e
-
-and exprk k f e =
- if member e k then
- match e with
- | EComment (c, e) ->
- if Settings.comment then
- fprintf f "(* %s *)%t%a" c nl (exprk k) e
- else
- exprk k f e
- | EPatComment (s, p, e) ->
- if Settings.comment then
- fprintf f "(* %s%a *)%t%a" s pat p nl (exprk k) e
- else
- exprk k f e
- | ELet (pes, e2) ->
- exprlet k pes f e2
- | ERecordWrite (e1, field, e2) ->
- fprintf f "%a.%s <- %a" atom e1 field (exprk (andNotSeq k)) e2
- | EMatch (e, []) ->
- assert false
- | EMatch (e, brs) ->
- fprintf f "match %a with%a" expr e (branches k) brs
- | ETry (_, []) ->
- assert false
- | ETry (e, brs) ->
- fprintf f "try%a%twith%a" (indent 2 expr) e nl (branches k) brs
- | EIfThen (e1, e2) ->
- fprintf f "if %a then%a" expr e1 (indent 2 (exprk (andNotSeq k))) e2
- | EIfThenElse (e0, e1, e2) ->
- fprintf f "if %a then%a%telse%a"
- expr e0 (indent 2 (exprk AllButIfThenSeq)) e1 nl (indent 2 (exprk (andNotSeq k))) e2
- | EFun (ps, e) ->
- fprintf f "fun%a ->%a" (list pat0 space) ps (indent 2 (exprk k)) e
- | EApp (EVar op, [ e1; e2 ])
- when op.[0] = '(' && op.[String.length op - 1] = ')' ->
- let op = String.sub op 1 (String.length op - 2) in
- fprintf f "%a %s %a" app e1 op app e2
- | EApp (e, args) ->
- fprintf f "%a%a" app e (list atom space) args
- | ERaise e ->
- fprintf f "raise %a" atom e
- | EMagic e ->
- fprintf f "Obj.magic %a" atom e
- | ERepr e ->
- fprintf f "Obj.repr %a" atom e
- | EData (d, []) ->
- var f d
- | EData (d, [ arg ]) ->
- fprintf f "%s %a" d atom arg
- | EData (d, arg :: args) ->
- fprintf f "%s (%a%a)" d app arg (list app comma) args
- | EVar v ->
- var f v
- | ETextual action ->
- stretch (X.raw_stretch_action) f action
- | EUnit ->
- fprintf f "()"
- | EIntConst k ->
- if k >= 0 then
- fprintf f "%d" k
- else
- fprintf f "(%d)" k
- | EStringConst s ->
- fprintf f "\"%s\"" (String.escaped s)
- | ETuple [] ->
- assert false
- | ETuple [ e ] ->
- atom f e
- | ETuple (e :: es) ->
- fprintf f "(%a%a)" app e (list app comma) es
- | EAnnot (e, s) ->
- (* TEMPORARY current ocaml does not support type schemes here; drop quantifiers, if any *)
- fprintf f "(%a : %a)" app e typ s.body (* should be scheme s *)
- | ERecordAccess (e, field) ->
- fprintf f "%a.%s" atom e field
- | ERecord fs ->
- fprintf f "{%a}" (indent 2 (list field nothing)) fs
- | EArray fs ->
- fprintf f "[|%a|]" (indent 2 (list array_field nothing)) fs
- | EArrayAccess (e, i) ->
- fprintf f "%a.(%a)" atom e expr i
- else
- fprintf f "(%a)" expr e
-
-and stretch raw f stretch =
- let content = stretch.Stretch.stretch_content
- and raw_content = stretch.Stretch.stretch_raw_content in
- match X.locate_stretches with
- | Some basename ->
- sharp f stretch.Stretch.stretch_linenum stretch.Stretch.stretch_filename;
- output_string f content;
- line := !line + stretch.Stretch.stretch_linecount;
- sharp f (!line + 2) basename;
- output f whitespace 0 !indentation
- | None ->
- output_string f (if raw then raw_content else content)
-
-and branches k f = function
- | [] ->
- ()
- | [ br ] ->
- fprintf f "%t| %a" nl (branch k) br
- | br :: brs ->
- fprintf f "%t| %a%a" nl (branch AllButFunTryMatch) br (branches k) brs
-
-and branch k f br =
- fprintf f "%a ->%a" pat br.branchpat (indent 4 (exprk k)) br.branchbody
-
-and field f (label, e) =
- fprintf f "%s = %a%t" label app e seminl
-
-and fpats f fps =
- list fpat nothing f fps
-
-and fpat f = function
- | (_, PWildcard) ->
- () (* in a record pattern, fields can be omitted *)
- | (label, p) ->
- fprintf f "%s = %a%t" label pat p seminl
-
-and array_field f e =
- fprintf f "%a%t" app e seminl
-
-and pat0 f = function
- | PUnit ->
- fprintf f "()"
- | PWildcard ->
- fprintf f "_"
- | PVar x ->
- var f x
- | PData (d, []) ->
- var f d
- | PTuple [] ->
- assert false
- | PTuple [ p ] ->
- pat0 f p
- | PTuple (p :: ps) ->
- fprintf f "(%a%a)" pat1 p (list pat1 comma) ps
- | PAnnot (p, t) ->
- fprintf f "(%a : %a)" pat p typ t
- | PRecord fps ->
- fprintf f "{%a}" (indent 2 fpats) fps
- | p ->
- fprintf f "(%a)" pat p
-
-and pat1 f = function
- | PData (d, [ arg ]) ->
- fprintf f "%s %a" d pat0 arg
- | PData (d, arg :: args) ->
- fprintf f "%s (%a%a)" d pat1 arg (list pat1 comma) args
- | PTuple [ p ] ->
- pat1 f p
- | p ->
- pat0 f p
-
-and pat2 f = function
- | POr [] ->
- assert false
- | POr (p :: ps) ->
- fprintf f "%a%a" pat2 p (list pat2 bar) ps
- | PTuple [ p ] ->
- pat2 f p
- | p ->
- pat1 f p
-
-and pat f p =
- pat2 f p
-
-and typevar f v =
- fprintf f "'%s" v
-
-and typ0 f = function
- | TypTextual (Stretch.Declared ocamltype) ->
- (* Parentheses are necessary to avoid confusion between 1 - ary
- data constructor with n arguments and n - ary data constructor. *)
- fprintf f "(%a)" (stretch true) ocamltype
- | TypTextual (Stretch.Inferred t) ->
- line := !line + LineCount.count 0 (Lexing.from_string t);
- fprintf f "(%s)" t
- | TypVar v ->
- typevar f v
- | TypApp (t, params) ->
- fprintf f "%a%s" (typeparams typ0 typ) params t
- | t ->
- fprintf f "(%a)" typ t
-
-and typ1 f = function
- | TypTuple [] ->
- assert false
- | TypTuple [ t ] ->
- typ1 f t
- | TypTuple (t :: ts) ->
- fprintf f "%a%a" typ0 t (list typ0 times) ts
- | t ->
- typ0 f t
-
-and typ2 f = function
- | TypArrow (t1, t2) ->
- fprintf f "%a -> %a" typ1 t1 typ2 t2
- | t ->
- typ1 f t
-
-and typ f =
- typ2 f
-
-and scheme f scheme =
- match scheme.quantifiers with
- | [] ->
- typ f scheme.body
- | qs ->
- fprintf f "%a. %a" (list typevar space) qs typ scheme.body
-
-(* ------------------------------------------------------------------------- *)
-(* Toplevel definition printer. *)
-
-let datavalparams f = function
- | [] ->
- ()
- | valparam :: valparams ->
- fprintf f " of %a%a" typ valparam (list typ times) valparams
-
-let datatypeparams f = function
- | None ->
- ()
- | Some typs ->
- fprintf f "(* %a*)" (list typ space) typs (* TEMPORARY not great *)
-
-let datadef f def =
- fprintf f " | %s%a%a" def.dataname datavalparams def.datavalparams datatypeparams def.datatypeparams
-
-let fielddef f def =
- fprintf f " %s%s: %a"
- (if def.modifiable then "mutable " else "")
- def.fieldname
- scheme def.fieldtype
-
-let typerhs f = function
- | TDefRecord [] ->
- assert false
- | TDefRecord (field :: fields) ->
- fprintf f " = {%t%a%a%t}" nl fielddef field (list fielddef seminl) fields nl
- | TDefSum [] ->
- ()
- | TDefSum defs ->
- fprintf f " = %a" (list datadef nl) defs
- | TAbbrev t ->
- fprintf f " = %a" typ t
-
-let typeconstraint f = function
- | None ->
- ()
- | Some (t1, t2) ->
- fprintf f "%tconstraint %a = %a" nl typ t1 typ t2
-
-let typedef f def =
- fprintf f "%a%s%a%a%t%t"
- (typeparams typevar typevar) def.typeparams
- def.typename
- typerhs def.typerhs
- typeconstraint def.typeconstraint
- nl nl
-
-let rec pdefs pdef sep1 sep2 f = function
- | [] ->
- ()
- | def :: defs ->
- fprintf f "%t%a%a" sep1 pdef def (pdefs pdef sep2 sep2) defs
-
-let valdef f = function
- | { valpat = PVar id; valval = EAnnot (e, ts) } ->
- (* TEMPORARY current ocaml does not support type schemes here; drop quantifiers, if any *)
- fprintf f "%s : %a =%a%t%t" id typ ts.body (* scheme ts *) (indent 2 expr) e nl nl
- | { valpat = p; valval = e } ->
- fprintf f "%a =%a%t%t" pat p (indent 2 expr) e nl nl
-
-let valdefs =
- pdefs valdef letrec et
-
-let nonrecvaldefs =
- pdefs valdef letnonrec letnonrec
-
-let typedefs =
- pdefs typedef keytyp et
-
-let directive f = function
- | DirOpen s ->
- fprintf f "open %s%t%t" s nl nl
- | DirInclude s ->
- fprintf f "include %s%t%t" s nl nl
-
-let directives =
- pdefs directive nothing nothing
-
-let excdef f def =
- match def.exceq with
- | None ->
- fprintf f "%s%t%t" def.excname nl nl
- | Some s ->
- fprintf f "%s = %s%t%t" def.excname s nl nl
-
-let excdefs =
- pdefs excdef exc exc
-
-let functorparams intf body b f params =
- match params with
- | [] ->
- fprintf f "%a%!" body b
- | _ ->
- fprintf f "module Make%a%t%s%t%a%t%tend%t%!"
- (list (stretch false) nl) params
- nl (if intf then ": sig" else "= struct") nl
- (indent 2 body) b
- nl nl nl
-
-let structure f p =
- fprintf f "struct%aend" (
- indent 2 (fun f p ->
- fprintf f "%t%a%a%a"
- nl
- excdefs p.struct_excdefs
- typedefs p.struct_typedefs
- nonrecvaldefs p.struct_nonrecvaldefs
- )
- ) p
-
-
-let rec modexpr f = function
- | MVar x ->
- fprintf f "%s" x
- | MStruct s ->
- structure f s
- | MApp (e1, e2) ->
- fprintf f "%a (%a)" modexpr e1 modexpr e2
-
-let moduledef f d =
- fprintf f "module %s = %a%t%t" d.modulename modexpr d.modulerhs nl nl
-
-let program f p =
- fprintf f "%a%a"
- excdefs p.excdefs
- typedefs p.typedefs;
- List.iter (stretch false f) p.prologue;
- fprintf f "%a%a%a"
- nonrecvaldefs p.nonrecvaldefs
- (list moduledef nothing) p.moduledefs
- valdefs p.valdefs;
- List.iter (output_string f) p.postlogue
-
-let valdecl f (x, ts) =
- fprintf f "val %s: %a" x typ ts.body
-
-let interface f i =
- fprintf f "%a%a%a%!" excdefs i.excdecls typedefs i.typedecls (list valdecl nl) i.valdecls
-
-let program p =
- functorparams false program p X.f p.paramdefs
-
-let interface i =
- functorparams true interface i X.f i.paramdecls
-
-let expr e =
- expr X.f e
-
-end
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* A pretty-printer for [IL]. *)
-
-module Make (X : sig
-
- (* This is the channel that is being written to. *)
-
- val f: out_channel
-
- (* If [raw_stretch_action] is set, then we print the semantic actions
- as they are found into the original source code. *)
- val raw_stretch_action: bool
-
- (* This controls the way we print Objective Caml stretches (types and
- semantic actions). We either surround them with #line directives
- (for better error reports if the generated code is ill-typed) or
- don't (for better readability). The value is either [None] -- do
- not provide #line directives -- or [Some filename] -- do provide
- them. [filename] is the name of the file that is being written. *)
-
- val locate_stretches: string option
-
-end) : sig
-
- val program: IL.program -> unit
-
- val expr: IL.expr -> unit
-
- val interface: IL.interface -> unit
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* A debugging pretty-printer for [IL]. Newlines are used liberally, so as to
- facilitate diffs. *)
-
-open IL
-open Printf
-
-module Make (X : sig
-
- (* This is the channel that is being written to. *)
-
- val f: out_channel
-
-end) = struct
-
-(* ------------------------------------------------------------------------- *)
-(* XML-style trees. *)
-
-type tree =
- | Node of string * tree list
-
-let node label ts =
- Node (label, ts)
-
-(* ------------------------------------------------------------------------- *)
-(* Dealing with newlines and indentation. *)
-
-let maxindent =
- 120
-
-let whitespace =
- String.make maxindent ' '
-
-let indentation =
- ref 0
-
-let line =
- ref 1
-
-(* [rawnl] is, in principle, the only place where writing a newline
- character to the output channel is permitted. This ensures that the
- line counter remains correct. But see also [stretch] and [typ0]. *)
-
-let rawnl f =
- incr line;
- output_char f '\n'
-
-let nl f =
- rawnl f;
- output f whitespace 0 !indentation
-
-let indent ofs producer f x =
- let old_indentation = !indentation in
- let new_indentation = old_indentation + ofs in
- if new_indentation <= maxindent then
- indentation := new_indentation;
- nl f;
- producer f x;
- indentation := old_indentation
-
-(* ------------------------------------------------------------------------- *)
-(* Tree printers. *)
-
-let rec print_tree f = function
- | Node (label, []) ->
- output_char f '<';
- output_string f label;
- output_char f '/';
- output_char f '>';
- nl f
- | Node (label, ts) ->
- output_char f '<';
- output_string f label;
- output_char f '>';
- indent 2 print_trees f ts;
- output_char f '<';
- output_char f '/';
- output_string f label;
- output_char f '>';
- nl f
-
-and print_trees f = function
- | [] ->
- ()
- | t :: ts ->
- print_tree f t;
- print_trees f ts
-
-(* ------------------------------------------------------------------------- *)
-(* Expression-to-tree converter. *)
-
-let rec expr e =
- match e with
- | EComment (c, e) ->
- node "comment" [ string c; expr e ]
- | EPatComment (s, p, e) ->
- node "patcomment" [ string s; pat p; expr e ]
- | ELet (pes, e2) ->
- node "let" ( patexprs pes @ [ expr e2 ])
- | ERecordWrite (e1, field, e2) ->
- node "recordwrite" [ expr e1; string field; expr e2 ]
- | EMatch (e, brs) ->
- node "match" ( expr e :: branches brs )
- | ETry (e, brs) ->
- node "try" ( expr e :: branches brs )
- | EIfThen (e1, e2) ->
- node "ifthen" [ expr e1; expr e2 ]
- | EIfThenElse (e0, e1, e2) ->
- node "ifthenelse" [ expr e0; expr e1; expr e2 ]
- | EFun (ps, e) ->
- node "fun" ( pats ps @ [ expr e ])
- | EApp (e, args) ->
- node "app" ( expr e :: exprs args )
- | ERaise e ->
- node "raise" [ expr e ]
- | EMagic e ->
- node "magic" [ expr e ]
- | ERepr e ->
- node "repr" [ expr e ]
- | EData (d, args) ->
- node "data" ( string d :: exprs args )
- | EVar v ->
- node "var" [ string v ]
- | ETextual action ->
- node "text" [ stretch action ]
- | EUnit ->
- node "unit" []
- | EIntConst k ->
- node "int" [ int k ]
- | EStringConst s ->
- node "string" [ string s ]
- | ETuple es ->
- node "tuple" ( exprs es )
- | EAnnot (e, s) ->
- node "annot" [ expr e; scheme s ]
- | ERecordAccess (e, field) ->
- node "recordaccess" [ expr e; string field ]
- | ERecord fs ->
- node "record" (fields fs)
- | EArray fs ->
- node "array" (exprs fs)
- | EArrayAccess (e1, e2) ->
- node "arrayaccess" [ expr e1; expr e2 ]
-
-and exprs es =
- List.map expr es
-
-and stretch stretch =
- string stretch.Stretch.stretch_content
-
-and branches brs =
- List.map branch brs
-
-and branch br =
- node "branch" [ pat br.branchpat; expr br.branchbody ]
-
-and fields fs =
- List.map field fs
-
-and field (label, e) =
- node "field" [ string label; expr e ]
-
-and pats ps =
- List.map pat ps
-
-and pat = function
- | PUnit ->
- node "punit" []
- | PWildcard ->
- node "pwildcard" []
- | PVar x ->
- node "pvar" [ string x ]
- | PTuple ps ->
- node "ptuple" (pats ps)
- | PAnnot (p, t) ->
- node "pannot" [ pat p; typ t ]
- | PData (d, args) ->
- node "pdata" (string d :: pats args)
- | PRecord fps ->
- node "precord" (fpats fps)
- | POr ps ->
- node "por" (pats ps)
-
-and fpats fps =
- List.map fpat fps
-
-and fpat (_, p) =
- pat p
-
-and patexprs pes =
- List.map patexpr pes
-
-and patexpr (p, e) =
- node "patexpr" [ pat p; expr e ]
-
-and string s =
- node s []
-
-and int k =
- node (string_of_int k) []
-
-and bool b =
- node (if b then "true" else "false") []
-
-and scheme s =
- string "omitted" (* TEMPORARY to be completed, someday *)
-
-and typ t =
- string "omitted" (* TEMPORARY to be completed, someday *)
-
-(* ------------------------------------------------------------------------- *)
-(* Convert to a tree, then print the tree. *)
-
-let expr e =
- print_tree X.f (expr e)
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* A debugging pretty-printer for [IL]. Newlines are used liberally, so as to
- facilitate diffs. *)
-
-module Make (X : sig
-
- (* This is the channel that is being written to. *)
-
- val f: out_channel
-
-end) : sig
-
- val expr: IL.expr -> unit
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open UnparameterizedSyntax
-open Syntax
-
-let rec visit grammar visited symbol =
- try
- let rule = StringMap.find symbol grammar.rules in
- if not (StringSet.mem symbol visited) then
- let visited = StringSet.add symbol visited in
- List.fold_left (visitb grammar) visited rule.branches
- else
- visited
- with Not_found ->
- (* This is a terminal symbol. *)
- assert (symbol = "error" || StringMap.mem symbol grammar.tokens);
- visited
-
-and visitb grammar visited { producers = symbols } =
- List.fold_left (visits grammar) visited symbols
-
-and visits grammar visited (symbol, _) =
- visit grammar visited symbol
-
-let trim grammar =
- if StringSet.cardinal grammar.start_symbols = 0 then
- Error.error [] "no start symbol has been declared."
- else
- let reachable =
- StringSet.fold (fun symbol visited ->
- visit grammar visited symbol
- ) grammar.start_symbols StringSet.empty
- in
- StringMap.iter (fun symbol rule ->
- if not (StringSet.mem symbol reachable) then
- Error.grammar_warning
- rule.positions
- (Printf.sprintf
- "symbol %s is unreachable from any of the start symbol(s)."
- symbol)
- ) grammar.rules;
- { grammar with rules = StringMap.restrict reachable grammar.rules }
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This extremely simple analysis restricts a grammar to the set
- of nonterminals that are reachable, via productions, from the
- start nonterminals. *)
-
-val trim: UnparameterizedSyntax.grammar -> UnparameterizedSyntax.grammar
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This file contains experimental code that has been used in an attempt to
- explore the validation of the termination property for LR(1) automata. *)
-
-(* This code is currently unused. It could be plugged in again (at the end of
- the module [Invariant]. *)
-
-(* ------------------------------------------------------------------------ *)
-(* Build a graph of all reductions. The vertices are the states of the automaton;
- there is an edge from [s1] to [s2] if a reduction (including the goto step)
- can take us from [s1] to [s2]. Every edge is labeled with its effect on the
- size of the stack. *)
-
-(* This graph is built with respect to a fixed lookahead token [tok]. We
- consider only the reductions that are permitted with [tok] is the next
- token on the stream. *)
-
-exception NoDanger
-
-let clique_count =
- ref 0
-
-let make_reduction_graph tok =
-
- (* Build the reduction graph for this token. The main part of the work
- is to define the edges; the rest is immediate. *)
-
- let module ReductionGraph = struct
-
- type node =
- Lr1.node
-
- let n =
- Lr1.n
-
- let index =
- Lr1.number
-
- (* This auxiliary function pops [n] cells off an abstract stack. The
- parameter [states] is a set of states that we might be in before
- popping. The function returns a set of states that we might be in
- after popping. *)
-
- let rec pop_word n states w =
- if n = 0 then
- states
- else
- match w with
- | [] ->
- (* the invariant is too weak to ensure that reduction is possible! *)
- assert false
- | (_, states) :: w ->
- pop_word (n-1) states w
-
- let pop_stack n states (w, _) =
- pop_word n states w
-
- (* The following function allows listing the successors of a node. Each
- edge is labeled with an integer value that represents the decrease in
- the size of the stack. *)
-
- let successors (action : int -> node -> unit) node : unit =
- (* Find which reductions are permitted at this node. *)
- let prods =
- match has_default_reduction node with
- | Some (prod, _) ->
- [ prod ]
- | None ->
- try
- TerminalMap.find tok (Lr1.reductions node)
- with Not_found ->
- []
- in
- (* Get a description of the stack at this node. *)
- let stack = lfp node in
- (* For each production [prod], ... *)
- List.iter (fun prod ->
- (* If this is a start production, ignore it. We are not interested in
- accept actions, only in true reduce actions. *)
- match Production.classify prod with
- | Some _ ->
- ()
- | None ->
- (* Find out how many cells are popped. *)
- let decrease = Production.length prod in
- (* Find out what states we might be in after popping. *)
- let states = pop_stack decrease (Lr1.NodeSet.singleton node) stack in
- (* Now, the goto step pushes one cell... *)
- let increase = 1 in
- let net = decrease - increase in
- (* Find out which states we might be in after the goto step. *)
- let symbol = Symbol.N (Production.nt prod) in
- let goto (state : Lr1.node) : Lr1.node =
- try
- SymbolMap.find symbol (Lr1.transitions state)
- with Not_found ->
- (* the invariant is too weak to ensure that goto is possible! *)
- assert false
- in
- (* There is a transition, labelled [decrease - increase], from [node]
- to every state in the image through [goto] of the set [states]. *)
- Lr1.NodeSet.iter (fun state ->
- action net (goto state)
- ) states
- ) prods
-
- let iter =
- Lr1.iter
-
- (* The [successors] function describes a multi-graph: there might be multiple
- edges with the same source and target nodes. In that case, we would like
- to keep only one, the one with minimum weight, as this is the most dangerous
- one. Do so (naively). *)
-
- let adjacency : (int * node) list Lr1.NodeMap.t ref =
- ref Lr1.NodeMap.empty
-
- let () =
- iter (fun source ->
- (* Compute a list of outgoing edges. *)
- let edges = ref [] in
- successors (fun weight target ->
- edges := (weight, target) :: !edges;
- ) source;
- let edges =
- List.sort (fun (weight1, _) (weight2, _) -> weight1 - weight2) !edges
- in
- (* Define a predicate that accepts an edge only the first time
- its target node is seen. *)
- let seen =
- ref Lr1.NodeSet.empty
- in
- let acceptable (_, node) =
- if Lr1.NodeSet.mem node !seen then
- false
- else begin
- seen := Lr1.NodeSet.add node !seen;
- true
- end
- in
- (* Filter the list of edges. This relies on [filter] evaluating the
- predicate left-to-right. *)
- let edges = List.filter acceptable edges in
- (* Augment the table. *)
- adjacency := Lr1.NodeMap.add source edges !adjacency
- )
-
- let successors (action : int -> node -> unit) source : unit =
- let edges =
- try
- Lr1.NodeMap.find source !adjacency
- with Not_found ->
- assert false
- in
- List.iter (fun (weight, target) ->
- action weight target
- ) edges
-
- end in
-
- (* We are interested in determining whether the reduction graph contains
- simple cycles of nonpositive weight. In order to answer this question,
- it is sufficient (and more tractable) to consider each strongly connected
- component separately. *)
-
- (* Compute the strongly connected components. *)
-
- let module SCC =
- Tarjan.Run (struct
- include ReductionGraph
- (* Forget the edge labels. *)
- let successors action node =
- successors (fun _ target -> action target) node
- end)
- in
-
- (* Examine the components, one at a time. *)
-
- SCC.iter (fun representative elements ->
- match elements with
- | [] ->
- assert false
- | [ _ ] ->
- ()
- | _ ->
-
- try
-
- (* We have a non-trivial component. [representative] is its
- representative, and [elements] is the list of its elements. *)
-
- (* This auxiliary function tests whether a node is a member of
- this component. *)
-
- let member node =
- Lr1.number (SCC.representative node) = Lr1.number representative
- in
-
- (* Build a description of this component. *)
-
- let module Clique = struct
-
- type node =
- Lr1.node
-
- (* Re-index the nodes. *)
-
- let n, node_to_new_index =
- List.fold_left (fun (n, map) node ->
- n + 1, Lr1.NodeMap.add node n map
- ) (0, Lr1.NodeMap.empty) elements
-
- let index node =
- try
- Lr1.NodeMap.find node node_to_new_index
- with Not_found ->
- assert false
-
- (* Restrict the edges to only those that remain within this component. *)
-
- let successors (action : int -> node -> unit) node : unit =
- ReductionGraph.successors (fun label successor ->
- if member successor then
- action label successor
- ) node
-
- (* Restrict the vertices to only the elements of this component. *)
-
- let iter (action : node -> unit) : unit =
- List.iter action elements
-
- end in
-
- (* In the following, we perform several tests, of increasing strength and
- cost, to determine whether there is a dangerous cycle in the clique. *)
-
- (* Check whether at least one edge has nonpositive weight. If that is not
- the case, then there is clearly no dangerous cycle. *)
-
- let danger =
- ref false
- in
-
- Clique.iter (fun node ->
- Clique.successors (fun weight _ ->
- if weight <= 0 then
- danger := true
- ) node
- );
-
- if not !danger then
- raise NoDanger;
-
- (* Check whether there is at least one edge of negative weight. If not,
- look for a non-trivial strongly connected component among the edges
- of zero weight. *)
-
- let negative =
- ref false
- in
-
- Clique.iter (fun node ->
- Clique.successors (fun weight _ ->
- if weight < 0 then
- negative := true
- ) node
- );
-
- if not !negative then begin
- let module ZeroWeight = struct
- include Clique
- let successors action source =
- successors (fun weight target ->
- if weight = 0 then
- action target
- ) source
- end in
- let module ZeroWeightSCC =
- Tarjan.Run (ZeroWeight)
- in
- danger := false;
- ZeroWeightSCC.iter (fun _ elements ->
- if List.length elements > 1 then
- danger := true
- )
- end;
-
- if not !danger then
- raise NoDanger;
-
- (* Use Floyd and Warshall's algorithm to determine if there is a dangerous
- cycle. *)
-
- let module NC =
- NonpositiveCycles.Run(Clique)
- in
-
- if not NC.graph_has_nonpositive_simple_cycle then
- raise NoDanger;
-
- (* If there might be danger, then print this clique for manual examination. *)
-
- let module PrintableClique = struct
-
- include Clique
-
- type vertex =
- node
-
- let name node =
- Printf.sprintf "s%d" (Lr1.number node)
-
- let successors (action: ?style:Dot.style -> label:string -> vertex -> unit) node : unit =
- successors (fun label successor ->
- action ~label:(string_of_int label) successor
- ) node
-
- let iter (action: ?style:Dot.style -> label:string -> vertex -> unit) : unit =
- iter (fun node ->
- action ~label:(name node) node
- )
-
- end in
-
- let filename =
- Printf.sprintf "%s.%d.dot"
- (Terminal.print tok)
- (Misc.postincrement clique_count)
- in
- let c = open_out filename in
- let module P = Dot.Print(PrintableClique) in
- P.print ~orientation:Dot.Portrait ~size:(8.,5.) c;
- close_out c
-
- with NoDanger ->
- ()
-
- )
-
-let () =
- (* The graphs are built, and printed to .dot files, only if requested by
- the user via [--make-reduction-graphs]. The reduction graphs are not
- used by Menhir itself. *)
- if Settings.make_reduction_graphs then begin
- Terminal.iter make_reduction_graph;
- Printf.fprintf stderr "Constructed %d potentially interesting reduction cliques.\n" !clique_count
- end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-open Cst
-
-(* Set up all of the information required by the LR engine. Everything is
- read directly from [Grammar] and [Lr1]. *)
-
-module T = struct
-
- type state =
- Lr1.node
-
- type token =
- Terminal.t
-
- type terminal =
- Terminal.t
-
- type semantic_value =
- cst
-
- let token2terminal (token : token) : terminal =
- token
-
- let token2value (token : token) : semantic_value =
- CstTerminal token
-
- let error_terminal =
- Terminal.error
-
- let error_value =
- CstError
-
- type production =
- Production.index
-
- let default_reduction (s : state) defred nodefred env =
- match Invariant.has_default_reduction s with
- | Some (prod, _) ->
- defred env prod
- | None ->
- nodefred env
-
- let action (s : state) (tok : terminal) value shift reduce fail env =
-
- (* Check whether [s] has an outgoing shift transition along [tok]. *)
-
- try
-
- let s' : state = SymbolMap.find (Symbol.T tok) (Lr1.transitions s) in
-
- (* There is such a transition. Return either [ShiftDiscard] or
- [ShiftNoDiscard], depending on the existence of a default
- reduction on [#] at [s']. *)
-
- match Invariant.has_default_reduction s' with
- | Some (_, toks) when TerminalSet.mem Terminal.sharp toks ->
- shift env false tok value s'
- | _ ->
- shift env true tok value s'
-
- (* There is no such transition. Look for a reduction. *)
-
- with Not_found ->
- try
-
- let prod = Misc.single (TerminalMap.find tok (Lr1.reductions s)) in
- reduce env prod
-
- (* There is no reduction either. Fail. *)
-
- with Not_found ->
- fail env
-
- let goto (s : state) (prod : production) : state =
- try
- SymbolMap.find (Symbol.N (Production.nt prod)) (Lr1.transitions s)
- with Not_found ->
- assert false
-
- open MenhirLib.EngineTypes
-
- exception Accept of semantic_value
- exception Error
-
- type semantic_action =
- (state, semantic_value, token) env -> unit
-
- let semantic_action (prod : production) : semantic_action =
- fun env ->
-
- (* Check whether [prod] is a start production. *)
-
- match Production.classify prod with
-
- (* If it is one, accept. Start productions are of the form S' ->
- S, where S is a non-terminal symbol, so the desired semantic
- value is found within the top cell of the stack. *)
-
- | Some _ ->
- raise (Accept env.stack.semv)
-
- (* If it is not, reduce. Pop a suffix of the stack, and use it
- to construct a new concrete syntax tree node. *)
-
- | None ->
-
- let n = Production.length prod in
- let values : semantic_value array =
- Array.make n CstError (* dummy *)
- and startp : Lexing.position ref =
- ref Lexing.dummy_pos
- and endp : Lexing.position ref =
- ref Lexing.dummy_pos
- in
-
- (* The auxiliary function [pop k stack] pops [k] stack cells
- and returns a truncated stack. It also updates the automaton's
- current state, and fills in [values], [startp], and [endp]. *)
-
- let rec pop k stack =
-
- if k = 0 then
-
- (* There are no more stack cells to pop. *)
-
- stack
-
- else begin
-
- (* Fetch a semantic value. *)
-
- values.(k - 1) <- stack.semv;
-
- (* Pop one cell. The stack must be non-empty. As we pop a cell,
- change the automaton's current state to the one stored within
- the cell. (It is sufficient to do this only when [k] is 1.)
- If this is the first (last) cell that we pop, update [endp]
- ([startp]). *)
-
- let next = stack.next in
- assert (stack != next);
- if k = n then begin
- endp := stack.endp
- end;
- if k = 1 then begin
- env.current <- stack.state;
- startp := stack.startp
- end;
- pop (k - 1) next
-
- end
-
- in
- let stack = pop n env.stack in
-
- (* Construct and push a new stack cell. The associated semantic
- value is a new concrete syntax tree. *)
-
- env.stack <- {
- state = env.current;
- semv = CstNonTerminal (prod, values);
- startp = !startp;
- endp = !endp;
- next = stack
- }
-
- (* The reference interpreter performs error recovery if and only if this
- is requested via [--recovery]. *)
-
- let recovery =
- Settings.recovery
-
- module Log = struct
-
- open Printf
-
- (* I use a reference as a quick and dirty form of parameter passing. *)
-
- let log =
- ref false
-
- let maybe action =
- if !log then begin
- action();
- prerr_newline()
- end
-
- let state s =
- maybe (fun () ->
- fprintf stderr "State %d:" (Lr1.number s)
- )
-
- let shift tok s' =
- maybe (fun () ->
- fprintf stderr "Shifting (%s) to state %d" (Terminal.print tok) (Lr1.number s')
- )
-
- let reduce_or_accept prod =
- maybe (fun () ->
- match Production.classify prod with
- | Some _ ->
- fprintf stderr "Accepting"
- | None ->
- fprintf stderr "Reducing production %s" (Production.print prod)
- )
-
- let lookahead_token lexbuf tok =
- maybe (fun () ->
- fprintf stderr "Lookahead token is now %s (%d-%d)"
- (Terminal.print tok)
- lexbuf.Lexing.lex_start_p.Lexing.pos_cnum
- lexbuf.Lexing.lex_curr_p.Lexing.pos_cnum
- )
-
- let initiating_error_handling () =
- maybe (fun () ->
- fprintf stderr "Initiating error handling"
- )
-
- let resuming_error_handling () =
- maybe (fun () ->
- fprintf stderr "Resuming error handling"
- )
-
- let handling_error s =
- maybe (fun () ->
- fprintf stderr "Handling error in state %d" (Lr1.number s)
- )
-
- let discarding_last_token tok =
- maybe (fun () ->
- fprintf stderr "Discarding last token read (%s)" (Terminal.print tok)
- )
-
- end
-
-end
-
-(* Instantiate the LR engine with this information. *)
-
-module E =
- MenhirLib.Engine.Make (T)
-
-(* Define a palatable user entry point. *)
-
-let interpret log nt lexer lexbuf =
-
- (* Find the start state that corresponds to [nt] in the automaton. *)
-
- let s : Lr1.node =
- try
- ProductionMap.find (Production.startsymbol2startprod nt) Lr1.entry
- with Not_found ->
- assert false
- in
-
- (* Run the engine. *)
-
- try
- T.Log.log := log;
- Some (E.entry s lexer lexbuf)
- with T.Error ->
- None
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Grammar
-open Cst
-
-(* This reference interpreter animates the LR automaton. It uses the
- grammar and automaton descriptions, as provided by [Grammar] and
- [Lr1], as well as the generic LR engine in [MenhirLib.Engine]. *)
-
-(* The first parameter to the interpreter is a Boolean flag that tells
- whether a trace should be produced on the standard error channel. *)
-
-(* The interpreter requires a start symbol, a lexer, and a lexing
- buffer. It either succeeds and produces a concrete syntax tree, or
- fails. *)
-
-val interpret:
- bool ->
- Nonterminal.t ->
- (Lexing.lexbuf -> Terminal.t) ->
- Lexing.lexbuf ->
- cst option
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module compresses a two-dimensional table, where some values
- are considered insignificant, via row displacement. *)
-
-(* This idea reportedly appears in Aho and Ullman's ``Principles
- of Compiler Design'' (1977). It is evaluated in Tarjan and Yao's
- ``Storing a Sparse Table'' (1979) and in Dencker, Dürre, and Heuft's
- ``Optimization of Parser Tables for Portable Compilers'' (1984). *)
-
-(* A compressed table is represented as a pair of arrays. The
- displacement array is an array of offsets into the data array. *)
-
-type 'a table =
- int array * (* displacement *)
- 'a array (* data *)
-
-(* In a natural version of this algorithm, displacements would be greater
- than (or equal to) [-n]. However, in the particular setting of Menhir,
- both arrays are intended to be compressed with [PackedIntArray], which
- does not efficiently support negative numbers. For this reason, we are
- careful not to produce negative displacements. *)
-
-(* In order to avoid producing negative displacements, we simply use the
- least significant bit as the sign bit. This is implemented by [encode]
- and [decode] below. *)
-
-(* One could also think, say, of adding [n] to every displacement, so as
- to ensure that all displacements are nonnegative. This would work, but
- would require [n] to be published, for use by the decoder. *)
-
-let encode (displacement : int) : int =
- if displacement >= 0 then
- displacement lsl 1
- else
- (-displacement) lsl 1 + 1
-
-let decode (displacement : int) : int =
- if displacement land 1 = 0 then
- displacement lsr 1
- else
- -(displacement lsr 1)
-
-(* It is reasonable to assume that, as matrices grow large, their
- density becomes low, i.e., they have many insignificant entries.
- As a result, it is important to work with a sparse data structure
- for rows. We internally represent a row as a list of its
- significant entries, where each entry is a pair of a [j] index and
- an element. *)
-
-type 'a row =
- (int * 'a) list
-
-(* [compress equal insignificant dummy m n t] turns the two-dimensional table
- [t] into a compressed table. The parameter [equal] is equality of data
- values. The parameter [wildcard] tells which data values are insignificant,
- and can thus be overwritten with other values. The parameter [dummy] is
- used to fill holes in the data array. [m] and [n] are the integer
- dimensions of the table [t]. *)
-
-let compress
- (equal : 'a -> 'a -> bool)
- (insignificant : 'a -> bool)
- (dummy : 'a)
- (m : int) (n : int)
- (t : 'a array array)
- : 'a table =
-
- (* Be defensive. *)
-
- assert (Array.length t = m);
- assert begin
- for i = 0 to m - 1 do
- assert (Array.length t.(i) = n)
- done;
- true
- end;
-
- (* This turns a row-as-array into a row-as-sparse-list. *)
-
- let sparse (line : 'a array) : 'a row =
-
- let rec loop (j : int) (row : 'a row) =
- if j < 0 then
- row
- else
- let x = line.(j) in
- loop
- (j - 1)
- (if insignificant x then row else (j, x) :: row)
- in
-
- loop (n - 1) []
-
- in
-
- (* Define the rank of a row as its number of significant entries. *)
-
- let rank (row : 'a row) : int =
- List.length row
- in
-
- (* Construct a list of all rows, together with their index and rank. *)
-
- let rows : (int * int * 'a row) list = (* index, rank, row *)
- Array.to_list (
- Array.mapi (fun i line ->
- let row = sparse line in
- i, rank row, row
- ) t
- )
- in
-
- (* Sort this list by decreasing rank. This does not have any impact
- on correctness, but reportedly improves compression. The
- intuitive idea is that rows with few significant elements are
- easy to fit, so they should be inserted last, after the problem
- has become quite constrained by fitting the heavier rows. This
- heuristic is attributed to Ziegler. *)
-
- let rows =
- List.sort (fun (_, rank1, _) (_, rank2, _) ->
- compare rank2 rank1
- ) rows
- in
-
- (* Allocate a one-dimensional array of displacements. *)
-
- let displacement : int array =
- Array.make m 0
- in
-
- (* Allocate a one-dimensional, infinite array of values. Indices
- into this array are written [k]. *)
-
- let data : 'a InfiniteArray.t =
- InfiniteArray.make dummy
- in
-
- (* Determine whether [row] fits at offset [k] within the current [data]
- array, up to extension of this array. *)
-
- (* Note that this check always succeeds when [k] equals the length of
- the [data] array. Indeed, the loop is then skipped. This property
- guarantees the termination of the recursive function [fit] below. *)
-
- let fits k (row : 'a row) : bool =
-
- let d = InfiniteArray.extent data in
-
- let rec loop = function
- | [] ->
- true
- | (j, x) :: row ->
-
- (* [x] is a significant element. *)
-
- (* By hypothesis, [k + j] is nonnegative. If it is greater than or
- equal to the current length of the data array, stop -- the row
- fits. *)
-
- assert (k + j >= 0);
-
- if k + j >= d then
- true
-
- (* We now know that [k + j] is within bounds of the data
- array. Check whether it is compatible with the element [y] found
- there. If it is, continue. If it isn't, stop -- the row does not
- fit. *)
-
- else
- let y = InfiniteArray.get data (k + j) in
- if insignificant y || equal x y then
- loop row
- else
- false
-
- in
- loop row
-
- in
-
- (* Find the leftmost position where a row fits. *)
-
- (* If the leftmost significant element in this row is at offset [j],
- then we can hope to fit as far left as [-j] -- so this element
- lands at offset [0] in the data array. *)
-
- (* Note that displacements may be negative. This means that, for
- insignificant elements, accesses to the data array could fail: they could
- be out of bounds, either towards the left or towards the right. This is
- not a problem, as long as [get] is invoked only at significant
- elements. *)
-
- let rec fit k row : int =
- if fits k row then
- k
- else
- fit (k + 1) row
- in
-
- let fit row =
- match row with
- | [] ->
- 0 (* irrelevant *)
- | (j, _) :: _ ->
- fit (-j) row
- in
-
- (* Write [row] at (compatible) offset [k]. *)
-
- let rec write k = function
- | [] ->
- ()
- | (j, x) :: row ->
- InfiniteArray.set data (k + j) x;
- write k row
- in
-
- (* Iterate over the sorted list of rows. Fit and write each row at
- the leftmost compatible offset. Update the displacement table. *)
-
- let () =
- List.iter (fun (i, _, row) ->
- let k = fit row in (* if [row] has leading insignificant elements, then [k] can be negative *)
- write k row;
- displacement.(i) <- encode k
- ) rows
- in
-
- (* Return the compressed tables. *)
-
- displacement, InfiniteArray.domain data
-
-(* [get ct i j] returns the value found at indices [i] and [j] in the
- compressed table [ct]. This function call is permitted only if the
- value found at indices [i] and [j] in the original table is
- significant -- otherwise, it could fail abruptly. *)
-
-(* Together, [compress] and [get] have the property that, if the value
- found at indices [i] and [j] in an uncompressed table [t] is
- significant, then [get (compress t) i j] is equal to that value. *)
-
-let get (displacement, data) i j =
- assert (0 <= i && i < Array.length displacement);
- let k = decode displacement.(i) in
- assert (0 <= k + j && k + j < Array.length data);
- (* failure of this assertion indicates an attempt to access an
- insignificant element that happens to be mapped out of the bounds
- of the [data] array. *)
- data.(k + j)
-
-(* [getget] is a variant of [get] which only requires read access,
- via accessors, to the two components of the table. *)
-
-let getget get_displacement get_data (displacement, data) i j =
- let k = decode (get_displacement displacement i) in
- get_data data (k + j)
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module compresses a two-dimensional table, where some values
- are considered insignificant, via row displacement. *)
-
-(* A compressed table is represented as a pair of arrays. The
- displacement array is an array of offsets into the data array. *)
-
-type 'a table =
- int array * (* displacement *)
- 'a array (* data *)
-
-(* [compress equal insignificant dummy m n t] turns the two-dimensional table
- [t] into a compressed table. The parameter [equal] is equality of data
- values. The parameter [wildcard] tells which data values are insignificant,
- and can thus be overwritten with other values. The parameter [dummy] is
- used to fill holes in the data array. [m] and [n] are the integer
- dimensions of the table [t]. *)
-
-val compress:
- ('a -> 'a -> bool) ->
- ('a -> bool) ->
- 'a ->
- int -> int ->
- 'a array array ->
- 'a table
-
-(* [get ct i j] returns the value found at indices [i] and [j] in the
- compressed table [ct]. This function call is permitted only if the
- value found at indices [i] and [j] in the original table is
- significant -- otherwise, it could fail abruptly. *)
-
-(* Together, [compress] and [get] have the property that, if the value
- found at indices [i] and [j] in an uncompressed table [t] is
- significant, then [get (compress t) i j] is equal to that value. *)
-
-val get:
- 'a table ->
- int -> int ->
- 'a
-
-(* [getget] is a variant of [get] which only requires read access,
- via accessors, to the two components of the table. *)
-
-val getget:
- ('displacement -> int -> int) ->
- ('data -> int -> 'a) ->
- 'displacement * 'data ->
- int -> int ->
- 'a
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This lexer is used to read the sentences provided on the standard input
- channel when [--interpret] is enabled. *)
-
-{
-
- open Lexing
- open SentenceParser
- open Grammar
-
- (* Updates the line counter, which is used in some error messages. *)
-
- let update_loc lexbuf =
- let pos = lexbuf.lex_curr_p in
- lexbuf.lex_curr_p <- { pos with
- pos_lnum = pos.pos_lnum + 1;
- pos_bol = pos.pos_cnum;
- }
-
- (* A short-hand. *)
-
- let error1 lexbuf msg =
- Error.error (Positions.one (lexeme_start_p lexbuf)) msg
-
-}
-
-let newline = ('\010' | '\013' | "\013\010")
-
-let whitespace = [ ' ' '\t' ';' ]
-
-let lowercase = ['a'-'z' '\223'-'\246' '\248'-'\255' '_']
-
-let uppercase = ['A'-'Z' '\192'-'\214' '\216'-'\222']
-
-let identchar = ['A'-'Z' 'a'-'z' '_' '\192'-'\214' '\216'-'\246' '\248'-'\255' '0'-'9'] (* '\'' forbidden *)
-
-rule lex = parse
- | (lowercase identchar *) as lid
- { try
- let nt = Nonterminal.lookup lid in
- if StringSet.mem lid Front.grammar.UnparameterizedSyntax.start_symbols then
- NONTERMINAL nt
- else
- error1 lexbuf (Printf.sprintf "\"%s\" is not a start symbol." lid)
- with Not_found ->
- error1 lexbuf (Printf.sprintf "\"%s\" is not a known non-terminal symbol." lid)
- }
- | (uppercase identchar *) as uid
- { try
- TERMINAL (Terminal.lookup uid)
- with Not_found ->
- error1 lexbuf (Printf.sprintf "\"%s\" is not a known terminal symbol." uid)
- }
- | whitespace
- { lex lexbuf }
- | newline
- { update_loc lexbuf; EOL }
- | eof
- { EOF }
- | ':'
- { COLON }
- | _
- { error1 lexbuf "unexpected character(s)." }
-
+++ /dev/null
-/**************************************************************************/
-/* */
-/* Menhir */
-/* */
-/* François Pottier, INRIA Rocquencourt */
-/* Yann Régis-Gianas, PPS, Université Paris Diderot */
-/* */
-/* Copyright 2005-2008 Institut National de Recherche en Informatique */
-/* et en Automatique. All rights reserved. This file is distributed */
-/* under the terms of the Q Public License version 1.0, with the change */
-/* described in file LICENSE. */
-/* */
-/**************************************************************************/
-
-/* This parser is used to read the sentences provided on the standard input
- channel when [--interpret] is enabled. */
-
-/* A sentence is a pair of an optional non-terminal start symbol and a list
- of terminal symbols. */
-
-%{
-
- open Grammar
-
-%}
-
-%token COLON EOF EOL
-%token<Grammar.Terminal.t> TERMINAL
-%token<Grammar.Nonterminal.t> NONTERMINAL
-
-%type <(Grammar.Nonterminal.t option * Grammar.Terminal.t list) option> sentence
-%start sentence
-
-%%
-
-sentence:
-| EOF
- { None }
-| NONTERMINAL COLON terminals EOL
- { Some (Some $1, $3) }
-| terminals EOL
- { Some (None, $1) }
-
-terminals:
-|
- { [] }
-| TERMINAL terminals
- { $1 :: $2 }
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Printf
-
-(* ------------------------------------------------------------------------- *)
-(* Prepare for parsing the command line. *)
-
-type token_type_mode =
- | TokenTypeAndCode (* produce the definition of the [token] type and code for the parser *)
- | TokenTypeOnly (* produce the type definition only *)
- | CodeOnly of string (* produce the code only; import token type from specified module *)
-
-let token_type_mode =
- ref TokenTypeAndCode
-
-let tokentypeonly () =
- token_type_mode := TokenTypeOnly
-
-let codeonly m =
- if String.capitalize m <> m then begin
- (* Not using module [Error] to avoid a circular dependency. *)
- fprintf stderr "Error: %s is not a valid Objective Caml module name.\n" m;
- exit 1
- end;
- token_type_mode := CodeOnly m
-
-let version =
- ref false
-
-let pager =
- ref true
-
-let explain =
- ref false
-
-let base =
- ref ""
-
-let dump =
- ref false
-
-let follow =
- ref false
-
-let graph =
- ref false
-
-let trace =
- ref false
-
-let noprefix =
- ref false
-
-type print_mode =
- | PrintNormal
- | PrintUnitActions
- | PrintUnitActionsUnitTokens
-
-type preprocess_mode =
- | PMNormal (* preprocess and continue *)
- | PMOnlyPreprocess of print_mode (* preprocess, print grammar, stop *)
-
-let preprocess_mode =
- ref PMNormal
-
-let recovery =
- ref false
-
-let v () =
- dump := true;
- explain := true
-
-let infer =
- ref false
-
-let inline =
- ref true
-
-type ocamldep_mode =
- | OMNone (* do not invoke ocamldep *)
- | OMRaw (* invoke ocamldep and echo its raw output *)
- | OMPostprocess (* invoke ocamldep and postprocess its output *)
-
-let depend =
- ref OMNone
-
-let code_inlining =
- ref true
-
-let comment =
- ref false
-
-let ocamlc =
- ref "ocamlc"
-
-let ocamldep =
- ref "ocamldep"
-
-let logG, logA, logC =
- ref 0, ref 0, ref 0
-
-let timings =
- ref false
-
-let filenames =
- ref StringSet.empty
-
-let no_stdlib =
- ref false
-
-let stdlib_path =
- ref Installation.libdir
-
-let insert name =
- filenames := StringSet.add name !filenames
-
-let interpret =
- ref false
-
-let interpret_show_cst =
- ref false
-
-let table =
- ref false
-
-let coq =
- ref false
-
-let coq_no_complete =
- ref false
-
-let coq_no_actions =
- ref false
-
-let strict =
- ref false
-
-type suggestion =
- | SuggestNothing
- | SuggestCompFlags
- | SuggestLinkFlags of string (* "cmo" or "cmx" *)
-
-let suggestion =
- ref SuggestNothing
-
-let options = Arg.align [
- "--base", Arg.Set_string base, "<basename> Specifies a base name for the output file(s)";
- "--comment", Arg.Set comment, " Include comments in the generated code";
- "--coq", Arg.Set coq, " (undocumented)";
- "--coq-no-complete", Arg.Set coq_no_complete, " (undocumented)";
- "--coq-no-actions", Arg.Set coq_no_actions, " (undocumented)";
- "--depend", Arg.Unit (fun () -> depend := OMPostprocess), " Invoke ocamldep and display dependencies";
- "--dump", Arg.Set dump, " Describe the automaton in <basename>.automaton";
- "--error-recovery", Arg.Set recovery, " Attempt recovery by discarding tokens after errors";
- "--explain", Arg.Set explain, " Explain conflicts in <basename>.conflicts";
- "--external-tokens", Arg.String codeonly, "<module> Import token type definition from <module>";
- "--follow-construction", Arg.Set follow, " (undocumented)";
- "--graph", Arg.Set graph, " Write grammar's dependency graph to <basename>.dot";
- "--infer", Arg.Set infer, " Invoke ocamlc for ahead of time type inference";
- "--interpret", Arg.Set interpret, " Interpret the sentences provided on stdin";
- "--interpret-show-cst", Arg.Set interpret_show_cst, " Show a concrete syntax tree upon acceptance";
- "--log-automaton", Arg.Set_int logA, "<level> Log information about the automaton";
- "--log-code", Arg.Set_int logC, "<level> Log information about the generated code";
- "--log-grammar", Arg.Set_int logG, "<level> Log information about the grammar";
- "--no-code-inlining", Arg.Clear code_inlining, " (undocumented)";
- "--no-inline", Arg.Clear inline, " Ignore the %inline keyword.";
- "--no-pager", Arg.Clear pager, " (undocumented)";
- "--no-prefix", Arg.Set noprefix, " (undocumented)";
- "--no-stdlib", Arg.Set no_stdlib, " Do not load the standard library";
- "--ocamlc", Arg.Set_string ocamlc, "<command> Specifies how ocamlc should be invoked";
- "--ocamldep", Arg.Set_string ocamldep, "<command> Specifies how ocamldep should be invoked";
- "--only-preprocess", Arg.Unit (fun () -> preprocess_mode := PMOnlyPreprocess PrintNormal),
- " Print grammar and exit";
- "--only-preprocess-u", Arg.Unit (fun () -> preprocess_mode := PMOnlyPreprocess PrintUnitActions),
- " Print grammar with unit actions and exit";
- "--only-preprocess-uu", Arg.Unit (fun () -> preprocess_mode := PMOnlyPreprocess PrintUnitActionsUnitTokens),
- " Print grammar with unit actions & tokens and exit";
- "--only-tokens", Arg.Unit tokentypeonly, " Generate token type definition only, no code";
- "--raw-depend", Arg.Unit (fun () -> depend := OMRaw), " Invoke ocamldep and echo its raw output";
- "--stdlib", Arg.Set_string stdlib_path, "<directory> Specify where the standard library lies";
- "--strict", Arg.Set strict, " Warnings about the grammar are errors";
- "--suggest-comp-flags", Arg.Unit (fun () -> suggestion := SuggestCompFlags),
- " Suggest compilation flags for ocaml{c,opt}";
- "--suggest-link-flags-byte", Arg.Unit (fun () -> suggestion := SuggestLinkFlags "cmo"),
- " Suggest link flags for ocamlc";
- "--suggest-link-flags-opt", Arg.Unit (fun () -> suggestion := SuggestLinkFlags "cmx"),
- " Suggest link flags for ocamlopt";
- "--table", Arg.Set table, " Use the table-based back-end";
- "--timings", Arg.Set timings, " Display internal timings";
- "--trace", Arg.Set trace, " Include tracing instructions in the generated code";
- "--version", Arg.Set version, " Show version number and exit";
- "-b", Arg.Set_string base, "<basename> Synonymous with --base <basename>";
- "-lg", Arg.Set_int logG, " Synonymous with --log-grammar";
- "-la", Arg.Set_int logA, " Synonymous with --log-automaton";
- "-lc", Arg.Set_int logC, " Synonymous with --log-code";
- "-t", Arg.Set table, " Synonymous with --table";
- "-v", Arg.Unit v, " Synonymous with --dump --explain";
-]
-
-let usage =
- sprintf "Usage: %s <options> <filenames>" Sys.argv.(0)
-
-(* ------------------------------------------------------------------------- *)
-(* Parse the command line. *)
-
-let () =
- Arg.parse options insert usage
-
-(* ------------------------------------------------------------------------- *)
-(* If required, print a version number and stop. *)
-
-let () =
- if !version then begin
- printf "menhir, version %s\n" Version.version;
- exit 0
- end
-
-(* ------------------------------------------------------------------------- *)
-
-(* Menhir is able to suggest compile and link flags to be passed to the
- Objective Caml compilers. If required, do so and stop. *)
-
-(* If [--table] is not passed, no flags are necessary. If [--table] is
- passed, then [MenhirLib] needs to be visible (at compile time) and
- linked in (at link time). This is done either via [ocamlfind], if
- it was available at installation time, or manually. *)
-
-(* The compilation flags are in fact meant to be used both at compile-
- and link-time. *)
-
-let () =
- match !suggestion with
- | SuggestNothing ->
- ()
- | SuggestCompFlags ->
- if !table then
- if Installation.ocamlfind then
- printf "-package menhirLib\n%!"
- else
- printf "-I %s\n%!" Installation.libdir;
- exit 0
- | SuggestLinkFlags extension ->
- if !table then
- if Installation.ocamlfind then
- printf "-linkpkg\n%!"
- else
- printf "menhirLib.%s\n%!" extension;
- exit 0
-
-(* ------------------------------------------------------------------------- *)
-(* Export the settings. *)
-
-let stdlib_filename =
- !stdlib_path ^ "/standard.mly"
-
-let filenames =
- StringSet.elements !filenames
-
-let base =
- if !base = "" then
- match filenames with
- | [] ->
- fprintf stderr "%s\n" usage;
- exit 1
- | [ filename ] ->
- Filename.chop_suffix filename (if !coq then ".vy" else ".mly")
- | _ ->
- fprintf stderr "Error: you must specify --base when providing multiple input files.\n";
- exit 1
- else
- !base
-
-let filenames =
- if !no_stdlib || !coq then
- filenames
- else
- stdlib_filename :: filenames
-
-let token_type_mode =
- !token_type_mode
-
-let pager =
- !pager
-
-let explain =
- !explain
-
-let dump =
- !dump
-
-let follow =
- !follow
-
-let graph =
- !graph
-
-let trace =
- !trace
-
-let recovery =
- !recovery
-
-let noprefix =
- !noprefix
-
-let infer =
- !infer
-
-let code_inlining =
- !code_inlining
-
-let depend =
- !depend
-
-let inline =
- !inline
-
-let comment =
- !comment
-
-let preprocess_mode =
- !preprocess_mode
-
-let ocamlc =
- !ocamlc
-
-let ocamldep =
- !ocamldep
-
-let logG, logA, logC =
- !logG, !logA, !logC
-
-let timings =
- !timings
-
-let interpret =
- !interpret
-
-let interpret_show_cst =
- !interpret_show_cst
-
-let table =
- !table
-
-let coq =
- !coq
-
-let coq_no_complete =
- !coq_no_complete
-
-let coq_no_actions =
- !coq_no_actions
-
-let strict =
- !strict
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module parses the command line. *)
-
-(* The list of file names that appear on the command line. *)
-
-val filenames: string list
-
-(* How to deal with the type of tokens. *)
-
-type token_type_mode =
- | TokenTypeAndCode (* produce the definition of the [token] type and code for the parser *)
- | TokenTypeOnly (* produce the type definition only *)
- | CodeOnly of string (* produce the code only, by relying on an external token type *)
-
-val token_type_mode: token_type_mode
-
-(* Whether Pager's algorithm should be used. *)
-
-val pager: bool
-
-(* Whether conflicts should be explained. *)
-
-val explain: bool
-
-(* Whether the automaton should be dumped. *)
-
-val dump: bool
-
-(* Whether the automaton's construction should be explained (very verbose). *)
-
-val follow: bool
-
-(* Whether the grammar's dependence graph should be dumped. *)
-
-val graph: bool
-
-(* Whether tracing instructions should be generated. *)
-
-val trace: bool
-
-(* Whether error recovery should be attempted. This consists
- in discarding tokens, after the [error] token has been
- shifted, until a token that can be accepted is found. *)
-
-val recovery: bool
-
-(* Whether one should stop and print the grammar after joining and
- expanding the grammar. *)
-
-type print_mode =
- | PrintNormal
- | PrintUnitActions
- | PrintUnitActionsUnitTokens
-
-type preprocess_mode =
- | PMNormal (* preprocess and continue *)
- | PMOnlyPreprocess of print_mode (* preprocess, print grammar, stop *)
-
-val preprocess_mode: preprocess_mode
-
-(* Whether one should invoke ocamlc in order to infer types for all
- nonterminals. *)
-
-val infer: bool
-
-(* Whether one should inline the non terminal definitions marked
- with the %inline keyword. *)
-
-val inline: bool
-
-(* Whether and how one should invoke ocamldep in order to compute and
- display dependencies. *)
-
-type ocamldep_mode =
- | OMNone (* do not invoke ocamldep *)
- | OMRaw (* invoke ocamldep and echo its raw output *)
- | OMPostprocess (* invoke ocamldep and postprocess its output *)
-
-val depend: ocamldep_mode
-
-(* Whether comments should be printed or discarded. *)
-
-val comment: bool
-
-(* This undocumented flag suppresses prefixing of identifiers with an
- unlikely prefix in the generated code. This increases the code's
- readability, but can cause identifiers in semantic actions to be
- captured. *)
-
-val noprefix: bool
-
-(* This undocumented flag causes the code to be transformed by
- [Inline]. It is on by default. *)
-
-val code_inlining: bool
-
-(* How [ocamlc] and [ocamldep] should be invoked. *)
-
-val ocamlc: string
-val ocamldep: string
-
-(* How verbose we should be. *)
-
-val logG: int (* diagnostics on the grammar *)
-val logA: int (* diagnostics on the automaton *)
-val logC: int (* diagnostics on the generated code *)
-
-(* Whether tasks should be timed. *)
-
-val timings: bool
-
-(* The base name that should be used for the files that we create.
- This name can contain a path. *)
-
-val base: string
-
-(* The filename of the standard library. *)
-
-val stdlib_filename : string
-
-(* Whether Menhir should behave as an interpreter. *)
-
-val interpret : bool
-
-(* Whether the interpreter should build and display concrete syntax trees. *)
-
-val interpret_show_cst : bool
-
-(* Whether to use the table-based back-end ([true]) or the code-based
- back-end ([false]). *)
-
-val table : bool
-
-(* Whether to generate a coq description of the grammar and automaton. *)
-
-val coq : bool
-
-(* Whether the coq description must contain completeness proofs. *)
-
-val coq_no_complete : bool
-
-(* Whether the coq backend should ignore types and semantic actions. *)
-
-val coq_no_actions : bool
-
-(* Whether unresolved LR(1) conflicts, useless precedence declarations,
- productions that are never reduced, etc. should be treated as errors. *)
-
-val strict: bool
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module extends the LR(0) automaton with lookahead information in order
- to construct an SLR(1) automaton. The lookahead information is obtained by
- considering the FOLLOW sets. *)
-
-(* This construction is not used by Menhir, but can be used to check whether
- the grammar is in the class SLR(1). This check is performed when the log
- level [lg] is at least 1. *)
-
-open Grammar
-
-(* This flag, which is reserved for internal use, causes more information
- about SLR(1) conflict states to be printed. *)
-
-let tell_me_everything =
- false
-
-(* The following function turns an LR(0) state into an SLR(1) state. *)
-
-let make_slr_state (s : Lr0.node) : Lr0.concretelr1state =
-
- (* Obtain the set of LR(0) items associated with the state [s]. *)
-
- let items = Lr0.items s in
-
- (* Unfortunately, this set is not closed. We do not have a function that
- computes the closure of a set of LR(0) items -- we could build one using
- [Item.Closure], but that would be overkill. So, we first convert this
- set to a set of LR(1) items, then compute the closure at this level, and
- finally we turn this LR(1) state into an SLR(1) state by letting the
- lookahead sets be the FOLLOW sets. This is somewhat ugly and naïve, but
- seems to work. *)
-
- (* Convert this set to a set of LR(1) items. Here, we can use any set of
- tokens as the lookahead set. We use the empty set. *)
-
- let s = Item.Map.lift (fun item -> TerminalSet.empty) items in
-
- (* Compute the LR(1) closure. *)
-
- let s = Lr0.closure s in
-
- (* We now have an LR(1) state that has the correct set of LR(0) items but
- phony lookahead information. We convert it into an SLR(1) state by
- deciding that, for each item, the lookahead set is the FOLLOW set of the
- symbol that appears on the left-hand side of the item. *)
-
- Item.Map.fold (fun item toks accu ->
- let _, nt, _, _, _ = Item.def item in
- let follow_nt = Analysis.follow nt in
- assert (TerminalSet.subset toks follow_nt); (* sanity check *)
- Item.Map.add item follow_nt accu
- ) s Item.Map.empty
-
-(* Insertion of a new reduce action into the table of reductions. Copied
- from [Lr1] (boo, hiss). *)
-
-let addl prod tok reductions =
- let prods =
- try
- TerminalMap.lookup tok reductions
- with Not_found ->
- []
- in
- TerminalMap.add tok (prod :: prods) reductions
-
-(* Same thing, for a set of tokens. *)
-
-let addl prod toks reductions =
- TerminalSet.fold (addl prod) toks reductions
-
-(* The following function turns a closed LR(1) state into a map of terminal
- symbols to reduction actions. Copied from a related function in [Lr0]. *)
-
-let reductions (s : Lr0.concretelr1state) : Production.index list TerminalMap.t =
- Item.Map.fold (fun item toks reductions ->
- match Item.classify item with
- | Item.Reduce prod ->
- addl prod toks reductions
- | Item.Shift _ ->
- reductions
- ) s TerminalMap.empty
-
-(* The following function turns a closed LR(1) state into a set of shift
- actions. *)
-
-let transitions (s : Lr0.concretelr1state) : TerminalSet.t =
- Item.Map.fold (fun item _ transitions ->
- match Item.classify item with
- | Item.Shift (Symbol.T tok, _) ->
- TerminalSet.add tok transitions
- | Item.Shift (Symbol.N _, _)
- | Item.Reduce _ ->
- transitions
- ) s TerminalSet.empty
-
-(* This function computes the domain of a terminal map, producing a terminal
- set. *)
-
-let domain (m : 'a TerminalMap.t) : TerminalSet.t =
- TerminalMap.fold (fun tok _ accu ->
- TerminalSet.add tok accu
- ) m TerminalSet.empty
-
-(* The following function checks whether a closed LR(1) state is free of
- conflicts. *)
-
-let state_is_ok (s : Lr0.concretelr1state) : bool =
-
- let reductions = reductions s
- and transitions = transitions s in
-
- (* Check for shift/reduce conflicts. *)
-
- TerminalSet.disjoint transitions (domain reductions) &&
-
- (* Check for reduce/reduce conflicts. *)
-
- TerminalMap.fold (fun _ prods ok ->
- ok && match prods with
- | []
- | [ _ ] ->
- true
- | _ :: _ :: _ ->
- false
- ) reductions true
-
-(* The following function counts the number of states in the SLR(1) automaton
- that have a conflict. *)
-
-let count_slr_violations () : int =
-
- let count = ref 0 in
-
- for s = 0 to Lr0.n - 1 do
- let s = make_slr_state s in
- if not (state_is_ok s) then begin
- incr count;
- if tell_me_everything then
- Printf.fprintf
- stderr
- "The following SLR(1) state has a conflict:\n%s"
- (Lr0.print_concrete s)
- end
- done;
-
- !count
-
-(* At log level 1, indicate whether the grammar is SLR(1). *)
-
-let () =
- Error.logG 1 (fun f ->
- let count = count_slr_violations() in
- if count = 0 then
- Printf.fprintf f "The grammar is SLR(1).\n"
- else
- Printf.fprintf f "The grammar is not SLR(1) -- %d states have a conflict.\n" count
- )
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module extends the LR(0) automaton with lookahead information in order
- to construct an SLR(1) automaton. The lookahead information is obtained by
- considering the FOLLOW sets. *)
-
-(* This construction is not used by Menhir, but can be used to check whether
- the grammar is in the class SLR(1). This check is performed when the log
- level [lg] is at least 1. *)
-
+++ /dev/null
-/**************************************************************************/
-/* */
-/* Menhir */
-/* */
-/* François Pottier, INRIA Rocquencourt */
-/* Yann Régis-Gianas, PPS, Université Paris Diderot */
-/* */
-/* Copyright 2005-2008 Institut National de Recherche en Informatique */
-/* et en Automatique. All rights reserved. This file is distributed */
-/* under the terms of the GNU Library General Public License, with the */
-/* special exception on linking described in file LICENSE. */
-/* */
-/**************************************************************************/
-
-(* This is menhir's standard library. It offers a number of
- parameterized nonterminal definitions, such as options and lists,
- that should be useful in a number of circumstances. *)
-
-%%
-
-(* ------------------------------------------------------------------------- *)
-(* Options. *)
-
-(* [option(X)] recognizes either nothing or [X]. It produces a value
- of type ['a option] if [X] produces a value of type ['a]. *)
-
-%public option(X):
- /* nothing */
- { None }
-| x = X
- { Some x }
-
-(* [ioption(X)] is identical to [option(X)], except its definition is
- inlined. This has the effect of duplicating the production that
- refers to it, possibly eliminating an LR(1) conflict. *)
-
-%public %inline ioption(X):
- /* nothing */
- { None }
-| x = X
- { Some x }
-
-(* [boption(X)] recognizes either nothing or [X]. It produces a value
- of type [bool]. *)
-
-%public boption(X):
- /* nothing */
- { false }
-| X
- { true }
-
-(* [loption(X)] recognizes either nothing or [X]. It produces a value
- of type ['a list] if [X] produces a value of type ['a list]. *)
-
-%public loption(X):
- /* nothing */
- { [] }
-| x = X
- { x }
-
-(* ------------------------------------------------------------------------- *)
-(* Sequences. *)
-
-(* [pair(X, Y)] recognizes the sequence [X Y]. It produces a value of
- type ['a * 'b] if [X] and [Y] produce values of type ['a] and ['b],
- respectively. *)
-
-%public %inline pair(X, Y):
- x = X; y = Y
- { (x, y) }
-
-(* [separated_pair(X, sep, Y)] recognizes the sequence [X sep Y]. It
- produces a value of type ['a * 'b] if [X] and [Y] produce values of
- type ['a] and ['b], respectively. *)
-
-%public %inline separated_pair(X, sep, Y):
- x = X; sep; y = Y
- { (x, y) }
-
-(* [preceded(opening, X)] recognizes the sequence [opening X]. It
- passes on the value produced by [X], so that it produces a value of
- type ['a] if [X] produces a value of type ['a]. *)
-
-%public %inline preceded(opening, X):
- opening; x = X
- { x }
-
-(* [terminated(X, closing)] recognizes the sequence [X closing]. It
- passes on the value produced by [X], so that it produces a value of
- type ['a] if [X] produces a value of type ['a]. *)
-
-%public %inline terminated(X, closing):
- x = X; closing
- { x }
-
-(* [delimited(opening, X, closing)] recognizes the sequence [opening X
- closing]. It passes on the value produced by [X], so that it
- produces a value of type ['a] if [X] produces a value of type
- ['a]. *)
-
-%public %inline delimited(opening, X, closing):
- opening; x = X; closing
- { x }
-
-(* ------------------------------------------------------------------------- *)
-(* Lists. *)
-
-(* [list(X)] recognizes a possibly empty list of [X]'s. It produces a
- value of type ['a list] if [X] produces a value of type ['a]. The
- front element of the list is the first element that was parsed. *)
-
-%public list(X):
- /* nothing */
- { [] }
-| x = X; xs = list(X)
- { x :: xs }
-
-(* [nonempty_list(X)] recognizes a nonempty list of [X]'s. It produces
- a value of type ['a list] if [X] produces a value of type ['a]. The
- front element of the list is the first element that was parsed. *)
-
-%public nonempty_list(X):
- x = X
- { [ x ] }
-| x = X; xs = nonempty_list(X)
- { x :: xs }
-
-(* [separated_list(separator, X)] recognizes a possibly empty list of
- [X]'s, separated with [separator]'s. It produces a value of type
- ['a list] if [X] produces a value of type ['a]. The front element
- of the list is the first element that was parsed. *)
-
-%public %inline separated_list(separator, X):
- xs = loption(separated_nonempty_list(separator, X))
- { xs }
-
-(* [separated_nonempty_list(separator, X)] recognizes a nonempty list
- of [X]'s, separated with [separator]'s. It produces a value of type
- ['a list] if [X] produces a value of type ['a]. The front element
- of the list is the first element that was parsed. *)
-
-%public separated_nonempty_list(separator, X):
- x = X
- { [ x ] }
-| x = X; separator; xs = separated_nonempty_list(separator, X)
- { x :: xs }
-
-%%
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: stretch.mli,v 1.4 2005/12/01 16:20:07 regisgia Exp $ *)
-
-(* A stretch is a fragment of a source file. It holds the file name,
- the line number, and the line count (that is, the length) of the
- fragment. These are used for generating #line directives when the
- fragment is copied to an output file. It also holds the textual
- content of the fragment, as a string. The [raw_content] field holds
- the text that was found in the source file, while the [content]
- field holds the same text after transformation by the lexer (which
- substitutes keywords, inserts padding, etc.). *)
-
-type t = {
- stretch_filename : string;
- stretch_linenum : int;
- stretch_linecount : int;
- stretch_raw_content : string;
- stretch_content : string;
- stretch_keywords : Keyword.keyword Positions.located list
- }
-
-(* An Objective Caml type is either a stretch (if it was found in some
- source file) or a string (if it was inferred via [Infer]). *)
-
-type ocamltype =
- | Declared of t
- | Inferred of string
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-include Map.Make (String)
-
-let cardinal s =
- fold (fun _ _ x -> x + 1) s 0
-
-let filter pred map =
- fold (fun key value map ->
- if pred key value then
- add key value map
- else
- map) map empty
-
-let restrict domain map =
- filter (fun k _ -> StringSet.mem k domain) map
-
-let domain map =
- fold (fun key _ acu -> StringSet.add key acu) map StringSet.empty
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-include Map.S with type key = string
-
-val cardinal : 'a t -> int
-
-(* [restrict s m] restricts the domain of the map [m] to (its
- intersection with) the set [s]. *)
-
-val restrict: StringSet.t -> 'a t -> 'a t
-
-(* [filter pred m] restricts the domain of the map [m] to
- (key, value) couples that verify [pred]. *)
-
-val filter: (string -> 'a -> bool) -> 'a t -> 'a t
-
-(* [domain m] returns the domain of the map [m]. *)
-val domain: 'a t -> StringSet.t
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-include Set.Make (String)
-
-let of_list xs =
- List.fold_right add xs empty
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-include Set.S with type elt = string
-
-val of_list: elt list -> t
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* Terminals and nonterminal symbols are strings. Identifiers
- (which are used to refer to a symbol's semantic value) are
- strings. A file name is a string. *)
-
-type terminal =
- string
-
-type nonterminal =
- string
-
-type symbol =
- string
-
-type identifier =
- string
-
-type filename =
- string
-
-(* A trailer is also a source file fragment. It is represented
- simply as a string. *)
-
-type trailer =
- string
-
-(* Objective Caml semantic actions are represented as stretches. *)
-
-type action =
- Action.t
-
-type token_associativity =
- LeftAssoc
- | RightAssoc
- | NonAssoc
- | UndefinedAssoc
-
-type precedence_level =
- UndefinedPrecedence
-
- (* Items are incomparable when they originate in different files. A
- brand of type [Mark.t] is used to record an item's origin. The
- positions allow locating certain warnings. *)
-
- | PrecedenceLevel of Mark.t * int * Lexing.position * Lexing.position
-
-type token_properties =
- {
- tk_filename : filename;
- tk_ocamltype : Stretch.ocamltype option;
- tk_position : Positions.t;
- mutable tk_associativity : token_associativity;
- mutable tk_priority : precedence_level; (* TEMPORARY terminologie toujours pas coherente *)
- mutable tk_is_declared : bool;
- }
-
-type parameter =
- | ParameterVar of symbol Positions.located
- | ParameterApp of symbol Positions.located * parameters
-
-and parameters =
- parameter list
-
-type declaration =
-
- (* Raw Objective Caml code. *)
-
- | DCode of Stretch.t
-
- (* Raw Objective Caml functor parameter. *)
-
- | DParameter of Stretch.ocamltype (* really a stretch *)
-
- (* Terminal symbol (token) declaration. *)
-
- | DToken of Stretch.ocamltype option * terminal
-
- (* Start symbol declaration. *)
-
- | DStart of nonterminal
-
- (* Priority and associativity declaration. *)
-
- | DTokenProperties of terminal * token_associativity * precedence_level
-
- (* Type declaration. *)
-
- | DType of Stretch.ocamltype * parameter
-
-type branch_shift_precedence =
- symbol Positions.located option
-
-type branch_reduce_precedence =
- precedence_level
-
-type producer =
- identifier Positions.located option * parameter
-
-type parameterized_branch =
- {
- pr_branch_position : Positions.t;
- pr_producers : producer list;
- pr_action : action;
- pr_branch_shift_precedence : branch_shift_precedence;
- pr_branch_reduce_precedence : branch_reduce_precedence
- }
-
-type parameterized_rule =
- {
- pr_public_flag : bool;
- pr_inline_flag : bool;
- pr_nt : nonterminal;
- pr_positions : Positions.t list;
- pr_parameters : symbol list;
- pr_branches : parameterized_branch list;
- }
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open CodeBits
-open Grammar
-open IL
-open Interface
-open PreFront
-open Printf
-open TokenType
-open CodePieces
-
-module Run (T : sig end) = struct
-
-(* ------------------------------------------------------------------------ *)
-
-(* Conventional names for modules, exceptions, record fields, functions. *)
-
-let menhirlib =
- "MenhirLib"
-
-let tableInterpreter =
- menhirlib ^ ".TableInterpreter"
-
-let make =
- tableInterpreter ^ ".Make"
-
-let accept =
- tableInterpreter ^ ".Accept"
-
-let engineTypes =
- menhirlib ^ ".EngineTypes"
-
-let field x =
- engineTypes ^ "." ^ x
-
-let fstate =
- field "state"
-
-let fsemv =
- field "semv"
-
-let fstartp =
- field "startp"
-
-let fendp =
- field "endp"
-
-let fnext =
- field "next"
-
-let fstack =
- field "stack"
-
-let fcurrent =
- field "current"
-
-let flexbuf =
- field "lexbuf"
-
-let fpreviouserror =
- field "previouserror"
-
-let flex_start_p =
- "Lexing.lex_start_p"
-
-let interpreter =
- "MenhirInterpreter"
-
-let entry =
- interpreter ^ ".entry"
-
-(* ------------------------------------------------------------------------ *)
-
-(* Code generation for semantic actions. *)
-
-(* The functions [reducecellparams] and [reducebody] are adpated from
- [CodeBackend]. *)
-
-(* Things are slightly more regular here than in the code-based
- back-end, since there is no optimization: every stack cell has the
- same structure and holds a state, a semantic value, and a pair of
- positions. Because every semantic value is represented, we do not
- have a separate [unitbindings]. *)
-
-(* [reducecellparams] constructs a pattern that describes the contents
- of a stack cell. If this is the bottom cell, the variable [state]
- is bound to the state found in the cell. If [ids.(i)] is used in
- the semantic action, then it is bound to the semantic value. The
- position variables are always bound. *)
-
-let reducecellparams prod i symbol (next : pattern) : pattern =
-
- let ids = Production.identifiers prod
- and used = Production.used prod in
-
- PRecord [
- fstate, (if i = 0 then PVar state else PWildcard);
- fsemv, (if used.(i) then PVar ids.(i) else PWildcard);
- fstartp, PVar (Printf.sprintf "_startpos_%s_" ids.(i));
- fendp, PVar (Printf.sprintf "_endpos_%s_" ids.(i));
- fnext, next;
- ]
-
-(* The semantic values bound in [reducecellparams] have type [Obj.t].
- They should now be cast to their real type. If we had [PMagic] in
- the syntax of patterns, we could do that in one swoop; since we don't,
- we have to issue a series of casts a posteriori. *)
-
-let reducecellcasts prod i symbol casts =
-
- let ids = Production.identifiers prod
- and used = Production.used prod in
-
- if used.(i) then
- let id = ids.(i) in
- let t : typ =
- match semvtype symbol with
- | [] ->
- tunit
- | [ t ] ->
- t
- | _ ->
- assert false
- in
- (* Cast: [let id = ((Obj.magic id) : t) in ...]. *)
- (
- PVar id,
- EAnnot (EMagic (EVar id), type2scheme t)
- ) :: casts
- else
- casts
-
-(* This is the body of the [reduce] function associated with
- production [prod]. It assumes that the variables [env] and [stack]
- have been bound. *)
-
-let reducebody prod =
-
- let nt, rhs = Production.def prod
- and ids = Production.identifiers prod
- and length = Production.length prod in
-
- (* Build a pattern that represents the shape of the stack. Out of
- the stack, we extract a state (except when the production is an
- epsilon production) and a number of semantic values. *)
-
- (* At the same time, build a series of casts. *)
-
- let (_ : int), pat, casts =
- Invariant.fold (fun (i, pat, casts) (_ : bool) symbol _ ->
- i + 1,
- reducecellparams prod i symbol pat,
- reducecellcasts prod i symbol casts
- ) (0, PVar stack, []) (Invariant.prodstack prod)
- in
-
- (* Determine start and end positions for the left-hand side of the
- production. *)
-
- let posbindings =
- ( PVar startp,
- if length > 0 then
- EVar (Printf.sprintf "_startpos_%s_" ids.(0))
- else
- ERecordAccess(ERecordAccess (EVar env, flexbuf), flex_start_p)
- ) ::
- ( PVar endp,
- if length > 0 then
- EVar (Printf.sprintf "_endpos_%s_" ids.(length - 1))
- else
- EVar startp
- ) :: []
- in
-
- (* Is this is one of the start productions? *)
-
- match Production.classify prod with
- | Some nt ->
-
- (* This is a start production. Raise [Accept]. *)
-
- EComment (
- sprintf "Accepting %s" (Nonterminal.print false nt),
- blet (
- [ pat, EVar stack ],
- ERaise (EData (accept, [ EVar ids.(0) ]))
- )
- )
-
- | None ->
-
- (* This is a regular production. Perform a reduction. *)
-
- let action =
- Production.action prod
- in
- let act =
- EAnnot (Action.to_il_expr action, type2scheme (semvtypent nt))
- in
-
- EComment (
- Production.print prod,
- blet (
- (pat, EVar stack) :: (* destructure the stack *)
- casts @ (* perform type casts *)
- posbindings @ (* bind [startp] and [endp] *)
- extrabindings fpreviouserror action @ (* add bindings for the weird keywords *)
- [ PVar semv, act ], (* run the user's code and bind [semv] *)
-
- ERecordWrite (
- EVar env, fstack, (* update the stack with ... *)
- ERecord [ (* ... a new stack cell *)
- fstate, EVar state; (* the current state after popping; it will be updated by [goto] *)
- fsemv, ERepr (EVar semv); (* the newly computed semantic value *)
- fstartp, EVar startp; (* the newly computed start and end positions *)
- fendp, EVar endp;
- fnext, EVar stack; (* this is the stack after popping *)
- ]
- )
-
- )
- )
-
-let semantic_action prod =
- EFun (
- [ PVar env ],
-
- if Invariant.ever_reduced prod then
-
- (* Access the stack and current state via the environment. *)
-
- (* In fact, the current state needs be bound here only if this is
- an epsilon production. Otherwise, the variable [state] will be
- bound by the pattern produced by [reducecellparams] above. *)
-
- ELet (
-
- [ PVar stack, ERecordAccess (EVar env, fstack) ] @
- (if Production.length prod = 0 then [ PVar state, ERecordAccess (EVar env, fcurrent) ] else []),
-
- (* Then, *)
-
- reducebody prod
-
- )
-
- else
-
- (* For productions that are never reduced, generate no code. *)
-
- (* We do this mainly because [Invariant.prodstack] does not
- support productions that are never reduced. *)
-
- EComment (
- "a production never reduced",
- EApp (EVar "assert", [ EData ("false", []) ])
- )
-
- )
-
-(* ------------------------------------------------------------------------ *)
-
-(* Table encodings. *)
-
-(* Encodings of entries in the default reduction table. *)
-
-let encode_DefRed prod = (* 1 + prod *)
- 1 + Production.p2i prod
-
-let encode_NoDefRed = (* 0 *)
- 0
-
-(* Encodings of entries in the action table. *)
-
-let encode_Reduce prod = (* prod | 01 *)
- (Production.p2i prod lsl 2) lor 1
-
-let encode_ShiftDiscard s = (* s | 10 *)
- ((Lr1.number s) lsl 2) lor 0b10
-
-let encode_ShiftNoDiscard s = (* s | 11 *)
- ((Lr1.number s) lsl 2) lor 0b11
-
-let encode_Fail = (* 00 *)
- 0
-
-(* Encodings of entries in the goto table. *)
-
-let encode_Goto node = (* 1 + node *)
- 1 + Lr1.number node
-
-let encode_NoGoto = (* 0 *)
- 0
-
-(* Encodings of the hole in the action and goto tables. *)
-
-let hole =
- assert (encode_Fail = 0);
- assert (encode_NoGoto = 0);
- 0
-
-(* Encodings of entries in the error bitmap. *)
-
-let encode_Error = (* 0 *)
- 0
-
-let encode_NoError = (* 1 *)
- 1
-
-(* ------------------------------------------------------------------------ *)
-
-(* Statistics. *)
-
-(* Integer division, rounded up. *)
-
-let div a b =
- if a mod b = 0 then a / b else a / b + 1
-
-(* [size] provides a rough measure of the size of its argument, in words.
- The [unboxed] parameter is true if we have already counted 1 for the
- pointer to the object. *)
-
-let rec size unboxed = function
- | EIntConst _
- | ETuple []
- | EData (_, []) ->
- if unboxed then 0 else 1
- | EStringConst s ->
- 1 + div (String.length s * 8) Sys.word_size
- | ETuple es
- | EData (_, es)
- | EArray es ->
- 1 + List.length es + List.fold_left (fun s e -> s + size true e) 0 es
- | _ ->
- assert false (* not implemented *)
-
-let size =
- size false
-
-(* Optionally, print a measure of each of the tables that we are defining. *)
-
-let define (name, expr) = {
- valpublic = true;
- valpat = PVar name;
- valval = expr
-}
-
-let define_and_measure (x, e) =
- Error.logC 1 (fun f ->
- fprintf f
- "The %s table occupies roughly %d bytes.\n"
- x
- (size e * (Sys.word_size / 8))
- );
- define (x, e)
-
-
-(* ------------------------------------------------------------------------ *)
-
-(* Table compression. *)
-
-(* Our sparse, two-dimensional tables are turned into one-dimensional tables
- via [RowDisplacement]. *)
-
-(* The error bitmap, which is two-dimensional but not sparse, is made
- one-dimensional by simple flattening. *)
-
-(* Every one-dimensional table is then packed via [PackedIntArray]. *)
-
-(* Optionally, we print some information about the compression ratio. *)
-
-(* [population] counts the number of significant entries in a
- two-dimensional matrix. *)
-
-let population (matrix : int array array) =
- Array.fold_left (fun population row ->
- Array.fold_left (fun population entry ->
- if entry = hole then population else population + 1
- ) population row
- ) 0 matrix
-
-(* [marshal1] marshals a one-dimensional array. *)
-
-let marshal1 (table : int array) =
- let (bits : int), (text : string) = MenhirLib.PackedIntArray.pack table in
- ETuple [ EIntConst bits; EStringConst text ]
-
-(* [marshal11] marshals a one-dimensional array whose bit width is
- statically known to be [1]. *)
-
-let marshal11 (table : int array) =
- let (bits : int), (text : string) = MenhirLib.PackedIntArray.pack table in
- assert (bits = 1);
- EStringConst text
-
-(* [marshal2] marshals a two-dimensional table. *)
-
-let marshal2 name m n (matrix : int list list) =
- let matrix : int array array =
- Array.of_list (List.map Array.of_list matrix)
- in
- let (displacement : int array), (data : int array) =
- MenhirLib.RowDisplacement.compress
- (=)
- (fun x -> x = hole)
- hole
- m
- n
- matrix
- in
- Error.logC 1 (fun f ->
- fprintf f
- "The %s table is %d entries; %d non-zero; %d compressed.\n"
- name
- (m * n)
- (population matrix)
- (Array.length displacement + Array.length data)
- );
- ETuple [
- marshal1 displacement;
- marshal1 data;
- ]
-
-let marshal1 (table : int list) =
- marshal1 (Array.of_list table)
-
-let marshal11 (table : int list) =
- marshal11 (Array.of_list table)
-
-(* ------------------------------------------------------------------------ *)
-
-(* Table generation. *)
-
-(* The action table. *)
-
-let action node t =
- match Invariant.has_default_reduction node with
- | Some _ ->
-
- (* [node] has a default reduction; in that case, the action
- table is never looked up. *)
-
- hole
-
- | None ->
-
- try
- let target = SymbolMap.find (Symbol.T t) (Lr1.transitions node) in
-
- (* [node] has a transition to [target]. If [target] has a default
- reduction on [#], use [ShiftNoDiscard], otherwise [ShiftDiscard]. *)
-
- match Invariant.has_default_reduction target with
- | Some (_, toks) when TerminalSet.mem Terminal.sharp toks ->
- assert (TerminalSet.cardinal toks = 1);
- encode_ShiftNoDiscard target
- | _ ->
- encode_ShiftDiscard target
-
- with Not_found ->
- try
-
- (* [node] has a reduction. *)
-
- let prod = Misc.single (TerminalMap.find t (Lr1.reductions node)) in
- encode_Reduce prod
-
- with Not_found ->
-
- (* [node] has no action. *)
-
- encode_Fail
-
-(* In the error bitmap and in the action table, the row that corresponds to the
- [#] pseudo-terminal is never accessed. Thus, we do not create this row. This
- does not create a gap in the table, because this is the right-most row. For
- sanity, we check this fact here. *)
-
-let () =
- assert (Terminal.t2i Terminal.sharp = Terminal.n - 1)
-
-(* The goto table. *)
-
-let goto node nt =
- try
- let target = SymbolMap.find (Symbol.N nt) (Lr1.transitions node) in
- encode_Goto target
- with Not_found ->
- encode_NoGoto
-
-(* The error bitmap reflects which entries in the action table are
- [Fail]. Like the action table, it is not accessed when [node] has a
- default reduction. *)
-
-let error node t =
- if action node t = encode_Fail then
- encode_Error
- else
- encode_NoError
-
-(* The default reductions table. *)
-
-let default_reduction node =
- match Invariant.has_default_reduction node with
- | Some (prod, _) ->
- encode_DefRed prod
- | None ->
- encode_NoDefRed
-
-(* Generate the table definitions. *)
-
-let action =
- define_and_measure (
- "action",
- marshal2 "action" Lr1.n (Terminal.n - 1) (
- Lr1.map (fun node ->
- Terminal.mapx (fun t ->
- action node t
- )
- )
- )
- )
-
-let goto =
- define_and_measure (
- "goto",
- marshal2 "goto" Lr1.n Nonterminal.n (
- Lr1.map (fun node ->
- Nonterminal.map (fun nt ->
- goto node nt
- )
- )
- )
- )
-
-let error =
- define_and_measure (
- "error",
- ETuple [
- EIntConst (Terminal.n - 1);
- marshal11 (
- List.flatten (
- Lr1.map (fun node ->
- Terminal.mapx (fun t ->
- error node t
- )
- )
- )
- )
- ]
- )
-
-let default_reduction =
- define_and_measure (
- "default_reduction",
- marshal1 (
- Lr1.map (fun node ->
- default_reduction node
- )
- )
- )
-
-let lhs =
- define_and_measure (
- "lhs",
- marshal1 (
- Production.map (fun prod ->
- Nonterminal.n2i (Production.nt prod)
- )
- )
- )
-
-let semantic_action =
- define (
- "semantic_action",
- EArray (Production.map semantic_action)
- )
-
-(* ------------------------------------------------------------------------ *)
-
-(* When [--trace] is enabled, we need tables that map terminals and
- productions to strings. *)
-
-let stringwrap f x =
- EStringConst (f x)
-
-let reduce_or_accept prod =
- match Production.classify prod with
- | Some _ ->
- "Accepting"
- | None ->
- "Reducing production " ^ (Production.print prod)
-
-let trace =
- define_and_measure (
- "trace",
- if Settings.trace then
- EData ("Some", [
- ETuple [
- EArray (Terminal.map (stringwrap Terminal.print));
- EArray (Production.map (stringwrap reduce_or_accept));
- ]
- ])
- else
- EData ("None", [])
- )
-
-(* ------------------------------------------------------------------------ *)
-
-(* Generate the two functions that map a token to its integer code and to
- its semantic value, respectively. *)
-
-let token2terminal =
- destructuretokendef
- "token2terminal"
- tint
- false
- (fun tok -> EIntConst (Terminal.t2i tok))
-
-let token2value =
- destructuretokendef
- "token2value"
- tobj
- true
- (fun tok ->
- ERepr (
- match Terminal.ocamltype tok with
- | None ->
- EUnit
- | Some _ ->
- EVar semv
- )
- )
-
-(* ------------------------------------------------------------------------ *)
-
-(* We are now ready to apply the functor [TableInterpreter.Make]. *)
-
-(* The type [token], which was defined at toplevel, must be defined again
- in the functor argument. We would like to write [type token = token], but
- that is not valid ocaml. The usual workaround involves a dummy type. *)
-
-let jeton =
- prefix "jeton"
-
-let tokendef1 = {
- typename = jeton;
- typeparams = [];
- typerhs = TAbbrev ttoken;
- typeconstraint = None;
-}
-
-let tokendef2 = {
- typename = "token"; (* not [TokenType.tctoken], as it might carry an undesired prefix *)
- typeparams = [];
- typerhs = TAbbrev (TypApp (jeton, []));
- typeconstraint = None;
-}
-
-(* Here is the application of [TableInterpreter.Make]. Note that the
- exception [Error], which is defined at toplevel, is re-defined
- within the functor argument: [exception Error = Error]. *)
-
-let application = {
-
- modulename =
- interpreter;
-
- modulerhs =
- MApp (
- MVar make,
- MStruct {
- struct_excdefs = [
- excredef;
- ];
- struct_typedefs = [
- tokendef2;
- ];
- struct_nonrecvaldefs = [
- token2terminal;
- define ("error_terminal", EIntConst (Terminal.t2i Terminal.error));
- token2value;
- default_reduction;
- error;
- action;
- lhs;
- goto;
- semantic_action;
- define ("recovery", eboolconst Settings.recovery);
- trace;
- ];
- }
- );
-
-}
-
-(* ------------------------------------------------------------------------ *)
-
-(* The client API invokes the interpreter with an appropriate start state. *)
-
-let api : IL.valdef list =
-
- let lexer = "lexer"
- and lexbuf = "lexbuf" in
-
- ProductionMap.fold (fun prod state api ->
-
- let nt : Nonterminal.t =
- match Production.classify prod with
- | Some nt ->
- nt
- | None ->
- assert false (* this is a start production *)
- in
-
- let t : typ =
- match Nonterminal.ocamltype nt with
- | Some t ->
- TypTextual t
- | None ->
- assert false (* every start symbol should carry a type *)
- in
-
- define (
- Nonterminal.print true nt,
- EFun (
- [ PVar lexer; PVar lexbuf ],
- EAnnot (
- EMagic (
- EApp (
- EVar entry, [
- EIntConst (Lr1.number state);
- EVar lexer;
- EVar lexbuf
- ]
- )
- ),
- type2scheme t
- )
- )
- ) ::
- api
-
- ) Lr1.entry []
-
-(* ------------------------------------------------------------------------ *)
-
-(* Let's put everything together. *)
-
-let program = {
-
- paramdefs =
- Front.grammar.UnparameterizedSyntax.parameters;
-
- prologue =
- Front.grammar.UnparameterizedSyntax.preludes;
-
- excdefs =
- [ excdef ];
-
- typedefs =
- tokentypedef @
- [ tokendef1 ];
-
- nonrecvaldefs =
- [ excvaldef ];
-
- moduledefs =
- [ application ];
-
- valdefs =
- api;
-
- postlogue =
- Front.grammar.UnparameterizedSyntax.postludes
-
-}
-
-let () =
- Time.tick "Producing abstract syntax"
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* The (table-based) code generator. *)
-
-module Run (T : sig end) : sig
-
- val program: IL.program
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This signature defines the format of the parse tables. It is used as
- an argument to [TableInterpreter]. *)
-
-module type TABLES = sig
-
- (* This is the parser's type of tokens. *)
-
- type token
-
- (* This maps a token to its internal (generation-time) integer code. *)
-
- val token2terminal: token -> int
-
- (* This is the integer code for the error pseudo-token. *)
-
- val error_terminal: int
-
- (* This maps a token to its semantic value. *)
-
- val token2value: token -> Obj.t
-
- (* Traditionally, an LR automaton is described by two tables, namely, an
- action table and a goto table. See, for instance, the Dragon book.
-
- The action table is a two-dimensional matrix that maps a state and a
- lookahead token to an action. An action is one of: shift to a certain
- state, reduce a certain production, accept, or fail.
-
- The goto table is a two-dimensional matrix that maps a state and a
- non-terminal symbol to either a state or undefined. By construction, this
- table is sparse: its undefined entries are never looked up. A compression
- technique is free to overlap them with other entries.
-
- In Menhir, things are slightly different. If a state has a default
- reduction on token [#], then that reduction must be performed without
- consulting the lookahead token. As a result, we must first determine
- whether that is the case, before we can obtain a lookahead token and use it
- as an index in the action table.
-
- Thus, Menhir's tables are as follows.
-
- A one-dimensional default reduction table maps a state to either ``no
- default reduction'' (encoded as: 0) or ``by default, reduce prod''
- (encoded as: 1 + prod). The action table is looked up only when there
- is no default reduction. *)
-
- val default_reduction: PackedIntArray.t
-
- (* Menhir follows Dencker, Dürre and Heuft, who point out that, although the
- action table is not sparse by nature (i.e., the error entries are
- significant), it can be made sparse by first factoring out a binary error
- matrix, then replacing the error entries in the action table with undefined
- entries. Thus:
-
- A two-dimensional error bitmap maps a state and a terminal to either
- ``fail'' (encoded as: 0) or ``do not fail'' (encoded as: 1). The action
- table, which is now sparse, is looked up only in the latter case. *)
-
- (* The error bitmap is flattened into a one-dimensional table; its width is
- recorded so as to allow indexing. The table is then compressed via
- [PackedIntArray]. The bit width of the resulting packed array must be
- [1], so it is not explicitly recorded. *)
-
- (* The error bitmap does not contain a column for the [#] pseudo-terminal.
- Thus, its width is [Terminal.n - 1]. We exploit the fact that the integer
- code assigned to [#] is greatest: the fact that the right-most column
- in the bitmap is missing does not affect the code for accessing it. *)
-
- val error: int (* width of the bitmap *) * string (* second component of [PackedIntArray.t] *)
-
- (* A two-dimensional action table maps a state and a terminal to one of
- ``shift to state s and discard the current token'' (encoded as: s | 10),
- ``shift to state s without discarding the current token'' (encoded as: s |
- 11), or ``reduce prod'' (encoded as: prod | 01). *)
-
- (* The action table is first compressed via [RowDisplacement], then packed
- via [PackedIntArray]. *)
-
- (* Like the error bitmap, the action table does not contain a column for the
- [#] pseudo-terminal. *)
-
- val action: PackedIntArray.t * PackedIntArray.t
-
- (* A one-dimensional lhs table maps a production to its left-hand side (a
- non-terminal symbol). *)
-
- val lhs: PackedIntArray.t
-
- (* A two-dimensional goto table maps a state and a non-terminal symbol to
- either undefined (encoded as: 0) or a new state s (encoded as: 1 + s). *)
-
- (* The goto table is first compressed via [RowDisplacement], then packed
- via [PackedIntArray]. *)
-
- val goto: PackedIntArray.t * PackedIntArray.t
-
- (* A one-dimensional semantic action table maps productions to semantic
- actions. The calling convention for semantic actions is described in
- [EngineTypes]. *)
-
- val semantic_action: ((int, Obj.t, token) EngineTypes.env -> unit) array
-
- (* The parser defines its own [Error] exception. This exception can be
- raised by semantic actions and caught by the engine, and raised by the
- engine towards the final user. *)
-
- exception Error
-
- (* The parser indicates whether to perform error recovery. *)
-
- val recovery: bool
-
- (* The parser indicates whether to generate a trace. Generating a
- trace requires two extra tables, which respectively map a
- terminal symbol and a production to a string. *)
-
- val trace: (string array * string array) option
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module instantiates the generic [Engine] with a thin decoding layer
- for the generated tables. Like [Engine], it is part of [MenhirLib]. *)
-
-(* The exception [Accept] is pre-declared here: this obviates the need
- for generating its definition. The exception [Error] is declared
- within the generated parser. This is preferable to pre-declaring it
- here, as it ensures that each parser gets its own, distinct [Error]
- exception. This is consistent with the code-based back-end. *)
-
-exception Accept of Obj.t
-
-(* This functor is invoked by the generated parser. *)
-
-module Make (T : TableFormat.TABLES)
-
-= Engine.Make (struct
-
- type state =
- int
-
- type token =
- T.token
-
- type terminal =
- int
-
- type semantic_value =
- Obj.t
-
- let token2terminal =
- T.token2terminal
-
- let token2value =
- T.token2value
-
- let error_terminal =
- T.error_terminal
-
- let error_value =
- Obj.repr ()
-
- type production =
- int
-
- let default_reduction state defred nodefred env =
- let code = PackedIntArray.get T.default_reduction state in
- if code = 0 then
- nodefred env
- else
- defred env (code - 1)
-
- (* This auxiliary function helps access a compressed, two-dimensional
- matrix, like the action and goto tables. *)
-
- let unmarshal2 table i j =
- RowDisplacement.getget
- PackedIntArray.get
- PackedIntArray.get
- table
- i j
-
- (* This auxiliary function helps access a flattened, two-dimensional
- matrix, like the error bitmap. *)
-
- let unflatten (n, data) i j =
- PackedIntArray.get1 data (n * i + j)
-
- let action state terminal value shift reduce fail env =
- match unflatten T.error state terminal with
- | 1 ->
- let action = unmarshal2 T.action state terminal in
- let opcode = action land 0b11
- and param = action lsr 2 in
- if opcode >= 0b10 then
- (* 0b10 : shift/discard *)
- (* 0b11 : shift/nodiscard *)
- let please_discard = (opcode = 0b10) in
- shift env please_discard terminal value param
- else
- (* 0b01 : reduce *)
- (* 0b00 : cannot happen *)
- reduce env param
- | c ->
- assert (c = 0);
- fail env
-
- let goto state prod =
- let code = unmarshal2 T.goto state (PackedIntArray.get T.lhs prod) in
- (* code = 1 + state *)
- code - 1
-
- exception Accept =
- Accept
-
- exception Error =
- T.Error
-
- type semantic_action =
- (state, semantic_value, token) EngineTypes.env -> unit
-
- let semantic_action prod =
- T.semantic_action.(prod)
-
- let recovery =
- T.recovery
-
- module Log = struct
-
- open Printf
-
- let state state =
- match T.trace with
- | Some _ ->
- fprintf stderr "State %d:\n%!" state
- | None ->
- ()
-
- let shift terminal state =
- match T.trace with
- | Some (terminals, _) ->
- fprintf stderr "Shifting (%s) to state %d\n%!" terminals.(terminal) state
- | None ->
- ()
-
- let reduce_or_accept prod =
- match T.trace with
- | Some (_, productions) ->
- fprintf stderr "%s\n%!" productions.(prod)
- | None ->
- ()
-
- let lookahead_token lexbuf token =
- match T.trace with
- | Some (terminals, _) ->
- fprintf stderr "Lookahead token is now %s (%d-%d)\n%!"
- terminals.(token)
- lexbuf.Lexing.lex_start_p.Lexing.pos_cnum
- lexbuf.Lexing.lex_curr_p.Lexing.pos_cnum
- | None ->
- ()
-
- let initiating_error_handling () =
- match T.trace with
- | Some _ ->
- fprintf stderr "Initiating error handling\n%!"
- | None ->
- ()
-
- let resuming_error_handling () =
- match T.trace with
- | Some _ ->
- fprintf stderr "Resuming error handling\n%!"
- | None ->
- ()
-
- let handling_error state =
- match T.trace with
- | Some _ ->
- fprintf stderr "Handling error in state %d\n%!" state
- | None ->
- ()
-
- let discarding_last_token token =
- match T.trace with
- | Some (terminals, _) ->
- fprintf stderr "Discarding last token read (%s)\n%!" terminals.(token)
- | None ->
- ()
-
- end
-
-end)
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the GNU Library General Public License, with the *)
-(* special exception on linking described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module instantiates the generic [Engine] with a thin decoding layer
- for the generated tables. Like [Engine], it is part of [MenhirLib]. *)
-
-(* The exception [Accept] is pre-declared here: this obviates the need
- for generating its definition. The exception [Error] is declared
- within the generated parser. This is preferable to pre-declaring it
- here, as it ensures that each parser gets its own, distinct [Error]
- exception. This is consistent with the code-based back-end. *)
-
-exception Accept of Obj.t
-
-(* This functor is invoked by the generated parser. *)
-
-module Make (T : TableFormat.TABLES)
-
-: EngineTypes.ENGINE with type state = int
- and type token = T.token
- and type semantic_value = Obj.t
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module provides an implementation of Tarjan's algorithm for
- finding the strongly connected components of a graph.
-
- The algorithm runs when the functor is applied. Its complexity is
- $O(V+E)$, where $V$ is the number of vertices in the graph $G$, and
- $E$ is the number of edges. *)
-
-module Run (G : sig
-
- type node
-
- (* We assume each node has a unique index. Indices must range from
- $0$ to $n-1$, where $n$ is the number of nodes in the graph. *)
-
- val n: int
- val index: node -> int
-
- (* Iterating over a node's immediate successors. *)
-
- val successors: (node -> unit) -> node -> unit
-
- (* Iterating over all nodes. *)
-
- val iter: (node -> unit) -> unit
-
-end) = struct
-
- (* Define the internal data structure associated with each node. *)
-
- type data = {
-
- (* Each node carries a flag which tells whether it appears
- within the SCC stack (which is defined below). *)
-
- mutable stacked: bool;
-
- (* Each node carries a number. Numbers represent the order in
- which nodes were discovered. *)
-
- mutable number: int;
-
- (* Each node [x] records the lowest number associated to a node
- already detected within [x]'s SCC. *)
-
- mutable low: int;
-
- (* Each node carries a pointer to a representative element of
- its SCC. This field is used by the algorithm to store its
- results. *)
-
- mutable representative: G.node;
-
- (* Each representative node carries a list of the nodes in
- its SCC. This field is used by the algorithm to store its
- results. *)
-
- mutable scc: G.node list
-
- }
-
- (* Define a mapping from external nodes to internal ones. Here, we
- simply use each node's index as an entry into a global array. *)
-
- let table =
-
- (* Create the array. We initially fill it with [None], of type
- [data option], because we have no meaningful initial value of
- type [data] at hand. *)
-
- let table = Array.create G.n None in
-
- (* Initialize the array. *)
-
- G.iter (fun x ->
- table.(G.index x) <- Some {
- stacked = false;
- number = 0;
- low = 0;
- representative = x;
- scc = []
- }
- );
-
- (* Define a function which gives easy access to the array. It maps
- each node to its associated piece of internal data. *)
-
- function x ->
- match table.(G.index x) with
- | Some dx ->
- dx
- | None ->
- assert false (* Indices do not cover the range $0\ldots n$, as expected. *)
-
- (* Create an empty stack, used to record all nodes which belong to
- the current SCC. *)
-
- let scc_stack = Stack.create()
-
- (* Initialize a function which allocates numbers for (internal)
- nodes. A new number is assigned to each node the first time it is
- visited. Numbers returned by this function start at 1 and
- increase. Initially, all nodes have number 0, so they are
- considered unvisited. *)
-
- let mark =
- let counter = ref 0 in
- fun dx ->
- incr counter;
- dx.number <- !counter;
- dx.low <- !counter
-
- (* This reference will hold a list of all representative nodes. *)
-
- let representatives =
- ref []
-
- (* Look at all nodes of the graph, one after the other. Any
- unvisited nodes become roots of the search forest. *)
-
- let () = G.iter (fun root ->
- let droot = table root in
-
- if droot.number = 0 then begin
-
- (* This node hasn't been visited yet. Start a depth-first walk
- from it. *)
-
- mark droot;
- droot.stacked <- true;
- Stack.push droot scc_stack;
-
- let rec walk x =
- let dx = table x in
-
- G.successors (fun y ->
- let dy = table y in
-
- if dy.number = 0 then begin
-
- (* $y$ hasn't been visited yet, so $(x,y)$ is a regular
- edge, part of the search forest. *)
-
- mark dy;
- dy.stacked <- true;
- Stack.push dy scc_stack;
-
- (* Continue walking, depth-first. *)
-
- walk y;
- if dy.low < dx.low then
- dx.low <- dy.low
-
- end
- else if (dy.low < dx.low) & dy.stacked then begin
-
- (* The first condition above indicates that $y$ has been
- visited before $x$, so $(x, y)$ is a backwards or
- transverse edge. The second condition indicates that
- $y$ is inside the same SCC as $x$; indeed, if it
- belongs to another SCC, then the latter has already
- been identified and moved out of [scc_stack]. *)
-
- if dy.number < dx.low then
- dx.low <- dy.number
-
- end
-
- ) x;
-
- (* We are done visiting $x$'s neighbors. *)
-
- if dx.low = dx.number then begin
-
- (* $x$ is the entry point of a SCC. The whole SCC is now
- available; move it out of the stack. We pop elements out
- of the SCC stack until $x$ itself is found. *)
-
- let rec loop () =
- let element = Stack.pop scc_stack in
- element.stacked <- false;
- dx.scc <- element.representative :: dx.scc;
- element.representative <- x;
- if element != dx then
- loop() in
-
- loop();
- representatives := x :: !representatives
-
- end in
-
- walk root
-
- end
- )
-
- (* There only remains to make our results accessible to the
- outside. *)
-
- let representative x =
- (table x).representative
-
- let scc x =
- (table x).scc
-
- let iter action =
- List.iter (fun x ->
- let data = table x in
- assert (data.representative == x); (* a sanity check *)
- assert (data.scc <> []); (* a sanity check *)
- action x data.scc
- ) !representatives
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module provides an implementation of Tarjan's algorithm for
- finding the strongly connected components of a graph.
-
- The algorithm runs when the functor is applied. Its complexity is
- $O(V+E)$, where $V$ is the number of vertices in the graph $G$, and
- $E$ is the number of edges. *)
-
-module Run (G : sig
-
- type node
-
- (* We assume each node has a unique index. Indices must range from
- $0$ to $n-1$, where $n$ is the number of nodes in the graph. *)
-
- val n: int
- val index: node -> int
-
- (* Iterating over a node's immediate successors. *)
-
- val successors: (node -> unit) -> node -> unit
-
- (* Iterating over all nodes. *)
-
- val iter: (node -> unit) -> unit
-
-end) : sig
-
- open G
-
- (* This function maps each node to a representative element of its strongly connected component. *)
-
- val representative: node -> node
-
- (* This function maps each representative element to a list of all
- members of its strongly connected component. Non-representative
- elements are mapped to an empty list. *)
-
- val scc: node -> node list
-
- (* [iter action] allows iterating over all strongly connected
- components. For each component, the [action] function is applied
- to the representative element and to a (non-empty) list of all
- elements. *)
-
- val iter: (node -> node list -> unit) -> unit
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-let channel =
- stderr
-
-open Unix
-open Printf
-
-let clock =
- ref (times())
-
-let tick msg =
- if Settings.timings then
- let times1 = !clock in
- let times2 = times() in
- fprintf channel "%s: %.02fs\n"
- msg
- (times2.tms_utime -. times1.tms_utime);
- clock := times()
-
-type chrono =
- float ref
-
-let fresh () =
- ref 0.
-
-let chrono (chrono : float ref) (task : unit -> 'a) : 'a =
- if Settings.timings then begin
- let times1 = times() in
- let result = task() in
- let times2 = times() in
- chrono := !chrono +. times2.tms_utime -. times1.tms_utime;
- result
- end
- else
- task()
-
-let display (chrono : float ref) msg =
- if Settings.timings then
- fprintf channel "%s: %.02fs\n"
- msg
- !chrono
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* Call [tick msg] to stop timing a task and start timing the next
- task. A message is displayed. The message includes [msg] as well
- as timing information. The very first task is deemed to begin when
- this module is initialized. *)
-
-val tick: string -> unit
-
-(* Another timing method, with separate chronometers; useful for more
- precise profiling. *)
-
-type chrono
-
-val fresh: unit -> chrono
-
-val chrono: chrono -> (unit -> 'a) -> 'a
-
-val display: chrono -> string -> unit
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module deals with a few details regarding the definition of
- the [token] type. In particular, if [--only-tokens] was specified,
- it emits the type definition and exits. *)
-
-open Syntax
-open UnparameterizedSyntax
-open IL
-open CodeBits
-
-(* This is the conventional name of the [token] type, with no
- prefix. A prefix is possibly appended to it below, where
- [tctoken] is redefined before being exported. *)
-
-let tctoken =
- "token"
-
-(* This is the definition of the type of tokens. *)
-
-let tokentypedef =
- let datadefs =
- StringMap.fold (fun token properties defs ->
-
- (* Pseudo-tokens (used in %prec declarations, but never
- declared using %token) are filtered out. *)
-
- if properties.tk_is_declared then
- let params =
- match properties.tk_ocamltype with
- | None ->
- []
- | Some t ->
- [ TypTextual t ]
- in
- {
- dataname = token;
- datavalparams = params;
- datatypeparams = None
- } :: defs
- else
- defs
- ) PreFront.grammar.tokens []
- in
- {
- typename = tctoken;
- typeparams = [];
- typerhs = TDefSum datadefs;
- typeconstraint = None
- }
-
-(* Consult the command line options to determine what to do.
- If we were asked to only produce a type definition, then
- do so and stop. Otherwise, tell the code generator whether
- it should produce a type definition as part of the code. *)
-
-let tokentypedef, tokenprefix =
- match Settings.token_type_mode with
- | Settings.TokenTypeOnly ->
-
- (* Create both an .mli file and an .ml file. This is made
- necessary by the fact that the two can be different
- when there are functor parameters. *)
-
- let module P =
- Printer.Make (struct
- let f = open_out (Settings.base ^ ".mli")
- let raw_stretch_action = false
- let locate_stretches = None
- let parenthesize_let_lhs = false
- end)
- in
- P.interface {
- paramdecls = PreFront.grammar.parameters;
- excdecls = [];
- typedecls = [ tokentypedef ];
- valdecls = []
- };
- let module P =
- Printer.Make (struct
- let f = open_out (Settings.base ^ ".ml")
- let raw_stretch_action = false
- let locate_stretches = None
- end)
- in
- P.program {
- paramdefs = PreFront.grammar.parameters;
- prologue = [];
- excdefs = [];
- typedefs = [ tokentypedef ];
- nonrecvaldefs = [];
- valdefs = [];
- moduledefs = [];
- postlogue = [];
- };
- exit 0
- | Settings.CodeOnly m ->
- [],
- (fun id -> m ^ "." ^ id)
- | Settings.TokenTypeAndCode ->
- [ tokentypedef ],
- (fun id -> id)
-
-(* Redefine the name of the [token] type to take a possible
- prefix into account. *)
-
-let tctoken =
- tokenprefix tctoken
-
-let ttoken =
- TypApp (tctoken, [])
-
-(* The type of lexers. *)
-
-let tlexer =
- TypArrow (tlexbuf, ttoken)
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This module deals with a few details regarding the definition of
- the [token] type. In particular, if [--only-tokens] was specified,
- it emits the type definition and exits. *)
-
-open Grammar
-
-(* This is the conventional name of the [token] type, for use by
- the code generator. *)
-
-val tctoken: string
-val ttoken: IL.typ
-
-(* This is the type of lexers. It refers to the [token] type,
- which is why it is defined here. *)
-
-val tlexer: IL.typ
-
-(* This is the definition of the type of tokens, for use by the
- code generator. *)
-
-val tokentypedef: IL.typedef list
-
-(* This function prefixes the name of a token with an appropriate
- Objective Caml module name, if necessary. *)
-
-val tokenprefix: string -> string
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* Code for traversing or transforming [IL] terms. *)
-
-open IL
-open CodeBits
-
-(* This turns a list of value definitions into a hash table. It also
-counts and numbers the definitions. We assume that the left-hand
-side of every definition is a variable. *)
-
-let tabulate_defs (defs : valdef list) : int * (string, int * valdef) Hashtbl.t =
- let count = ref 0 in
- let table = Hashtbl.create 1023 in
- List.iter (fun def ->
- let k = !count in
- count := k + 1;
- Hashtbl.add table (pat2var def.valpat) (k, def)
- ) defs;
- !count, table
-
-(* This mixin class, used by [map] and [fold] below, helps maintain
- environments, which can be used to keep track of local variable
- bindings. *)
-
-class virtual ['env] env = object(self)
-
- (* The virtual method [pvar] records a local variable binding in
- the environment. *)
-
- method virtual pvar: 'env -> string -> 'env
-
- method pat env = function
- | PWildcard
- | PUnit ->
- env
- | PVar id ->
- self#pvar env id
- | PTuple ps
- | POr ps
- | PData (_, ps) ->
- self#pats env ps
- | PAnnot (p, _) ->
- self#pat env p
- | PRecord fps ->
- self#fpats env fps
-
- method pats env ps =
- List.fold_left self#pat env ps
-
- method fpats env fps =
- List.fold_left self#fpat env fps
-
- method fpat env (_, p) =
- self#pat env p
-
-end
-
-(* A class that helps transform expressions. The environment [env] can be
- used to keep track of local variable bindings. *)
-
-exception NoChange
-
-class virtual ['env] map = object (self)
-
- inherit ['env] env
-
- method expr (env : 'env) e =
- try
- match e with
- | EVar x ->
- self#evar env x
- | EFun (ps, e) ->
- self#efun env ps e
- | EApp (e, es) ->
- self#eapp env e es
- | ELet (bs, e) ->
- self#elet env bs e
- | EMatch (e, bs) ->
- self#ematch env e bs
- | EIfThen (e, e1) ->
- self#eifthen env e e1
- | EIfThenElse (e, e1, e2) ->
- self#eifthenelse env e e1 e2
- | ERaise e ->
- self#eraise env e
- | ETry (e, bs) ->
- self#etry env e bs
- | EUnit ->
- self#eunit env
- | EIntConst k ->
- self#eintconst env k
- | EStringConst s ->
- self#estringconst env s
- | EData (d, es) ->
- self#edata env d es
- | ETuple es ->
- self#etuple env es
- | EAnnot (e, t) ->
- self#eannot env e t
- | EMagic e ->
- self#emagic env e
- | ERepr _ ->
- self#erepr env e
- | ERecord fs ->
- self#erecord env fs
- | ERecordAccess (e, f) ->
- self#erecordaccess env e f
- | ERecordWrite (e, f, e1) ->
- self#erecordwrite env e f e1
- | ETextual action ->
- self#etextual env action
- | EComment (s, e) ->
- self#ecomment env s e
- | EPatComment (s, p, e) ->
- self#epatcomment env s p e
- | EArray es ->
- self#earray env es
- | EArrayAccess (e, i) ->
- self#earrayaccess env e i
- with NoChange ->
- e
-
- method evar env x =
- raise NoChange
-
- method efun env ps e =
- let e' = self#expr (self#pats env ps) e in
- if e == e' then
- raise NoChange
- else
- EFun (ps, e')
-
- method eapp env e es =
- let e' = self#expr env e
- and es' = self#exprs env es in
- if e == e' && es == es' then
- raise NoChange
- else
- EApp (e', es')
-
- method elet env bs e =
- let env, bs' = self#bindings env bs in
- let e' = self#expr env e in
- if bs == bs' && e == e' then
- raise NoChange
- else
- ELet (bs', e')
-
- method ematch env e bs =
- let e' = self#expr env e
- and bs' = self#branches env bs in
- if e == e' && bs == bs' then
- raise NoChange
- else
- EMatch (e', bs')
-
- method eifthen env e e1 =
- let e' = self#expr env e
- and e1' = self#expr env e1 in
- if e == e' && e1 == e1' then
- raise NoChange
- else
- EIfThen (e', e1')
-
- method eifthenelse env e e1 e2 =
- let e' = self#expr env e
- and e1' = self#expr env e1
- and e2' = self#expr env e2 in
- if e == e' && e1 == e1' && e2 == e2' then
- raise NoChange
- else
- EIfThenElse (e', e1', e2')
-
- method eraise env e =
- let e' = self#expr env e in
- if e == e' then
- raise NoChange
- else
- ERaise e'
-
- method etry env e bs =
- let e' = self#expr env e
- and bs' = self#branches env bs in
- if e == e' && bs == bs' then
- raise NoChange
- else
- ETry (e', bs')
-
- method eunit env =
- raise NoChange
-
- method eintconst env k =
- raise NoChange
-
- method estringconst env s =
- raise NoChange
-
- method edata env d es =
- let es' = self#exprs env es in
- if es == es' then
- raise NoChange
- else
- EData (d, es')
-
- method etuple env es =
- let es' = self#exprs env es in
- if es == es' then
- raise NoChange
- else
- ETuple es'
-
- method eannot env e t =
- let e' = self#expr env e in
- if e == e' then
- raise NoChange
- else
- EAnnot (e', t)
-
- method emagic env e =
- let e' = self#expr env e in
- if e == e' then
- raise NoChange
- else
- EMagic e'
-
- method erepr env e =
- let e' = self#expr env e in
- if e == e' then
- raise NoChange
- else
- ERepr e'
-
- method erecord env fs =
- let fs' = self#fields env fs in
- if fs == fs' then
- raise NoChange
- else
- ERecord fs'
-
- method erecordaccess env e f =
- let e' = self#expr env e in
- if e == e' then
- raise NoChange
- else
- ERecordAccess (e', f)
-
- method erecordwrite env e f e1 =
- let e' = self#expr env e
- and e1' = self#expr env e1 in
- if e == e' && e1 == e1' then
- raise NoChange
- else
- ERecordWrite (e', f, e1')
-
- method earray env es =
- let es' = self#exprs env es in
- if es == es' then
- raise NoChange
- else
- EArray es'
-
- method earrayaccess env e i =
- let e' = self#expr env e in
- if e == e' then
- raise NoChange
- else
- EArrayAccess (e', i)
-
- method etextual env action =
- raise NoChange
-
- method ecomment env s e =
- let e' = self#expr env e in
- if e == e' then
- raise NoChange
- else
- EComment (s, e')
-
- method epatcomment env s p e =
- let e' = self#expr env e in
- if e == e' then
- raise NoChange
- else
- EPatComment (s, p, e')
-
- method exprs env es =
- Misc.smap (self#expr env) es
-
- method fields env fs =
- Misc.smap (self#field env) fs
-
- method field env ((f, e) as field) =
- let e' = self#expr env e in
- if e == e' then
- field
- else
- (f, e')
-
- method branches env bs =
- Misc.smap (self#branch env) bs
-
- method branch env b =
- let e = b.branchbody in
- let e' = self#expr (self#pat env b.branchpat) e in
- if e == e' then
- b
- else
- { b with branchbody = e' }
-
- (* The method [binding] produces a pair of an updated environment
- and a transformed binding. *)
-
- method binding env ((p, e) as b) =
- let e' = self#expr env e in
- self#pat env p,
- if e == e' then
- b
- else
- (p, e')
-
- (* For nested non-recursive bindings, the environment produced by
- each binding is used to traverse the following bindings. The
- method [binding] produces a pair of an updated environment
- and a transformed list of bindings. *)
-
- method bindings env bs =
- Misc.smapa self#binding env bs
-
- method valdef env def =
- let e = def.valval in
- let e' = self#expr env e in
- if e == e' then
- def
- else
- { def with valval = e' }
-
- method valdefs env defs =
- Misc.smap (self#valdef env) defs
-
-end
-
-(* A class that helps iterate, or fold, over expressions. *)
-
-class virtual ['env, 'a] fold = object (self)
-
- inherit ['env] env
-
- method expr (env : 'env) (accu : 'a) e =
- match e with
- | EVar x ->
- self#evar env accu x
- | EFun (ps, e) ->
- self#efun env accu ps e
- | EApp (e, es) ->
- self#eapp env accu e es
- | ELet (bs, e) ->
- self#elet env accu bs e
- | EMatch (e, bs) ->
- self#ematch env accu e bs
- | EIfThen (e, e1) ->
- self#eifthen env accu e e1
- | EIfThenElse (e, e1, e2) ->
- self#eifthenelse env accu e e1 e2
- | ERaise e ->
- self#eraise env accu e
- | ETry (e, bs) ->
- self#etry env accu e bs
- | EUnit ->
- self#eunit env accu
- | EIntConst k ->
- self#eintconst env accu k
- | EStringConst s ->
- self#estringconst env accu s
- | EData (d, es) ->
- self#edata env accu d es
- | ETuple es ->
- self#etuple env accu es
- | EAnnot (e, t) ->
- self#eannot env accu e t
- | EMagic e ->
- self#emagic env accu e
- | ERepr _ ->
- self#erepr env accu e
- | ERecord fs ->
- self#erecord env accu fs
- | ERecordAccess (e, f) ->
- self#erecordaccess env accu e f
- | ERecordWrite (e, f, e1) ->
- self#erecordwrite env accu e f e1
- | ETextual action ->
- self#etextual env accu action
- | EComment (s, e) ->
- self#ecomment env accu s e
- | EPatComment (s, p, e) ->
- self#epatcomment env accu s p e
- | EArray es ->
- self#earray env accu es
- | EArrayAccess (e, i) ->
- self#earrayaccess env accu e i
-
- method evar (env : 'env) (accu : 'a) x =
- accu
-
- method efun (env : 'env) (accu : 'a) ps e =
- let accu = self#expr (self#pats env ps) accu e in
- accu
-
- method eapp (env : 'env) (accu : 'a) e es =
- let accu = self#expr env accu e in
- let accu = self#exprs env accu es in
- accu
-
- method elet (env : 'env) (accu : 'a) bs e =
- let env, accu = self#bindings env accu bs in
- let accu = self#expr env accu e in
- accu
-
- method ematch (env : 'env) (accu : 'a) e bs =
- let accu = self#expr env accu e in
- let accu = self#branches env accu bs in
- accu
-
- method eifthen (env : 'env) (accu : 'a) e e1 =
- let accu = self#expr env accu e in
- let accu = self#expr env accu e1 in
- accu
-
- method eifthenelse (env : 'env) (accu : 'a) e e1 e2 =
- let accu = self#expr env accu e in
- let accu = self#expr env accu e1 in
- let accu = self#expr env accu e2 in
- accu
-
- method eraise (env : 'env) (accu : 'a) e =
- let accu = self#expr env accu e in
- accu
-
- method etry (env : 'env) (accu : 'a) e bs =
- let accu = self#expr env accu e in
- let accu = self#branches env accu bs in
- accu
-
- method eunit (env : 'env) (accu : 'a) =
- accu
-
- method eintconst (env : 'env) (accu : 'a) k =
- accu
-
- method estringconst (env : 'env) (accu : 'a) s =
- accu
-
- method edata (env : 'env) (accu : 'a) d es =
- let accu = self#exprs env accu es in
- accu
-
- method etuple (env : 'env) (accu : 'a) es =
- let accu = self#exprs env accu es in
- accu
-
- method eannot (env : 'env) (accu : 'a) e t =
- let accu = self#expr env accu e in
- accu
-
- method emagic (env : 'env) (accu : 'a) e =
- let accu = self#expr env accu e in
- accu
-
- method erepr (env : 'env) (accu : 'a) e =
- let accu = self#expr env accu e in
- accu
-
- method erecord (env : 'env) (accu : 'a) fs =
- let accu = self#fields env accu fs in
- accu
-
- method erecordaccess (env : 'env) (accu : 'a) e f =
- let accu = self#expr env accu e in
- accu
-
- method erecordwrite (env : 'env) (accu : 'a) e f e1 =
- let accu = self#expr env accu e in
- let accu = self#expr env accu e1 in
- accu
-
- method earray (env : 'env) (accu : 'a) es =
- let accu = self#exprs env accu es in
- accu
-
- method earrayaccess (env : 'env) (accu : 'a) e i =
- let accu = self#expr env accu e in
- accu
-
- method etextual (env : 'env) (accu : 'a) action =
- accu
-
- method ecomment (env : 'env) (accu : 'a) s e =
- let accu = self#expr env accu e in
- accu
-
- method epatcomment (env : 'env) (accu : 'a) s p e =
- let accu = self#expr env accu e in
- accu
-
- method exprs (env : 'env) (accu : 'a) es =
- List.fold_left (self#expr env) accu es
-
- method fields (env : 'env) (accu : 'a) fs =
- List.fold_left (self#field env) accu fs
-
- method field (env : 'env) (accu : 'a) (f, e) =
- let accu = self#expr env accu e in
- accu
-
- method branches (env : 'env) (accu : 'a) bs =
- List.fold_left (self#branch env) accu bs
-
- method branch (env : 'env) (accu : 'a) b =
- let accu = self#expr (self#pat env b.branchpat) accu b.branchbody in
- accu
-
- method binding ((env, accu) : 'env * 'a) (p, e) =
- let accu = self#expr env accu e in
- self#pat env p,
- accu
-
- method bindings (env : 'env) (accu : 'a) bs =
- List.fold_left self#binding (env, accu) bs
-
- method valdef (env : 'env) (accu : 'a) def =
- let accu = self#expr env accu def.valval in
- accu
-
- method valdefs (env : 'env) (accu : 'a) defs =
- List.fold_left (self#valdef env) accu defs
-
-end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: unionFind.ml,v 1.5 2005/12/01 16:20:07 regisgia Exp $ *)
-
-(** This module implements a simple and efficient union/find algorithm.
- See Robert E. Tarjan, ``Efficiency of a Good But Not Linear Set
- Union Algorithm'', JACM 22(2), 1975. *)
-
-(** The abstraction defined by this module is a set of points,
- partitioned into equivalence classes. With each equivalence class,
- a piece of information, of abstract type ['a], is associated; we
- call it a descriptor.
-
- A point is implemented as a cell, whose (mutable) contents consist
- of a single link to either information about the equivalence class,
- or another point. Thus, points form a graph, which must be acyclic,
- and whose connected components are the equivalence classes. In
- every equivalence class, exactly one point has no outgoing edge,
- and carries information about the class instead. It is the class's
- representative element.
-
- Information about a class consists of an integer weight (the number
- of elements in the class) and of the class's descriptor. *)
-type 'a point = {
- mutable link: 'a link
- }
-
-and 'a link =
- | Info of 'a info
- | Link of 'a point
-
-and 'a info = {
- mutable weight: int;
- mutable descriptor: 'a
- }
-
-(** [fresh desc] creates a fresh point and returns it. It forms an
- equivalence class of its own, whose descriptor is [desc]. *)
-let fresh desc = {
- link = Info { weight = 1; descriptor = desc }
-}
-
-(** [repr point] returns the representative element of [point]'s
- equivalence class. It is found by starting at [point] and following
- the links. For efficiency, the function performs path compression
- at the same time. *)
-let rec repr point =
- match point.link with
- | Link point' ->
- let point'' = repr point' in
- if point'' != point' then
-
- (* [point''] is [point']'s representative element. Because we
- just invoked [repr point'], [point'.link] must be [Link
- point'']. We write this value into [point.link], thus
- performing path compression. Note that this function never
- performs memory allocation. *)
-
- point.link <- point'.link;
- point''
- | Info _ ->
- point
-
-(** [find point] returns the descriptor associated with [point]'s
- equivalence class. *)
-let rec find point =
-
- (* By not calling [repr] immediately, we optimize the common cases
- where the path starting at [point] has length 0 or 1, at the
- expense of the general case. *)
-
- match point.link with
- | Info info
- | Link { link = Info info } ->
- info.descriptor
- | Link { link = Link _ } ->
- find (repr point)
-
-let rec change point v =
- match point.link with
- | Info info
- | Link { link = Info info } ->
- info.descriptor <- v
- | Link { link = Link _ } ->
- change (repr point) v
-
-(** [union point1 point2] merges the equivalence classes associated
- with [point1] and [point2] (which must be distinct) into a single
- class whose descriptor is that originally associated with [point2].
-
- The fact that [point1] and [point2] do not originally belong to the
- same class guarantees that we do not create a cycle in the graph.
-
- The weights are used to determine whether [point1] should be made
- to point to [point2], or vice-versa. By making the representative
- of the smaller class point to that of the larger class, we
- guarantee that paths remain of logarithmic length (not accounting
- for path compression, which makes them yet smaller). *)
-let union point1 point2 =
- let point1 = repr point1
- and point2 = repr point2 in
- assert (point1 != point2);
- match point1.link, point2.link with
- | Info info1, Info info2 ->
- let weight1 = info1.weight
- and weight2 = info2.weight in
- if weight1 >= weight2 then begin
- point2.link <- Link point1;
- info1.weight <- weight1 + weight2;
- info1.descriptor <- info2.descriptor
- end
- else begin
- point1.link <- Link point2;
- info2.weight <- weight1 + weight2
- end
- | _, _ ->
- assert false (* [repr] guarantees that [link] matches [Info _]. *)
-
-(** [equivalent point1 point2] tells whether [point1] and [point2]
- belong to the same equivalence class. *)
-let equivalent point1 point2 =
- repr point1 == repr point2
-
-(** [eunion point1 point2] is identical to [union], except it does
- nothing if [point1] and [point2] are already equivalent. *)
-let eunion point1 point2 =
- if not (equivalent point1 point2) then
- union point1 point2
-
-(** [redundant] maps all members of an equivalence class, but one, to
- [true]. *)
-let redundant = function
- | { link = Link _ } ->
- true
- | { link = Info _ } ->
- false
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* $Id: unionFind.mli,v 1.5 2005/12/01 16:20:07 regisgia Exp $ *)
-
-(** This module implements a simple and efficient union/find algorithm.
- See Robert E. Tarjan, ``Efficiency of a Good But Not Linear Set
- Union Algorithm'', JACM 22(2), 1975. *)
-
-(** The abstraction defined by this module is a set of points,
- partitioned into equivalence classes. With each equivalence class,
- a piece of information, of abstract type ['a], is associated; we
- call it a descriptor. *)
-type 'a point
-
-(** [fresh desc] creates a fresh point and returns it. It forms an
- equivalence class of its own, whose descriptor is [desc]. *)
-val fresh: 'a -> 'a point
-
-(** [find point] returns the descriptor associated with [point]'s
- equivalence class. *)
-val find: 'a point -> 'a
-
-(** [union point1 point2] merges the equivalence classes associated
- with [point1] and [point2] (which must be distinct) into a single
- class whose descriptor is that originally associated with [point2]. *)
-val union: 'a point -> 'a point -> unit
-
-(** [equivalent point1 point2] tells whether [point1] and [point2]
- belong to the same equivalence class. *)
-val equivalent: 'a point -> 'a point -> bool
-
-(** [eunion point1 point2] is identical to [union], except it does
- nothing if [point1] and [point2] are already equivalent. *)
-val eunion: 'a point -> 'a point -> unit
-
-(** [redundant] maps all members of an equivalence class, but one, to
- [true]. *)
-val redundant: 'a point -> bool
-
-(** [change p d] updates the descriptor of [p] to [d]. *)
-val change: 'a point -> 'a -> unit
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-open Positions
-open Misc
-open Syntax
-open Stretch
-open UnparameterizedSyntax
-open Settings
-
-let print_preludes f g =
- List.iter (fun prelude ->
- Printf.fprintf f "%%{%s%%}\n" prelude.stretch_raw_content
- ) g.preludes
-
-let print_start_symbols b g =
- StringSet.iter (fun symbol ->
- Printf.fprintf b "%%start %s\n" (Misc.normalize symbol)
- ) g.start_symbols
-
-let rec insert_in_partitions item m = function
- | [] ->
- [ (m, [ item ]) ]
-
- | (m', items) :: partitions when Mark.same m m' ->
- (m', item :: items) :: partitions
-
- | t :: partitions ->
- t :: (insert_in_partitions item m partitions)
-
-let insert (undefined, partitions) = function
- | (item, UndefinedPrecedence) ->
- ((item, 0) :: undefined, partitions)
-
- | (item, PrecedenceLevel (m, v, _, _)) ->
- (undefined, insert_in_partitions (item, v) m partitions)
-
-let print_ocamltype ocamltype =
- Printf.sprintf " <%s>" (
- match ocamltype with
- | Declared stretch ->
- stretch.stretch_raw_content
- | Inferred t ->
- t
- )
-
-let print_assoc = function
- | LeftAssoc ->
- Printf.sprintf "%%left"
- | RightAssoc ->
- Printf.sprintf "%%right"
- | NonAssoc ->
- Printf.sprintf "%%nonassoc"
- | UndefinedAssoc ->
- ""
-
-let print_tokens mode b g =
- (* Sort tokens wrt precedence. *)
- let undefined, partition_tokens =
- StringMap.fold (fun token prop acu ->
- insert acu (token, prop.tk_priority)
- ) g.tokens ([], [])
- in
- let ordered_tokens =
- List.fold_left (fun acu (_, ms) ->
- acu @ List.sort (fun (_, v) (_, v') -> compare v v') ms
- ) undefined partition_tokens
- in
- List.iter (fun (token, _) ->
- let prop = StringMap.find token g.tokens in
- if prop.tk_is_declared then
- Printf.fprintf b "%%token%s %s\n"
- begin match mode with
- | PrintNormal
- | PrintUnitActions ->
- Misc.o2s prop.tk_ocamltype print_ocamltype
- | PrintUnitActionsUnitTokens ->
- "" (* omitted ocamltype after %token means <unit> *)
- end
- token
- ) ordered_tokens;
-
- ignore (List.fold_left
- (fun last_prop (token, v) ->
- let prop = StringMap.find token g.tokens in
- match last_prop with
-
- | None ->
- if prop.tk_associativity = UndefinedAssoc then
- None
- else (
- Printf.fprintf b "%s %s "
- (print_assoc prop.tk_associativity) token;
- Some v)
-
- | Some v' when v <> v' ->
- if prop.tk_associativity = UndefinedAssoc then
- None
- else (
- Printf.fprintf b "\n%s %s "
- (print_assoc prop.tk_associativity) token;
- Some v)
-
- | Some v' ->
- Printf.fprintf b "%s " token;
- last_prop
-
- ) None ordered_tokens);
- Printf.fprintf b "\n"
-
-let print_types mode b g =
- StringMap.iter (fun symbol ty ->
- Printf.fprintf b "%%type%s %s\n"
- begin match mode with
- | PrintNormal ->
- print_ocamltype ty
- | PrintUnitActions
- | PrintUnitActionsUnitTokens ->
- " <unit>"
- end
- (Misc.normalize symbol)
- ) g.types
-
-let binding mode id =
- match mode with
- | PrintNormal ->
- id ^ " = "
- | PrintUnitActions
- | PrintUnitActionsUnitTokens ->
- ""
-
-let string_of_producer mode (symbol, ido) =
- Misc.o2s ido (binding mode) ^ (Misc.normalize symbol)
-
-let print_branch mode f branch =
- Printf.fprintf f "%s%s\n {"
- (String.concat " " (List.map (string_of_producer mode) branch.producers))
- (Misc.o2s branch.branch_shift_precedence (fun x -> " %prec "^x.value));
- begin match mode with
- | PrintNormal ->
- Action.print f branch.action
- | PrintUnitActions
- | PrintUnitActionsUnitTokens ->
- Printf.fprintf f "()"
- end;
- Printf.fprintf f "}\n"
-
-let print_trailers b g =
- List.iter (Printf.fprintf b "%s\n") g.postludes
-
-let branches_order r r' =
- let branch_order b b' =
- match b.branch_reduce_precedence, b'.branch_reduce_precedence with
- | UndefinedPrecedence, _ | _, UndefinedPrecedence ->
- 0
- | PrecedenceLevel (m, l, _, _), PrecedenceLevel (m', l', _, _) ->
- if Mark.same m m' then
- if l < l' then
- -1
- else if l > l' then
- 1
- else
- 0
- else 0
- in
- let rec lexical_order bs bs' =
- match bs, bs' with
- | [], [] ->
- 0
- | [], _ ->
- -1
- | _, [] ->
- 1
- | b :: bs, b' :: bs' ->
- match branch_order b b' with
- | 0 ->
- lexical_order bs bs'
- | x ->
- x
- in
- lexical_order r.branches r'.branches
-
-let print_rules mode b g =
- let rules_as_list =
- StringMap.fold (fun nt r acu -> (nt, r) :: acu) g.rules []
- in
- let ordered_rules =
- List.sort (fun (nt, r) (nt', r') -> branches_order r r') rules_as_list
- in
- List.iter (fun (nt, r) ->
- Printf.fprintf b "\n%s:\n" (Misc.normalize nt);
- List.iter (fun br ->
- Printf.fprintf b "| ";
- print_branch mode b br
- ) r.branches
- ) ordered_rules
-
-let print mode f g =
- begin match mode with
- | PrintNormal ->
- print_preludes f g
- | PrintUnitActions
- | PrintUnitActionsUnitTokens ->
- ()
- end;
- print_start_symbols f g;
- print_tokens mode f g;
- print_types mode f g;
- Printf.fprintf f "%%%%\n";
- print_rules mode f g;
- Printf.fprintf f "\n%%%%\n";
- begin match mode with
- | PrintNormal ->
- print_trailers f g
- | PrintUnitActions
- | PrintUnitActionsUnitTokens ->
- ()
- end
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* This is a pretty-printer for grammars. *)
-
-(* If the [mode] parameter requests ``unit actions'', then semantic actions
- are dropped: that is, they are replaced with trivial semantic actions that
- return unit. Accordingly, all [%type] declarations are changed to unit. The
- prologue and epilogue are dropped. All bindings for semantic values are
- suppressed.
-
- If, furthermore, the [mode] parameter requests ``unit tokens'', then the
- types carried by tokens are changed to unit. *)
-
-val print: Settings.print_mode -> out_channel -> UnparameterizedSyntax.grammar -> unit
-
+++ /dev/null
-(**************************************************************************)
-(* *)
-(* Menhir *)
-(* *)
-(* François Pottier, INRIA Rocquencourt *)
-(* Yann Régis-Gianas, PPS, Université Paris Diderot *)
-(* *)
-(* Copyright 2005-2008 Institut National de Recherche en Informatique *)
-(* et en Automatique. All rights reserved. This file is distributed *)
-(* under the terms of the Q Public License version 1.0, with the change *)
-(* described in file LICENSE. *)
-(* *)
-(**************************************************************************)
-
-(* A parameterized branch may instantiate parameterized non terminals.
- If the parameterized branch contributes to the definition of a
- parameterized terminal, then the instantiation of parameterized
- non terminals that are defined simultaneously must only be done with
- formal parameters.
- Furthermore, all the parameterized non terminals that are in a common
- mutual recursive definition must have the same arity.
- These conditions are sufficient to ensure termination of expansion.
- For example:
- C[x] : ... // This definition does not involve A or B.
- A[x,y] : B[x,y] C[Y] // This mutual recursive definition is ok.
- B[x,y] : A[x,y]
- D[x] : E[D[x]] // This one is incorrect.
- E[y] : D[y]
-*)
-open Syntax
-
-type branch =
- {
- branch_position : Positions.t;
- producers : (symbol * identifier option) list; (* TEMPORARY convention renversée
- par rapport à syntax.mli; faire un type record au lieu d'une paire? *)
- action : action;
- branch_shift_precedence : branch_shift_precedence;
- branch_reduce_precedence : branch_reduce_precedence
- }
-
-type rule =
- {
- branches : branch list;
- positions : Positions.t list;
- (* This flag is not relevant after the NonTerminalInlining.inline pass. *)
- inline_flag : bool;
- }
-
-type grammar =
- {
- preludes : Stretch.t list;
- postludes : Syntax.trailer list;
- parameters : Stretch.t list;
- start_symbols : StringSet.t;
- types : Stretch.ocamltype StringMap.t;
- tokens : Syntax.token_properties StringMap.t;
- rules : rule StringMap.t;
- }
+++ /dev/null
-let version = "20120123"
--- /dev/null
+menhir-20120123/src/InfiniteArray
+menhir-20120123/src/PackedIntArray
+menhir-20120123/src/RowDisplacement
+menhir-20120123/src/EngineTypes
+menhir-20120123/src/Engine
+menhir-20120123/src/TableFormat
+menhir-20120123/src/TableInterpreter
+menhir-20120123/src/Convert
@$(MAKE) all-opt-build
all-opt-build: $(PCRE_MARKER) pcre.cmxa META
+# prepares the source bundle for building.
+.prepare: $(PCRE_MARKER)
+ touch .prepare
+
clean:
rm -f dllpcre_stubs.so libpcre_stubs.a pcre_stubs.o \
pcre.cma pcre.cmi pcre.cmo META \
distclean: clean
rm -rf $(PCRE_DIR)
+ rm -f .prepare
depend: $(PCRE_MARKER)
--- /dev/null
+# Includes the sources of the
+# bundles' source directory if
+# this directory is included.
+
+<pcre-ocaml-release-6.2.5/lib>: include
--- /dev/null
+pcre-ocaml-release-6.2.5/lib/pcre_stubs.o
pycaml.cmxa: $(PYCAMLDIR)/pycaml.cmx $(PYCAMLDIR)/pycaml.cmi dllpycaml_stubs.so
$(OCAMLOPT_CMD) -I $(PYCAMLDIR) -a -o pycaml.cmxa $<
+# prepares the source bundle for building.
+.prepare: $(PYCAMLMARKER)
+ touch .prepare
+
clean:
rm -f $(PYCAMLDIR)/pycaml.mli pycaml.cm[aixo] $(PYCAMLDIR)/pycaml.cm[aixo] \
pycaml.[ao] libpycaml_stubs.a pycaml_stubs.o dllpycaml_stubs.so libpycaml_stubs.so \
distclean: clean
rm -rf $(PYCAMLDIR)
+ rm -f .prepare
.PHONEY: all all.opt all-build all-opt-build distclean clean depend
# $(PATCH) -d "${PYCAMLDIR}" -p1 < ./python3-compat-fix.patch
# $(PATCH) -d "${PYCAMLDIR}" -p1 < ./pyunicodeapichanges-fix.patch
$(PATCH) -d "${PYCAMLDIR}" -p2 < ./removeunicode.patch
+ $(PATCH) -d "${PYCAMLDIR}" -p1 < ./ignoreheader.patch
+ $(PATCH) -d "${PYCAMLDIR}" -p1 < ./elim-warnings.patch
rm -f "${PYCAMLDIR}/pycaml.mli"
touch $@
--- /dev/null
+# Includes the sources of the
+# bundles' source directory if
+# this directory is included.
+
+<chemoelectric-pycaml-8614105>: include
--- /dev/null
+diff -ru old-pycaml/pycaml_stubs.c chemoelectric-pycaml-8614105/pycaml_stubs.c
+--- old-pycaml/pycaml_stubs.c 2012-08-15 23:03:45.604693537 +0200
++++ chemoelectric-pycaml-8614105/pycaml_stubs.c 2012-08-16 22:03:01.969958132 +0200
+@@ -1886,7 +1886,6 @@
+ CAMLparam1(array);
+ PyObject *tuple = PyTuple_New(Wosize_val(array));
+ int i;
+- int x;
+
+ for( i = 0; i < Wosize_val(array); i++ )
+ {
+@@ -1904,7 +1903,7 @@
+ does this of its own! Nice, isn't it?
+ */
+ Py_INCREF(entry);
+- x = PyTuple_SetItem(tuple,i,entry);
++ PyTuple_SetItem(tuple,i,entry);
+ }
+
+ CAMLreturn(pywrap_steal(tuple));
+@@ -1973,7 +1972,6 @@
+ CAMLparam1(array);
+ PyObject *list = PyList_New(Wosize_val(array));
+ int i;
+- int x;
+
+ for( i = 0; i < Wosize_val(array); i++ )
+ {
+@@ -1981,7 +1979,7 @@
+ entry=pyunwrap(Field(array,i));
+ /* T.F.: See pytuple_fromarray code comments! */
+ Py_INCREF(entry);
+- x = PyList_SetItem(list,i,entry);
++ PyList_SetItem(list,i,entry);
+ }
+ CAMLreturn(pywrap_steal(list));
+ }
--- /dev/null
+diff -Naur old-pycaml/pycaml_stubs.c chemoelectric-pycaml-8614105/pycaml_stubs.c
+--- old-pycaml/pycaml_stubs.c 2012-08-15 23:03:45.604693537 +0200
++++ chemoelectric-pycaml-8614105/pycaml_stubs.c 2012-08-15 23:04:06.010917137 +0200
+@@ -40,7 +40,6 @@
+ #include <unistd.h>
+ #include <stdlib.h>
+ #include <stdio.h>
+-#include "pycaml_stubs.h"
+
+ #if 3 <= PY_MAJOR_VERSION
+ #include <wchar.h>
--- /dev/null
+chemoelectric-pycaml-8614105/pycaml_stubs.o
@$(MAKE) all-opt-build
all-opt-build: .depend $(SEXPMARKER) sexplib.cmxa META
+# prepares the source bundle for building.
+.prepare: $(SEXPMARKER)
+ touch .prepare
+
clean:
rm -f sexplib.cma sexplib.cmxa META \
$(SEXPLIB)/*.cm[ioxa] \
distclean: clean
rm -rf $(SEXPDIR)
+ rm -f .prepare
$(SEXPMARKER): $(SEXPDIR).tar.gz sexp-3.10-compat.patch
$(TAR) xfvz $<
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
ifneq ($(MAKECMDGOALS),depend-build)
-include .depend
+ifneq ($(FEATURE_OCAMLBUILD),yes)
+-include .depend
+endif
endif
endif
endif
- Added a crude mechanism for integrating the results of external analyses with
coccinelle, using positions to connect them together. This is an experimental
feature. See demos/external_ana.{c,cocci,data}.
-
+- Try to do better pretty printing when array elements are individually
+ replaced
+- Just fail quietly on attempt to remove a multi-variable declaration,
+ allowing the semantic patch to continue. A warning message is printed.
+- Ignore unknown identifiers around known types.
+- Ignore --use-glimpse if multiple directories given
+- Added support for c++ namespace syntax in cocci files.
** Bugfix:
- Corrected parsing of script strings delimited by a single quote. Thanks
to Eugeniy Meshcheryakov for reporting the problem.
- Ocaml 4.00.0 compatibility fixes
- Drop inlines, reduce parser code size
- Bind const_vol in the right order in Ast0 visitor
+- use arg_expression for printing iterator arguments instead of expression,
+ to get the right spacing. Thanks to Lars-Peter Clausen for the fix.
+- Better spacing for generated argument lists. Thanks to Lars-Peter Clausen
+ for reporting the problem.
+- Collect all module interfaces for ocaml scripting in a single
+ coccilib.cmi file, with the list of exposed internal modules in
+ ocaml/exposed_modules.ml. This simplifies the installation of the
+ ocaml version of coccilib, and allows us to specify which modules
+ can be accessed by an ocaml script. The coccilib.cmi must either
+ reside in $COCCI_DIR/ocaml/ or $COCCI_DIR/ocaml/coccilib/.
+- Ocamlbuild-based compilation of coccinelle (experimental). In a
+ cleaned repository, use the configure option --enable-ocamlbuild to
+ enable it. The Makefiles will then use ocamlbuild.
+- Ocamlscripts can access more of coccinelle: the file
+ ocaml/exposed_modules.ml specifies which modules are accessible.
+- Use arg_expression to print macro arguments. Thanks to Lars-Peter
+ Clausen for the fix.
+- Remove some trailing whitespace due to unindent or added if braces.
+ Thanks to Eric LeBlond for reporting one of the problems.
+- Remove undesired newline after if header when body is a metavariable.
+ Thanks to Eric LeBlond for reporting the problem.
+- Improve macro expansion to take into account variable numbers of
+ arguments
+- Don't count macros or ifdefs in counting fields
+- Better counting of indent size when indent contains multiple tabs
+- Get the right annotation on trailing , that is after a nest. Requires
+ avoiding double processing in transformation_c.ml
+- Fixed an issue where an 'Impossible' exception could be raised.
+- Fixed an issue where some identifiers were incorrectly interpreted as typedef.
* 0.2.5
** Language:
Flag_cocci.include_options -> 'a) = fun xs choose_includes ->
match choose_includes with
Flag_cocci.I_UNSPECIFIED -> failwith "not possible"
- | Flag_cocci.I_NO_INCLUDES -> []
+ | Flag_cocci.I_NO_INCLUDES -> !Flag_cocci.extra_includes
| x ->
let all_includes =
List.mem x
)
| _ -> None))
+> List.concat
- +> (fun x -> (List.rev (Common.uniq (List.rev x)))) (*uniq keeps last*)
+ +> (fun x ->
+ (List.rev
+ (Common.uniq
+ (!Flag_cocci.extra_includes@(List.rev x)))))(*uniq keeps last*)
let rec interpret_dependencies local global = function
Ast_cocci.Dep s -> List.mem s local
match c with
| Ast_c.Local x -> Left (x, aref)
| Ast_c.NonLocal x -> Right (x, aref)
- | Ast_c.Weird x -> raise Impossible
+ | Ast_c.Weird x -> raise (Impossible 161)
) in
update_rel_pos_bis locals;
let groups = Common.group_assoc_bykey_eff xs in
groups +> Common.map_filter (fun (file, xs) ->
match xs with
- | [] -> raise Impossible
+ | [] -> raise (Impossible 162)
| [res] -> Some (file, res)
| res::xs ->
match res with
OPTOBJS = $(SRC:.ml=.cmx)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
all: $(LIB)
all.opt:
@$(MAKE) $(OPTLIB) BUILD_OPT=yes
clean::
rm -f $(TARGET).top
+else
+all:
+ cd .. && $(OCAMLBUILD) commons/commons.cma
+all.opt:
+ cd .. && $(OCAMLBUILD) commons/commons.cmxa
+clean::
+ cd .. && $(OCAMLBUILD) -clean
+endif
##############################################################################
# Other commons libs target
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
+endif
include ../Makefile.common
* this file.
*)
+(* don't the code below, use the Dumper module in ocamlextra instead.
(* start of dumper.ml *)
(* Dump an OCaml value into a printable string.
let dump v = dump (repr v)
(* end of dumper.ml *)
+*)
(*
let (dump : 'a -> string) = fun x ->
(* ---------------------------------------------------------------------- *)
-let pr2_gen x = pr2 (dump x)
+let pr2_gen x = pr2 (Dumper.dump x)
let assert_equal a b =
if not (a = b)
then failwith ("assert_equal: those 2 values are not equal:\n\t" ^
- (dump a) ^ "\n\t" ^ (dump b) ^ "\n")
+ (Dumper.dump a) ^ "\n\t" ^ (Dumper.dump b) ^ "\n")
let (example2: string -> bool -> unit) = fun s b ->
try assert b with x -> failwith s
(*****************************************************************************)
exception Todo
-exception Impossible
+exception Impossible of int
exception Here
exception ReturnExn
(* old: let _TODO () = failwith "TODO", now via fix_caml with raise Todo *)
let internal_error s = failwith ("internal error: "^s)
-let error_cant_have x = internal_error ("cant have this case: " ^(dump x))
+let error_cant_have x = internal_error ("cant have this case: " ^(Dumper.dump x))
let myassert cond = if cond then () else failwith "assert error"
* In fact dont have to name it, use +> (fun v -> ...) so when want
* erase debug just have to erase one line.
*)
-let warning s v = (pr2 ("Warning: " ^ s ^ "; value = " ^ (dump v)); v)
+let warning s v = (pr2 ("Warning: " ^ s ^ "; value = " ^ (Dumper.dump v)); v)
short_usage_fun();
raise (UnixExit (2))
| Arg.Help msg -> (* printf "%s" msg; exit 0; *)
- raise Impossible (* -help is specified in speclist *)
+ raise (Impossible 1) (* -help is specified in speclist *)
)
| 11 -> "November"
| 12 -> "December"
*)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 2)
let month_info = [
let assoc_with_err_msg k l =
try List.assoc k l
with Not_found ->
- pr2 (spf "pb assoc_with_err_msg: %s" (dump k));
+ pr2 (spf "pb assoc_with_err_msg: %s" (Dumper.dump k));
raise Not_found
(*****************************************************************************)
| ("|" | "/" | "\\" ) ->
f !a !b BnotinA; f !a !b AnotinB; incr a; incr b;
| "<" -> f !a !b AnotinB; incr a;
- | _ -> raise Impossible
+ | _ -> raise (Impossible 3)
)
(*
let _ =
| ">" -> f !a !b BnotinA; incr b;
| "|" -> f !a !b BnotinA; f !a !b AnotinB; incr a; incr b;
| "<" -> f !a !b AnotinB; incr a;
- | _ -> raise Impossible
+ | _ -> raise (Impossible 4)
)
profile_code "Common.full_charpos_to_pos" (fun () -> full_charpos_to_pos2 a)
let test_charpos file =
- full_charpos_to_pos file +> dump +> pr2
+ full_charpos_to_pos file +> Dumper.dump +> pr2
optionise (fun () -> Hashtbl.find newscore res),
optionise (fun () -> Hashtbl.find bestscore res)
with
- | None, None -> raise Impossible
+ | None, None -> raise (Impossible 5)
| Some x, None ->
Printf.printf "new test file appeared: %s\n" res;
Hashtbl.add newbestscore res x;
(* use Dumper.dump *)
val pr2_gen: 'a -> unit
-val dump: 'a -> string
+(* val dump: 'a -> string *)
(* see flag: val disable_pr2_once : bool ref *)
val _already_printed : (string, bool) Hashtbl.t
(* Error managment *)
(*****************************************************************************)
exception Todo
-exception Impossible
+exception Impossible of int
exception Here
exception ReturnExn
--- /dev/null
+Dumper
+ANSITerminal
+Setb
+Mapb
+SetPt
+Commands
+Common
+Common_extra
+Interfaces
+Objet
+Ocollection
+Seti
+Oset
+Oassoc
+Osequence
+Ograph
+Oseti
+Oseth
+Osetb
+Osetpt
+Oassocb
+Oassoch
+Oassoc_buffer
+Oassoc_cache
+Oassocid
+Oarray
+Ograph2way
+Ograph_simple
+Ograph_extended
+Glimpse
+Parser_combinators
+Enum
+DynArray
+Suffix_tree
+Suffix_tree_ext
--- /dev/null
+Dumper
+ANSITerminal
+Setb
+Mapb
+SetPt
+Commands
+Common
+Common_extra
+Interfaces
+Objet
+Ocollection
+Seti
+Oset
+Oassoc
+Osequence
+Ograph
+Oseti
+Oseth
+Osetb
+Osetpt
+Oassocb
+Oassoch
+Oassoc_buffer
+Oassoc_cache
+Oassocid
+Oarray
+Ograph2way
+Ograph_simple
+Ograph_extended
+Glimpse
+Parser_combinators
+Enum
+DynArray
+Suffix_tree
+Suffix_tree_ext
object ('o)
method add_node : 'key -> 'node -> unit
method del_node : 'key -> unit
- method replace_node: 'key -> 'node -> unit
+ method replace_node : 'key -> 'node -> unit
method add_arc : ('key * 'key) -> 'edge -> unit
method allsuccessors : ('key, ('key * 'edge) Oset.oset) Oassoc.oassoc
- method del_leaf_node_and_its_edges: 'key -> unit
+ method del_leaf_node_and_its_edges : 'key -> unit
+
method ancestors : 'key -> 'key Oset.oset
method leaf_nodes : unit -> 'key Oset.oset
method virtual minus: 'o -> 'o
(* allow binary methods tricks, generate exception when not good type *)
- method tosetb: 'a Setb.t = raise Impossible
- method tosetpt: SetPt.t = raise Impossible
- method toseti: Seti.seti = raise Impossible
+ method tosetb: 'a Setb.t = raise (Impossible 10)
+ method tosetpt: SetPt.t = raise (Impossible 11)
+ method toseti: Seti.seti = raise (Impossible 12)
method virtual toset: 'b. 'b (* generic (not safe) tricks *)
(* is_intersect, equal, subset *)
| (Interv (i,j)::xs) when x =|= i-1 -> pack x j xs
| (Interv (i,j)::xs) when x < i-1 -> (Interv (i,j))::add x xs
- | _ -> raise Impossible
+ | _ -> raise (Impossible 6)
)
and add x y = let _ = count5 () in add2 x y
)
| Sup -> aux (y::ys) (x::xs) (* can cos commutative *)
)
- | _ -> raise Impossible (* intervise *)
+ | _ -> raise (Impossible 7) (* intervise *)
)
in
(* TODO avoid the rev rev, but aux good ? need order ? *)
)
| Sup -> aux (y::ys) (x::xs) (* can cos commutative *)
)
- | _ -> raise Impossible (* intervise *)
+ | _ -> raise (Impossible 8) (* intervise *)
)
in
(* union_set (tolist xs) (tolist ys) +> fromlist *)
(* [ ] *)
)
)
- | _ -> raise Impossible (* intervise *)
+ | _ -> raise (Impossible 9) (* intervise *)
)
in
(* minus_set (tolist xs) (tolist ys) +> fromlist *)
#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for coccinelle 1.0.0-rc14.
+# Generated by GNU Autoconf 2.69 for coccinelle 1.0.0-rc15.
#
# Report bugs to <cocci@diku.dk>.
#
# Identity of this package.
PACKAGE_NAME='coccinelle'
PACKAGE_TARNAME='coccinelle'
-PACKAGE_VERSION='1.0.0-rc14'
-PACKAGE_STRING='coccinelle 1.0.0-rc14'
+PACKAGE_VERSION='1.0.0-rc15'
+PACKAGE_STRING='coccinelle 1.0.0-rc15'
PACKAGE_BUGREPORT='cocci@diku.dk'
PACKAGE_URL='http://coccinelle.lip6.fr/'
ac_unique_file="cocci.ml"
-ac_subst_vars='LTLIBOBJS
+ac_subst_vars='am__EXEEXT_FALSE
+am__EXEEXT_TRUE
+LTLIBOBJS
LIBOBJS
+FEATURE_OCAMLBUILD
MAKETARGET_SPATCH
SPATCHNAME
enable_opt
OCAMLLIB
OCAMLVERSION
OCAMLC
+PKG_CONFIG_ORIG
SUBSTITUTED_PKG_CONFIG
OCAMLYACC
OCAMLLEXDOTOPT
OCAMLLEX
+PKG_CONFIG_LIBDIR
+PKG_CONFIG_PATH
with_PKG_CONFIG
PKG_CONFIG
PATCHELF
+INSTALL
PATCH
TAR
CPP
+am__fastdepCC_FALSE
+am__fastdepCC_TRUE
+CCDEPMODE
+am__nodep
+AMDEPBACKSLASH
+AMDEP_FALSE
+AMDEP_TRUE
+am__quote
+am__include
+DEPDIR
OBJEXT
EXEEXT
ac_ct_CC
LDFLAGS
CFLAGS
CC
+DATE
+GIT
+CONFVERSION
+am__untar
+am__tar
+AMTAR
+am__leading_dot
+SET_MAKE
+AWK
+mkdir_p
MKDIR_P
+INSTALL_STRIP_PROGRAM
+STRIP
+install_sh
+MAKEINFO
+AUTOHEADER
+AUTOMAKE
+AUTOCONF
+ACLOCAL
+VERSION
+PACKAGE
+CYGPATH_W
+am__isrc
INSTALL_DATA
INSTALL_SCRIPT
INSTALL_PROGRAM
-DATE
-GIT
-CONFVERSION
COCCI_SRCDIR
COCCI_VERSION
CONFIGURE_FLAGS
ac_subst_files=''
ac_user_opts='
enable_option_checking
+enable_dependency_tracking
with_pkg_config
with_ocamllex
with_ocamlyacc
with_pdflatex
enable_release
enable_opt
+enable_ocamlbuild
'
ac_precious_vars='PYVER
build_alias
CPPFLAGS
CPP
PKG_CONFIG
+PKG_CONFIG_PATH
+PKG_CONFIG_LIBDIR
OCAMLLEX
OCAMLYACC
OCAMLFIND
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
-\`configure' configures coccinelle 1.0.0-rc14 to adapt to many kinds of systems.
+\`configure' configures coccinelle 1.0.0-rc15 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
_ACEOF
cat <<\_ACEOF
+
+Program names:
+ --program-prefix=PREFIX prepend PREFIX to installed program names
+ --program-suffix=SUFFIX append SUFFIX to installed program names
+ --program-transform-name=PROGRAM run sed PROGRAM on installed program names
_ACEOF
fi
if test -n "$ac_init_help"; then
case $ac_init_help in
- short | recursive ) echo "Configuration of coccinelle 1.0.0-rc14:";;
+ short | recursive ) echo "Configuration of coccinelle 1.0.0-rc15:";;
esac
cat <<\_ACEOF
--disable-option-checking ignore unrecognized --enable/--with options
--disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)
--enable-FEATURE[=ARG] include FEATURE [ARG=yes]
+ --enable-dependency-tracking
+ do not reject slow dependency extractors
+ --disable-dependency-tracking
+ speeds up one-time build
--enable-dynlink enable global package dynlink (yes,no) (default:
auto)
--enable-camlp4 enable global package camlp4 (yes,no) (default:
--enable-release build with a release configuration (yes,no,profile
default: no)
--enable-opt build an optimized spatch (yes,no, default: auto)
+ --enable-ocamlbuild enable ocamlbuild support (default: no)
Optional Packages:
--with-PACKAGE[=ARG] use PACKAGE [ARG=yes]
you have headers in a nonstandard directory <include dir>
CPP C preprocessor
PKG_CONFIG path to pkg-config
+ PKG_CONFIG_PATH
+ directories to add to pkg-config's search path
+ PKG_CONFIG_LIBDIR
+ path overriding pkg-config's built-in search path
OCAMLLEX path to ocamllex
OCAMLYACC path to ocamlyacc
OCAMLFIND path to ocamlfind
test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
cat <<\_ACEOF
-coccinelle configure 1.0.0-rc14
+coccinelle configure 1.0.0-rc15
generated by GNU Autoconf 2.69
Copyright (C) 2012 Free Software Foundation, Inc.
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
-It was created by coccinelle $as_me 1.0.0-rc14, which was
+It was created by coccinelle $as_me 1.0.0-rc15, which was
generated by GNU Autoconf 2.69. Invocation command line was
$ $0 $@
ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var.
-
CONFIGURE_FLAGS="$*"
COCCI_VERSION="$PACKAGE_VERSION"
{ $as_echo "$as_me:${as_lineno-$LINENO}: configuring coccinelle $COCCI_VERSION in $COCCI_SRCDIR" >&5
$as_echo "$as_me: configuring coccinelle $COCCI_VERSION in $COCCI_SRCDIR" >&6;}
+am__api_version='1.12'
+
+# Find a good install program. We prefer a C program (faster),
+# so one script is as good as another. But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# OS/2's system install, which has a completely different semantic
+# ./install, which can be erroneously created by make from ./install.sh.
+# Reject install programs that cannot install multiple files.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
+$as_echo_n "checking for a BSD-compatible install... " >&6; }
+if test -z "$INSTALL"; then
+if ${ac_cv_path_install+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in #((
+ ./ | .// | /[cC]/* | \
+ /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+ ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
+ /usr/ucb/* ) ;;
+ *)
+ # OSF1 and SCO ODT 3.0 have their own names for install.
+ # Don't use installbsd from OSF since it installs stuff as root
+ # by default.
+ for ac_prog in ginstall scoinst install; do
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
+ if test $ac_prog = install &&
+ grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+ # AIX install. It has an incompatible calling convention.
+ :
+ elif test $ac_prog = install &&
+ grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+ # program-specific install script used by HP pwplus--don't use.
+ :
+ else
+ rm -rf conftest.one conftest.two conftest.dir
+ echo one > conftest.one
+ echo two > conftest.two
+ mkdir conftest.dir
+ if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
+ test -s conftest.one && test -s conftest.two &&
+ test -s conftest.dir/conftest.one &&
+ test -s conftest.dir/conftest.two
+ then
+ ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+ break 3
+ fi
+ fi
+ fi
+ done
+ done
+ ;;
+esac
+
+ done
+IFS=$as_save_IFS
+
+rm -rf conftest.one conftest.two conftest.dir
+
+fi
+ if test "${ac_cv_path_install+set}" = set; then
+ INSTALL=$ac_cv_path_install
+ else
+ # As a last resort, use the slow shell script. Don't cache a
+ # value for INSTALL within a source directory, because that will
+ # break other packages using the cache if that directory is
+ # removed, or if the value is a relative name.
+ INSTALL=$ac_install_sh
+ fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
+$as_echo "$INSTALL" >&6; }
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
+$as_echo_n "checking whether build environment is sane... " >&6; }
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name. Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+ *[\\\"\#\$\&\'\`$am_lf]*)
+ as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
+esac
+case $srcdir in
+ *[\\\"\#\$\&\'\`$am_lf\ \ ]*)
+ as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
+esac
+
+# Do 'set' in a subshell so we don't clobber the current shell's
+# arguments. Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+ am_has_slept=no
+ for am_try in 1 2; do
+ echo "timestamp, slept: $am_has_slept" > conftest.file
+ set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+ if test "$*" = "X"; then
+ # -L didn't work.
+ set X `ls -t "$srcdir/configure" conftest.file`
+ fi
+ if test "$*" != "X $srcdir/configure conftest.file" \
+ && test "$*" != "X conftest.file $srcdir/configure"; then
+
+ # If neither matched, then we have a broken ls. This can happen
+ # if, for instance, CONFIG_SHELL is bash and it inherits a
+ # broken ls alias from the environment. This has actually
+ # happened. Such a system could not be considered "sane".
+ as_fn_error $? "ls -t appears to fail. Make sure there is not a broken
+ alias in your environment" "$LINENO" 5
+ fi
+ if test "$2" = conftest.file || test $am_try -eq 2; then
+ break
+ fi
+ # Just in case.
+ sleep 1
+ am_has_slept=yes
+ done
+ test "$2" = conftest.file
+ )
+then
+ # Ok.
+ :
+else
+ as_fn_error $? "newly created file is older than distributed files!
+Check your system clock" "$LINENO" 5
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+ ( sleep 1 ) &
+ am_sleep_pid=$!
+fi
+
+rm -f conftest.file
+
+test "$program_prefix" != NONE &&
+ program_transform_name="s&^&$program_prefix&;$program_transform_name"
+# Use a double $ so make ignores it.
+test "$program_suffix" != NONE &&
+ program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+# Double any \ or $.
+# By default was `s,x,x', remove it if useless.
+ac_script='s/[\\$]/&&/g;s/;s,x,x,$//'
+program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
+
+# expand $ac_aux_dir to an absolute path
+am_aux_dir=`cd $ac_aux_dir && pwd`
+
+if test x"${MISSING+set}" != xset; then
+ case $am_aux_dir in
+ *\ * | *\ *)
+ MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
+ *)
+ MISSING="\${SHELL} $am_aux_dir/missing" ;;
+ esac
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --run true"; then
+ am_missing_run="$MISSING --run "
+else
+ am_missing_run=
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
+$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
+fi
+
+if test x"${install_sh}" != xset; then
+ case $am_aux_dir in
+ *\ * | *\ *)
+ install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+ *)
+ install_sh="\${SHELL} $am_aux_dir/install-sh"
+ esac
+fi
+
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip". However 'strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the 'STRIP' environment variable to overrule this program.
+if test "$cross_compiling" != no; then
+ if test -n "$ac_tool_prefix"; then
+ # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_STRIP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$STRIP"; then
+ ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+$as_echo "$STRIP" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+ ac_ct_STRIP=$STRIP
+ # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$ac_ct_STRIP"; then
+ ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_ac_ct_STRIP="strip"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+$as_echo "$ac_ct_STRIP" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+ if test "x$ac_ct_STRIP" = x; then
+ STRIP=":"
+ else
+ case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+ STRIP=$ac_ct_STRIP
+ fi
+else
+ STRIP="$ac_cv_prog_STRIP"
+fi
+
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
+$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
+if test -z "$MKDIR_P"; then
+ if ${ac_cv_path_mkdir+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_prog in mkdir gmkdir; do
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
+ case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
+ 'mkdir (GNU coreutils) '* | \
+ 'mkdir (coreutils) '* | \
+ 'mkdir (fileutils) '4.1*)
+ ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext
+ break 3;;
+ esac
+ done
+ done
+ done
+IFS=$as_save_IFS
+
+fi
+
+ test -d ./--version && rmdir ./--version
+ if test "${ac_cv_path_mkdir+set}" = set; then
+ MKDIR_P="$ac_cv_path_mkdir -p"
+ else
+ # As a last resort, use the slow shell script. Don't cache a
+ # value for MKDIR_P within a source directory, because that will
+ # break other packages using the cache if that directory is
+ # removed, or if the value is a relative name.
+ MKDIR_P="$ac_install_sh -d"
+ fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
+$as_echo "$MKDIR_P" >&6; }
+
+for ac_prog in gawk mawk nawk awk
+do
+ # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AWK+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -n "$AWK"; then
+ ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+ IFS=$as_save_IFS
+ test -z "$as_dir" && as_dir=.
+ for ac_exec_ext in '' $ac_executable_extensions; do
+ if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+ ac_cv_prog_AWK="$ac_prog"
+ $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+ break 2
+ fi
+done
+ done
+IFS=$as_save_IFS
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+$as_echo "$AWK" >&6; }
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+ test -n "$AWK" && break
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
+set x ${MAKE-make}
+ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
+if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ cat >conftest.make <<\_ACEOF
+SHELL = /bin/sh
+all:
+ @echo '@@@%%%=$(MAKE)=@@@%%%'
+_ACEOF
+# GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
+case `${MAKE-make} -f conftest.make 2>/dev/null` in
+ *@@@%%%=?*=@@@%%%*)
+ eval ac_cv_prog_make_${ac_make}_set=yes;;
+ *)
+ eval ac_cv_prog_make_${ac_make}_set=no;;
+esac
+rm -f conftest.make
+fi
+if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+ SET_MAKE=
+else
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+ SET_MAKE="MAKE=${MAKE-make}"
+fi
+
+rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+ am__leading_dot=.
+else
+ am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+ # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+ # is not polluted with repeated "-I."
+ am__isrc=' -I$(srcdir)'
+ # test to see if srcdir already configured
+ if test -f $srcdir/config.status; then
+ as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
+ fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+ if (cygpath --version) >/dev/null 2>/dev/null; then
+ CYGPATH_W='cygpath -w'
+ else
+ CYGPATH_W=echo
+ fi
+fi
+
+
+# Define the identity of the package.
+ PACKAGE='coccinelle'
+ VERSION='1.0.0-rc15'
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE "$PACKAGE"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define VERSION "$VERSION"
+_ACEOF
+
+# Some tools Automake needs.
+
+ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
+
+
+AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
+
+
+AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
+
+
+AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
+
+
+MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
+
+# For better backward compatibility. To be removed once Automake 1.9.x
+# dies out for good. For more background, see:
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+mkdir_p='$(MKDIR_P)'
+
+# We need awk for the "check" target. The system "awk" is bad on
+# some platforms.
+# Always define AMTAR for backward compatibility. Yes, it's still used
+# in the wild :-( We should find a proper way to deprecate it ...
+AMTAR='$${TAR-tar}'
+
+am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
+
+
+
+
+
{ $as_echo "$as_me:${as_lineno-$LINENO}: determining version suffix" >&5
$as_echo "$as_me: version suffix set to $CONFVERSION" >&6;}
-{ $as_echo "$as_me:${as_lineno-$LINENO}: this configure program uses pkg-config m4 macros" >&5
-$as_echo "$as_me: this configure program uses pkg-config m4 macros" >&6;}
-{ $as_echo "$as_me:${as_lineno-$LINENO}: this configure program uses ocaml m4 macros (see setup/ocaml.m4)" >&5
-$as_echo "$as_me: this configure program uses ocaml m4 macros (see setup/ocaml.m4)" >&6;}
-{ $as_echo "$as_me:${as_lineno-$LINENO}: this configure program uses custom m4 macros (see setup/cocci.m4)" >&5
-$as_echo "$as_me: this configure program uses custom m4 macros (see setup/cocci.m4)" >&6;}
-{ $as_echo "$as_me:${as_lineno-$LINENO}: some fake substitutions for required but unavailable programs may be used (see setup/fake*)" >&5
-$as_echo "$as_me: some fake substitutions for required but unavailable programs may be used (see setup/fake*)" >&6;}
-
-
-
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: verifying basic tools" >&5
-$as_echo "$as_me: verifying basic tools" >&6;}
-
-# Find a good install program. We prefer a C program (faster),
-# so one script is as good as another. But avoid the broken or
-# incompatible versions:
-# SysV /etc/install, /usr/sbin/install
-# SunOS /usr/etc/install
-# IRIX /sbin/install
-# AIX /bin/install
-# AmigaOS /C/install, which installs bootblocks on floppy discs
-# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
-# AFS /usr/afsws/bin/install, which mishandles nonexistent args
-# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
-# OS/2's system install, which has a completely different semantic
-# ./install, which can be erroneously created by make from ./install.sh.
-# Reject install programs that cannot install multiple files.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
-$as_echo_n "checking for a BSD-compatible install... " >&6; }
-if test -z "$INSTALL"; then
-if ${ac_cv_path_install+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
- IFS=$as_save_IFS
- test -z "$as_dir" && as_dir=.
- # Account for people who put trailing slashes in PATH elements.
-case $as_dir/ in #((
- ./ | .// | /[cC]/* | \
- /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
- ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
- /usr/ucb/* ) ;;
- *)
- # OSF1 and SCO ODT 3.0 have their own names for install.
- # Don't use installbsd from OSF since it installs stuff as root
- # by default.
- for ac_prog in ginstall scoinst install; do
- for ac_exec_ext in '' $ac_executable_extensions; do
- if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
- if test $ac_prog = install &&
- grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
- # AIX install. It has an incompatible calling convention.
- :
- elif test $ac_prog = install &&
- grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
- # program-specific install script used by HP pwplus--don't use.
- :
- else
- rm -rf conftest.one conftest.two conftest.dir
- echo one > conftest.one
- echo two > conftest.two
- mkdir conftest.dir
- if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
- test -s conftest.one && test -s conftest.two &&
- test -s conftest.dir/conftest.one &&
- test -s conftest.dir/conftest.two
- then
- ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
- break 3
- fi
- fi
- fi
- done
- done
- ;;
-esac
-
- done
-IFS=$as_save_IFS
-
-rm -rf conftest.one conftest.two conftest.dir
-
-fi
- if test "${ac_cv_path_install+set}" = set; then
- INSTALL=$ac_cv_path_install
- else
- # As a last resort, use the slow shell script. Don't cache a
- # value for INSTALL within a source directory, because that will
- # break other packages using the cache if that directory is
- # removed, or if the value is a relative name.
- INSTALL=$ac_install_sh
- fi
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
-$as_echo "$INSTALL" >&6; }
-
-# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
-# It thinks the first close brace ends the variable substitution.
-test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
-
-test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
-
-test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
-$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
-if test -z "$MKDIR_P"; then
- if ${ac_cv_path_mkdir+:} false; then :
- $as_echo_n "(cached) " >&6
-else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
-do
- IFS=$as_save_IFS
- test -z "$as_dir" && as_dir=.
- for ac_prog in mkdir gmkdir; do
- for ac_exec_ext in '' $ac_executable_extensions; do
- as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
- case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
- 'mkdir (GNU coreutils) '* | \
- 'mkdir (coreutils) '* | \
- 'mkdir (fileutils) '4.1*)
- ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext
- break 3;;
- esac
- done
- done
- done
-IFS=$as_save_IFS
-
+{ $as_echo "$as_me:${as_lineno-$LINENO}: this configure program uses pkg-config m4 macros" >&5
+$as_echo "$as_me: this configure program uses pkg-config m4 macros" >&6;}
+{ $as_echo "$as_me:${as_lineno-$LINENO}: this configure program uses ocaml m4 macros (see setup/ocaml.m4)" >&5
+$as_echo "$as_me: this configure program uses ocaml m4 macros (see setup/ocaml.m4)" >&6;}
+{ $as_echo "$as_me:${as_lineno-$LINENO}: this configure program uses custom m4 macros (see setup/cocci.m4)" >&5
+$as_echo "$as_me: this configure program uses custom m4 macros (see setup/cocci.m4)" >&6;}
+{ $as_echo "$as_me:${as_lineno-$LINENO}: some fake substitutions for required but unavailable programs may be used (see setup/fake*)" >&5
+$as_echo "$as_me: some fake substitutions for required but unavailable programs may be used (see setup/fake*)" >&6;}
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: verifying basic tools" >&5
+$as_echo "$as_me: verifying basic tools" >&6;}
+
+
+
+DEPDIR="${am__leading_dot}deps"
+
+ac_config_commands="$ac_config_commands depfiles"
+
+
+am_make=${MAKE-make}
+cat > confinc << 'END'
+am__doit:
+ @echo this is the am__doit target
+.PHONY: am__doit
+END
+# If we don't find an include directive, just comment out the code.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
+$as_echo_n "checking for style of include used by $am_make... " >&6; }
+am__include="#"
+am__quote=
+_am_result=none
+# First try GNU make style include.
+echo "include confinc" > confmf
+# Ignore all kinds of additional output from 'make'.
+case `$am_make -s -f confmf 2> /dev/null` in #(
+*the\ am__doit\ target*)
+ am__include=include
+ am__quote=
+ _am_result=GNU
+ ;;
+esac
+# Now try BSD make style include.
+if test "$am__include" = "#"; then
+ echo '.include "confinc"' > confmf
+ case `$am_make -s -f confmf 2> /dev/null` in #(
+ *the\ am__doit\ target*)
+ am__include=.include
+ am__quote="\""
+ _am_result=BSD
+ ;;
+ esac
fi
- test -d ./--version && rmdir ./--version
- if test "${ac_cv_path_mkdir+set}" = set; then
- MKDIR_P="$ac_cv_path_mkdir -p"
- else
- # As a last resort, use the slow shell script. Don't cache a
- # value for MKDIR_P within a source directory, because that will
- # break other packages using the cache if that directory is
- # removed, or if the value is a relative name.
- MKDIR_P="$ac_install_sh -d"
- fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
+$as_echo "$_am_result" >&6; }
+rm -f confinc confmf
+
+# Check whether --enable-dependency-tracking was given.
+if test "${enable_dependency_tracking+set}" = set; then :
+ enableval=$enable_dependency_tracking;
+fi
+
+if test "x$enable_dependency_tracking" != xno; then
+ am_depcomp="$ac_aux_dir/depcomp"
+ AMDEPBACKSLASH='\'
+ am__nodep='_no'
+fi
+ if test "x$enable_dependency_tracking" != xno; then
+ AMDEP_TRUE=
+ AMDEP_FALSE='#'
+else
+ AMDEP_TRUE='#'
+ AMDEP_FALSE=
fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
-$as_echo "$MKDIR_P" >&6; }
+
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compiler_gnu=$ac_cv_c_compiler_gnu
+depcc="$CC" am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if ${am_cv_CC_dependencies_compiler_type+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+ # We make a subdir and do the tests there. Otherwise we can end up
+ # making bogus files that we don't know about and never remove. For
+ # instance it was reported that on HP-UX the gcc test will end up
+ # making a dummy file named 'D' -- because '-MD' means "put the output
+ # in D".
+ rm -rf conftest.dir
+ mkdir conftest.dir
+ # Copy depcomp to subdir because otherwise we won't find it if we're
+ # using a relative directory.
+ cp "$am_depcomp" conftest.dir
+ cd conftest.dir
+ # We will build objects and dependencies in a subdirectory because
+ # it helps to detect inapplicable dependency modes. For instance
+ # both Tru64's cc and ICC support -MD to output dependencies as a
+ # side effect of compilation, but ICC will put the dependencies in
+ # the current directory while Tru64 will put them in the object
+ # directory.
+ mkdir sub
+
+ am_cv_CC_dependencies_compiler_type=none
+ if test "$am_compiler_list" = ""; then
+ am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
+ fi
+ am__universal=false
+ case " $depcc " in #(
+ *\ -arch\ *\ -arch\ *) am__universal=true ;;
+ esac
+
+ for depmode in $am_compiler_list; do
+ # Setup a source with many dependencies, because some compilers
+ # like to wrap large dependency lists on column 80 (with \), and
+ # we should not choose a depcomp mode which is confused by this.
+ #
+ # We need to recreate these files for each test, as the compiler may
+ # overwrite some of them when testing with obscure command lines.
+ # This happens at least with the AIX C compiler.
+ : > sub/conftest.c
+ for i in 1 2 3 4 5 6; do
+ echo '#include "conftst'$i'.h"' >> sub/conftest.c
+ # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+ # Solaris 10 /bin/sh.
+ echo '/* dummy */' > sub/conftst$i.h
+ done
+ echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+ # We check with '-c' and '-o' for the sake of the "dashmstdout"
+ # mode. It turns out that the SunPro C++ compiler does not properly
+ # handle '-M -o', and we need to detect this. Also, some Intel
+ # versions had trouble with output in subdirs.
+ am__obj=sub/conftest.${OBJEXT-o}
+ am__minus_obj="-o $am__obj"
+ case $depmode in
+ gcc)
+ # This depmode causes a compiler race in universal mode.
+ test "$am__universal" = false || continue
+ ;;
+ nosideeffect)
+ # After this tag, mechanisms are not by side-effect, so they'll
+ # only be used when explicitly requested.
+ if test "x$enable_dependency_tracking" = xyes; then
+ continue
+ else
+ break
+ fi
+ ;;
+ msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+ # This compiler won't grok '-c -o', but also, the minuso test has
+ # not run yet. These depmodes are late enough in the game, and
+ # so weak that their functioning should not be impacted.
+ am__obj=conftest.${OBJEXT-o}
+ am__minus_obj=
+ ;;
+ none) break ;;
+ esac
+ if depmode=$depmode \
+ source=sub/conftest.c object=$am__obj \
+ depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+ $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+ >/dev/null 2>conftest.err &&
+ grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+ grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+ grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+ ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+ # icc doesn't choke on unknown options, it will just issue warnings
+ # or remarks (even with -Werror). So we grep stderr for any message
+ # that says an option was ignored or not supported.
+ # When given -MP, icc 7.0 and 7.1 complain thusly:
+ # icc: Command line warning: ignoring option '-M'; no argument required
+ # The diagnosis changed in icc 8.0:
+ # icc: Command line remark: option '-MP' not supported
+ if (grep 'ignoring option' conftest.err ||
+ grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+ am_cv_CC_dependencies_compiler_type=$depmode
+ break
+ fi
+ fi
+ done
+
+ cd ..
+ rm -rf conftest.dir
+else
+ am_cv_CC_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
+$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
+CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+
+ if
+ test "x$enable_dependency_tracking" != xno \
+ && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
+ am__fastdepCC_TRUE=
+ am__fastdepCC_FALSE='#'
+else
+ am__fastdepCC_TRUE='#'
+ am__fastdepCC_FALSE=
+fi
+
+
ac_ext=c
ac_cpp='$CPP $CPPFLAGS'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
fi
+
+if test "$INSTALL" = "setup/install-sh -c" -o "$INSTALL" = "./setup-install-sh -c"; then :
+ INSTALL="$COCCI_SRCDIR/$INSTALL"
+
+
+fi
+
+if test "$MKDIR_P" = "setup/install-sh -c -d" -o "$INSTALL" = "./setup-install-sh -c -d"; then :
+ MKDIR_P="$COCCI_SRCDIR/$MKDIR_P"
+
+
+fi
+
# Extract the first word of "patchelf", so it can be a program name with args.
set dummy patchelf; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
if test "x$PKG_CONFIG" = xpkg-config -a "xPKG_CONFIG" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "x$PKG_CONFIG" = xocamllex -a "xPKG_CONFIG" = xOCAMLLEX; then :
fi
- if test -n "$COCCI_SRCDIR/setup/fake-subst.sh pkg-config"; then :
- { $as_echo "$as_me:${as_lineno-$LINENO}: pkg-config not found. Trying substitute $COCCI_SRCDIR/setup/fake-subst.sh pkg-config." >&5
-$as_echo "$as_me: pkg-config not found. Trying substitute $COCCI_SRCDIR/setup/fake-subst.sh pkg-config." >&6;}
- PKG_CONFIG="$COCCI_SRCDIR/setup/fake-subst.sh pkg-config"
+ if test -n ""; then :
+ { $as_echo "$as_me:${as_lineno-$LINENO}: pkg-config not found. Trying substitute ." >&5
+$as_echo "$as_me: pkg-config not found. Trying substitute ." >&6;}
+ PKG_CONFIG=""
if test "xpkg-config" = xpkg-config -a "xPKG_CONFIG" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "xpkg-config" = xocamllex -a "xPKG_CONFIG" = xOCAMLLEX; then :
fi
if test "x$PKG_CONFIG" = xno; then :
- as_fn_error $? "A suitable pkg-config could not be found." "$LINENO" 5
+ PKG_CONFIG_ORIG=pkg-config
+
+
+else
+ PKG_CONFIG_ORIG=$PKG_CONFIG
+
fi
+PKG_CONFIG="$COCCI_SRCDIR/setup/fake-subst.sh $PKG_CONFIG_ORIG"
+
+
+
# checking for ocamlc
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}ocamlc", so it can be a program name with args.
if test "x$OCAMLLEX" = xpkg-config -a "xOCAMLLEX" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "x$OCAMLLEX" = xocamllex -a "xOCAMLLEX" = xOCAMLLEX; then :
if test "xocamllex" = xpkg-config -a "xOCAMLLEX" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "xocamllex" = xocamllex -a "xOCAMLLEX" = xOCAMLLEX; then :
if test "x$OCAMLYACC" = xpkg-config -a "xOCAMLYACC" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "x$OCAMLYACC" = xocamllex -a "xOCAMLYACC" = xOCAMLLEX; then :
if test "xocamlyacc" = xpkg-config -a "xOCAMLYACC" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "xocamlyacc" = xocamllex -a "xOCAMLYACC" = xOCAMLLEX; then :
if test "x$OCAMLFIND" = xpkg-config -a "xOCAMLFIND" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "x$OCAMLFIND" = xocamllex -a "xOCAMLFIND" = xOCAMLLEX; then :
if test "xocamlfind" = xpkg-config -a "xOCAMLFIND" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "xocamlfind" = xocamllex -a "xOCAMLFIND" = xOCAMLLEX; then :
if test "x$OCAMLPROF" = xpkg-config -a "xOCAMLPROF" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "x$OCAMLPROF" = xocamllex -a "xOCAMLPROF" = xOCAMLLEX; then :
if test "xocamlprof" = xpkg-config -a "xOCAMLPROF" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "xocamlprof" = xocamllex -a "xOCAMLPROF" = xOCAMLLEX; then :
if test "x$MENHIR" = xpkg-config -a "xMENHIR" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "x$MENHIR" = xocamllex -a "xMENHIR" = xOCAMLLEX; then :
if test "xmenhir" = xpkg-config -a "xMENHIR" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "xmenhir" = xocamllex -a "xMENHIR" = xOCAMLLEX; then :
if test "x$PYTHON" = xpkg-config -a "xPYTHON" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "x$PYTHON" = xocamllex -a "xPYTHON" = xOCAMLLEX; then :
if test "xpython" = xpkg-config -a "xPYTHON" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "xpython" = xocamllex -a "xPYTHON" = xOCAMLLEX; then :
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
pkg_cv_PYTHON_CFLAGS=`$PKG_CONFIG --cflags "python-$PYVER" 2>/dev/null`
+ test "x$?" != "x0" && pkg_failed=yes
else
pkg_failed=yes
fi
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
pkg_cv_PYTHON_LIBS=`$PKG_CONFIG --libs "python-$PYVER" 2>/dev/null`
+ test "x$?" != "x0" && pkg_failed=yes
else
pkg_failed=yes
fi
if test $pkg_failed = yes; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
_pkg_short_errors_supported=yes
_pkg_short_errors_supported=no
fi
if test $_pkg_short_errors_supported = yes; then
- PYTHON_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "python-$PYVER" 2>&1`
+ PYTHON_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "python-$PYVER" 2>&1`
else
- PYTHON_PKG_ERRORS=`$PKG_CONFIG --print-errors "python-$PYVER" 2>&1`
+ PYTHON_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "python-$PYVER" 2>&1`
fi
# Put the nasty error message in config.log where it belongs
echo "$PYTHON_PKG_ERRORS" >&5
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
- HAVE_PYTHON=no
+ HAVE_PYTHON=no
elif test $pkg_failed = untried; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
HAVE_PYTHON=no
else
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
pkg_cv_PYTHON_CFLAGS=`$PKG_CONFIG --cflags "python" 2>/dev/null`
+ test "x$?" != "x0" && pkg_failed=yes
else
pkg_failed=yes
fi
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
pkg_cv_PYTHON_LIBS=`$PKG_CONFIG --libs "python" 2>/dev/null`
+ test "x$?" != "x0" && pkg_failed=yes
else
pkg_failed=yes
fi
if test $pkg_failed = yes; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
_pkg_short_errors_supported=yes
_pkg_short_errors_supported=no
fi
if test $_pkg_short_errors_supported = yes; then
- PYTHON_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "python" 2>&1`
+ PYTHON_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "python" 2>&1`
else
- PYTHON_PKG_ERRORS=`$PKG_CONFIG --print-errors "python" 2>&1`
+ PYTHON_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "python" 2>&1`
fi
# Put the nasty error message in config.log where it belongs
echo "$PYTHON_PKG_ERRORS" >&5
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
- HAVE_PYTHON=no
+ HAVE_PYTHON=no
elif test $pkg_failed = untried; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
HAVE_PYTHON=no
else
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
pkg_cv_PCRE_CFLAGS=`$PKG_CONFIG --cflags "libpcre" 2>/dev/null`
+ test "x$?" != "x0" && pkg_failed=yes
else
pkg_failed=yes
fi
$as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
test $ac_status = 0; }; then
pkg_cv_PCRE_LIBS=`$PKG_CONFIG --libs "libpcre" 2>/dev/null`
+ test "x$?" != "x0" && pkg_failed=yes
else
pkg_failed=yes
fi
if test $pkg_failed = yes; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
_pkg_short_errors_supported=yes
_pkg_short_errors_supported=no
fi
if test $_pkg_short_errors_supported = yes; then
- PCRE_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors "libpcre" 2>&1`
+ PCRE_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "libpcre" 2>&1`
else
- PCRE_PKG_ERRORS=`$PKG_CONFIG --print-errors "libpcre" 2>&1`
+ PCRE_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "libpcre" 2>&1`
fi
# Put the nasty error message in config.log where it belongs
echo "$PCRE_PKG_ERRORS" >&5
- { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
- HAVE_PCRE=no
+ HAVE_PCRE=no
elif test $pkg_failed = untried; then
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
HAVE_PCRE=no
else
if test "x$PDFLATEX" = xpkg-config -a "xPDFLATEX" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "x$PDFLATEX" = xocamllex -a "xPDFLATEX" = xOCAMLLEX; then :
if test "xpdflatex" = xpkg-config -a "xPDFLATEX" = xPKG_CONFIG; then :
+
+
+
+
+
if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
$as_echo "no" >&6; }
PKG_CONFIG=""
fi
-
fi
elif test "xpdflatex" = xocamllex -a "xPDFLATEX" = xOCAMLLEX; then :
MAKETARGET_ALL=all-dev
- OCAMLC="$COCCI_SRCDIR/setup/wrapper-ocamlcp.sh \"$OCAMLCORIG\" \"$OCAMLPROF\""
+ OCAMLC="$COCCI_SRCDIR/setup/wrapper-ocamlcp.sh $OCAMLCORIG $OCAMLPROF"
MODULES_profiling=profiling.cmo
fi
-# set the default enable-opt setting
if test -z "$enable_opt"; then :
if test "x$enable_release" = xyes -o "x$enable_release" = xno; then :
enable_opt="$enable_release"
fi
+# Check whether --enable-ocamlbuild was given.
+if test "${enable_ocamlbuild+set}" = set; then :
+ enableval=$enable_ocamlbuild;
+fi
+
+if test "x$enable_ocamlbuild" = xyes; then :
+ if test -z "$OCAMLBUILD" -o "x$OCAMLBUILD" = xno; then :
+ as_fn_error $? "Ocamlbuild is required but is not installed." "$LINENO" 5
+
+fi
+
+ FEATURE_OCAMLBUILD=yes
+
+
+else
+ FEATURE_OCAMLBUILD=
+
+
+fi
+
+
-ac_config_files="$ac_config_files Makefile.config version.ml commons/commands.ml globals/config.ml globals/regexp.ml python/pycocci.ml ocaml/prepare_ocamlcocci.ml scripts/spatch.sh docs/spatch.1"
+ac_config_files="$ac_config_files Makefile.config version.ml commons/commands.ml globals/config.ml globals/regexp.ml python/pycocci.ml ocaml/prepare_ocamlcocci.ml scripts/spatch.sh docs/spatch.1 myocamlbuild.ml setup/Makefile"
cat >confcache <<\_ACEOF
LTLIBOBJS=$ac_ltlibobjs
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
+$as_echo_n "checking that generated files are newer than configure... " >&6; }
+ if test -n "$am_sleep_pid"; then
+ # Hide warnings about reused PIDs.
+ wait $am_sleep_pid 2>/dev/null
+ fi
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5
+$as_echo "done" >&6; }
+ if test -n "$EXEEXT"; then
+ am__EXEEXT_TRUE=
+ am__EXEEXT_FALSE='#'
+else
+ am__EXEEXT_TRUE='#'
+ am__EXEEXT_FALSE=
+fi
+
+if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
+ as_fn_error $? "conditional \"AMDEP\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
+ as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
: "${CONFIG_STATUS=./config.status}"
ac_write_fail=0
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
-This file was extended by coccinelle $as_me 1.0.0-rc14, which was
+This file was extended by coccinelle $as_me 1.0.0-rc15, which was
generated by GNU Autoconf 2.69. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
# Files that config.status was made for.
config_files="$ac_config_files"
+config_commands="$ac_config_commands"
_ACEOF
Configuration files:
$config_files
+Configuration commands:
+$config_commands
+
Report bugs to <cocci@diku.dk>.
coccinelle home page: <http://coccinelle.lip6.fr/>."
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
-coccinelle config.status 1.0.0-rc14
+coccinelle config.status 1.0.0-rc15
configured by $0, generated by GNU Autoconf 2.69,
with options \\"\$ac_cs_config\\"
srcdir='$srcdir'
INSTALL='$INSTALL'
MKDIR_P='$MKDIR_P'
+AWK='$AWK'
test -n "\$AWK" || AWK=awk
_ACEOF
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+#
+# INIT-COMMANDS
+#
+AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+
_ACEOF
cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
for ac_config_target in $ac_config_targets
do
case $ac_config_target in
+ "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
"Makefile.config") CONFIG_FILES="$CONFIG_FILES Makefile.config" ;;
"version.ml") CONFIG_FILES="$CONFIG_FILES version.ml" ;;
"commons/commands.ml") CONFIG_FILES="$CONFIG_FILES commons/commands.ml" ;;
"ocaml/prepare_ocamlcocci.ml") CONFIG_FILES="$CONFIG_FILES ocaml/prepare_ocamlcocci.ml" ;;
"scripts/spatch.sh") CONFIG_FILES="$CONFIG_FILES scripts/spatch.sh" ;;
"docs/spatch.1") CONFIG_FILES="$CONFIG_FILES docs/spatch.1" ;;
+ "myocamlbuild.ml") CONFIG_FILES="$CONFIG_FILES myocamlbuild.ml" ;;
+ "setup/Makefile") CONFIG_FILES="$CONFIG_FILES setup/Makefile" ;;
*) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
esac
# bizarre bug on SunOS 4.1.3.
if $ac_need_defaults; then
test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+ test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
fi
# Have a temporary directory for convenience. Make it in the build tree
fi # test -n "$CONFIG_FILES"
-eval set X " :F $CONFIG_FILES "
+eval set X " :F $CONFIG_FILES :C $CONFIG_COMMANDS"
shift
for ac_tag
do
;;
+ :C) { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
+$as_echo "$as_me: executing $ac_file commands" >&6;}
+ ;;
+ esac
+
+ case $ac_file$ac_mode in
+ "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
+ # Autoconf 2.62 quotes --file arguments for eval, but not when files
+ # are listed without --file. Let's play safe and only enable the eval
+ # if we detect the quoting.
+ case $CONFIG_FILES in
+ *\'*) eval set x "$CONFIG_FILES" ;;
+ *) set x $CONFIG_FILES ;;
esac
+ shift
+ for mf
+ do
+ # Strip MF so we end up with the name of the file.
+ mf=`echo "$mf" | sed -e 's/:.*$//'`
+ # Check whether this is an Automake generated Makefile or not.
+ # We used to match only the files named 'Makefile.in', but
+ # some people rename them; so instead we look at the file content.
+ # Grep'ing the first line is not enough: some people post-process
+ # each Makefile.in and add a new line on top of each file to say so.
+ # Grep'ing the whole file is not good either: AIX grep has a line
+ # limit of 2048, but all sed's we know have understand at least 4000.
+ if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
+ dirpart=`$as_dirname -- "$mf" ||
+$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$mf" : 'X\(//\)[^/]' \| \
+ X"$mf" : 'X\(//\)$' \| \
+ X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$mf" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)[^/].*/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'`
+ else
+ continue
+ fi
+ # Extract the definition of DEPDIR, am__include, and am__quote
+ # from the Makefile without running 'make'.
+ DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
+ test -z "$DEPDIR" && continue
+ am__include=`sed -n 's/^am__include = //p' < "$mf"`
+ test -z "am__include" && continue
+ am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
+ # Find all dependency output files, they are included files with
+ # $(DEPDIR) in their names. We invoke sed twice because it is the
+ # simplest approach to changing $(DEPDIR) to its actual value in the
+ # expansion.
+ for file in `sed -n "
+ s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
+ sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
+ # Make sure the directory exists.
+ test -f "$dirpart/$file" && continue
+ fdir=`$as_dirname -- "$file" ||
+$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$file" : 'X\(//\)[^/]' \| \
+ X"$file" : 'X\(//\)$' \| \
+ X"$file" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$file" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)[^/].*/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'`
+ as_dir=$dirpart/$fdir; as_fn_mkdir_p
+ # echo "creating $dirpart/$file"
+ echo '# dummy' > "$dirpart/$file"
+ done
+ done
+}
+ ;;
+ esac
done # for ac_tag
+dnl run 'autoreconf' to obtain aclocal.m4, and update configure and setup/pkg.m4
+dnl run 'automake -acf' to update setup/{install-sh,missing}
+
dnl standard initialization (we only use autoconf not automake)
AC_PREREQ([2.68])
AC_INIT([coccinelle], m4_esyscmd([cat ./version | tr -d '\n']), [cocci@diku.dk], [], [http://coccinelle.lip6.fr/])
AC_CONFIG_MACRO_DIR([setup])
AC_CONFIG_AUX_DIR([setup])
-
AC_SUBST([CONFIGURE_FLAGS], ["$*"])
AC_SUBST([COCCI_VERSION], ["$PACKAGE_VERSION"])
AC_SUBST([COCCI_SRCDIR], ["$(pwd)"])
AC_MSG_NOTICE([configuring coccinelle $COCCI_VERSION in $COCCI_SRCDIR])
+AM_INIT_AUTOMAKE
AC_CONFIG_SRCDIR([cocci.ml]) dnl this file must be present in our src directory
AC_COCCI_CONFVERSION
AC_PROG_CPP
AC_PATH_PROG([TAR],[tar])
AC_PATH_PROG([PATCH],[patch])
+
+dnl ensures that INSTALL points to an absolute install-sh when that one is configured.
+AS_IF([test "$INSTALL" = "setup/install-sh -c" -o "$INSTALL" = "./setup-install-sh -c"],
+[dnl
+ AC_SUBST([INSTALL], ["$COCCI_SRCDIR/$INSTALL"])
+])
+
+dnl the same for MKDIR_P
+AS_IF([test "$MKDIR_P" = "setup/install-sh -c -d" -o "$INSTALL" = "./setup-install-sh -c -d"],
+[dnl
+ AC_SUBST([MKDIR_P], ["$COCCI_SRCDIR/$MKDIR_P"])
+])
+
+dnl patchelf is an optional dependency and in principle not used for building coccinelle
AC_PATH_PROG([PATCHELF],[patchelf])
-dnl pkg config is required
-AC_COCCI_TOOL([PKG_CONFIG],[pkg-config],[$COCCI_SRCDIR/setup/fake-subst.sh pkg-config])
+dnl pkg config is required, but we have an alternative script for it
+AC_COCCI_TOOL([PKG_CONFIG],[pkg-config])
AS_IF([test "x$PKG_CONFIG" = xno],
-[dnl
- AC_MSG_ERROR([A suitable pkg-config could not be found.])
+[dnl no specific pkg-config configured
+ AC_SUBST([PKG_CONFIG_ORIG],[pkg-config])
+],
+[dnl a specific pkg-config configured
+ AC_SUBST([PKG_CONFIG_ORIG],[$PKG_CONFIG])
])
-dnl ocaml compile
+dnl always use the wrapper around pkg-config
+AC_SUBST([PKG_CONFIG],["$COCCI_SRCDIR/setup/fake-subst.sh $PKG_CONFIG_ORIG"])
+
+
+dnl ocaml compiler configuration
AC_PROG_OCAML
AC_CHECK_OCAMLVERSION([OCAMLATLEAST310],[3.10])
AC_CHECK_OCAMLVERSION([OCAMLATLEAST311],[3.11])
dnl configuration-time overrides for profiling
AC_SUBST([MAKETARGET_ALL], [all-dev])
- AC_SUBST([OCAMLC], ["$COCCI_SRCDIR/setup/wrapper-ocamlcp.sh \"$OCAMLCORIG\" \"$OCAMLPROF\""])
+ AC_SUBST([OCAMLC], ["$COCCI_SRCDIR/setup/wrapper-ocamlcp.sh $OCAMLCORIG $OCAMLPROF"])
AC_SUBST([MODULES_profiling], [profiling.cmo])
AC_MSG_NOTICE([configured coccinelle for profiling])
],
])
])
-# set the default enable-opt setting
+dnl set the default enable-opt setting
AS_IF([test -z "$enable_opt"],
[dnl
AS_IF([test "x$enable_release" = xyes -o "x$enable_release" = xno],
])
+dnl ocamlbuild handling
+AC_ARG_ENABLE([ocamlbuild], AS_HELP_STRING([--enable-ocamlbuild], [enable ocamlbuild support (default: no)]))
+AS_IF([test "x$enable_ocamlbuild" = xyes],
+[dnl ocamlbuild support requested
+ AS_IF([test -z "$OCAMLBUILD" -o "x$OCAMLBUILD" = xno],
+ [dnl
+ AC_MSG_ERROR([Ocamlbuild is required but is not installed.])
+ ])
+
+ AC_SUBST([FEATURE_OCAMLBUILD], [yes])
+],
+[dnl default: disable ocamlbuild support
+ AC_SUBST([FEATURE_OCAMLBUILD], [ ])
+])
+
+
dnl
dnl generating configuration
dnl
ocaml/prepare_ocamlcocci.ml
scripts/spatch.sh
docs/spatch.1
+ myocamlbuild.ml
+
+ setup/Makefile
])
AC_OUTPUT
OBJS = $(SRC:.ml=.cmo)
OPTOBJS = $(SRC:.ml=.cmx)
+
+ifneq ($(FEATURE_OCAMLBUILD),yes)
all: $(LIB)
all.opt:
@$(MAKE) $(OPTLIB) BUILD_OPT=yes
clean::
rm -f $(LIB) $(OPTLIB) $(LIB:.cma=.a) $(TARGET).top
+else
+all:
+ cd .. && $(OCAMLBUILD) ctl/ctl.cma
+
+all.opt:
+ cd .. && $(OCAMLBUILD) ctl/ctl.cmxa
+
+clean::
+ cd .. && $(OCAMLBUILD) -clean
+ rm -f test_ctl
+
+test_ctl:
+ cd .. && $(OCAMLBUILD) ctl/test_ctl.byte
+ cp ../_build/ctl/test_ctl.byte test_ctl
+endif
.SUFFIXES:
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
+endif
include ../Makefile.common
--- /dev/null
+Ast_ctl
+Ctl_engine
+Flag_ctl
+Pretty_print_ctl
+Wrapper_ctl
--- /dev/null
+Ast_ctl
+Ctl_engine
+Flag_ctl
+Pretty_print_ctl
+Wrapper_ctl
match phi with
| A.False -> pp "False"
| A.True -> pp "True"
- | A.Pred(p) -> pp ("Pred" ^ (Common.dump p))
+ | A.Pred(p) -> pp ("Pred" ^ (Dumper.dump p))
| A.Not(phi) -> pp "Not"
- | A.Exists(_,v,phi) -> pp ("Exists " ^ (Common.dump(v)))
+ | A.Exists(_,v,phi) -> pp ("Exists " ^ (Dumper.dump(v)))
| A.And(_,phi1,phi2) -> pp "And"
| A.AndAny(dir,_,phi1,phi2) -> pp "AndAny"
| A.HackForStmt(dir,_,phi1,phi2) -> pp "HackForStmt"
@@
-identifier *X;
+idexpression *X;
statement S;
@@
S
@@
-identifier *X;
+idexpression *X;
statement S;
@@
@@
- kcalloc(1, X, Y)
-
-//=> kmalloc(x, y)
++ kmalloc(X, Y)
- memset((T2)x,0,E1);
@@
-type T, T2;
+type T2;
type T1;
T1 *x;
identifier f,fld;
- memset((T2)x,0,sizeof(*x));
@@
-type T, T2;
+type T2;
type T1;
T1 *x;
identifier f,fld;
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
@@
-type T, T2;
+type T2;
expression x;
identifier f,fld;
expression E;
} else S1
@@
-type T, T2;
+type T2;
type T1;
T1 *x;
identifier f,fld;
} else S1
@@
-type T, T2;
+type T2;
type T1;
T1 *x;
identifier f,fld;
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
@@
-type T, T2;
+type T2;
type T1;
identifier x;
identifier f,fld;
- memset((T2)x,0,E1);
@@
-type T, T2;
+type T2;
type T1;
identifier x;
identifier f,fld;
- memset((T2)x,0,sizeof(*x));
@@
-type T, T2;
+type T2;
type T1;
identifier x;
identifier f,fld;
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
@@
-type T, T2;
+type T2;
type T1;
identifier x;
identifier f,fld;
} else S1
@@
-type T, T2;
+type T2;
type T1;
identifier x;
identifier f,fld;
} else S1
@@
-type T, T2;
+type T2;
type T1;
identifier x;
identifier f,fld;
@@
-iterator list_for_each;
+iterator name list_for_each;
statement S;
expression head;
struct list_head *pos;
@@
- for (pos = head.next; pos != &head; pos = pos->next)
-- S
-//+ list_for_each(pos, &head)
++ list_for_each(pos, &head)
+ S
+
@@
struct list_head *pos;
@@
- for (pos = head->next; pos != head; pos = pos->next)
-- S
-//+ list_for_each(pos, head)
++ list_for_each(pos, head)
+ S
@ rule1 @
identifier initfunc;
+declarer name module_init;
@@
module_init(initfunc);
@@
identifier x;
-constant char *s;
+constant char [] s;
@@
$(PDFLATEX_CMD) options.tex
distclean:: clean
- rm -f manual.pdf cocci_syntax.pdf options.pdf
+ @if test -z "${KEEP_GENERATED}"; then \
+ rm -f manual.pdf cocci_syntax.pdf options.pdf; fi
# lindig trick
rm -f *.aux *.dvi *.haux *.htoc *.log *.out *~
distclean:: clean
- rm -f *.pdf *.html *.gif *.css
+ @if test -z "${KEEP_GENERATED}"; then \
+ rm -f *.pdf *.html *.gif *.css; fi
check: $(HTML)
checklink $<
\normal{-I $\langle$path$\rangle$}{ This option specifies a directory
in which to find non-local include files. This option can be used
- several times.}
+ several times to specify multipls include paths.}
+
+\rare{--include $\langle$file$\rangle$}{ This option give the name of a
+ file to consider as being included in each processed file. The file is
+ added to the end of the file's list of included files. The complete path
+ name should be given; the {\bf -I} options are not taken into account to
+ find the file. This option can be used
+ several times to include multiple files.}
\rare{--relax-include-path}{This option when combined with --all-includes
causes the search for local
.\" -*- nroff -*-
.\" Please adjust this date whenever revising the manpage.
-.TH SPATCH 1 "may 17, 2011"
+.TH SPATCH 1 "aug 02, 2012"
.\" see http://www.fnal.gov/docs/products/ups/ReferenceManual/html/manpages.html
.\" see http://www.linuxjournal.com/article/1158
##############################################################################
# Top rules
##############################################################################
+ifneq ($(FEATURE_OCAMLBUILD),yes)
all: $(TARGET).cma
all.opt:
@$(MAKE) $(TARGET).cmxa BUILD_OPT=yes
clean::
rm -f $(TARGET).top
+else
+all:
+ cd .. && $(OCAMLBUILD) engine/engine.cma
+all.opt:
+ cd .. && $(OCAMLBUILD) engine/engine.cmxa
+
+clean::
+ cd .. && $(OCAMLBUILD) -clean
+endif
##############################################################################
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
+endif
include ../Makefile.common
Ast.make_inherited_term (Ast.unwrap (k e)) inh in
let do_absolutely_nothing r k e = k e in
let mcode m = Ast.make_mcode(Ast.unwrap_mcode m) in
+ let decl r k d =
+ let res = do_nothing r k d in
+ if Ast.get_safe_decl d
+ then {res with Ast.safe_for_multi_decls = true}
+ else res in
let rule_elem r k re =
let res = do_nothing r k re in
let no_mcode = Ast.CONTEXT(Ast.NoPos,Ast.NOTHING) in
mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode mcode
do_nothing do_nothing do_nothing do_nothing do_nothing
do_nothing do_nothing do_nothing do_nothing do_nothing do_nothing
- do_nothing rule_elem do_nothing do_nothing
+ decl rule_elem do_nothing do_nothing
do_nothing do_absolutely_nothing in
recursor.V.rebuilder_rule_elem x
module F = Control_flow_c
-module Flag = Flag_matcher
+module FlagM = Flag_matcher
(*****************************************************************************)
(* Wrappers *)
(*****************************************************************************)
-let pr2, pr2_once = Common.mk_pr2_wrappers Flag_matcher.verbose_matcher
+let pr2, pr2_once = Common.mk_pr2_wrappers FlagM.verbose_matcher
let (+++) a b = match a with Some x -> Some x | None -> b
| A.CONTEXT _ -> true
| A.MINUS (_,_,_,A.NOREPLACEMENT) -> false
| A.MINUS (_,_,_,A.REPLACEMENT _) -> true (* repl is nonempty *)
- | A.PLUS _ -> raise Impossible
+ | A.PLUS _ -> raise (Impossible 13)
let mcode_simple_minus = function
| A.MINUS (_,_,_,A.NOREPLACEMENT) -> true
let (s1, i, mck, pos) = ia in
let new_mck =
match mck with
- | A.PLUS _ -> raise Impossible
+ | A.PLUS _ -> raise (Impossible 14)
| A.CONTEXT (A.NoPos,x) ->
A.CONTEXT (A.DontCarePos,x)
| A.MINUS (A.NoPos,inst,adj,x) ->
| A.CONTEXT ((A.FixPos _|A.DontCarePos), _)
| A.MINUS ((A.FixPos _|A.DontCarePos), _, _, _)
->
- raise Impossible
+ raise (Impossible 15)
in
(s1, i, new_mck, pos)
|B.MetaParamListVal _|B.MetaParamVal _|B.MetaExprListVal _
|B.MetaExprVal _|B.MetaLocalFuncVal _|B.MetaFuncVal _|B.MetaIdVal _
), _
- -> raise Impossible
+ -> raise (Impossible 16)
(* probably only one argument needs to be stripped, because inherited
metavariables containing expressions are stripped in advance. But don't
|B.MetaParamListVal _|B.MetaParamVal _|B.MetaExprListVal _
|B.MetaExprVal _|B.MetaLocalFuncVal _|B.MetaFuncVal _|B.MetaIdVal _
), _
- -> raise Impossible
+ -> raise (Impossible 17)
(*---------------------------------------------------------------------------*)
let commas = List.map snd (x::xs) +> List.flatten in
let commas = commas @ [iicomma] in
zip elems commas
- | _ -> raise Impossible
+ | _ -> raise (Impossible 18)
| None, _ ->
ty
- | x -> raise Impossible
+ | x -> raise (Impossible 19)
)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 20)
(*---------------------------------------------------------------------------*)
let one_initialisation_to_affectation x =
*)
match !tybis with
| Some ty_with_typename_completed -> ty_with_typename_completed
- | None -> raise Impossible
+ | None -> raise (Impossible 21)
in
let typ = ref (Some (typexp,local), Ast_c.NotTest) in
(A.expression, B.expression) matcher -> (A.expression, F.node) matcher
val cocciExpExp :
+ A.mcodekind ->
(A.expression, B.expression) matcher ->
(A.expression, B.expression) matcher
let fail2 () =
match X.mode with
| PatternMode -> fail
- | TransformMode -> raise Impossible
+ | TransformMode -> raise (Impossible 22)
let (option: ('a,'b) matcher -> ('a option,'b option) matcher)= fun f t1 t2 ->
let list_matcher match_dots rebuild_dots match_comma rebuild_comma
match_metalist rebuild_metalist mktermval special_cases
- element distrf get_iis = fun eas ebs ->
+ element distrf get_iis lenfilter = fun eas ebs ->
let rec loop = function
[], [] -> return ([], [])
| [], eb::ebs -> fail
then fail
else
let startxs' = Ast_c.unsplit_comma startxs in
- let len = List.length startxs' in
+ let len = List.length (lenfilter startxs') in
(match leninfo with
| A.MetaListLen (lenname,lenkeep,leninherited) ->
element ea eb >>= (fun ea eb ->
loop (eas, ebs) >>= (fun eas ebs ->
return (ea::eas, Left eb::ebs)))
- | (Right y)::ys -> raise Impossible
+ | (Right y)::ys -> raise (Impossible 23)
| [] -> fail) in
loop (eas,ebs)
| A.NestExpr(starter,exps,ender,None,true), eb ->
(match A.unwrap exps with
A.DOTS [exp] ->
- X.cocciExpExp expression exp eb >>= (fun exp eb ->
+ (* if minus and trafo do nothing *)
+ X.cocciExpExp (A.get_mcodekind starter)
+ expression exp eb >>= (fun exp eb ->
+ (* minus and trafo will do something here *)
X.distrf_e (dots2metavar starter) eb >>= (fun mcode eb ->
return (
(A.NestExpr
| A.Ecircles _, _
| A.Estars _, _
->
- raise Impossible
+ raise (Impossible 24)
| A.DisjExpr eas, eb ->
eas +> List.fold_left (fun acc ea -> acc >|+|> (expression ea eb)) fail
list_matcher match_dots build_dots match_comma build_comma
match_metalist build_metalist mktermval
special_cases argument X.distrf_args
- Lib_parsing_c.ii_of_args eas ebs
+ Lib_parsing_c.ii_of_args (function x -> x) eas ebs
and argument arga argb =
X.all_bound (A.get_inherited arga) >&&>
list_matcher match_dots build_dots match_comma build_comma
match_metalist build_metalist mktermval
special_cases parameter X.distrf_params
- Lib_parsing_c.ii_of_params eas ebs
+ Lib_parsing_c.ii_of_params (function x -> x) eas ebs
(*
let split_register_param = fun (hasreg, idb, ii_b_s) ->
| None, Some _ -> fail)
| (A.OptParam _ | A.UniqueParam _), _ ->
failwith "not handling Opt/Unique for Param"
- | A.Pcircles (_), ys -> raise Impossible (* in Ordered mode *)
+ | A.Pcircles (_), ys -> raise (Impossible 25) (* in Ordered mode *)
| _ -> fail
(* ------------------------------------------------------------------------- *)
(B.DeclList ([var], iiptvirgb::iifakestart::iisto))
)))
- | _, (B.DeclList (xs, ((iiptvirgb::iifakestart::iisto) as ii))) ->
+ | _, (B.DeclList (xs, (iiptvirgb::iifakestart::iisto))) ->
let indexify l =
let rec loop n = function
[] -> []
[] -> []
| x::xs ->
if n = cur then vl :: xs else x :: (repln n vl (cur+1) xs) in
- if X.mode =*= PatternMode || A.get_safe_decl decla
+ if !Flag.sgrep_mode2(*X.mode =*= PatternMode *) || A.get_safe_decl decla
then
(indexify xs) +> List.fold_left (fun acc (n,var) ->
(* consider all possible matches *)
)))) tin))
fail
else
- error ii
- "More than one variable in the declaration, and so it cannot be transformed. Check that there is no transformation on the type or the ;"
+ begin
+ let firstii = iiptvirgb in
+ pr2_once
+ (Printf.sprintf "%s: %d: %s"
+ (Ast_c.file_of_info firstii) (Ast_c.line_of_info firstii)
+ "More than one variable in the declaration, and so it cannot be transformed. Check that there is no transformation on the type or the ;");
+ fail
+ end
| A.MacroDecl (sa,lpa,eas,rpa,enda), B.MacroDecl ((sb,ebs,true),ii) ->
let (iisb, lpb, rpb, iiendb, iifakestart, iistob) =
(match ii with
| iisb::lpb::rpb::iiendb::iifakestart::iisto ->
(iisb,lpb,rpb,iiendb, iifakestart,iisto)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 26)
) in
(if allminus
then minusize_list iistob
(match ii with
| iisb::lpb::rpb::iifakestart::iisto ->
(iisb,lpb,rpb,iifakestart,iisto)
- | _ -> raise Impossible) in
+ | _ -> raise (Impossible 27)) in
(if allminus
then minusize_list iistob
else return ((), iistob)) >>=
(match ii with
| iisb::lpb::rpb::weqb::iiendb::iifakestart::iisto ->
(iisb,lpb,rpb,weqb,iiendb, iifakestart,iisto)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 28)
) in
(if allminus
then minusize_list iistob
},
iivirg),iiptvirgb,iistob)
)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 29)
)
(* do we need EnumName here too? *)
},
iivirg),iiptvirgb,iistob)
)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 30)
)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 31)
)
| _ -> fail
)))))
match fake_typeb with
| _nQ, ((B.TypeName (nameidb, _typ)), []) ->
return (ida, nameidb)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 32)
)
| A.TypeName sa ->
-> raise Todo
)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 33)
) >>= (fun ida nameidb ->
return (
(* only in struct type decls *)
| A.Ddots(dots,whencode), _ ->
- raise Impossible
+ raise (Impossible 34)
| A.OptDecl _, _ | A.UniqueDecl _, _ ->
failwith "not handling Opt/Unique Decl"
(B.InitList ibs, ib1::ib2::iicommaopt)
))))
- | _ -> raise Impossible
+ | _ -> raise (Impossible 35)
)
| (A.StrInitList (allminus, ia1, ias, ia2, []), (B.InitList ibs, ii)) ->
(B.InitList ibs, ib1::ib2::iicommaopt)
))))
- | _ -> raise Impossible
+ | _ -> raise (Impossible 36)
)
| (A.StrInitList (allminus, i1, ias, i2, whencode),
| A.IComma(comma), _ ->
- raise Impossible
+ raise (Impossible 37)
| A.UniqueIni _,_ | A.OptIni _,_ ->
failwith "not handling Opt/Unique on initialisers"
(List.map (function (elem,comma) -> [Left elem; Right [comma]]) ibs) in
initialisers_ordered2 ias ibs >>=
(fun ias ibs_split ->
-
let ibs,iicomma =
match List.rev ibs_split with
(Right comma)::rest -> (Ast_c.unsplit_comma (List.rev rest),comma)
let no_ii x = failwith "not possible" in
list_matcher match_dots build_dots match_comma build_comma
match_metalist build_metalist mktermval
- special_cases initialiser X.distrf_inis no_ii ias ibs
+ special_cases initialiser X.distrf_inis no_ii
+ (function x -> x) ias ibs
and initialisers_unordered2 = fun allminus ias ibs ->
match ias, ibs with
return (
(x, (A.IComma commax) +> A.rewrap xcomma),
(y, commay))))
- | _ -> raise Impossible (* unsplit_iicomma wrong *)
+ | _ -> raise (Impossible 38) (* unsplit_iicomma wrong *)
(* ------------------------------------------------------------------------- *)
and (struct_fields: (A.declaration list, B.field list) matcher) =
let startxs = unmake_ebs startxs in
X.distrf_struct_fields mcode startxs >>=
(fun mcode startxs -> return (mcode,make_ebs startxs)) in
+ let filter_fields l =
+ List.filter
+ (function x ->
+ match Ast_c.unwrap x with
+ Ast_c.DeclarationField fld -> true
+ | Ast_c.EmptyField info -> true
+ | Ast_c.MacroDeclField decl -> true
+ | Ast_c.CppDirectiveStruct cpp -> false
+ | Ast_c.IfdefStruct ifdef -> false)
+ l in
list_matcher match_dots build_dots match_comma build_comma
match_metalist build_metalist mktermval
- special_cases struct_field distrf no_ii eas (make_ebs ebs) >>=
+ special_cases struct_field distrf no_ii
+ filter_fields eas (make_ebs ebs) >>=
(fun eas ebs -> return (eas,unmake_ebs ebs))
and (struct_field: (A.declaration, B.field) matcher) = fun fa fb ->
let iiptvirgb = tuple_of_list1 iiptvirg in
(match onefield_multivars with
- | [] -> raise Impossible
+ | [] -> raise (Impossible 39)
| [onevar,iivirg] ->
assert (null iivirg);
(match onevar with
(B.FieldDeclList ([onevar, iivirg], [iiptvirgb])))
)
)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 40)
)
)
list_matcher match_dots build_dots match_comma build_comma
match_metalist build_metalist mktermval
special_cases enum_field X.distrf_enum_fields
- Lib_parsing_c.ii_of_enum_fields eas ebs
+ Lib_parsing_c.ii_of_enum_fields (function x -> x) eas ebs
and enum_field ida idb =
X.all_bound (A.get_inherited ida) >&&>
| false, true -> fail
| true, false -> do_stuff ()
| true, true ->
- if !Flag.show_misc
+ if !FlagM.show_misc
then pr2_once "USING optional_qualifier builtin isomorphism";
do_stuff()
)
(rebuilda ([stringa], signaopt)) +> A.rewrap ta,
(B.BaseType (baseb), iisignbopt ++ [ibaseb])
)))
- | _ -> raise Impossible
+ | _ -> raise (Impossible 41)
)
)))))
| [ibase1b;ibase2b] -> fail (* int omitted *)
| [] -> fail (* should something be done in this case? *)
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 42))
| A.LongLongType, B.IntType (B.Si (_, B.CLongLong))
| [ibase1b] -> fail (* short or long *)
| [ibase1b;ibase2b;ibase3b] -> fail (* long long case *)
| [] -> fail (* should something be done in this case? *)
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 43))
| _, (B.Void|B.FloatType _|B.IntType _
|B.SizeType|B.SSizeType|B.PtrDiffType) -> fail
| [], B.IntType (B.Si (_sign, B.CInt)) ->
sign (Some signa) signbopt >>= (fun signaopt iisignbopt ->
match signaopt with
- | None -> raise Impossible
+ | None -> raise (Impossible 45)
| Some signa ->
return (
(A.SignedT (signa,None)) +> A.rewrap ta,
match fake_su with
| _nQ, (B.StructUnionName (sub, sb), [iisub;iisb]) ->
return (ty, [iisub; iisb])
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 46))
| _ -> fail in
process_type
match fake_su with
| _nQ, (B.EnumName sb, [iisub;iisb]) ->
return (ty, [iisub; iisb])
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 47))
| _ -> fail in
process_type
| false, _ -> fail
| true, B.NoSto -> do_minus ()
| true, _ ->
- if !Flag.show_misc
+ if !FlagM.show_misc
then pr2_once "USING optional_storage builtin isomorphism";
do_minus()
)
if optional_storage
then
begin
- if !Flag.show_misc
+ if !FlagM.show_misc
then pr2_once "USING optional_storage builtin isomorphism";
do_minus()
end
let no_ii x = failwith "not possible" in
list_matcher match_dots build_dots match_comma build_comma
match_metalist build_metalist mktermval
- special_cases define_parameter X.distrf_define_params no_ii eas ebs
+ special_cases define_parameter X.distrf_define_params no_ii
+ (function x -> x) eas ebs
and define_parameter = fun parama paramb ->
match A.unwrap parama, paramb with
return ((A.DParam ida)+> A.rewrap parama,(idb, [ib1])))
| (A.OptDParam _ | A.UniqueDParam _), _ ->
failwith "handling Opt/Unique for define parameters"
- | A.DPcircles (_), ys -> raise Impossible (* in Ordered mode *)
+ | A.DPcircles (_), ys -> raise (Impossible 48) (* in Ordered mode *)
| _ -> fail
(*****************************************************************************)
ioparenb::icparenb::iifakestart::iistob)
)
)))))))))
- | _ -> raise Impossible
+ | _ -> raise (Impossible 49)
)
| A.Decl (mckstart,allminus,decla), F.Decl declb ->
(Ast_cocci.expression, Control_flow_c.node) matcher
val cocciExpExp :
+ Ast_cocci.mcodekind ->
(Ast_cocci.expression, Ast_c.expression) matcher ->
(Ast_cocci.expression, Ast_c.expression) matcher
::prev
(* see BindGood in asttotctl2 *)
| Lib_engine.BindGood (_) -> prev
- | _ -> raise Impossible
+ | _ -> raise (Impossible 50)
) []
(*****************************************************************************)
--- /dev/null
+Asttoctl2
+Asttomember
+C_vs_c
+Check_exhaustive_pattern
+Check_reachability
+Cocci_vs_c
+Ctlcocci_integration
+Ctltotex
+Externalanalysis
+Flag_engine
+Flag_matcher
+Isomorphisms_c_c
+Lib_engine
+Lib_matcher_c
+Pattern_c
+Postprocess_transinfo
+Pretty_print_engine
+Transformation_c
--- /dev/null
+Asttoctl2
+Asttomember
+C_vs_c
+Check_exhaustive_pattern
+Check_reachability
+Cocci_vs_c
+Ctlcocci_integration
+Ctltotex
+Externalanalysis
+Flag_engine
+Flag_matcher
+Isomorphisms_c_c
+Lib_engine
+Lib_matcher_c
+Pattern_c
+Postprocess_transinfo
+Pretty_print_engine
+Transformation_c
-(*
- * Copyright 2012, INRIA
- * Julia Lawall, Gilles Muller
- * Copyright 2010-2011, INRIA, University of Copenhagen
- * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
- * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
- * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
- * This file is part of Coccinelle.
- *
- * Coccinelle 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, according to version 2 of the License.
- *
- * Coccinelle 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 Coccinelle. If not, see <http://www.gnu.org/licenses/>.
- *
- * The authors reserve the right to distribute this or future versions of
- * Coccinelle under other licenses.
- *)
-
-
-# 0 "./asttoctl.ml"
(* true = don't see all matched nodes, only modified ones *)
let onlyModif = ref true(*false*)
(* set to true for line numbers in the output of ctl_engine *)
-(*
- * Copyright 2012, INRIA
- * Julia Lawall, Gilles Muller
- * Copyright 2010-2011, INRIA, University of Copenhagen
- * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
- * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
- * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
- * This file is part of Coccinelle.
- *
- * Coccinelle 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, according to version 2 of the License.
- *
- * Coccinelle 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 Coccinelle. If not, see <http://www.gnu.org/licenses/>.
- *
- * The authors reserve the right to distribute this or future versions of
- * Coccinelle under other licenses.
- *)
-
-
-# 0 "./sgrep.ml"
(* no longer used *)
type marker =
(* same as cocciExp, but for expressions in an expression, not expressions
in a node *)
- let cocciExpExp = fun expf expa expb -> fun tin ->
+ let cocciExpExp = fun _ expf expa expb -> fun tin ->
let globals = ref [] in
let bigf = {
(* same as cocciExp, but for expressions in an expression, not expressions
in a node *)
- let cocciExpExp = fun expf expa expb -> fun tin ->
+ let cocciExpExp = fun mc expf expa expb -> fun tin ->
+ match mc with
+ Ast_cocci.MINUS _ -> Some (expa,expb) (* do nothing *)
+ | _ ->
let bigf = {
Visitor_c.default_visitor_c_s with
(* ------------------------------------------------------------------------*)
let check_pos info mck pos =
match mck with
- | Ast_cocci.PLUS _ -> raise Impossible
+ | Ast_cocci.PLUS _ -> raise (Impossible 51)
| Ast_cocci.CONTEXT (Ast_cocci.FixPos (i1,i2),_)
| Ast_cocci.MINUS (Ast_cocci.FixPos (i1,i2),_,_,_) ->
pos <= i2 && pos >= i1
mck
in
(match mck, Ast_c.pinfo_of_info ib with
- | _, Ast_c.AbstractLineTok _ -> raise Impossible
+ | _, Ast_c.AbstractLineTok _ -> raise (Impossible 52)
| Ast_cocci.MINUS(_), Ast_c.ExpandedTok _ ->
failwith
(Printf.sprintf
) expr
)
- | Ast_cocci.PLUS _ -> raise Impossible
+ | Ast_cocci.PLUS _ -> raise (Impossible 53)
(* use new strategy, collect ii, sort, recollect and tag *)
let get_pos mck =
match mck with
- | Ast_cocci.PLUS _ -> raise Impossible
+ | Ast_cocci.PLUS _ -> raise (Impossible 54)
| Ast_cocci.CONTEXT (Ast_cocci.FixPos (i1,i2),_)
| Ast_cocci.MINUS (Ast_cocci.FixPos (i1,i2),_,_,_) ->
Ast_cocci.FixPos (i1,i2)
| Ast_cocci.DontCarePos -> true
| Ast_cocci.FixPos (i1, i2) ->
i1 =*= min && i2 =*= max
- | _ -> raise Impossible
+ | _ -> raise (Impossible 55)
)
then
let transform_re_node a b tin =
match TRANS.rule_elem_node a b tin with
- | None -> raise Impossible
+ | None -> raise (Impossible 56)
| Some (_sp, b') -> b'
let (transform2: string (* rule name *) -> string list (* dropped_isos *) ->
OBJS = $(SOURCES:.ml=.cmo)
OPTOBJS = $(SOURCES:.ml=.cmx)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
all: $(TARGET).cma
all.opt:
clean::
rm -f $(TARGET).byte $(TARGET).opt rm -f $(TARGET).top
+else
+all:
+ cd .. && $(OCAMLBUILD) extra/extra.cma
+
+all.opt:
+ cd .. && $(OCAMLBUILD) extra/extra.cmxa
+
+clean::
+ cd .. && $(OCAMLBUILD) -clean
+endif
+
.SUFFIXES: .ml .mli .cmo .cmi .cmx
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
+endif
include ../Makefile.common
--- /dev/null
+Classic_patch
+Kbuild
+Maintainers
--- /dev/null
+Classic_patch
+Kbuild
+Maintainers
optionise (fun () -> List.assoc dir das),
optionise (fun () -> List.assoc dir dbs)
with
- | None, None -> raise Impossible
+ | None, None -> raise (Impossible 57)
| None, Some gbs -> pr2 ("new directory appeared:" ^ dir)
| Some gas, None -> pr2 ("old directory disappeared:" ^ dir)
| Some gas, Some gbs ->
let all_files = afiles $+$ bfiles in
all_files +> List.iter (fun file ->
match List.mem file afiles, List.mem file bfiles with
- | false, false -> raise Impossible
+ | false, false -> raise (Impossible 58)
| false, true -> pr2 ("new file appeared:" ^ file ^ " in " ^ dir)
| true, false -> pr2 ("old file disappeared:" ^ file ^ " in " ^ dir)
| true, true -> ()
let relax_include_path = ref false
+let extra_includes = ref ([] : string list)
+
let timeout = ref (None : int option)
let worth_trying_opt = ref true
##############################################################################
# Top rules
##############################################################################
+ifneq ($(FEATURE_OCAMLBUILD),yes)
all: $(TARGET).cma
all.opt:
$(TARGET).cmxa: $(LIBS:.cma=.cmxa) $(OPTOBJS)
$(OCAMLOPT_CMD) -a -o $(TARGET).cmxa $(OPTOBJS)
+else
+all:
+ cd .. && $(OCAMLBUILD) globals/globals.cma
+
+all.opt:
+ cd .. && $(OCAMLBUILD) globals/globals.cmxa
+
+clean:
+ cd .. && $(OCAMLBUILD) -clean
+endif
##############################################################################
# Developer rules
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
+endif
include ../Makefile.common
--- /dev/null
+Config
+Flag
+Iteration
+Regexp
--- /dev/null
+Config
+Flag
+Iteration
+Regexp
should not expect that every test will pass.
In order to use the OCaml scripting feature in SmPL, you must compile
-Coccinelle with at least OCaml version 3.11.
-
+Coccinelle with at least OCaml version 3.11. An extra file, coccilib.cmi,
+is produced and installed in /usr/share/cocci/ocaml, which is needed for
+the compilation of ocaml scripts.
** Bash integration **
" For integration in a toolchain (must be set before the first unknown option)";
"--include-headers", Arg.Set include_headers,
" process header files independently";
- "-I", Arg.String (fun x ->
- FC.include_path:= x::!FC.include_path
- ),
- " <dir> containing the header files (optional)";
+ "-I", Arg.String (fun x -> FC.include_path:= x::!FC.include_path),
+ " <dir> containing the header files";
+ "--include", Arg.String (fun x -> FC.extra_includes:=x::!FC.extra_includes),
+ " file to consider as being included";
"--preprocess", Arg.Set preprocess,
" run the C preprocessor before applying the semantic match";
| Arg.Bad emsg ->
arg_parse_no_fail l f msg
| Arg.Help msg -> (* printf "%s" msg; exit 0; *)
- raise Impossible (* -help is specified in speclist *)
+ raise (Impossible 165) (* -help is specified in speclist *)
(* copy paste of Arg.parse. Don't want the default -help msg *)
let arg_parse2 l f msg argv =
else
arg_parse_no_fail l f msg;
| Arg.Help msg -> (* printf "%s" msg; exit 0; *)
- raise Impossible (* -help is specified in speclist *)
+ raise (Impossible 166) (* -help is specified in speclist *)
)
let infiles =
Common.profile_code "Main.infiles computation" (fun () ->
- match !dir, !kbuild_info, !Flag.scanner with
+ match !dir, !kbuild_info, !Flag.scanner, xs with
(* glimpse *)
- | false, _, (Flag.Glimpse|Flag.IdUtils) -> [x::xs]
- | true, s, (Flag.Glimpse|Flag.IdUtils) when s <> "" ->
+ | false, _, (Flag.Glimpse|Flag.IdUtils), _ -> [x::xs]
+ | true, s, (Flag.Glimpse|Flag.IdUtils), _ when s <> "" ->
failwith
- "-use_glimpse or -id_utils does not work with -kbuild"
- | true, "", Flag.Glimpse ->
- (if not (null xs)
- then failwith "-use_glimpse can accept only one dir");
+ "--use-glimpse or --id-utils does not work with --kbuild"
+ | true, "", Flag.Glimpse, [] ->
+ (*if not (null xs)
+ then failwith "--use-glimpse can accept only one dir"*)
let files =
match glimpse_filter (!cocci_file, !Config.std_iso) x with
None -> get_files x
| Some files -> files in
files +> List.map (fun x -> [x])
- | true, "", Flag.IdUtils ->
- (if not (null xs)
- then failwith "-id_utils can accept only one dir");
+ | true, "", Flag.IdUtils, [] ->
+ (*if not (null xs)
+ then failwith "--id-utils can accept only one dir"*)
let files =
match idutils_filter (!cocci_file, !Config.std_iso) x with
| Some files -> files in
files +> List.map (fun x -> [x])
(* normal *)
- | false, _, _ -> [x::xs]
- | true, "", _ ->
+ | false, _, _, _ -> [x::xs]
+ | true, "", _, _ ->
get_files (join " " (x::xs)) +> List.map (fun x -> [x])
(* kbuild *)
- | true, kbuild_info_file,_ ->
+ | true, kbuild_info_file,_,_ ->
let dirs =
Common.cmd_to_list ("find "^(join " " (x::xs))^" -type d")
in
--- /dev/null
+# 2 "myocamlbuild.ml.in"
+
+(*
+ * This file is a plugin that provides the needed customization of
+ * calls to the ocaml compiler needed for components of coccinelle.
+ * The classification of particular components is done by tags, which
+ * are specified in the _tags file.
+ *
+ * This file is also a compromise: some aspects of coccocinelle's
+ * build process are somehwat complicated due to packaging some
+ * bundled software, having no requirement on ocamlfind, etc.
+ * We therefore let 'configure' find out the configuration and
+ * paths to tools and libraries, and this plugin is transformed
+ * by that configuration to customize ocamlbuild accordingly.
+ *)
+
+(* Some useful commandline arguments to ocamlbuild are:
+ * -yaccflag -v verbose ocamlyacc and menhir output
+ * -classic-display see the individual build steps
+ * -j 0 parallel building
+ * -tag "-custom" pure bytecode building
+ * -tag "-dtypes" no type annotation generation
+ *)
+
+
+(* Configuration of this build plugin
+ *)
+
+let ocamlc_path = "/usr/bin/ocamlc.opt"
+let ocamlopt_path = "/usr/bin/ocamlopt.opt"
+let ocamldep_path = "/usr/bin/ocamldep"
+let ocamldoc_path = "/usr/bin/ocamldoc"
+let ocamlyacc_path = "/usr/bin/ocamlyacc"
+let ocamllex_path = "/usr/bin/ocamllex.opt"
+let ocamlmklib_path = "/usr/bin/ocamlmklib"
+let ocamlmktop_path = "/usr/bin/ocamlmktop"
+let camlp4o_path = "/usr/bin/camlp4o"
+let menhir_path = "/usr/bin/menhir"
+
+let pycaml_path = ""
+let pcre_path = ""
+let menhirLib_path = "/home/jll/coccinelle-release/bundles/menhirLib/"
+let dynlink_path = "/usr/lib/ocaml"
+
+let pcre_cflags = ""
+let pcre_ldflags = ""
+let python_cflags = ""
+let python_ldflags = ""
+let python_major_version = ""
+
+let profiling_modules = ""
+
+
+(* The plugin code starts here. *)
+open Ocamlbuild_plugin
+open Command
+
+(* Removes double separators and single dots from
+ * a path. It does not resolve symlinks or turn
+ * relative paths in absolute paths.
+ *)
+let rec normalize_path path =
+ let parent = Pathname.dirname path in
+ if Pathname.equal path "/" || Pathname.equal parent "/" || Pathname.equal parent path
+ then path
+ else let name = Pathname.basename path in
+ if Pathname.equal name "."
+ then normalize_path parent
+ else normalize_path parent / name
+
+(* Makes path relative and implicit, if it is a child of the
+ * current directory. Relative paths are a must when dealing
+ * with the build directory.
+ * Todo: find out if there is a library function for
+ * exactly this purpose.
+ *)
+let relative_path path =
+ let current = normalize_path Pathname.pwd in
+ let target = normalize_path path in
+ if Pathname.is_prefix current target
+ then let len_current = String.length current in
+ let len_target = String.length target in
+ if len_current == len_target
+ then "."
+ else let len_tail = len_target - len_current - 1 in
+ let ind_tail = len_current + 1 in
+ String.sub target ind_tail len_tail
+ else target
+
+let add_flags flag_ref flags =
+ flag_ref := List.append flags !flag_ref
+
+
+let mk_use_tag name = "use_" ^ name
+
+
+(* Sets up a tag for compiling c and library files against
+ * an external c library.
+ *)
+let setup_clib name compile_flags link_flags =
+ let tag = mk_use_tag name in
+ flag [tag; "c"; "compile"] (S[A "-ccopt"; A compile_flags]);
+ flag [tag; "c"; "ocamlmklib"] (S[A "-ldopt"; A link_flags]);
+ flag [tag; "ocaml"; "link"] (S[A "-ccopt"; A compile_flags]);
+ flag [tag; "ocaml"; "link"] (S[A "-ccopt"; A link_flags])
+
+(* Sets up a tag for declaring a dependency on a stubs library,
+ * and linking it in. The dependency includes both a .a archive
+ * and a .so dll.
+ *)
+let setup_stubs name stubs_dir =
+ let tag = mk_use_tag name in
+ let path_a = Printf.sprintf "%s/lib%s_stubs.a" stubs_dir name in
+ if not (Pathname.exists path_a) then
+ dep [tag; "link"; "ocaml"] [path_a];
+ let stubs_arg = Printf.sprintf "-l%s_stubs" name in
+ flag [tag; "ocaml"; "link"; "byte"]
+ (S[A "-I"; P stubs_dir; A "-dllib"; A stubs_arg; A "-cclib"; A stubs_arg]);
+ flag [tag; "ocaml"; "link"; "native"]
+ (S[A "-I"; P stubs_dir; A "-cclib"; A stubs_arg]);
+ flag [tag; "ocaml"; "doc"]
+ (S[A "-I"; P stubs_dir])
+
+(* The use of bundled software is simply the
+ * inclusion of the appropriate source directory.
+ * The build system can find automatically how to
+ * deal with the bundled sources.
+ *)
+let setup_bundle rootdir =
+ tag_file rootdir ["include"; "traverse"]
+
+(* Sets up a tag that adds the given module directory and module
+ * as additional argument to ocaml when it processes a
+ * file with that tag.
+ * Todo: it may be beneficial to add a dependency on the target
+ * module.
+ *)
+let setup_module name modname rootdir =
+ let tag = mk_use_tag name in
+ let link_args isNative = S [A "-I"; P rootdir; A (modname isNative) ] in
+ let compile_args = S [A "-I"; P rootdir] in
+ flag [tag; "ocaml"; "compile"] compile_args;
+ flag [tag; "ocaml"; "byte"; "link"; "program"] (link_args false);
+ flag [tag; "ocaml"; "native"; "link"; "program"] (link_args true);
+ flag [tag; "ocaml"; "doc"] (S[A "-I"; P rootdir])
+
+(* Sets up the use of either a bundled source package or precompiled module. *)
+let setup_package name modname rootdir =
+ let exists_path isNative = Pathname.exists (rootdir / modname isNative) in
+ let is_binary = exists_path false || exists_path true in
+ if is_binary
+ then setup_module name modname rootdir
+ else setup_bundle rootdir
+
+
+(* Most files depend on these standard modules, hence we setup a
+ * single tag for them.
+ * This setup routine should be called before the others to ensure
+ * that these modules appear first on the ocaml commandlines.
+ *)
+let setup_basic_libs use_dynlink =
+ ocaml_lib ~extern:true ~tag_name:"use_base" "unix";
+ ocaml_lib ~extern:true ~tag_name:"use_base" "str";
+ ocaml_lib ~extern:true ~tag_name:"use_base" "nums";
+ ocaml_lib ~extern:true ~tag_name:"use_base" "bigarray";
+ if use_dynlink then
+ ocaml_lib ~extern:true ~tag_name:"use_base" "dynlink";
+ ()
+
+(* The menhir package provides individual object files
+ * instead of an archive.
+ *)
+let setup_menhirLib () =
+ let menhirLib_dir = relative_path menhirLib_path in
+ let modname isNative = match isNative with
+ true -> "menhirLib.cmx"
+ | false -> "menhirLib.cmo" in
+
+ setup_package "menhirLib" modname menhirLib_dir
+
+(* Pycaml is a stubs library with some conditional
+ * code that depends on the python version. We
+ * additionally introduce a tag pp_pycaml which
+ * runs the appropriate preprocessors.
+ *)
+let setup_pycaml () =
+ let pycaml_dir = relative_path pycaml_path in
+ let modname isNative = match isNative with
+ true -> "pycaml.cmxa"
+ | false -> "pycaml.cma" in
+
+ setup_package "pycaml" modname pycaml_dir;
+ setup_stubs "pycaml" pycaml_dir;
+ setup_clib "pycaml" python_cflags python_ldflags;
+
+ let macrodef = Printf.sprintf "-D PYMAJOR%s" python_major_version in
+ flag ["pp_pycaml"; "c"; "compile"] (S[A "-ccopt"; A macrodef]);
+ let camlp4cmd = Printf.sprintf "%s -parser Camlp4MacroParser -D PYMAJOR%s"
+ camlp4o_path python_major_version in
+ flag ["pp_pycaml"; "ocaml"; "pp"] (Sh camlp4cmd)
+
+(* Pcre is a standard stub library. *)
+let setup_pcre () =
+ let pcre_dir = relative_path pcre_path in
+ let modname isNative = match isNative with
+ true -> "pcre.cmxa"
+ | false -> "pcre.cma" in
+
+ setup_package "pcre" modname pcre_dir;
+ setup_stubs "pcre" pcre_dir;
+ setup_clib "pcre" pcre_cflags pcre_ldflags
+
+(* Some utility code on strings and paths. *)
+let any_non_space str =
+ let have_non_space = ref false in
+ String.iter begin
+ fun c -> match c with
+ ' ' -> ()
+ | '\t' -> ()
+ | _ -> have_non_space := true
+ end str;
+ !have_non_space
+
+let not_empty str =
+ String.length str > 0 && any_non_space str
+
+let is_path_configured path =
+ not_empty path && Pathname.exists path
+
+(* Note: the setup of the modules is done before the hygiene phase
+ * in order to benefit from additional "include" tags that may be
+ * given to directories.
+ *)
+let _ = dispatch begin
+ function
+ | Before_options ->
+ Options.hygiene := true;
+ Options.sanitize := true;
+ Options.make_links := false;
+ Options.catch_errors := true;
+ Options.use_menhir := true;
+
+ let menhir_wrapper = Printf.sprintf
+ "%s/setup/wrapper-menhir.sh" Pathname.pwd in
+ Options.ocamlc := Sh ocamlc_path;
+ Options.ocamlopt := Sh ocamlopt_path;
+ Options.ocamldep := Sh ocamldep_path;
+ Options.ocamldoc := Sh ocamldoc_path;
+ Options.ocamlyacc := S[P menhir_wrapper; P ocamlyacc_path; P menhir_path];
+ Options.ocamllex := Sh ocamllex_path;
+ Options.ocamlmklib := Sh ocamlmklib_path;
+ Options.ocamlmktop := Sh ocamlmktop_path;
+ ()
+
+ | Before_hygiene ->
+ let use_dynlink = is_path_configured dynlink_path in
+ setup_basic_libs use_dynlink;
+
+ if is_path_configured menhirLib_path then
+ setup_menhirLib ();
+
+ if is_path_configured pcre_path then
+ setup_pcre ();
+
+ if is_path_configured pycaml_path then
+ setup_pycaml ();
+ ()
+
+ | After_rules ->
+ (* produces a slightly faster native version *)
+ (* flag ["ocaml"; "compile"; "native"] (A "-unsafe"); *)
+
+ (* adds debugging info (including exception backtraces) *)
+ flag ["ocaml"; "compile"] (A "-g");
+
+ (* flags to parameterize ocamldoc to produce web pages *)
+ flag ["gen_html"; "ocaml"; "doc"]
+ (S [A "-colorize-code"; A "-short-functors"; A "-all-params"]);
+ flag ["gen_man"; "ocaml"; "doc"]
+ (S [A "-man"; A "-man-mini"]);
+
+ (* when profiling, link with profiling.cmo *)
+ if not_empty profiling_modules then
+ flag ["ocaml"; "link"; "byte"]
+ (S [A profiling_modules]);
+
+ (* the warning about unused function arguments are disabled
+ * for files with this tag. *)
+ flag ["nowarn20"; "ocaml"; "compile"] (S [A "-w"; A "-20"]);
+
+ (* adds the custom option, unless 'nocustom' is given as a tag *)
+ if not (Tags.mem "nocustom" (tags_of_pathname "myocamlbuild.ml"))
+ then flag ["ocaml"; "link"; "byte"] (A "-custom");
+ ()
+
+ | _ -> ()
+end
--- /dev/null
+# 2 "myocamlbuild.ml.in"
+
+(*
+ * This file is a plugin that provides the needed customization of
+ * calls to the ocaml compiler needed for components of coccinelle.
+ * The classification of particular components is done by tags, which
+ * are specified in the _tags file.
+ *
+ * This file is also a compromise: some aspects of coccocinelle's
+ * build process are somehwat complicated due to packaging some
+ * bundled software, having no requirement on ocamlfind, etc.
+ * We therefore let 'configure' find out the configuration and
+ * paths to tools and libraries, and this plugin is transformed
+ * by that configuration to customize ocamlbuild accordingly.
+ *)
+
+(* Some useful commandline arguments to ocamlbuild are:
+ * -yaccflag -v verbose ocamlyacc and menhir output
+ * -classic-display see the individual build steps
+ * -j 0 parallel building
+ * -tag "-custom" pure bytecode building
+ * -tag "-dtypes" no type annotation generation
+ *)
+
+
+(* Configuration of this build plugin
+ *)
+
+let ocamlc_path = "@OCAMLC@"
+let ocamlopt_path = "@OCAMLOPT@"
+let ocamldep_path = "@OCAMLDEP@"
+let ocamldoc_path = "@OCAMLDOC@"
+let ocamlyacc_path = "@OCAMLYACC@"
+let ocamllex_path = "@OCAMLLEX@"
+let ocamlmklib_path = "@OCAMLMKLIB@"
+let ocamlmktop_path = "@OCAMLMKTOP@"
+let camlp4o_path = "@CAMLP4O@"
+let menhir_path = "@MENHIR@"
+
+let pycaml_path = "@PATH_pycaml@"
+let pcre_path = "@PATH_pcre@"
+let menhirLib_path = "@PATH_menhirLib@"
+let dynlink_path = "@PATH_dynlink@"
+
+let pcre_cflags = "@PCRE_CFLAGS@"
+let pcre_ldflags = "@PCRE_LIBS@"
+let python_cflags = "@PYTHON_CFLAGS@"
+let python_ldflags = "@PYTHON_LIBS@"
+let python_major_version = "@PYVER_MAJOR@"
+
+let profiling_modules = "@MODULES_profiling@"
+
+
+(* The plugin code starts here. *)
+open Ocamlbuild_plugin
+open Command
+
+(* Removes double separators and single dots from
+ * a path. It does not resolve symlinks or turn
+ * relative paths in absolute paths.
+ *)
+let rec normalize_path path =
+ let parent = Pathname.dirname path in
+ if Pathname.equal path "/" || Pathname.equal parent "/" || Pathname.equal parent path
+ then path
+ else let name = Pathname.basename path in
+ if Pathname.equal name "."
+ then normalize_path parent
+ else normalize_path parent / name
+
+(* Makes path relative and implicit, if it is a child of the
+ * current directory. Relative paths are a must when dealing
+ * with the build directory.
+ * Todo: find out if there is a library function for
+ * exactly this purpose.
+ *)
+let relative_path path =
+ let current = normalize_path Pathname.pwd in
+ let target = normalize_path path in
+ if Pathname.is_prefix current target
+ then let len_current = String.length current in
+ let len_target = String.length target in
+ if len_current == len_target
+ then "."
+ else let len_tail = len_target - len_current - 1 in
+ let ind_tail = len_current + 1 in
+ String.sub target ind_tail len_tail
+ else target
+
+let add_flags flag_ref flags =
+ flag_ref := List.append flags !flag_ref
+
+
+let mk_use_tag name = "use_" ^ name
+
+
+(* Sets up a tag for compiling c and library files against
+ * an external c library.
+ *)
+let setup_clib name compile_flags link_flags =
+ let tag = mk_use_tag name in
+ flag [tag; "c"; "compile"] (S[A "-ccopt"; A compile_flags]);
+ flag [tag; "c"; "ocamlmklib"] (S[A "-ldopt"; A link_flags]);
+ flag [tag; "ocaml"; "link"] (S[A "-ccopt"; A compile_flags]);
+ flag [tag; "ocaml"; "link"] (S[A "-ccopt"; A link_flags])
+
+(* Sets up a tag for declaring a dependency on a stubs library,
+ * and linking it in. The dependency includes both a .a archive
+ * and a .so dll.
+ *)
+let setup_stubs name stubs_dir =
+ let tag = mk_use_tag name in
+ let path_a = Printf.sprintf "%s/lib%s_stubs.a" stubs_dir name in
+ if not (Pathname.exists path_a) then
+ dep [tag; "link"; "ocaml"] [path_a];
+ let stubs_arg = Printf.sprintf "-l%s_stubs" name in
+ flag [tag; "ocaml"; "link"; "byte"]
+ (S[A "-I"; P stubs_dir; A "-dllib"; A stubs_arg; A "-cclib"; A stubs_arg]);
+ flag [tag; "ocaml"; "link"; "native"]
+ (S[A "-I"; P stubs_dir; A "-cclib"; A stubs_arg]);
+ flag [tag; "ocaml"; "doc"]
+ (S[A "-I"; P stubs_dir])
+
+(* The use of bundled software is simply the
+ * inclusion of the appropriate source directory.
+ * The build system can find automatically how to
+ * deal with the bundled sources.
+ *)
+let setup_bundle rootdir =
+ tag_file rootdir ["include"; "traverse"]
+
+(* Sets up a tag that adds the given module directory and module
+ * as additional argument to ocaml when it processes a
+ * file with that tag.
+ * Todo: it may be beneficial to add a dependency on the target
+ * module.
+ *)
+let setup_module name modname rootdir =
+ let tag = mk_use_tag name in
+ let link_args isNative = S [A "-I"; P rootdir; A (modname isNative) ] in
+ let compile_args = S [A "-I"; P rootdir] in
+ flag [tag; "ocaml"; "compile"] compile_args;
+ flag [tag; "ocaml"; "byte"; "link"; "program"] (link_args false);
+ flag [tag; "ocaml"; "native"; "link"; "program"] (link_args true);
+ flag [tag; "ocaml"; "doc"] (S[A "-I"; P rootdir])
+
+(* Sets up the use of either a bundled source package or precompiled module. *)
+let setup_package name modname rootdir =
+ let exists_path isNative = Pathname.exists (rootdir / modname isNative) in
+ let is_binary = exists_path false || exists_path true in
+ if is_binary
+ then setup_module name modname rootdir
+ else setup_bundle rootdir
+
+
+(* Most files depend on these standard modules, hence we setup a
+ * single tag for them.
+ * This setup routine should be called before the others to ensure
+ * that these modules appear first on the ocaml commandlines.
+ *)
+let setup_basic_libs use_dynlink =
+ ocaml_lib ~extern:true ~tag_name:"use_base" "unix";
+ ocaml_lib ~extern:true ~tag_name:"use_base" "str";
+ ocaml_lib ~extern:true ~tag_name:"use_base" "nums";
+ ocaml_lib ~extern:true ~tag_name:"use_base" "bigarray";
+ if use_dynlink then
+ ocaml_lib ~extern:true ~tag_name:"use_base" "dynlink";
+ ()
+
+(* The menhir package provides individual object files
+ * instead of an archive.
+ *)
+let setup_menhirLib () =
+ let menhirLib_dir = relative_path menhirLib_path in
+ let modname isNative = match isNative with
+ true -> "menhirLib.cmx"
+ | false -> "menhirLib.cmo" in
+
+ setup_package "menhirLib" modname menhirLib_dir
+
+(* Pycaml is a stubs library with some conditional
+ * code that depends on the python version. We
+ * additionally introduce a tag pp_pycaml which
+ * runs the appropriate preprocessors.
+ *)
+let setup_pycaml () =
+ let pycaml_dir = relative_path pycaml_path in
+ let modname isNative = match isNative with
+ true -> "pycaml.cmxa"
+ | false -> "pycaml.cma" in
+
+ setup_package "pycaml" modname pycaml_dir;
+ setup_stubs "pycaml" pycaml_dir;
+ setup_clib "pycaml" python_cflags python_ldflags;
+
+ let macrodef = Printf.sprintf "-D PYMAJOR%s" python_major_version in
+ flag ["pp_pycaml"; "c"; "compile"] (S[A "-ccopt"; A macrodef]);
+ let camlp4cmd = Printf.sprintf "%s -parser Camlp4MacroParser -D PYMAJOR%s"
+ camlp4o_path python_major_version in
+ flag ["pp_pycaml"; "ocaml"; "pp"] (Sh camlp4cmd)
+
+(* Pcre is a standard stub library. *)
+let setup_pcre () =
+ let pcre_dir = relative_path pcre_path in
+ let modname isNative = match isNative with
+ true -> "pcre.cmxa"
+ | false -> "pcre.cma" in
+
+ setup_package "pcre" modname pcre_dir;
+ setup_stubs "pcre" pcre_dir;
+ setup_clib "pcre" pcre_cflags pcre_ldflags
+
+(* Some utility code on strings and paths. *)
+let any_non_space str =
+ let have_non_space = ref false in
+ String.iter begin
+ fun c -> match c with
+ ' ' -> ()
+ | '\t' -> ()
+ | _ -> have_non_space := true
+ end str;
+ !have_non_space
+
+let not_empty str =
+ String.length str > 0 && any_non_space str
+
+let is_path_configured path =
+ not_empty path && Pathname.exists path
+
+(* Note: the setup of the modules is done before the hygiene phase
+ * in order to benefit from additional "include" tags that may be
+ * given to directories.
+ *)
+let _ = dispatch begin
+ function
+ | Before_options ->
+ Options.hygiene := true;
+ Options.sanitize := true;
+ Options.make_links := false;
+ Options.catch_errors := true;
+ Options.use_menhir := true;
+
+ let menhir_wrapper = Printf.sprintf
+ "%s/setup/wrapper-menhir.sh" Pathname.pwd in
+ Options.ocamlc := Sh ocamlc_path;
+ Options.ocamlopt := Sh ocamlopt_path;
+ Options.ocamldep := Sh ocamldep_path;
+ Options.ocamldoc := Sh ocamldoc_path;
+ Options.ocamlyacc := S[P menhir_wrapper; P ocamlyacc_path; P menhir_path];
+ Options.ocamllex := Sh ocamllex_path;
+ Options.ocamlmklib := Sh ocamlmklib_path;
+ Options.ocamlmktop := Sh ocamlmktop_path;
+ ()
+
+ | Before_hygiene ->
+ let use_dynlink = is_path_configured dynlink_path in
+ setup_basic_libs use_dynlink;
+
+ if is_path_configured menhirLib_path then
+ setup_menhirLib ();
+
+ if is_path_configured pcre_path then
+ setup_pcre ();
+
+ if is_path_configured pycaml_path then
+ setup_pycaml ();
+ ()
+
+ | After_rules ->
+ (* produces a slightly faster native version *)
+ (* flag ["ocaml"; "compile"; "native"] (A "-unsafe"); *)
+
+ (* adds debugging info (including exception backtraces) *)
+ flag ["ocaml"; "compile"] (A "-g");
+
+ (* flags to parameterize ocamldoc to produce web pages *)
+ flag ["gen_html"; "ocaml"; "doc"]
+ (S [A "-colorize-code"; A "-short-functors"; A "-all-params"]);
+ flag ["gen_man"; "ocaml"; "doc"]
+ (S [A "-man"; A "-man-mini"]);
+
+ (* when profiling, link with profiling.cmo *)
+ if not_empty profiling_modules then
+ flag ["ocaml"; "link"; "byte"]
+ (S [A profiling_modules]);
+
+ (* the warning about unused function arguments are disabled
+ * for files with this tag. *)
+ flag ["nowarn20"; "ocaml"; "compile"] (S [A "-w"; A "-20"]);
+
+ (* adds the custom option, unless 'nocustom' is given as a tag *)
+ if not (Tags.mem "nocustom" (tags_of_pathname "myocamlbuild.ml"))
+ then flag ["ocaml"; "link"; "byte"] (A "-custom");
+ ()
+
+ | _ -> ()
+end
include ../Makefile.config
endif
-include Makefile.doc
-
TARGET=cocciocaml
-SRC=coccilib.ml ocamlcocci_aux.ml $(OCAMLCOCCI_FILE) prepare_ocamlcocci.ml run_ocamlcocci.ml
+SRC=exposed_modules.ml coccilib.ml ocamlcocci_aux.ml $(OCAMLCOCCI_FILE) prepare_ocamlcocci.ml run_ocamlcocci.ml
#LIBS=../commons/commons.cma ../parsing_c/parsing_c.cma
#INCLUDES= -I ../commons -I ../parsing_c
##############################################################################
# Top rules
##############################################################################
+ifneq ($(FEATURE_OCAMLBUILD),yes)
all: $(TARGET).cma
all.opt:
@$(MAKE) $(TARGET).cmxa BUILD_OPT=yes
clean::
rm -f $(TARGET).top
+else
+all:
+ cd .. && $(OCAMLBUILD) ocaml/ocaml.cma
+all.opt:
+ cd .. && $(OCAMLBUILD) ocaml/ocaml.cmxa
+
+clean::
+ cd .. && $(OCAMLBUILD) -clean
+endif
+
+include Makefile.doc
##############################################################################
rm -f .depend
distclean: clean
+ rm -f coccilib/coccilib.cmi
.depend depend:
$(OCAMLDEP_CMD) *.mli *.ml > .depend
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
ifneq ($(MAKECMDGOALS),cleandoc)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
endif
+endif
include ../Makefile.common
include ../Makefile.config
endif
-API=coccilib.mli
DEST=../docs
FLAGS=$(INCLUDES) -hide Pervasives
HTMLFLAGS=-all-params -colorize-code
doc: html man
html: $(DEST)/html/index.html
-$(DEST)/html/index.html: $(API) ../parsing_c/ast_c.cmi
+man: $(DEST)/man/Coccilib.3o
+
+ifneq ($(FEATURE_OCAMLBUILD),yes)
+$(DEST)/man/Coccilib.3o: coccilib.cmi ../parsing_c/ast_c.cmi
+ $(MKDIR_P) $(DEST)/man
+ $(OCAMLDOC) $(FLAGS) -hide Exposed_modules \
+ -man $(MANFLAGS) -d $(DEST)/man ../parsing_c/ast_c.ml coccilib.ml
+
+$(DEST)/html/index.html: coccilib.cmi ../parsing_c/ast_c.cmi
$(MKDIR_P) $(DEST)/html
- $(OCAMLDOC) $(FLAGS) -html $(HTMLFLAGS) -d $(DEST)/html $(API)
+ $(OCAMLDOC) $(FLAGS) -hide Exposed_modules \
+ -html $(HTMLFLAGS) -d $(DEST)/html ../parsing_c/ast_c.ml coccilib.ml
+else
-man: $(DEST)/man/Coccilib.3o
-$(DEST)/man/Coccilib.3o: $(API) ../parsing_c/ast_c.cmi
+$(DEST)/man/Coccilib.3o: ../_build/ocaml/coccilib.cmi coccilib.ml exposed_modules.ml man.odocl
$(MKDIR_P) $(DEST)/man
- $(OCAMLDOC) $(FLAGS) -man $(MANFLAGS) -d $(DEST)/man $(API)
+ cd .. && $(OCAMLBUILD) ocaml/man.docdir/index.html
+ cp -r ../_build/ocaml/man.docdir/* $(DEST)/man/
+
+$(DEST)/html/index.html: ../_build/ocaml/coccilib.cmi coccilib.ml exposed_modules.ml html.odocl
+ $(MKDIR_P) $(DEST)/html
+ cd .. && $(OCAMLBUILD) ocaml/html.docdir/index.html
+ cp -r ../_build/ocaml/html.docdir/* $(DEST)/html/
+
+# build coccilib.cmi if needed
+../_build/ocaml/coccilib.cmi:
+ cd .. && $(OCAMLBUILD) ocaml/coccilib.cmi
+
+endif
cleandoc:
- rm -rf $(DEST)/html $(DEST)/man
+ @if test -z "${KEEP_GENERATED}"; then \
+ rm -rf $(DEST)/html $(DEST)/man; fi
-(* Function table management *)
+(** A library of functions for use with Coccinelle OCaml script code.
+*)
-type pos = { current_element : string;
- file :string ;
- line : int;
- col : int;
- line_end : int;
- col_end : int; }
+(**/**)
+(** Coccinelle modules accessible from an ocaml script.
+*)
+include Exposed_modules
+(**/**)
+
+(** A value of type {b pos} describes a position in a source file.
+*)
+type pos = {
+ current_element : string;
+ (** {b current_element} is the name of the function containing the
+ matched position *)
+ file :string ;
+ (** {b file} is the name of the file containing the matched
+ position *)
+ line : int;
+ (** {b line} is the number of the line containing the first
+ character of the matched position *)
+ col : int;
+ (** {b col} is the column containing the first character of the
+ matched position *)
+ line_end : int;
+ (** {b line_end} is the number of the line containing the last
+ character of the matched position *)
+ col_end : int;
+ (** {b col_end} is the column containing the last character of the
+ matched position. *)
+}
+
+(**
+ Types describing the metavariables.
+*)
type param_type =
Pos of pos list
| Str of string
| FieldList of Ast_c.field list
| Stmt of Ast_c.statement
+
+(* Function table management *)
+
+(**/**)
+(**
+ For internal use only.
+*)
let fcts : (string, param_type list -> string ref list -> unit) Hashtbl.t =
Hashtbl.create 11 (* Use prime number *)
+(**/**)
(* ---------------------------------------------------------------------- *)
(* Match management *)
+(**
+ See include_match.
+*)
let inc_match = ref true
+
+(** If the argument is true, retain the environment with respect to
+ which the ocaml script code is being executed for use in subsequent
+ rules. If the argument is false, discard this environment. By
+ default, the environment is retained.
+*)
let include_match x = inc_match := x
+(**
+ See exit
+*)
let exited = ref false
-let exit _ = exited := true
+
+(** If called, aborts the treatment of the current file. All previous
+ changes take effect.
+*)
+let exit () = exited := true
let dir () = !Flag.dir
pos transformations
*)
+(** convert the filename of a pos to its basename *)
let basename_pos pos = { pos with file = Filename.basename (pos.file) }
(in a separate module to not pollute the namespace)
*)
+(** external analysis integration. Note: do not use after transformations. *)
module Ana = struct
+ (** the type of analysis results: currently only integer ranges. *)
type result = Externalanalysis.result
type bound = Externalanalysis.bound
+ (** convert a bound to a string for showing. *)
let show_bound = Externalanalysis.show_bound
+
+ (** convert a result value to a string for showing. *)
let show_result = Externalanalysis.show_result
+ (** loads some analysis results from the given file. *)
let load_results =
Externalanalysis.load_external_results
+ (** finds the analysis results for a given position. *)
let find pos =
Externalanalysis.find_results pos.file (pos.line, pos.col) (pos.line_end, pos.col_end)
+ (** computes the intersection of analysis results, if possible. *)
let inter = Externalanalysis.intersect_results
+ (** predicate over a list of analysis results of a given position. *)
let satisfy f pos =
Externalanalysis.satisfy f pos.file (pos.line, pos.col) (pos.line_end, pos.col_end)
+ (** predicate over the intersection of analysis results. *)
let satisfy1 f pos =
Externalanalysis.satisfy1 f pos.file (pos.line, pos.col) (pos.line_end, pos.col_end)
+ (** true if an analysis result exists for the given position. *)
let has_any pos =
Externalanalysis.has_any_result pos.file (pos.line, pos.col) (pos.line_end, pos.col_end)
+ (** predicate over all analysis results of a given position. *)
let for_all p pos =
Externalanalysis.for_all p pos.file (pos.line, pos.col) (pos.line_end, pos.col_end)
+ (** predicate over all analysis results (at least one) of a given position. *)
let for_all1 p pos =
Externalanalysis.for_all1 p pos.file (pos.line, pos.col) (pos.line_end, pos.col_end)
+ (** true if the predicate is satisfied for at least one result
+ of a given position. *)
let exists p pos =
Externalanalysis.exists p pos.file (pos.line, pos.col) (pos.line_end, pos.col_end)
+ (** true if the result contains only a single integer as range *)
let single_int = Externalanalysis.single_int
+
+ (** true if the result range contains the given integer. *)
let contains_int = Externalanalysis.contains_int
+ (** analysis result of the position has only the zero value. *)
let has_only_nul pos =
Externalanalysis.has_only_nul pos.file (pos.line, pos.col) (pos.line_end, pos.col_end)
+ (** analysis result of the position contains also the zero value. *)
let has_also_nul pos =
Externalanalysis.has_also_nul pos.file (pos.line, pos.col) (pos.line_end, pos.col_end)
+ (** analysis result of the position contains also the given integer. *)
let has_also_int c pos =
Externalanalysis.has_also_int c pos.file (pos.line, pos.col) (pos.line_end, pos.col_end)
-
end
+++ /dev/null
-(** Library of functions for use with Coccinelle OCaml script code
-*)
-
-(** A value of type {b pos} describes a position in a source file.
-*)
-type pos = {
- current_element : string;
- (** {b current_element} is the name of the function containing the
- matched position *)
- file :string ;
- (** {b file} is the name of the file containing the matched
- position *)
- line : int;
- (** {b line} is the number of the line containing the first
- character of the matched position *)
- col : int;
- (** {b col} is the column containing the first character of the
- matched position *)
- line_end : int;
- (** {b line_end} is the number of the line containing the last
- character of the matched position *)
- col_end : int;
- (** {b col_end} is the column containing the last character of the
- matched position. *)
-}
-
-(**
- Types describing the metavariables
-*)
-type param_type =
- Pos of pos list
- | Str of string
- | Type of Ast_c.fullType
- | Init of Ast_c.initialiser
- | InitList of Ast_c.initialiser Ast_c.wrap2 list
- | Int of int
- | Param of Ast_c.parameterType
- | ParamList of Ast_c.parameterType Ast_c.wrap2 list
- | Expr of Ast_c.expression
- | ExprList of Ast_c.argument Ast_c.wrap2 list
- | Decl of Ast_c.declaration
- | Field of Ast_c.field
- | FieldList of Ast_c.field list
- | Stmt of Ast_c.statement
-
-(* ---------------------------------------------------------------------- *)
-(* Match management *)
-
-(** If the argument is true, retain the environment with respect to
- which the ocaml script code is being executed for use in subsequent
- rules. If the argument is false, discard this environment. By
- default, the environment is retained.
-*)
-val include_match : bool -> unit
-
-(**
- See include_match
-*)
-val inc_match : bool ref
-
-(** If called, aborts the treatment of the current file. All previous
- changes take effect.
-*)
-val exit : unit -> unit
-
-(**
- See exit
-*)
-val exited : bool ref
-
-(** Returns the directory on which spatch was launched.*)
-val dir : unit -> string
-
-(**/**)
-
-(**
- For internal use only
-*)
-val fcts : (string, param_type list -> string ref list -> unit) Hashtbl.t
-
-(* org mode *)
-
-val print_main : ?color:string -> string -> pos list -> unit
-val print_sec : ?color:string -> string -> pos list -> unit
-val print_secs : ?color:string -> string -> pos list -> unit
-
-
-(* ---------------------------------------------------------------------- *)
-(* Pos transformations *)
-
-(** convert the filename of a pos to its basename *)
-val basename_pos : pos -> pos
-
-
-(* ---------------------------------------------------------------------- *)
-(* External analysis *)
-
-(** external analysis integration. Note: do not use after transformations. *)
-module Ana :
- sig
- (** the type of analysis results: currently only integer ranges. *)
- type result = Externalanalysis.result
- type bound = Externalanalysis.bound
-
- (** convert a result value to a string for showing. *)
- val show_result : result -> string
-
- (** convert a bound to a string for showing. *)
- val show_bound : bound -> string
-
- (** loads some analysis results from the given file. *)
- val load_results : string -> unit
-
- (** finds the analysis results for a given position. *)
- val find : pos -> result list
-
- (** computes the intersection of analysis results, if possible. *)
- val inter :
- result -> result -> result option
-
- (** predicate over a list of analysis results of a given position. *)
- val satisfy : (result list -> bool) -> pos -> bool
-
- (** predicate over the intersection of analysis results. *)
- val satisfy1 : (result -> bool) -> pos -> bool
-
- (** true if an analysis result exists for the given position. *)
- val has_any : pos -> bool
-
- (** predicate over all analysis results of a given position. *)
- val for_all : (result -> bool) -> pos -> bool
-
- (** predicate over all analysis results (at least one) of a given position. *)
- val for_all1 : (result -> bool) -> pos -> bool
-
- (** true if the predicate is satisfied for at least one result
- of a given position. *)
- val exists : (result -> bool) -> pos -> bool
-
- (** true if the result contains only a single integer as range *)
- val single_int : int64 -> result -> bool
-
- (** true if the result range contains the given integer. *)
- val contains_int : int64 -> result -> bool
-
- (** analysis result of the position has only the zero value. *)
- val has_only_nul : pos -> bool
-
- (** analysis result of the position contains also the zero value. *)
- val has_also_nul : pos -> bool
-
- (** analysis result of the position contains also the given integer. *)
- val has_also_int : int64 -> pos -> bool
- end
--- /dev/null
+(* Modules accessible by the ocaml scripts.
+ *)
+
+module Ast_c = Ast_c (* parsing_c/ast_c.ml *)
+module Parser_c = Parser_c (* parsing_c/parser_c.mly *)
+module Lexer_c = Lexer_c (* parsing_c/lexer_c.mll *)
+module Pretty_print_c = Pretty_print_c (* parsing_c/pretty_print_c.ml *)
+module Lib_parsing_c = Lib_parsing_c (* parsing_c/lib_parsing_c.ml *)
+module Visitor_c = Visitor_c (* parsing_c/visitor_c.ml *)
+
+module Regexp = Regexp (* globals/regexp.ml *)
+module Config = Config (* globals/config.ml *)
+module Flag = Flag (* globals/flag.ml *)
+module Iteration = Iteration (* globals/iteration.ml *)
+module Common = Common (* commons/common.ml *)
+
+module Ast_cocci = Ast_cocci (* parsing_cocci/ast_cocci.ml *)
+module Ast0_cocci = Ast0_cocci (* parsing_cocci/ast0_cocci.ml *)
+module Type_cocci = Type_cocci (* parsing_cocci/type_cocci.ml *)
--- /dev/null
+Common
+Ast_c
+Visitor_c
+Lib_parsing_c
+Iteration
+Flag
+Coccilib
\ No newline at end of file
--- /dev/null
+Common
+Ast_c
+Visitor_c
+Lib_parsing_c
+Iteration
+Flag
+Coccilib
\ No newline at end of file
--- /dev/null
+Coccilib
+Ocamlcocci_aux
+Run_ocamlcocci
+Prepare_ocamlcocci
\ No newline at end of file
--- /dev/null
+Coccilib
+Ocamlcocci_aux
+Run_ocamlcocci
+Prepare_ocamlcocci
\ No newline at end of file
+(* Note: this module passes paths to other commands, but does not take
+ * quoting into account. Thus, if these paths contain spaces, it's likely
+ * that things go wrong.
+ *)
+
module Ast = Ast_cocci
exception CompileFailure of string
Some file
end
-let filter_dep (accld, accinc) dep =
- match dep with
+(* give a path to the coccilib cmi file *)
+let find_cmifile name =
+ let path1 = Printf.sprintf "%s/ocaml/%s.cmi" Config.path name in
+ if Sys.file_exists path1 then path1 else
+ let path2 = Printf.sprintf "%s/ocaml/coccilib/%s.cmi" Config.path name in
+ if Sys.file_exists path2 then path2 else
+ raise (CompileFailure ("No coccilib.cmi in " ^ path1 ^ " or " ^ path2))
+
+(* extract upper case identifiers from the cmi file. This will be an
+ * approximation of the modules referenced by the coccilib, which are
+ * thus present in the application and do not need to be loaded by
+ * the dynamic linker.
+ *)
+
+module ModuleSet = Set.Make(String)
+
+let approx_coccilib_deps cmi =
+ let chan = open_in_bin cmi in
+ let tbl = Hashtbl.create 1024 in
+ let buf = Buffer.create 140 in
+ begin
+ try
+ while true do
+ let c = input_char chan in
+ let has_ident = Buffer.length buf > 0 in
+ if has_ident
+ then begin
+ if (c >= 'a' && c <= 'z') ||
+ (c >= 'A' && c <= 'Z') ||
+ (c >= '0' && c <= '9') ||
+ c == '_' || c == '\''
+ then Buffer.add_char buf c
+ else begin
+ if Buffer.length buf >= 3
+ then begin
+ let key = Buffer.contents buf in
+ if Hashtbl.mem tbl key
+ then ()
+ else Hashtbl.add tbl (Buffer.contents buf) ()
+ end;
+ Buffer.clear buf
+ end
+ end
+ else begin
+ if c >= 'A' && c <= 'Z'
+ then (* perhaps the begin of a captialized identifier *)
+ Buffer.add_char buf c
+ else ()
+ end
+ done
+ with End_of_file -> ()
+ end;
+ close_in chan;
+ tbl
+
+let filter_dep existing_deps (accld, accinc) dep =
+ if Hashtbl.mem existing_deps dep
+ then (accld, accinc) (* skip an existing dep *)
+ else match dep with
(* Built-in and OCaml defaults are filtered out *)
"Arg" | "Arith_status" | "Array" | "ArrayLabels" | "Big_int" | "Bigarray"
| "Buffer" | "Callback" | "CamlinternalLazy" | "CamlinternalMod"
| "Queue" | "Random" | "Scanf" | "Set" | "Sort" | "Stack" | "StdLabels"
| "Str" | "Stream"
| "String" | "StringLabels" | "Sys" | "ThreadUnix" | "Unix" | "UnixLabels"
- | "Weak"
-
- (* Coccilib is filtered out too *)
- | "Coccilib" | "Common" | "Ast_c" | "Visitor_c" | "Lib_parsing_c"
- | "Iteration" | "Flag" ->
- (accld, accinc)
-
+ | "Weak" -> (accld, accinc)
| "Dbm" -> ("dbm"::accld, accinc)
| "Graphics" -> ("graphics"::accld, accinc)
| "Thread" -> ("thread"::accld, accinc)
let dir = List.hd (Common.cmd_to_list inclcmd) in
(dir, p)
-let parse_dep mlfile depout =
+let parse_dep cmifile mlfile depout =
+ let empty_deps = ([], "") in
+ let existing_deps = approx_coccilib_deps cmifile in
let re_colon = Str.regexp_string ":" in
match Str.split re_colon depout with
_::[dep] ->
let deplist = Str.split (Str.regexp_string " ") dep in
- let (libs, orderdep) = List.fold_left filter_dep ([],[]) deplist in
+ let (libs, orderdep) = List.fold_left (filter_dep existing_deps) ([],[]) deplist in
if libs <> [] || orderdep <> [] then
begin
if check_cmd (!Flag.ocamlfind ^ " printconf 2>&1 > /dev/null")
let flags =
String.concat " " (List.map (fun (d,_) -> "-I "^d) inclflags) in
if flags <> "" || libs <> []
- then
- begin
- Common.pr2
- ("Extra OCaml packages used in the semantic patch:"^ plist);
- (alllibs (* , inclflags *), flags)
- end
- else
- raise
- (CompileFailure
- ("ocamlfind did not find "^
+ then begin
+ Common.pr2
+ ("Extra OCaml packages used in the semantic patch:"^ plist);
+ (alllibs, flags)
+ end
+ else begin
+ Common.pr2 ("Warning: ocamlfind did not find "^
(if (List.length libs + List.length orderdep) = 1
then "this package:"
- else "one of these packages:")^ plist))
- else
- raise
- (CompileFailure ("ocamlfind not found but "^mlfile^" uses "^dep))
+ else "one of these packages:")^ plist);
+ empty_deps
+ end
+ else begin
+ Common.pr2 ("Warning: ocamlfind not found but "^mlfile^" uses "^dep);
+ empty_deps
+ end
end
else
- ([] (* , [] *), "")
+ empty_deps
| _ ->
raise
(CompileFailure ("Wrong dependencies for "^mlfile^" (Got "^depout^")"))
-let dep_flag mlfile =
+let dep_flag cmifile mlfile =
let depcmd = !Flag.ocamldep ^" -modules "^mlfile in
match Common.cmd_to_list depcmd with
- [dep] -> parse_dep mlfile dep
+ [dep] -> parse_dep cmifile mlfile dep
| err ->
List.iter (function x -> Common.pr2 (x^"\n")) err;
raise (CompileFailure ("Failed ocamldep for "^mlfile))
0 -> ()
| _ -> raise (CompileFailure mlfile)
-let rec load_obj obj =
- try
- Dynlink.loadfile obj
+let load_obj obj =
+ Dynlink.allow_unsafe_modules true;
+ try Dynlink.loadfile obj
with Dynlink.Error e ->
- match e with
- Dynlink.Unsafe_file ->
- Dynlink.allow_unsafe_modules true;
- load_obj obj
- | _ ->
- Common.pr2 (Dynlink.error_message e);
- raise (LinkFailure obj)
-
-(*
-let link_lib (dir, name) = name ^ ext
-
-let link_libs libs =
- String.concat " " (List.map link_lib libs)
-*)
+ Common.pr2 (Dynlink.error_message e);
+ raise (LinkFailure obj)
let load_lib (dir, name) =
let obj = dir ^ "/" ^name ^ ext in
List.iter load_lib libs
let load_file mlfile =
- let (ldlibs (* , lklibs *), inc) = dep_flag mlfile in
-(* let linklibs = link_libs lklibs in *)
+ let cmifile = find_cmifile "coccilib" in
+ let (ldlibs, inc) = dep_flag cmifile mlfile in
+ (* add ocaml and ocaml/coccilib as search directories for the ocaml scripting *)
let flags =
Printf.sprintf
- "-g -I %s %s -I %s/globals -I %s/ocaml -I %s/parsing_c -I %s/commons "
- (sysdir ()) inc Config.path Config.path Config.path Config.path in
+ "-g -I %s %s -I %s"
+ (sysdir ()) inc (Filename.dirname cmifile) in
let (obj, cmd) =
if Config.dynlink_is_native
then compile_native_cmd flags mlfile
Common.pr2 "Compilation OK!";
load_libs ldlibs;
Common.pr2 "Loading ML code of the SP...";
- try Dynlink.loadfile obj
- with Dynlink.Error e ->
- Common.pr2 (Dynlink.error_message e);
- raise (LinkFailure obj)
+ load_obj obj
let clean_file mlfile =
let basefile = Filename.chop_extension mlfile in
TARGET=parsing_c
# - type_cocci.ml ast_cocci.ml # + unparse_hrule
-SRC= flag_parsing_c.ml parsing_stat.ml \
+SRC= token_annot.ml flag_parsing_c.ml parsing_stat.ml \
token_c.ml ast_c.ml control_flow_c.ml \
visitor_c.ml lib_parsing_c.ml \
control_flow_c_build.ml \
##############################################################################
# Top rules
##############################################################################
+ifneq ($(FEATURE_OCAMLBUILD),yes)
all: $(TARGET).cma
all.opt:
@$(MAKE) $(TARGET).cmxa BUILD_OPT=yes
$(OCAMLYACC) -v $<
clean::
rm -f parser_c.ml parser_c.mli parser_c.output
+else
+all:
+ cd .. && $(OCAMLBUILD) parsing_c/parsing_c.cma
+
+all.opt:
+ cd .. && $(OCAMLBUILD) parsing_c/parsing_c.cmxa
+
+clean::
+ cd .. && $(OCAMLBUILD) -clean
+endif
##############################################################################
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
+endif
include ../Makefile.common
(* set in comment_annotater_c.ml *)
comments_tag: comments_around ref;
+ (* annotations on the token (mutable) *)
+ mutable annots_tag: Token_annot.annots
+
(* todo? token_info : sometimes useful to know what token it was *)
}
and il = info list
| DefineFunction of definition
| DefineInit of initialiser (* in practice only { } with possible ',' *)
- (* TODO DefineMulti of define_val list *)
+ | DefineMulti of statement list
| DefineText of string wrap
| DefineEmpty
let fakeInfo pi =
{ pinfo = FakeTok ("",no_virt_pos);
cocci_tag = ref emptyAnnot;
+ annots_tag = Token_annot.empty;
comments_tag = ref emptyComments;
}
file = "";
str = str_of_info x});
cocci_tag = ref emptyAnnot;
+ annots_tag = Token_annot.empty;
comments_tag = ref emptyComments;
}
file = "";
str = str_of_info x});
cocci_tag = ref emptyAnnot;
+ annots_tag = Token_annot.empty;
comments_tag = ref emptyComments;
}
file = "";
str = str_of_info x});
cocci_tag = ref emptyAnnot;
+ annots_tag = Token_annot.empty;
comments_tag = ref (al_comments !(x.comments_tag));
}
let semi_al_info_cpp x =
{ x with
cocci_tag = ref emptyAnnot;
+ annots_tag = Token_annot.empty;
comments_tag = ref (al_comments !(x.comments_tag));
}
file = "";
str = str_of_info x});
cocci_tag = ref emptyAnnot;
+ annots_tag = Token_annot.empty;
comments_tag = ref (al_comments !(x.comments_tag));
}
let empty_ii = [] in
(e, empty_ii)::unsplit_comma xs
| Right ii::_ ->
- raise Impossible
+ raise (Impossible 59)
s, [iis]
| CppConcatenatedName xs ->
(match xs with
- | [] -> raise Impossible
+ | [] -> raise (Impossible 60)
| ((s,iis),noiiop)::xs ->
s, iis
)
let name_of_parameter param =
param.p_namei +> Common.map_option (str_of_name)
+
+(* ------------------------------------------------------------------------- *)
+(* Annotations on tokens *)
+(* ------------------------------------------------------------------------- *)
+
+(* to put a given annotation on a token *)
+let put_annot_info info key value =
+ info.annots_tag <- Token_annot.put_annot key value info.annots_tag
+
+(* to check if an annotation has such a token *)
+let get_annot_info info key =
+ Token_annot.get_annot info.annots_tag key
| Parser_c.TCommentCpp(cppcommentkind, info) ->
Token_c.TCommentCpp cppcommentkind, (Ast_c.parse_info_of_info info)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 61)
(*****************************************************************************)
let (iiheader, iielse, iifakeend) =
match ii with
| [i1;i2;i3;i4;i5] -> [i1;i2;i3], i4, i5
- | _ -> raise Impossible
+ | _ -> raise (Impossible 62)
in
let newi = !g +> add_node (IfHeader (stmt, (e, iiheader))) lbl "if" in
!g +> add_arc_opt (starti, newi);
(Case (stmt, (e, ii))), st
| Labeled (Ast_c.CaseRange (e, e2, st)), ii ->
(CaseRange (stmt, ((e, e2), ii))), st
- | _ -> raise Impossible
+ | _ -> raise (Impossible 63)
in
let newi = !g +> add_node node lbl "case:" in
let (iido, iiwhiletail, iifakeend) =
match ii with
| [i1;i2;i3;i4;i5;i6] -> i1, [i2;i3;i4;i5], i6
- | _ -> raise Impossible
+ | _ -> raise (Impossible 64)
in
let doi = !g +> add_node (DoHeader (stmt, iido)) lbl "do" in
!g +> add_arc_opt (starti, doi);
match context_info with
LoopInfo (loopstarti, loopendi, braces, parent_lbl) -> parent_lbl
| SwitchInfo (startbrace, loopendi, braces, parent_lbl) -> parent_lbl
- | NoInfo -> raise Impossible in
+ | NoInfo -> raise (Impossible 65) in
(* flow_to_ast: *)
let (node_info, string) =
| Ast_c.Break ->
(Break (stmt, ((), ii)),
Printf.sprintf "break; [%s]" parent_string)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 66)
) in
(* idea: break or continue records the label of its parent loop or
(* if no loops, then continue behaves like break - just
one iteration *)
if !Flag_parsing_c.no_loops then loopendi else loopstarti
- | x -> raise Impossible
+ | x -> raise (Impossible 67)
) in
let difference = List.length xi.braces - List.length braces in
assert (difference >= 0);
let newi = insert_all_braces toend newi in
!g#add_arc ((newi, loopendi), Direct);
None
- | NoInfo -> raise Impossible
+ | NoInfo -> raise (Impossible 68)
)
| Jump ((Ast_c.Return | Ast_c.ReturnExpr _) as kind) ->
match kind with
| Ast_c.Return -> "return"
| Ast_c.ReturnExpr _ -> "return ..."
- | _ -> raise Impossible
+ | _ -> raise (Impossible 69)
in
let newi =
!g +> add_node
(match kind with
| Ast_c.Return -> Return (stmt, ((),ii))
| Ast_c.ReturnExpr e -> ReturnExpr (stmt, (e, ii))
- | _ -> raise Impossible
+ | _ -> raise (Impossible 70)
)
lbl s
in
else !g#add_arc ((newi, exiti), Direct)
;
None
- | _ -> raise Impossible
+ | _ -> raise (Impossible 71)
)
| ioparen::icparen::iobrace::icbrace::iifake::isto ->
ioparen::icparen::iifake::isto,
[iobrace;icbrace]
- | _ -> raise Impossible
+ | _ -> raise (Impossible 72)
)
in
let (st, (e, ii)) = specialdeclmacro_to_stmt (s, args, ii) in
(Control_flow_c.ExprStatement (st, (Some e, ii))), "macrotoplevel"
(*(Control_flow_c.MacroTop (s, args,ii), "macrotoplevel") *)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 73)
in
let ei = !g +> add_node elem lbl_0 str in
let endi = !g +> add_node EndNode lbl_0 "[end]" in
!g#add_arc ((headeri, endi),Direct);
| Ast_c.DefineInit _ ->
raise (Error(Define(pinfo_of_ii ii)))
+ | Ast_c.DefineMulti sts -> (* christia: todo *)
+ raise (Error(Define(pinfo_of_ii ii)))
| Ast_c.DefineTodo ->
raise (Error(Define(pinfo_of_ii ii)))
-(* Yoann Padioleau
- *
- * Copyright (C) 2010, University of Copenhagen DIKU and INRIA.
- * Copyright (C) 2009 University of Urbana Champaign
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License (GPL)
- * version 2 as published by the Free Software Foundation.
- *
- * 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
- * file license.txt for more details.
- *)
-
open Common
open Oset
let file =
match !node with
| (file, _)::xs -> file
- | [] -> raise Impossible
+ | [] -> raise (Impossible 74)
in
(* in apache/srclib/apr/include/arch/win32/apr_dbg_win32_handles.h
* we get some __ROOT__ -> CreateMutexA -> CreateMutexA because
(* get the longuest one ? or the one that contains the dangerous macro ? *)
let get_single_file_and_def_of_node k v =
match !v with
- | [] -> raise Impossible
+ | [] -> raise (Impossible 75)
| [file, def] -> file, def
| (file, def)::y::ys ->
pr2 (spf "multiple def for %s but I kept only one" k);
else
let remaining = g#nodes#tolist in
(match remaining with
- | [] -> raise Impossible
+ | [] -> () (* christia: commented this out: raise (Impossible 76)
+ * This seems to be the case when there are no
+ * problematic macros. Which is possible.
+ *)
| [(k,n)] ->
assert (k = rootname);
(* end recursion *)
()
- | x::y::xs ->
+ | (k, v)::y::xs ->
let leafs = (g#leaf_nodes ())#tolist in
pr2 (spf "step: %d, %s" depth (leafs +> Common.join " "));
(spf "/tmp/graph-%d.dot" depth)
g;
- assert(not (null leafs));
+ assert(not (null leafs));
(* little specialisation to avoid useless work *)
else true
(* ex: AP_DECLARE(x) x *)
- | Cpp_token_c.Params([s1]), Cpp_token_c.DefineBody [TIdent (s2,i1)] ->
- s1 =$= s2
+ | Cpp_token_c.Params([s1]),
+ Cpp_token_c.DefineBody [TIdent (s2,i1)] ->
+ (match s1 with
+ Cpp_token_c.FixedArg s1 -> s1 =$= s2
+ | Cpp_token_c.VariadicArg _ -> false)
(* keyword aliases. eg: APR_inline __inline__ *)
| Cpp_token_c.NoParam, Cpp_token_c.DefineBody [x] ->
let grouped = Common.group_assoc_bykey_eff final_macros in
grouped
+
| IfdefStmt (IfdefDirective ((_, tag2),_)) ->
tag =*= tag2
| StmtElem _ | CppDirectiveStmt _ -> false
- | IfdefStmt2 _ -> raise Impossible
+ | IfdefStmt2 _ -> raise (Impossible 77)
xxs +> List.map snd +> List.map (fun x ->
match x with
| IfdefStmt y -> y
- | StmtElem _ | CppDirectiveStmt _ | IfdefStmt2 _ -> raise Impossible
+ | StmtElem _ | CppDirectiveStmt _ | IfdefStmt2 _ -> raise (Impossible 78)
),
xxs +> List.map fst,
xs
-(* Yoann Padioleau
- *
- * Copyright (C) 2010, University of Copenhagen DIKU and INRIA.
- * Copyright (C) 2007, 2008 Ecole des Mines de Nantes
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License (GPL)
- * version 2 as published by the Free Software Foundation.
- *
- * 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
- * file license.txt for more details.
- *)
-
open Common
module TH = Token_helpers
type define_def = string * define_param * define_body
and define_param =
| NoParam
- | Params of string list
+ | Params of define_arg list
+ and define_arg = FixedArg of string | VariadicArg of string
and define_body =
| DefineBody of Parser_c.token list
| DefineHint of parsinghack_hint
| NoParam ->
spf "#define %s " s
| Params xs ->
+ let xs = List.map (function FixedArg s -> s | VariadicArg s -> s) xs in
spf "#define %s(%s) " s (Common.join "," xs)
in
let s2 =
* the job right and already replaced the macro parameter with a TIdent.
*)
match tok with
- | TIdent (s,i1) when List.mem_assoc s env -> Common.assoc s env
+ | TIdent (s,i1) when List.mem_assoc s env ->
+ Common.assoc s env
| x -> [x]
)
+> List.flatten
| DefineBody bodymacro ->
(* bugfix: better to put this that before the match body,
- * cos our macrostatement hint can have variable number of
- * arguments and so it's ok if it does not match exactly
- * the number of arguments. *)
- if List.length params != List.length xxs
- then begin
- pr2_once ("WEIRD: macro with wrong number of arguments: " ^ s);
- (* old: id.new_tokens_before <- bodymacro; *)
-
- (* update: if wrong number, then I just pass this macro *)
- [Parenthised (xxs, info_parens)] +>
+ * cos our macrostatement hint can have variable number of
+ * arguments and so it's ok if it does not match exactly
+ * the number of arguments. *)
+ let build_binder params xxs =
+ let rec loop = function
+ ([],[]) -> Some (function [] -> [] | _ -> failwith "bad")
+ | ([],l) -> None
+ | ([(VariadicArg s)],l) ->
+ Some (function l -> List.map (function a -> (s,a)) l)
+ | ((VariadicArg _)::_,l) -> None
+ | ((FixedArg _)::_,[]) -> None
+ | ((FixedArg s)::rest,x::xs) ->
+ (match loop (rest,xs) with
+ Some k ->
+ Some (function l -> (s,(List.hd l)) :: k (List.tl l))
+ | None -> None) in
+ loop (params, xxs) in
+ (match build_binder params xxs with
+ None ->
+ pr2_once
+ ("WEIRD: macro with wrong number of arguments: " ^ s);
+ (* old: id.new_tokens_before <- bodymacro; *)
+
+ (* update: if wrong number, then I just pass this macro *)
+ [Parenthised (xxs, info_parens)] +>
iter_token_paren (set_as_comment Token_c.CppMacro);
- set_as_comment Token_c.CppMacro id;
-
- ()
- end
- else
-
- let xxs' = xxs +> List.map (fun x ->
- (tokens_of_paren_ordered x) +> List.map (fun x ->
- TH.visitor_info_of_tok Ast_c.make_expanded x.tok
- )
- ) in
- id.new_tokens_before <-
- (* !!! cpp expansion job here !!! *)
- cpp_engine ?evaluate_concatop
- (Common.zip params xxs') bodymacro;
-
- (* important to do that after have apply the macro, otherwise
- * will pass as argument to the macro some tokens that
- * are all TCommentCpp
- *)
- [Parenthised (xxs, info_parens)] +>
+ set_as_comment Token_c.CppMacro id
+ | Some bind ->
+
+ let xxs' = xxs +> List.map (fun x ->
+ (tokens_of_paren_ordered x) +> List.map (fun x ->
+ TH.visitor_info_of_tok Ast_c.make_expanded x.tok
+ )
+ ) in
+ id.new_tokens_before <-
+ (* !!! cpp expansion job here !!! *)
+ cpp_engine ?evaluate_concatop
+ (bind xxs') bodymacro;
+
+ (* important to do that after have apply the macro,
+ otherwise will pass as argument to the macro some
+ tokens that are all TCommentCpp
+ *)
+ [Parenthised (xxs, info_parens)] +>
iter_token_paren (set_as_comment Token_c.CppMacro);
- set_as_comment Token_c.CppMacro id;
-
- | DefineHint (HintMacroStatement as hint) ->
+ set_as_comment Token_c.CppMacro id)
+
+ | DefineHint (HintMacroStatement as hint) ->
(* important to do that after have apply the macro, otherwise
- * will pass as argument to the macro some tokens that
+ * will pass as argument to the macro some tokens that
* are all TCommentCpp
*
* note: such macrostatement can have a variable number of
let (_s, params, body) = Hashtbl.find defs s in
(match params with
- | Params params ->
+ | Params _ ->
pr2 ("WEIRD: macro with params but no parens found: " ^ s);
(* dont apply the macro, perhaps a redefinition *)
()
xs +> Common.split_when (function TDefEOL _ -> true | _ -> false) in
let params =
tokparams +> Common.map_filter (function
- | TComma _ -> None
- | TIdent (s, _) -> Some s
+ | TComma _ -> None
+ | TIdent (s, _) -> Some (FixedArg s)
(* TODO *)
- | TDefParamVariadic (s, _) -> Some s
+ | TDefParamVariadic (s, _) -> Some (VariadicArg s)
(* TODO *)
- | TEllipsis _ -> Some "..."
+ | TEllipsis _ -> Some (VariadicArg "...")
- | x ->
+ | x ->
(* bugfix: param of macros can be tricky *)
- let s = TH.str_of_tok x in
- if s ==~ Common.regexp_alpha
- then begin
- pr2 (spf "remapping: %s to a macro parameter" s);
- Some s
- end
- else
- begin
- pr2 (spf "bad character %s in macro parameter list" s);
- raise Bad_param
- end) in
+ let s = TH.str_of_tok x in
+ if s ==~ Common.regexp_alpha
+ then begin
+ pr2 (spf "remapping: %s to a macro parameter" s);
+ Some (FixedArg s)
+ end
+ else
+ begin
+ pr2 (spf "bad character %s in macro parameter list" s);
+ raise Bad_param
+ end) in
(* bugfix: also substitute to ident in body so cpp_engine will
- * have an easy job.
- *)
+ * have an easy job.
+ *)
let body = body +> List.map (fun tok ->
match tok with
| TIdent _ -> tok
| _ ->
let s = TH.str_of_tok tok in
let ii = TH.info_of_tok tok in
+ let params =
+ List.map
+ (function FixedArg s -> s | VariadicArg s -> s)
+ params in
if s ==~ Common.regexp_alpha && List.mem s params
then begin
pr2 (spf "remapping: %s to an ident in macro body" s);
type define_def = string * define_param * define_body
and define_param =
| NoParam
- | Params of string list
+ | Params of define_arg list
+ and define_arg = FixedArg of string | VariadicArg of string
and define_body =
| DefineBody of Parser_c.token list
| DefineHint of parsinghack_hint
};
(* must generate a new ref each time, otherwise share *)
cocci_tag = ref Ast_c.emptyAnnot;
+ annots_tag = Token_annot.empty;
comments_tag = ref Ast_c.emptyComments;
}
let digit = ['0'-'9']
(* not used for the moment *)
-let punctuation = ['!' '"' '#' '%' '&' '\'' '(' ')' '*' '+' ',' '-' '.' '/' ':'
- ';' '<' '=' '>' '?' '[' '\\' ']' '^' '{' '|' '}' '~']
+let punctuation = ['!' '\"' '#' '%' '&' '\'' '(' ')' '*' '+' ',' '-' '.' '/' ':'
+ ';' '<' '=' '>' '?' '[' '\\' ']' '^' '{' '|' '}' '~']
let space = [' ' '\t' '\n' '\r' '\011' '\012' ]
let additionnal = [ ' ' '\b' '\t' '\011' '\n' '\r' '\007' ]
(* 7 = \a = bell in C. this is not the only char allowed !!
{ TCppDirectiveOther (tokinfo lexbuf) }
(* only after cpp, ex: # 1 "include/linux/module.h" 1 *)
- | "#" sp pent sp '"' [^ '"']* '"' (spopt pent)* spopt ('\n' | "\r\n")
+ | "#" sp pent sp '\"' [^ '\"']* '\"' (spopt pent)* spopt ('\n' | "\r\n")
{ TCppDirectiveOther (tokinfo lexbuf) }
* later in parser_c.mly. So redo a little bit of lexing there; ugly but
* simpler to generate a single token here. *)
| (("#" [' ''\t']* "include" [' ' '\t']*) as includes)
- (('"' ([^ '"']+) '"' |
+ (('\"' ([^ '\"']+) '\"' |
'<' [^ '>']+ '>' |
['A'-'Z''_']+
) as filename)
}
(* gccext: found in glibc *)
| (("#" [' ''\t']* "include_next" [' ' '\t']*) as includes)
- (('"' ([^ '"']+) '"' |
+ (('\"' ([^ '\"']+) '\"' |
'<' [^ '>']+ '>' |
['A'-'Z''_']+
) as filename)
let s = char lexbuf in
TChar ((s, IsChar), (info +> tok_add_s (s ^ "'")))
}
- | '"'
+ | '\"'
{ let info = tokinfo lexbuf in
let s = string lexbuf in
TString ((s, IsChar), (info +> tok_add_s (s ^ "\"")))
let s = char lexbuf in
TChar ((s, IsWchar), (info +> tok_add_s (s ^ "'")))
}
- | 'L' '"'
+ | 'L' '\"'
{ let info = tokinfo lexbuf in
let s = string lexbuf in
TString ((s, IsWchar), (info +> tok_add_s (s ^ "\"")))
(match v with (* Machine specific ? *)
| 'n' -> () | 't' -> () | 'v' -> () | 'b' -> () | 'r' -> ()
| 'f' -> () | 'a' -> ()
- | '\\' -> () | '?' -> () | '\'' -> () | '"' -> ()
+ | '\\' -> () | '?' -> () | '\'' -> () | '\"' -> ()
| 'e' -> () (* linuxext: ? *)
| _ ->
pr2 ("LEXER: unrecognised symbol in char:"^tok lexbuf);
(match v with (* Machine specific ? *)
| 'n' -> () | 't' -> () | 'v' -> () | 'b' -> () | 'r' -> ()
| 'f' -> () | 'a' -> ()
- | '\\' -> () | '?' -> () | '\'' -> () | '"' -> ()
+ | '\\' -> () | '?' -> () | '\'' -> () | '\"' -> ()
| 'e' -> () (* linuxext: ? *)
| _ ->
pr2 ("LEXER: unrecognised symbol in char:"^tok lexbuf);
(* todo? factorise code with char ? but not same ending token so hard. *)
and string = parse
- | '"' { "" }
+ | '\"' { "" }
| (_ as x) { string_of_char x^string lexbuf}
| ("\\" (oct | oct oct | oct oct oct)) as x { x ^ string lexbuf }
| ("\\x" (hex | hex hex)) as x { x ^ string lexbuf }
(match v with (* Machine specific ? *)
| 'n' -> () | 't' -> () | 'v' -> () | 'b' -> () | 'r' -> ()
| 'f' -> () | 'a' -> ()
- | '\\' -> () | '?' -> () | '\'' -> () | '"' -> ()
+ | '\\' -> () | '?' -> () | '\'' -> () | '\"' -> ()
| 'e' -> () (* linuxext: ? *)
(* old: "x" -> 10 gccext ? todo ugly, I put a fake value *)
| Ast_c.OriginTok _ ->
Buffer.add_string buf (TH.str_of_tok tok)
| Ast_c.AbstractLineTok _ ->
- raise Impossible
+ raise (Impossible 79)
| _ -> ()
);
Buffer.contents buf
!cur_tok
)
in
- let lexbuf_fake = Lexing.from_function (fun buf n -> raise Impossible) in
+ let lexbuf_fake = Lexing.from_function (fun buf n -> raise (Impossible 80)) in
let result = parsefunc lexer_function lexbuf_fake in
result
tr.passed <- [];
- let lexbuf_fake = Lexing.from_function (fun buf n -> raise Impossible) in
+ let lexbuf_fake = Lexing.from_function (fun buf n -> raise (Impossible 81)) in
(try
(* -------------------------------------------------- *)
pr2 ("parse error \n = " ^ error_msg_tok cur)
| Semantic_c.Semantic (s, i) ->
pr2 ("semantic error " ^s^ "\n ="^ error_msg_tok cur)
- | e -> raise Impossible
+ | e -> raise (Impossible 82)
);
(* bugfix: *)
if (checkpoint_file =$= checkpoint2_file) &&
let addInlineD = function
| ((true,ii), ({inlineD = (false,[])} as v)) -> { v with inlineD=(true,[ii])}
| ((true,ii), ({inlineD = (true, ii2)} as v)) -> warning "duplicate inline" v
- | _ -> raise Impossible
+ | _ -> raise (Impossible 86)
let addTypeD = function
{
CppConcatenatedName (
match $3 with
- | [] -> raise Impossible
+ | [] -> raise (Impossible 87)
| (x,concatnull)::xs ->
assert(null concatnull);
(mk_string_wrap $1, [])::(x,[$2])::xs
let fty = mk_ty (Array (Some $3, ty.Ast_c.p_type)) [$2;$4] in
let pty = { ty with p_type = fty } in
Right(ArgType pty)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 88)
}
unary_op:
*)
}
- | spec_qualif_list TPtVirg
+ | spec_qualif_list TPtVirg
{
(* gccext: allow empty elements if it is a structdef or enumdef *)
let (returnType,storage) = fixDeclSpecForDecl $1 in
DefineType typ
}
-/* can be in conflict with decl_spec, maybe change fixDeclSpecForMacro
+/*(* can be in conflict with decl_spec, maybe change fixDeclSpecForMacro
* to also allow storage ?
| storage_class_spec { DefineTodo }
| Tinline { DefineTodo }
-*/
+*)*/
- /*(* a few special cases *)*/
- | stat_or_decl stat_or_decl_list { DefineTodo }
-/*
+ | stat_or_decl stat_or_decl_list
+ { DefineMulti
+ (List.map
+ (function
+ StmtElem e -> e
+ | _ -> failwith "unexpected statement for DefineMulti")
+ ($1 :: $2)) }
+/*(*
| statement statement { DefineTodo }
| decl function_definition { DefineTodo }
-*/
+*)*/
*)*/
-expr_opt:
- | expr { Some $1 }
- | /*(* empty *)*/ { None }
-
--- /dev/null
+Token_annot
+Flag_parsing_c
+Parsing_stat
+Token_c
+Ast_c
+Control_flow_c
+Visitor_c
+Lib_parsing_c
+Control_flow_c_build
+Pretty_print_c
+Semantic_c
+Lexer_parser
+Parser_c
+Lexer_c
+Token_helpers
+Token_views_c
+Cpp_token_c
+Parsing_hacks
+Cpp_analysis_c
+Unparse_cocci
+Unparse_c
+Unparse_hrule
+Parsing_recovery_c
+Parsing_consistency_c
+Parse_c
+Type_c
+Cpp_ast_c
+Type_annoter_c
+Comment_annotater_c
+Compare_c
+Test_parsing_c
--- /dev/null
+Token_annot
+Flag_parsing_c
+Parsing_stat
+Token_c
+Ast_c
+Control_flow_c
+Visitor_c
+Lib_parsing_c
+Control_flow_c_build
+Pretty_print_c
+Semantic_c
+Lexer_parser
+Parser_c
+Lexer_c
+Token_helpers
+Token_views_c
+Cpp_token_c
+Parsing_hacks
+Cpp_analysis_c
+Unparse_cocci
+Unparse_c
+Unparse_hrule
+Parsing_recovery_c
+Parsing_consistency_c
+Parse_c
+Type_c
+Cpp_ast_c
+Type_annoter_c
+Comment_annotater_c
+Compare_c
+Test_parsing_c
| "u8" | "u16" | "u32" | "u64"
| "s8" | "s16" | "s32" | "s64"
| "__u8" | "__u16" | "__u32" | "__u64"
- -> true
+ -> true
| "acpi_handle"
| "acpi_status"
| "UTS_RELEASE"
| "SIZE_STR"
| "DMA_STR"
- -> true
+ -> true
(* s when s =~ ".*STR.*" -> true *)
| _ -> false
)
(* opti: better to built then once and for all, especially regexp_foreach *)
-let regexp_macro = Str.regexp
+let regexp_macro = Str.regexp
"^[A-Z_][A-Z_0-9]*$"
(* linuxext: *)
-let regexp_annot = Str.regexp
+let regexp_annot = Str.regexp
"^__.*$"
(* linuxext: *)
-let regexp_declare = Str.regexp
+let regexp_declare = Str.regexp
".*DECLARE.*"
(* linuxext: *)
let not_annot s =
not (s ==~ regexp_annot)
+let is_macro s =
+ s ==~ regexp_macro
+let not_macro s =
+ not (is_macro s)
single statement in the body of the loop. undoubtedly more
cases are needed.
todo: premier(statement) - suivant(funcall)
- *)
+ *)
| TCPar _::TIdent _::xs -> true, xs
| TCPar _::Tif _::xs -> true, xs
| TCPar _::Twhile _::xs -> true, xs
| TIfdefBool (_, tag, _)
| TIfdefMisc (_, tag, _)
- | TIfdefVersion (_, tag, _)
- ->
- tag := Some cnt;
+ | TIfdefVersion (_, tag, _) ->
+ tag := Some cnt;
- | _ -> raise Impossible
+ | _ -> raise (Impossible 89)
Common.charpos = Ast_c.pos_of_info ii + 1
};
cocci_tag = ref Ast_c.emptyAnnot;
+ annots_tag = Token_annot.empty;
comments_tag = ref Ast_c.emptyComments;
}
in
* body (it would be a recursive macro, which is forbidden).
*)
- | TCommentSpace i1::t::xs ->
-
+ | TCommentSpace i1::t::xs
+ when TH.str_of_tok t ==~ Common.regexp_alpha
+ ->
let s = TH.str_of_tok t in
let ii = TH.info_of_tok t in
- if s ==~ Common.regexp_alpha
- then begin
- pr2 (spf "remapping: %s to an ident in macro name" s);
- let acc = (TCommentSpace i1) :: acc in
- let acc = (TIdentDefine (s,ii)) :: acc in
- define_ident acc xs
- end
- else begin
- pr2 "WEIRD: weird #define body";
- define_ident acc xs
- end
-
- | _ ->
+ pr2 (spf "remapping: %s to an ident in macro name" s);
+ let acc = (TCommentSpace i1) :: acc in
+ let acc = (TIdentDefine (s,ii)) :: acc in
+ define_ident acc xs
+
+ | TCommentSpace _::_::xs
+ | xs ->
pr2 "WEIRD: weird #define body";
define_ident acc xs
)
};
(* must generate a new ref each time, otherwise share *)
cocci_tag = ref Ast_c.emptyAnnot;
+ annots_tag = Token_annot.empty;
comments_tag = ref Ast_c.emptyComments;
}
msg_ifdef_bool_passing is_ifdef_positif;
(match xxs with
- | [] -> raise Impossible
+ | [] -> raise (Impossible 90)
| firstclause::xxs ->
info_ifdef_stmt +>
List.iter (TV.save_as_comment (fun x -> Token_c.CppIfDirective x));
| NotIfdefLine _ -> ()
| Ifdef (xxs, info_ifdef_stmt) ->
(match xxs with
- | [] -> raise Impossible
+ | [] -> raise (Impossible 91)
| [first] -> ()
| first::second::rest ->
(* don't analyse big ifdef *)
| NotIfdefLine _ -> ()
| Ifdef (xxs, info_ifdef_stmt) ->
(match xxs with
- | [] -> raise Impossible
+ | [] -> raise (Impossible 92)
| [first] -> ()
| first::second::rest ->
+let can_be_on_top_level tl =
+ match tl with
+ | Tstruct _
+ | Ttypedef _
+ | TDefine _
+ | TIfdef _
+ | TIfdefelse _
+ | TIfdefelif _
+ | TIfdefBool _
+ | TIfdefMisc _
+ | TIfdefVersion _
+ | TEndif _ -> true
+ | _ -> false
+
(*****************************************************************************)
(* Lexing with lookahead *)
TIdent _ -> true
| _ -> false
+let is_type = function
+ | TypedefIdent _
+ | Tvoid _
+ | Tchar _
+ | Tfloat _
+ | Tdouble _
+ (* christia: not sure what these are? *)
+ | Tsize_t _
+ | Tssize_t _
+ | Tptrdiff_t _
+
+ | Tint _
+ | Tlong _
+ | Tshort _ -> true
+ | _ -> false
+
+let is_cparen = function (TCPar _) -> true | _ -> false
+let is_oparen = function (TOPar _) -> true | _ -> false
+
+let rec not_has_type_before f xs =
+ match xs with
+ | [] -> raise (Impossible 666)
+ | x :: xs ->
+ if f x then
+ true
+ else if is_type x then
+ false
+ else
+ not_has_type_before f xs
+
(* This function is inefficient, because it will look over a K&R header,
or function prototype multiple times. At least when we see a , and are in a
parameter list, we know we will eventually see a close paren, and it
should come fairly soon. *)
let k_and_r l =
- let l1 = drop_until (function (TCPar _) -> true | _ -> false) l in
+ let l1 = drop_until is_cparen l in
match l1 with
(TCPar _) :: (TOCro _) :: _ -> false
| (TCPar _) :: _ -> true
let lookahead2 ~pass next before =
match (next, before) with
-
+
(* c++ hacks *)
(* yy xx( and in function *)
| TOPar i1::_, TIdent(s,i2)::TypedefIdent _::_
if !Flag_parsing_c.debug_typedef
then pr2 ("TYPEDEF: disable typedef cos special case: " ^ s);
- LP.disable_typedef();
+ LP.disable_typedef();
msg_typedef s i1 1; LP.add_typedef_root s;
TypedefIdent (s, i1)
+ (* christia *)
+ (* xx const tt *)
+ | (TIdent (s, i1)::(Tconst _|Tvolatile _|Trestrict _)::type_::_ , _) when not_struct_enum before
+ && is_type type_
+ ->
+
+ TCommentCpp (Token_c.CppDirective, i1)
+
+ (* xx struct *)
+ | (TIdent (s, i1)::Tstruct _::_ , _) when not_struct_enum before
+ ->
+ TCommentCpp (Token_c.CppDirective, i1)
+
+ (* xx tt *)
+ | (TIdent (s, i1)::type_::_ , _) when not_struct_enum before
+ && is_type type_
+ ->
+ TCommentCpp (Token_c.CppDirective, i1)
+
+ (* tt xx yy *)
+ | (TIdent (s, i1)::TIdent (s2, i2)::_ , seen::_) when not_struct_enum before
+ && is_type seen
+ ->
+ if is_macro s2 then
+ TIdent (s, i1)
+ else
+ TCommentCpp (Token_c.CppDirective, i1)
+
+ | (TIdent (s2, i2)::_ , TIdent (s, i1)::seen::_) when not_struct_enum before
+ && is_macro s2 && is_type seen
+ ->
+ TCommentCpp (Token_c.CppDirective, i2)
+
+ (* tt xx * *)
+ | (TIdent (s, i1)::ptr::_ , seen::_) when not_struct_enum before
+ && pointer ptr && is_type seen
+ ->
+ TCommentCpp (Token_c.CppDirective, i1)
+
+ (* tt * xx yy *)
+ | (TIdent (s, i1)::TIdent(s2, i2)::_ , ptr::_) when not_struct_enum before
+ && pointer ptr
+ ->
+ if is_macro s2 then
+ TIdent (s, i1)
+ else
+ TCommentCpp (Token_c.CppDirective, i1)
+
+ (* tt * xx yy *)
+ | (TIdent(s2, i2)::_ , TIdent (s, i1)::ptr::_) when not_struct_enum before
+ && is_macro s2 && pointer ptr
+ ->
+ TCommentCpp (Token_c.CppDirective, i2)
+
+ (* exception to next rule *)
+ | (TIdent(s2, i2)::TOPar _ :: _ , TIdent(s, i1)::seen::_) when not_struct_enum before
+ && is_macro s2 && is_type seen
+ ->
+ TIdent(s2, i2)
+ (* tt xx yy *)
+ | (TIdent(s2, i2)::_ , TIdent(s, i1)::seen::_) when not_struct_enum before
+ && is_macro s2 && is_type seen
+ ->
+ TCommentCpp (Token_c.CppDirective, i2)
+
+ (* xx * yy AND in paramdecl *)
+ | (TIdent (s, i1)::ptr::TIdent (s2, i2)::_ , _)
+ when not_struct_enum before && (LP.current_context() =*= LP.InParameter)
+ && pointer ptr && ok_typedef s
+ ->
+
+ msg_typedef s i1 14; LP.add_typedef_root s;
+ TypedefIdent (s, i1)
+
+ (* xx yy ( *)
+ | (TIdent (s, i1)::TIdent (s2, i2)::TOPar _::_ , _) when not_struct_enum before
+ && ok_typedef s && is_macro s2
+ ->
+ TIdent (s, i1)
(* xx yy *)
| (TIdent (s, i1)::TIdent (s2, i2)::_ , _) when not_struct_enum before
&& ok_typedef s
->
(* && not_annot s2 BUT lead to false positive*)
-
msg_typedef s i1 2; LP.add_typedef_root s;
TypedefIdent (s, i1)
| (TIdent (s, i1)::Tinline i2::_ , _) when not_struct_enum before
&& ok_typedef s
->
+
msg_typedef s i1 3; LP.add_typedef_root s;
TypedefIdent (s, i1)
(* [,(] xx [,)] AND param decl *)
| (TIdent (s, i1)::(((TComma _|TCPar _)::_) as rest) ,
- (TComma _ |TOPar _)::_ )
+ ((TComma _ |TOPar _)::_ as bef))
when not_struct_enum before && (LP.current_context() =*= LP.InParameter)
- && k_and_r rest
+ && k_and_r rest
+ && not_has_type_before is_cparen rest
+ && not_has_type_before is_oparen bef
->
+
TKRParam(s,i1)
| (TIdent (s, i1)::((TComma _|TCPar _)::_) , (TComma _ |TOPar _)::_ )
when not_struct_enum before && (LP.current_context() =*= LP.InParameter)
&& ok_typedef s
->
+
msg_typedef s i1 4; LP.add_typedef_root s;
TypedefIdent (s, i1)
(* && !LP._lexer_hint = Some LP.ParameterDeclaration *)
&& ok_typedef s
->
+
msg_typedef s i1 5; LP.add_typedef_root s;
TypedefIdent (s, i1)
(* && !LP._lexer_hint = Some LP.ParameterDeclaration *)
&& ok_typedef s
->
+
msg_typedef s i1 6; LP.add_typedef_root s;
TypedefIdent (s, i1)
when pointer ptr && not_struct_enum before
&& ok_typedef s
->
+
(* && !LP._lexer_hint = Some LP.ParameterDeclaration *)
msg_typedef s i1 9; LP.add_typedef_root s;
(* ( const xx) *)
| (TIdent (s, i1)::TCPar _::_, (Tconst _ | Tvolatile _|Trestrict _)::TOPar _::_) when
ok_typedef s ->
+
msg_typedef s i1 10; LP.add_typedef_root s;
TypedefIdent (s, i1)
when not_struct_enum before
&& ok_typedef s
->
+
msg_typedef s i1 11; LP.add_typedef_root s;
TypedefIdent (s, i1)
when (LP.current_context() =*= LP.InParameter)
&& ok_typedef s
->
+
msg_typedef s i1 12; LP.add_typedef_root s;
TypedefIdent (s, i1)
(Tregister _|Tstatic _ |Tvolatile _|Tconst _|Trestrict _)::_) when
pointer ptr && ok_typedef s
->
+
msg_typedef s i1 13; LP.add_typedef_root s;
TypedefIdent (s, i1)
when not_struct_enum before && pointer ptr &&
(LP.is_top_or_struct (LP.current_context ()))
->
+
msg_typedef s i1 15; LP.add_typedef_root s;
TypedefIdent (s, i1)
&& (LP.is_top_or_struct (LP.current_context ()))
&& ok_typedef s && pointer ptr
->
+
msg_typedef s i1 17; LP.add_typedef_root s;
TypedefIdent (s, i1)
(LP.is_top_or_struct (LP.current_context ()))
&& ok_typedef s && pointer ptr
->
+
msg_typedef s i1 18; LP.add_typedef_root s;
TypedefIdent (s, i1)
when (LP.is_top_or_struct (LP.current_context ()))
&& ok_typedef s
->
+
msg_typedef s i1 19; LP.add_typedef_root s;
TypedefIdent (s, i1)
when not_struct_enum before
&& ok_typedef s && pointer ptr
->
+
msg_typedef s i1 21; LP.add_typedef_root s;
TypedefIdent (s, i1)
when not_struct_enum before && (LP.current_context () =*= LP.InParameter)
&& ok_typedef s && pointer ptr
->
+
msg_typedef s i1 22; LP.add_typedef_root s;
TypedefIdent (s, i1)
(TOBrace _| TPtVirg _)::_) when not_struct_enum before
&& ok_typedef s & pointer ptr
->
+
msg_typedef s i1 23; LP.add_typedef_root s;
msg_maybe_dangereous_typedef s;
TypedefIdent (s, i1)
(TOBrace _| TPtVirg _)::_) when
ok_typedef s && pointer ptr
->
+
msg_typedef s i1 24; LP.add_typedef_root s;
TypedefIdent (s, i1)
(* struct user_info_t sometimes *)
&& ok_typedef s && pointer ptr
->
+
msg_typedef s i1 25; LP.add_typedef_root s;
TypedefIdent (s, i1)
| (TIdent (s, i1)::TMul _::TMul _::TIdent (s2, i2)::_ , _)
when not_struct_enum before
(* && !LP._lexer_hint = Some LP.ParameterDeclaration *)
- && ok_typedef s
- ->
+ && ok_typedef s
+ (* christia : this code catches 'a * *b' which is wrong
+ *)
+ && true
+ ->
+
msg_typedef s i1 26; LP.add_typedef_root s;
TypedefIdent (s, i1)
&& ok_typedef s
(* && !LP._lexer_hint = Some LP.ParameterDeclaration *)
->
+
msg_typedef s i1 27; LP.add_typedef_root s;
TypedefIdent (s, i1)
(* && !LP._lexer_hint = Some LP.ParameterDeclaration *)
&& ok_typedef s
->
+
msg_typedef s i1 28; LP.add_typedef_root s;
TypedefIdent (s, i1)
&& ok_typedef s
&& not (ident x) (* possible K&R declaration *)
->
+
msg_typedef s i1 29; LP.add_typedef_root s;
(*TOPar info*)
TypedefIdent (s, i1)
(TOPar info)::(TEq _ |TEqEq _)::_)
when ok_typedef s && paren_before_comma rest
->
+
msg_typedef s i1 31; LP.add_typedef_root s;
(* TOPar info *)
TypedefIdent (s, i1)
| (TIdent (s, i1)::ptr::TCPar _::TIdent (s2, i2)::_ , (TOPar info)::_)
when ok_typedef s && pointer ptr
->
+
msg_typedef s i1 32; LP.add_typedef_root s;
(*TOPar info*)
TypedefIdent (s,i1)
when (*s ==~ regexp_typedef && *) not (TH.is_stuff_taking_parenthized x)
&& ok_typedef s
->
+
msg_typedef s i1 33; LP.add_typedef_root s;
TypedefIdent (s, i1)
when not_struct_enum before
&& ok_typedef s
->
+
msg_typedef s i1 34; LP.add_typedef_root s;
TypedefIdent (s, i1)
when not_struct_enum before
&& ok_typedef s
->
+
msg_typedef s i1 35; LP.add_typedef_root s;
TypedefIdent (s, i1)
as x)
::_, _
->
+
(*
if not !Flag_parsing_c.ifdef_to_if
then TCommentCpp (Ast_c.CppIfDirective, ii)
end
else TIdent (s, i1)
- (*-------------------------------------------------------------*)
+(* (* christia: here insert support for macros on top level *)
+ | TIdent (s, ii) :: tl :: _, _ when
+ can_be_on_top_level tl && LP.current_context () = InTopLevel ->
+ pr2_cpp ("'" ^ s ^ "' looks like a macro, I treat it as comment");
+ TCommentCpp (Token_c.CppDirective, ii)
+*)
+
+(*-------------------------------------------------------------*)
| v::xs, _ -> v
- | _ -> raise Impossible
+ | _ -> raise (Impossible 93)
let lookahead ~pass a b =
Common.profile_code "C parsing.lookahead" (fun () -> lookahead2 ~pass a b)
pr2_err ("ERROR-RECOV: found sync '}' at line "^i_to_s (TH.line_of_tok v));
(match xs with
- | [] -> raise Impossible (* there is a EOF token normally *)
+ | [] -> raise (Impossible 94) (* there is a EOF token normally *)
(* still useful: now parser.mly allow empty ';' so normally no pb *)
| Parser_c.TPtVirg iptvirg::xs ->
=
let start_block () = pr_nl(); pr_indent() in
let end_block () = pr_unindent(); pr_nl() in
-
+(*
+ let pr_nl_slash _ = (* multiline macro *)
+ let slash = (Ast_c.fakeInfo() +> Ast_c.rewrap_str " \\") in
+ pr_elem slash; pr_nl() in
+*)
let indent_if_needed st f =
match Ast_c.unwrap_st st with
Compound _ -> pr_space(); f()
| ArrayAccess (_,_) | RecordAccess (_,_) | RecordPtAccess (_,_)
| SizeOfExpr (_) | SizeOfType (_) | Cast (_,_)
| StatementExpr (_) | Constructor _
- | ParenExpr (_) | New (_) | Delete (_)),_ -> raise Impossible
+ | ParenExpr (_) | New (_) | Delete (_)),_ -> raise (Impossible 95)
);
if !Flag_parsing_c.pretty_print_type_info
| _st2, [i4;iifakend] -> pr_elem i4;
indent_if_needed st2 (function _ -> pp_statement st2);
pr_elem iifakend
- | x -> raise Impossible
+ | x -> raise (Impossible 96)
)
| Selection (Switch (e, st)), [i1;i2;i3;iifakend] ->
pr_elem i1; pr_space(); pr_elem i2; pp_expression e; pr_elem i3;
pr_elem iasm; pr_elem ivolatile; pr_elem iopar;
pp_asmbody asmbody;
pr_elem icpar; pr_elem iptvirg
- | _ -> raise Impossible
+ | _ -> raise (Impossible 97)
)
| NestedFunc def, ii ->
| Jump ((Continue|Break|Return)) | Jump (ReturnExpr _)
| Jump (GotoComputed _)
| Decl _
- ), _ -> raise Impossible
+ ), _ -> raise (Impossible 98)
and pp_statement_seq = function
| StmtElem st -> pp_statement st
| if1::ifxs ->
pp_ifdef if1;
pp_ifdef_tree_sequence_aux ifxs xxs
- | _ -> raise Impossible
+ | _ -> raise (Impossible 99)
(* XXX elsif YYY elsif ZZZ endif *)
and pp_ifdef_tree_sequence_aux ifdefs xxs =
pr_elem iopar;
pp_expression e;
pr_elem icpar
- | _ -> raise Impossible))
+ | _ -> raise (Impossible 100)))
))
pr_elem i1; pr_elem i2; pr_elem i3;
| None, [i1;i2;i3] ->
pr_elem i1; pr_elem i2;
- | x -> raise Impossible
+ | x -> raise (Impossible 101)
);
fields +> List.iter pp_field;
(match sopt,iis with
| Some s , [i1;i2;i3;i4] -> pr_elem i4
| None, [i1;i2;i3] -> pr_elem i3;
- | x -> raise Impossible
+ | x -> raise (Impossible 102)
);
pr_elem i1; pr_elem i2; pr_elem i3;
| (None, ([i1;i2;i3]|[i1;i2;i3;_])) ->
pr_elem i1; pr_elem i2
- | x -> raise Impossible
+ | x -> raise (Impossible 103)
);
enumt +> List.iter (fun ((name, eopt), iicomma) ->
pr_elem i4; pr_elem i3 (* trailing comma *)
- | x -> raise Impossible
+ | x -> raise (Impossible 104)
);
pr_elem itypeof; pr_elem iopar;
pp_expression e;
pr_elem icpar;
- | _ -> raise Impossible
+ | _ -> raise (Impossible 105)
)
| (TypeOfType (t), iis) ->
pr_elem itypeof; pr_elem iopar;
pp_type t;
pr_elem icpar;
- | _ -> raise Impossible
+ | _ -> raise (Impossible 106)
)
| (Pointer _ | (*ParenType _ |*) Array _ | FunctionType _
(* | StructUnion _ | Enum _ | BaseType _ *)
(* | StructUnionName _ | EnumName _ | TypeName _ *)
(* | TypeOfExpr _ | TypeOfType _ *)
- ), _ -> raise Impossible
+ ), _ -> raise (Impossible 107)
and pp_field_list fields = fields +> Common.print_between pr_nl pp_field
and pp_field = function
pp_expression expr
)); (* iter other vars *)
- | [] -> raise Impossible
+ | [] -> raise (Impossible 108)
); (* onefield_multivars *)
assert (List.length iiptvirg =|= 1);
iiptvirg +> List.iter pr_elem;
| (FunctionType _ | Array _ | ParenType _ | Pointer _), _ ->
- raise Impossible
+ raise (Impossible 109)
and (pp_type_left: fullType -> unit) =
| TypeOfType _, _ -> ()
| TypeOfExpr _, _ -> ()
- | (FunctionType _ | Array _ | Pointer _), _ -> raise Impossible
+ | (FunctionType _ | Array _ | Pointer _), _ -> raise (Impossible 110)
and pp_param param =
| TypeOfType _, _ -> ()
| TypeOfExpr _, _ -> ()
- | (FunctionType _ | Array _ | Pointer _), _ -> raise Impossible
+ | (FunctionType _ | Array _ | Pointer _), _ -> raise (Impossible 111)
and pp_type t =
pp_type_with_ident None None t Ast_c.noattr
| Ast_c.ValInit(iini,init) -> pr_elem iini; pp_init init
| Ast_c.ConstrInit((init,[lp;rp])) ->
pr_elem lp; pp_arg_list init; pr_elem rp
- | Ast_c.ConstrInit _ -> raise Impossible)
+ | Ast_c.ConstrInit _ -> raise (Impossible 112))
| None -> pp_type returnType
);
| Ast_c.ValInit(iini,init) -> pr_elem iini; pp_init init
| Ast_c.ConstrInit((init,[lp;rp])) ->
pr_elem lp; pp_arg_list init; pr_elem rp
- | Ast_c.ConstrInit _ -> raise Impossible);
+ | Ast_c.ConstrInit _ -> raise (Impossible 113));
- | x -> raise Impossible
+ | x -> raise (Impossible 114)
);
pr_elem iivirg;
pr_elem iiend;
| (DeclList (_, _) | (MacroDecl _) | (MacroDeclInit _)) ->
- raise Impossible
+ raise (Impossible 115)
(* ---------------------- *)
and pp_init (init, iinit) =
| (InitIndexOld _ | InitFieldOld _ | InitDesignators _
| InitList _ | InitExpr _
- ), _ -> raise Impossible
+ ), _ -> raise (Impossible 116)
and pp_init_list ini = pp_list pp_init ini
pp_expression e2; pr_elem iccro;
| (DesignatorField _ | DesignatorIndex _ | DesignatorRange _
- ), _ -> raise Impossible
+ ), _ -> raise (Impossible 117)
(* ---------------------- *)
pr_elem i1;
statxs +> List.iter pp_statement_seq;
pr_elem i2;
- | _ -> raise Impossible
+ | _ -> raise (Impossible 118)
and pp_param_list paramst = pp_list pp_param paramst
pr_elem iwhile; pr_elem iopar;
pp_expression e;
pr_elem icpar
- | _ -> raise Impossible
+ | _ -> raise (Impossible 119)
)
| DefineFunction def -> pp_def def
| DefineText (s, ii) -> List.iter pr_elem ii
| DefineEmpty -> ()
| DefineInit ini -> pp_init ini
-
+ | DefineMulti ss ->
+ ss +> List.iter pp_statement
| DefineTodo -> pr2 "DefineTodo"
in
(match defkind with
| IfdefTop ifdefdir -> pp_ifdef ifdefdir
- | (MacroTop _) -> raise Impossible in
+ | (MacroTop _) -> raise (Impossible 120) in
--- /dev/null
+(* Provides a dictionary of possible annotations on tokens, indexed by keys.
+ *
+ * The purpose of these annotations is to direct the pretty printing of
+ * tokens. The annotations can be set by AST transformations.
+ *
+ * Assumptions: only a few tokens have annotations, and those have only
+ * a few of them.
+ *)
+
+type annot_key =
+ Exclude_start
+ | Exclude_end
+
+type annot_val =
+ Unit
+
+(* A linked list should offer a good tradeoff between space usage
+ * and lookup overhead given our assumptions.
+ *)
+type annots = (annot_key * annot_val) list
+
+let empty = []
+
+let get_annot anns key =
+ if List.mem_assoc key anns
+ then Some (List.assoc key anns)
+ else None
+
+let put_annot key value anns =
+ (key, value) :: anns
--- /dev/null
+type annot_key =
+ Exclude_start
+ | Exclude_end
+
+type annot_val =
+ Unit
+
+type annots
+
+val empty : annots
+val get_annot : annots -> annot_key -> annot_val option
+val put_annot : annot_key -> annot_val -> annots -> annots
| PToken x -> x.line
| Parenthised (xxs, info_parens) ->
(match info_parens with
- | [] -> raise Impossible
+ | [] -> raise (Impossible 121)
| x::xs -> x.line
)
| [] ->
pr2 "PB:not found closing brace in fuzzy parsing";
[NotBodyLine body]
- | _ -> raise Impossible
+ | _ -> raise (Impossible 122)
)
| _ ->
(match List.rev xs with
| cpar::xs ->
opar, cpar, List.rev xs
- | _ -> raise Impossible
+ | _ -> raise (Impossible 123)
)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 124)
in
push2 opar g;
aux_args (xxs,commas);
xs +> List.iter aux_tokens_ordered;
push2 comma g;
aux_args (ys::xxs, commas)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 125)
in
(*
VarOrFunc("malloc",
- (Lib.al_type(Parse_c.type_of_string "void* (*)(int size)"),
+ (Lib.al_type(Parse_c.type_of_string "void* ( * )(int size)"),
Ast_c.NotLocalVar));
VarOrFunc("free",
- (Lib.al_type(Parse_c.type_of_string "void (*)(void *ptr)"),
+ (Lib.al_type(Parse_c.type_of_string "void ( * )(void *ptr)"),
Ast_c.NotLocalVar));
*)
]
| Pointer (t) -> Some t
| _ -> None
)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 159)
in
(match topt with
*)
| iifunc1::iifunc2::ibrace1::ibrace2::ifakestart::isto ->
iifunc1, iifunc2
- | _ -> raise Impossible
+ | _ -> raise (Impossible 160)
in
let funcs = Ast_c.str_of_name name in
Ast_c.cocci_tag =
{contents =
Some (Ast_cocci.CONTEXT (Ast_cocci.NoPos, Ast_cocci.NOTHING), [])};
+ Ast_c.annots_tag = Token_annot.empty;
Ast_c.comments_tag = {contents =
{Ast_c.mbefore = []; Ast_c.mafter = [];
Ast_c.mbefore2 = []; Ast_c.mafter2 = []
qu, Ast_c.mk_tybis (StructUnionName (su, s)) [i1;i2]
| None, _ ->
ty
- | x -> raise Impossible
+ | x -> raise (Impossible 126)
)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 127)
(*****************************************************************************)
match decl with
| Ast_c.DeclList (xs,ii1) ->
(match xs with
- | [] -> raise Impossible
+ | [] -> raise (Impossible 128)
(* todo? for other xs ? *)
| (x,ii2)::xs ->
match decl with
| Ast_c.DeclList (xs,ii1) ->
(match xs with
- | [] -> raise Impossible
+ | [] -> raise (Impossible 129)
(* todo? for other xs ? *)
| (x,ii2)::xs ->
(match Ast_c.unwrap_typeC v_type with
| Ast_c.StructUnion (su, _must_be_some, fields) ->
(su, fields)
- | _ -> raise Impossible
+ | _ -> raise (Impossible 130)
)
)
- | Ast_c.MacroDecl _ | Ast_c.MacroDeclInit _ -> raise Impossible
+ | Ast_c.MacroDecl _ | Ast_c.MacroDeclInit _ -> raise (Impossible 131)
-(* Yoann Padioleau, Julia Lawall
- *
- * Copyright (C) 2012, INRIA.
- * Copyright (C) 2010, 2011, University of Copenhagen DIKU and INRIA.
- * Copyright (C) 2006, 2007, 2008, 2009 Ecole des Mines de Nantes and DIKU
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License (GPL)
- * version 2 as published by the Free Software Foundation.
- *
- * 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
- * file license.txt for more details.
- *
- *
- * Modifications by Julia Lawall for better newline handling.
- *)
-open Common
-
-open Ast_c
-
-module TH = Token_helpers
-
-
-(* should keep comments and directives in between adjacent deleted terms,
-but not comments and directives within deleted terms. should use the
-labels found in the control-flow graph *)
-
-
-
-(*****************************************************************************)
-(* Wrappers *)
-(*****************************************************************************)
-let pr2, pr2_once = Common.mk_pr2_wrappers Flag_parsing_c.verbose_unparsing
-
-(*****************************************************************************)
-(* Types used during the intermediate phases of the unparsing *)
-(*****************************************************************************)
-
-type token1 =
- | Fake1 of info
- | T1 of Parser_c.token
-
-(* The cocci_tag of the token should always be a NOTHING. The mark of
- * the token can only be OriginTok or ExpandedTok. Why not get rid of
- * token and get something simpler ? because we need to know if the
- * info is a TCommentCpp or TCommentSpace, etc for some of the further
- * analysis so easier to keep with the token.
- *
- * This type contains the whole information. Have all the tokens with this
- * type.
- *)
-type min =
- Min of (int list (* match numbers from witness trees *) *
- Ast_cocci.adjacency (* adjacency information *))
- | Ctx
-
-type token2 =
- | T2 of Parser_c.token * min *
- int option (* orig index, abstracting away comments and space *)
- | Fake2 of min
- | Cocci2 of string * int (* line *) * int (* lcol *) * int (* rcol *)
- * Unparse_cocci.nlhint option
- | C2 of string
- | Comma of string
- | Indent_cocci2
- | Unindent_cocci2 of bool (* true for permanent, false for temporary *)
- | EatSpace2
-
-(* not used yet *)
-type token3 =
- | T3 of Parser_c.token
- | Cocci3 of string
- | C3 of string
-
-
-(* similar to the tech in parsing_hack *)
-type token_extended = {
- tok2 : token2;
- str : string;
- idx: int option; (* to know if 2 tokens were consecutive in orig file *)
- mutable new_tokens_before : token2 list;
- mutable remove : bool;
-}
-
-
-(*****************************************************************************)
-(* Helpers *)
-(*****************************************************************************)
-
-let info_of_token1 t =
- match t with
- | Fake1 info -> info
- | T1 tok -> TH.info_of_tok tok
-
-let print_token1 = function
- T1 tok -> TH.str_of_tok tok
- | Fake1 info -> "fake"
-
-let str_of_token2 = function
- | T2 (t,_,_) -> TH.str_of_tok t
- | Fake2 _ -> ""
- | Cocci2 (s,_,_,_,_) -> s
- | C2 s -> s
- | Comma s -> s
- | Indent_cocci2 -> ""
- | Unindent_cocci2 _ -> ""
- | EatSpace2 -> ""
-
-let print_token2 = function
- | T2 (t,b,_) ->
- let t_str =
- match t with
- | Parser_c.TCommentSpace _ -> " sp "
- | Parser_c.TCommentNewline _ -> " nl "
- | Parser_c.TCommentCpp _ -> " cp "
- | Parser_c.TCommentMisc _ -> " misc "
- | Parser_c.TComment _ -> " comment "
- | _ -> "" in
- let b_str =
- match b with
- Min (index,adj) ->
- Printf.sprintf "-%d[%s]"
- (match adj with Ast_cocci.ADJ n -> n | _ -> -1)
- (String.concat " " (List.map string_of_int index))
- | Ctx -> "" in
- "T2:"^b_str^t_str^TH.str_of_tok t
- | Fake2 b ->
- let b_str =
- match b with
- Min (index,adj) ->
- Printf.sprintf "-%d[%s]"
- (match adj with Ast_cocci.ADJ n -> n | _ -> -1)
- (String.concat " " (List.map string_of_int index))
- | Ctx -> "" in
- b_str^"fake"
- | Cocci2 (s,_,lc,rc,_) -> Printf.sprintf "Cocci2:%d:%d%s" lc rc s
- | C2 s -> "C2:"^s
- | Comma s -> "Comma:"^s
- | Indent_cocci2 -> "Indent"
- | Unindent_cocci2 _ -> "Unindent"
- | EatSpace2 -> "EatSpace"
-
-let simple_print_all_tokens1 l =
- List.iter (function x -> Printf.printf "|%s| " (print_token1 x)) l;
- Printf.printf "\n"
-
-let simple_print_all_tokens2 l =
- List.iter (function x -> Printf.printf "|%s| " (print_token2 x)) l;
- Printf.printf "\n"
-
-let str_of_token3 = function
- | T3 t -> TH.str_of_tok t
- | Cocci3 s | C3 s -> s
-
-
-
-let mk_token_extended x =
- let origidx =
- match x with
- | T2 (_,_, idx) -> idx
- | _ -> None
- in
- { tok2 = x;
- str = str_of_token2 x;
- idx = origidx;
- new_tokens_before = [];
- remove = false;
- }
-
-let rebuild_tokens_extented toks_ext =
- let _tokens = ref [] in
- toks_ext +> List.iter (fun tok ->
- tok.new_tokens_before +> List.iter (fun x -> push2 x _tokens);
- if not tok.remove then push2 tok.tok2 _tokens;
- );
- let tokens = List.rev !_tokens in
- (tokens +> List.map mk_token_extended)
-
-
-let mcode_contain_plus = function
- | Ast_cocci.CONTEXT (_,Ast_cocci.NOTHING) -> false
- | Ast_cocci.CONTEXT _ -> true
-(* patch: when need full coccinelle transformation *)
- | Ast_cocci.MINUS (_,_,_,Ast_cocci.NOREPLACEMENT) -> false
- | Ast_cocci.MINUS (_,_,_,Ast_cocci.REPLACEMENT _) -> true(*REPL is not empty*)
- | Ast_cocci.PLUS _ -> raise Impossible
-
-let contain_plus info =
- let mck = Ast_c.mcode_of_info info in
- mcode_contain_plus mck
-
-(*****************************************************************************)
-(* Last fix on the ast *)
-(*****************************************************************************)
-
-(* Because of the ugly trick to handle initialiser, I generate fake ','
- * for the last initializer element, but if there is nothing around it,
- * I don't want in the end to print it.
- *)
-
-let remove_useless_fakeInfo_struct program =
- let bigf = { Visitor_c.default_visitor_c_s with
- Visitor_c.kini_s = (fun (k,bigf) ini ->
- match k ini with
- | InitList args, ii ->
- (match ii with
- | [_i1;_i2] -> ini
- | [i1;i2;iicommaopt] ->
- if (not (contain_plus iicommaopt)) && (not (contain_plus i2))
- && (Ast_c.is_fake iicommaopt)
- (* sometimes the guy put a normal iicommaopt *)
- then InitList args, [i1;i2]
- else InitList args, [i1;i2;iicommaopt]
- | [i1;i2;iicommaopt;end_comma_opt] ->
- (* only in #define. end_comma_opt canot be fake *)
- (* not sure if this will be considered ambiguous with a previous
- case? *)
- if (not (contain_plus iicommaopt)) && (not (contain_plus i2))
- && (Ast_c.is_fake iicommaopt)
- (* sometimes the guy put a normal iicommaopt *)
- then InitList args, [i1;i2;end_comma_opt]
- else InitList args, [i1;i2;iicommaopt;end_comma_opt]
- | _ -> raise Impossible
- )
- | x -> x
- )
- } in
- Visitor_c.vk_toplevel_s bigf program
-
-
-(*****************************************************************************)
-(* Tokens1 generation *)
-(*****************************************************************************)
-
-let get_fakeInfo_and_tokens celem toks =
- let toks_in = ref toks in
- let toks_out = ref [] in
-
- (* todo? verify good order of position ? *)
- let pr_elem info =
- match Ast_c.pinfo_of_info info with
- | FakeTok _ ->
- Common.push2 (Fake1 info) toks_out
- | OriginTok _ | ExpandedTok _ ->
- (* get the associated comments/space/cppcomment tokens *)
- let (before, x, after) =
- !toks_in +> Common.split_when (fun tok ->
- info =*= TH.info_of_tok tok)
- in
- assert(info =*= TH.info_of_tok x);
- (*old: assert(before +> List.for_all (TH.is_comment)); *)
- before +> List.iter (fun x ->
- if not (TH.is_comment x)
- then pr2 ("WEIRD: not a comment:" ^ TH.str_of_tok x)
- (* case such as int asm d3("x"); not yet in ast *)
- );
- before +> List.iter (fun x -> Common.push2 (T1 x) toks_out);
- push2 (T1 x) toks_out;
- toks_in := after;
- | AbstractLineTok _ ->
- (* can be called on type info when for instance use -type_c *)
- if !Flag_parsing_c.pretty_print_type_info
- then Common.push2 (Fake1 info) toks_out
- else raise Impossible (* at this stage *)
- in
-
- let pr_space _ = () in (* use the spacing that is there already *)
-
- Pretty_print_c.pp_program_gen pr_elem pr_space celem;
-
- if not (null !toks_in)
- then failwith "WEIRD: unparsing not finished";
-
- List.rev !toks_out
-
-(* Fake nodes that have BEFORE code or are - should be moved over any subsequent
-whitespace and newlines, but not any comments, to get as close to the affected
-code as possible. Similarly, fake nodes that have AFTER code should be moved
-backwards. No fake nodes should have both before and after code. *)
-
-let displace_fake_nodes toks =
- let is_fake = function Fake1 _ -> true | _ -> false in
- let is_whitespace = function
- T1(Parser_c.TCommentSpace _)
- (* patch: cocci *)
- | T1(Parser_c.TCommentNewline _) -> true
- | _ -> false in
- let rec loop toks =
- let fake_info =
- try Some (Common.split_when is_fake toks)
- with Not_found -> None in
- match fake_info with
- Some(bef,((Fake1 info) as fake),aft) ->
- (match !(info.cocci_tag) with
- | Some x ->
- (match x with
- (Ast_cocci.CONTEXT(_,Ast_cocci.BEFORE _),_)
- | (Ast_cocci.MINUS(_,_,_,Ast_cocci.REPLACEMENT _),_) ->
- (* move the fake node forwards *)
- let (whitespace,rest) = Common.span is_whitespace aft in
- bef @ whitespace @ fake :: (loop rest)
- | (Ast_cocci.CONTEXT(_,Ast_cocci.AFTER _),_) ->
- (* move the fake node backwards *)
- let revbef = List.rev bef in
- let (revwhitespace,revprev) = Common.span is_whitespace revbef in
- let whitespace = List.rev revwhitespace in
- let prev = List.rev revprev in
- prev @ fake :: (loop (whitespace @ aft))
- | (Ast_cocci.CONTEXT(_,Ast_cocci.NOTHING),_) ->
- bef @ fake :: (loop aft)
- | (Ast_cocci.CONTEXT(_,Ast_cocci.BEFOREAFTER _),_) ->
- failwith "fake node should not be before-after"
- | _ -> bef @ fake :: (loop aft) (* old: was removed when have simpler yacfe *)
- )
- | None ->
- bef @ fake :: (loop aft)
- )
- | None -> toks
- | _ -> raise Impossible in
- loop toks
-
-(*****************************************************************************)
-(* Tokens2 generation *)
-(*****************************************************************************)
-
-let comment2t2 = function
- (Token_c.TCommentCpp
- (* not sure iif the following list is exhaustive or complete *)
- (Token_c.CppAttr|Token_c.CppMacro|Token_c.CppPassingCosWouldGetError),
- (info : Token_c.info)) ->
- C2(info.Common.str)
- | (Token_c.TCommentCpp x,(info : Token_c.info)) ->
- C2("\n"^info.Common.str^"\n")
- | x -> failwith (Printf.sprintf "unexpected comment %s" (Common.dump x))
-
-let expand_mcode toks =
- let toks_out = ref [] in
-
- let index = ref 0 in
-
- let add_elem t minus =
- match t with
- | Fake1 info ->
- let str = Ast_c.str_of_info info in
- if str =$= ""
- then push2 (Fake2 minus) toks_out
- (* fx the fake "," at the end of a structure or enum.
- no idea what other fake info there can be... *)
- else push2 (Comma str) toks_out
-
-
- | T1 tok ->
- (*let (a,b) = !((TH.info_of_tok tok).cocci_tag) in*)
- (* no tag on expandedTok ! *)
- let modified = function
- None -> false
- | Some (Ast_cocci.CONTEXT(pos,Ast_cocci.NOTHING),l) -> false
- | _ -> true in
- (if (TH.is_expanded tok &&
- modified !((TH.info_of_tok tok).cocci_tag)
- (*!((TH.info_of_tok tok).cocci_tag) <> Ast_c.emptyAnnot*))
- then
- failwith
- (Printf.sprintf
- "expanded token %s on line %d is either modified or stored in a metavariable"
- (TH.str_of_tok tok) (TH.line_of_tok tok)));
-
- let tok' = tok +> TH.visitor_info_of_tok (fun i ->
- { i with cocci_tag = ref Ast_c.emptyAnnot; }
- ) in
-
- let optindex =
- if TH.is_origin tok && not (TH.is_real_comment tok)
- then begin
- incr index;
- Some !index
- end
- else None
- in
-
- push2 (T2 (tok', minus, optindex)) toks_out
- in
-
- let expand_info t =
- let (mcode,env) =
- Ast_c.mcode_and_env_of_cocciref ((info_of_token1 t).cocci_tag) in
-
- let pr_cocci s ln col rcol hint =
- push2 (Cocci2(s,ln,col,rcol,hint)) toks_out in
- let pr_c info =
- (match Ast_c.pinfo_of_info info with
- Ast_c.AbstractLineTok _ ->
- push2 (C2 (Ast_c.str_of_info info)) toks_out
- | Ast_c.FakeTok (s,_) ->
- push2 (C2 s) toks_out
- | _ ->
- Printf.fprintf stderr "line: %s\n" (Common.dump info);
- failwith "not an abstract line");
- (!(info.Ast_c.comments_tag)).Ast_c.mafter +>
- List.iter (fun x -> Common.push2 (comment2t2 x) toks_out) in
-
- let pr_barrier ln col = (* marks a position, used around C code *)
- push2 (Cocci2("",ln,col,col,None)) toks_out in
- let pr_nobarrier ln col = () in (* not needed for linux spacing *)
-
- let pr_cspace _ = push2 (C2 " ") toks_out in
-
- let pr_space _ = () (* rely on add_space in cocci code *) in
- let pr_arity _ = () (* not interested *) in
-
- let indent _ = push2 Indent_cocci2 toks_out in
- let unindent x = push2 (Unindent_cocci2 x) toks_out in
- let eat_space _ = push2 EatSpace2 toks_out in
-
- let args_pp =
- (env, pr_cocci, pr_c, pr_cspace,
- (match !Flag_parsing_c.spacing with
- Flag_parsing_c.SMPL -> pr_space | _ -> pr_cspace),
- pr_arity,
- (match !Flag_parsing_c.spacing with
- Flag_parsing_c.SMPL -> pr_barrier | _ -> pr_nobarrier),
- indent, unindent, eat_space) in
-
- (* old: when for yacfe with partial cocci:
- * add_elem t false;
- *)
-
- (* patch: when need full coccinelle transformation *)
- let unparser = Unparse_cocci.pp_list_list_any args_pp false in
- match mcode with
- | Ast_cocci.MINUS (_,inst,adj,any_xxs) ->
- (* Why adding ? because I want to have all the information, the whole
- * set of tokens, so I can then process and remove the
- * is_between_two_minus for instance *)
- add_elem t (Min (inst,adj));
- (match any_xxs with
- Ast_cocci.NOREPLACEMENT -> ()
- | Ast_cocci.REPLACEMENT(any_xxs,_) ->
- unparser any_xxs Unparse_cocci.InPlace)
- | Ast_cocci.CONTEXT (_,any_befaft) ->
- (match any_befaft with
- | Ast_cocci.NOTHING ->
- add_elem t Ctx
- | Ast_cocci.BEFORE (xxs,_) ->
- unparser xxs Unparse_cocci.Before;
- add_elem t Ctx
- | Ast_cocci.AFTER (xxs,_) ->
- add_elem t Ctx;
- unparser xxs Unparse_cocci.After;
- | Ast_cocci.BEFOREAFTER (xxs, yys, _) ->
- unparser xxs Unparse_cocci.Before;
- add_elem t Ctx;
- unparser yys Unparse_cocci.After;
- )
- | Ast_cocci.PLUS _ -> raise Impossible
-
- in
-
- toks +> List.iter expand_info;
- List.rev !toks_out
-
-
-(*****************************************************************************)
-(* Tokens2 processing, filtering, adjusting *)
-(*****************************************************************************)
-
-let is_space = function
- | T2(Parser_c.TCommentSpace _,_b,_i) -> true (* only whitespace *)
- | _ -> false
-
-let is_newline = function
- | T2(Parser_c.TCommentNewline _,_b,_i) -> true
- | _ -> false
-
-let is_whitespace = function
- | (T2 (t,_b,_i)) ->
- (match t with
- | Parser_c.TCommentSpace _ -> true (* only whitespace *)
- | Parser_c.TCommentNewline _ (* newline plus whitespace *) -> true
- | _ -> false
- )
- | _ -> false
-
-let is_minusable_comment = function
- | (T2 (t,_b,_i)) ->
- (match t with
- | Parser_c.TCommentSpace _ (* only whitespace *)
- (* patch: coccinelle *)
- | Parser_c.TCommentNewline _ (* newline plus whitespace *) -> true
- | Parser_c.TComment _ when !Flag_parsing_c.keep_comments -> false
- | Parser_c.TComment _
- | Parser_c.TCommentCpp (Token_c.CppAttr, _)
- | Parser_c.TCommentCpp (Token_c.CppMacro, _)
- | Parser_c.TCommentCpp (Token_c.CppIfDirective _, _)
- | Parser_c.TCommentCpp (Token_c.CppDirective, _) (* result was false *)
- -> true
-
- | Parser_c.TCommentMisc _
- | Parser_c.TCommentCpp (Token_c.CppPassingCosWouldGetError, _)
- -> false
-
- | _ -> false
- )
- | _ -> false
-
-let is_minusable_comment_nocpp = function
- | (T2 (t,_b,_i)) ->
- (match t with
- | Parser_c.TCommentSpace _ (* only whitespace *)
- (* patch: coccinelle *)
- | Parser_c.TCommentNewline _ (* newline plus whitespace *) -> true
- | Parser_c.TComment _ when !Flag_parsing_c.keep_comments -> false
- | Parser_c.TComment _ -> true
- | Parser_c.TCommentCpp (Token_c.CppAttr, _)
- | Parser_c.TCommentCpp (Token_c.CppMacro, _)
- | Parser_c.TCommentCpp (Token_c.CppIfDirective _, _)
- | Parser_c.TCommentCpp (Token_c.CppDirective, _)
- -> false
-
- | Parser_c.TCommentMisc _
- | Parser_c.TCommentCpp (Token_c.CppPassingCosWouldGetError, _)
- -> false
-
- | _ -> false
- )
- | _ -> false
-
-let all_coccis = function
- Cocci2 _ | C2 _ | Comma _ | Indent_cocci2 | Unindent_cocci2 _
- | EatSpace2 -> true
- | _ -> false
-
-(*previously gave up if the first character was a newline, but not clear why*)
-let is_minusable_comment_or_plus x = is_minusable_comment x or all_coccis x
-
-let set_minus_comment adj = function
- | T2 (t,Ctx,idx) ->
- let str = TH.str_of_tok t in
- (match t with
- | Parser_c.TCommentSpace _
-(* patch: coccinelle *)
- | Parser_c.TCommentNewline _ -> ()
-
- | Parser_c.TComment _
- | Parser_c.TCommentCpp (Token_c.CppAttr, _)
- | Parser_c.TCommentCpp (Token_c.CppMacro, _)
- | Parser_c.TCommentCpp (Token_c.CppIfDirective _, _)
- | Parser_c.TCommentCpp (Token_c.CppDirective, _)
- ->
- pr2 (Printf.sprintf "%d: ERASING_COMMENTS: %s"
- (TH.line_of_tok t) str)
- | _ -> raise Impossible
- );
- T2 (t, Min adj, idx)
-(* patch: coccinelle *)
- | T2 (t,Min adj,idx) as x -> x
- | Fake2 _ as x -> x
- | _ -> raise Impossible
-
-(* don't touch ifdefs, done after *)
-let set_minus_comment_or_plus adj = function
- Cocci2 _ | C2 _ | Comma _ | Indent_cocci2 | Unindent_cocci2 _
- | EatSpace2 as x -> x
- | x -> set_minus_comment adj x
-
-let drop_minus xs =
- xs +> Common.exclude (function
- | T2 (t,Min adj,_) -> true
- | _ -> false
- )
-
-let drop_expanded xs =
- xs +> Common.exclude (function
- | T2 (t,_,_) when TH.is_expanded t -> true
- | _ -> false
- )
-
-let drop_fake xs =
- xs +> Common.exclude (function
- | Fake2 _ -> true
- | _ -> false
- )
-
-let remove_minus_and_between_and_expanded_and_fake xs =
-
- (* get rid of expanded tok *)
- let xs = drop_expanded xs in
-
- let minus_or_comment = function
- T2(_,Min adj,_) -> true
- | x -> is_minusable_comment x in
-
- let minus_or_comment_nocpp = function
- T2(_,Min adj,_) -> true
- | x -> is_minusable_comment_nocpp x in
-
- let common_adj (index1,adj1) (index2,adj2) =
- let same_adj = (* same adjacency info *)
- match (adj1,adj2) with
- (Ast_cocci.ADJ adj1,Ast_cocci.ADJ adj2) -> adj1 = adj2
- | (Ast_cocci.ALLMINUS,_) | (_,Ast_cocci.ALLMINUS) -> true in
- same_adj &&
- (* non-empty intersection of witness trees *)
- not ((Common.inter_set index1 index2) = []) in
-
- (* new idea: collects regions not containing non-space context code
- if two adjacent adjacent minus tokens satisfy common_adj then delete
- all spaces, comments etc between them
- if two adjacent minus tokens do not satisfy common_adj only delete
- the spaces between them if there are no comments, etc.
- if the region contain no plus code and is both preceded and followed
- by a newline, delete the initial newline. *)
-
- let rec adjust_around_minus = function
- [] -> []
- | (T2(Parser_c.TCommentNewline c,_b,_i) as x)::
- ((Fake2(Min adj1) | T2(_,Min adj1,_)) as t1)::xs ->
- let (minus_list,rest) = Common.span not_context (t1::xs) in
- let contains_plus = List.exists is_plus minus_list in
- let x =
- match List.rev minus_list with
- (T2(Parser_c.TCommentNewline c,_b,_i))::rest
- when List.for_all minus_or_comment minus_list ->
- set_minus_comment_or_plus adj1 x
- | _ -> x in
- x :: adjust_within_minus contains_plus minus_list @
- adjust_around_minus rest
- | ((Fake2(Min adj1) | T2(_,Min adj1,_)) as t1)::xs ->
- let (minus_list,rest) = Common.span not_context (t1::xs) in
- let contains_plus = List.exists is_plus minus_list in
- adjust_within_minus contains_plus minus_list @ adjust_around_minus rest
- | x::xs ->
- x :: adjust_around_minus xs
- and adjust_within_minus cp (* contains plus *) = function
- ((Fake2(Min adj1) | T2(_,Min adj1,_)) as t1)::xs ->
- let not_minus = function T2(_,Min _,_) -> false | _ -> true in
- let (not_minus_list,rest) = Common.span not_minus xs in
- t1 ::
- (match rest with
- ((Fake2(Min adj2) | T2(_,Min adj2,_)) as t2)::xs
- when common_adj adj1 adj2 ->
- (List.map (set_minus_comment_or_plus adj1) not_minus_list)
- @ (adjust_within_minus cp (t2::xs))
- | ((Fake2(Min adj2) | T2(_,Min adj2,_)) as t2)::xs ->
- if not cp && List.for_all is_whitespace not_minus_list
- then
- (List.map (set_minus_comment_or_plus adj1) not_minus_list)
- @ (adjust_within_minus cp (t2::xs))
- else
- not_minus_list @ (adjust_within_minus cp (t2::xs))
- | _ ->
- if cp
- then xs
- else
- (* remove spaces after removed stuff, eg a comma after a
- function argument *)
- (let (spaces,rest) = Common.span is_space xs in
- (List.map (set_minus_comment_or_plus adj1) spaces)
- @ rest))
- | xs -> failwith "should always start with minus"
- and not_context = function
- (T2(_,Ctx,_) as x) when not (is_minusable_comment x) -> false
- | _ -> true
- and is_plus = function
- C2 _ | Comma _ | Cocci2 _ -> true
- | _ -> false in
-
- let xs = adjust_around_minus xs in
-
- (* get rid of fake tok *)
- let xs = drop_fake xs in
-
- (* this drops blank lines after a brace introduced by removing code *)
- let minus_or_comment_nonl = function
- T2(_,Min adj,_) -> true
- | T2(Parser_c.TCommentNewline _,_b,_i) -> false
- | x -> is_minusable_comment x in
-
- let rec adjust_after_brace = function
- [] -> []
- | ((T2(_,Ctx,_)) as x)::((T2(_,Min adj,_)::_) as xs)
- when str_of_token2 x =$= "{" ->
- let (between_minus,rest) = Common.span minus_or_comment_nonl xs in
- let is_whitespace = function
- T2(Parser_c.TCommentSpace _,_b,_i)
- (* patch: cocci *)
- | T2(Parser_c.TCommentNewline _,_b,_i) -> true
- | _ -> false in
- let (newlines,rest) = Common.span is_whitespace rest in
- let (drop_newlines,last_newline) =
- let rec loop = function
- [] -> ([],[])
- | ((T2(Parser_c.TCommentNewline _,_b,_i)) as x) :: rest ->
- (List.rev rest,[x])
- | x::xs ->
- let (drop_newlines,last_newline) = loop xs in
- (drop_newlines,x::last_newline) in
- loop (List.rev newlines) in
- x::between_minus@(List.map (set_minus_comment adj) drop_newlines)@
- last_newline@
- adjust_after_brace rest
- | x::xs -> x::adjust_after_brace xs in
-
- let xs = adjust_after_brace xs in
-
- (* search backwards from context } over spaces until reaching a newline.
- then go back over all minus code until reaching some context or + code.
- get rid of all intervening spaces, newlines, and comments
- input is reversed *)
- let rec adjust_before_brace = function
- [] -> []
- | ((T2(t,Ctx,_)) as x)::xs when str_of_token2 x =$= "}" or is_newline x ->
- let (outer_spaces,rest) = Common.span is_space xs in
- x :: outer_spaces @
- (match rest with
- ((T2 (Parser_c.TCommentNewline _,Ctx,_i)) as h) ::
- (* the rest of this code is the same as from_newline below
- but merging them seems to be error prone... *)
- ((T2 (t, Min adj, idx)) as m) :: rest ->
- let (spaces,rest) = Common.span minus_or_comment_nocpp rest in
- h :: m ::
- (List.map (set_minus_comment adj) spaces) @
- (adjust_before_brace rest)
- | _ -> adjust_before_brace rest)
- | x::xs -> x :: (adjust_before_brace xs) in
-
- let from_newline = function
- ((T2 (t, Min adj, idx)) as m) :: rest ->
- let (spaces,rest) = Common.span minus_or_comment_nocpp rest in
- m ::
- (List.map (set_minus_comment adj) spaces) @
- (adjust_before_brace rest)
- | ((T2 (t0, Ctx, idx0)) as m0) :: ((T2 (t, Min adj, idx)) as m) :: rest
- when TH.str_of_tok t0 = "" ->
- (* This is for the case of a #define that is completely deleted,
- because a #define has a strange EOL token at the end.
- We hope there i no other kind of token that is represented by
- "", but it seems like changing the kind of token might break
- the end of entity recognition in the C parser.
- See parsing_hacks.ml *)
- let (spaces,rest) = Common.span minus_or_comment_nocpp rest in
- m0 :: m ::
- (List.map (set_minus_comment adj) spaces) @
- (adjust_before_brace rest)
- | rest -> adjust_before_brace rest in
-
- let xs = List.rev (from_newline (List.rev xs)) in
-
- let cleanup_ifdefs toks =
- (* TODO: these functions are horrid, but using tokens caused circularity *)
- let is_ifdef = function
- T2((Parser_c.TCommentCpp
- (Token_c.CppIfDirective Token_c.IfDef, _)),m,idx) -> true
- | T2((Parser_c.TCommentCpp
- (Token_c.CppIfDirective Token_c.IfDef0, _)),m,idx) -> true
- | t -> false in
- let is_else = function
- T2((Parser_c.TCommentCpp
- (Token_c.CppIfDirective Token_c.Else, _)),m,idx) -> true
- | _ -> false in
- let is_endif = function
- T2((Parser_c.TCommentCpp
- (Token_c.CppIfDirective Token_c.Endif, _)),m,idx) -> true
- | _ -> false in
- let add t = function
- l::rest -> (t::l)::rest
- | _ -> failwith "not possible" in
- let rec parse_ifdef acc_keywords acc_code stack = function
- [] -> (None,acc_keywords,acc_code)
- | t::rest when is_else t ->
- (match stack with
- [] -> parse_ifdef (t::acc_keywords) ([]::acc_code) stack rest
- | _ -> parse_ifdef acc_keywords (add t acc_code) stack rest)
- | t::rest when is_endif t ->
- (match stack with
- [] -> ((Some (t,rest)),acc_keywords,acc_code)
- | _::stack -> parse_ifdef acc_keywords (add t acc_code) stack rest)
- | t::rest when is_ifdef t ->
- parse_ifdef acc_keywords (add t acc_code) (()::stack) rest
- | t::rest -> parse_ifdef acc_keywords (add t acc_code) stack rest in
- let unminus = function
- T2 (t,Min adj,idx) -> T2 (t,Ctx,idx)
- | x -> x in
- let is_minus = function
- T2 (t,Min adj,idx) -> true
- | x -> false in
- let rec loop = function
- [] -> []
- | t::rest when is_ifdef t ->
- let (ender,acc_keywords,acc_code) =
- parse_ifdef [t] [[]] [] rest in
- let acc_code = List.map loop acc_code in
- let merge = (* args reversed *)
- List.fold_left2
- (fun prev kwd code -> kwd :: (List.rev code) @ prev)
- [] in
- (match ender with
- None -> merge (List.map unminus acc_keywords) acc_code
- | Some(endif,rest) ->
- let rest = loop rest in
- if List.for_all is_minus (endif::acc_keywords)
- then (merge acc_keywords acc_code) @ (endif :: rest)
- else
- (merge (List.map unminus acc_keywords) acc_code) @
- ((unminus endif) :: rest))
- | x::xs -> x :: loop xs in
- loop toks in
-
- let xs = cleanup_ifdefs xs in
- let xs = drop_minus xs in
- xs
-
-(* things that should not be followed by space - boundary between SmPL
- code and C code *)
-let adjust_eat_space toks =
- let rec loop = function
- [] -> []
- | EatSpace2 :: x :: rest when is_space x -> loop rest
- | EatSpace2 :: rest -> loop rest
- | x :: xs -> x :: loop xs in
- loop toks
-
-(* normally, in C code, a semicolon is not preceded by a space or newline *)
-let adjust_before_semicolon toks =
- let toks = List.rev toks in
- let rec search_semic = function
- [] -> []
- | ((T2(_,Ctx,_)) as x)::xs | ((Cocci2 _) as x)::xs ->
- if List.mem (str_of_token2 x) [";";")";","]
- then x :: search_semic (search_minus false xs)
- else x :: search_semic xs
- | x::xs -> x :: search_semic xs
- and search_minus seen_minus xs =
- let (spaces, rest) = Common.span is_space xs in
- (* only delete spaces if something is actually deleted *)
- match rest with
- ((T2(_,Min _,_)) as a)::rerest -> a :: search_minus true rerest
- | _ -> if seen_minus then rest else xs in
- List.rev (search_semic toks)
-
-(* normally, in C code, a ( is not followed by a space or newline *)
-let adjust_after_paren toks =
- let rec search_paren = function
- [] -> []
- | ((T2(_,Ctx,_)) as x)::xs | ((Cocci2 _) as x)::xs ->
- if List.mem (str_of_token2 x) ["("] (* other things? *)
- then x :: search_paren(search_minus false xs)
- else x :: search_paren xs
- | x::xs -> x :: search_paren xs
- and search_minus seen_minus xs =
- let (spaces, rest) = Common.span is_whitespace xs in
- (* only delete spaces if something is actually deleted *)
- match rest with
- ((T2(_,Min _,_)) as a)::rerest -> (* minus *)
- a :: search_minus true rerest
- | ((T2(_,Ctx,_)) as a)::rerest when seen_minus && str_of_token2 a = "," ->
- (* comma after ( will be deleted, so consider it as minus code
- already *)
- a :: search_minus true rerest
- | _ -> if seen_minus then rest else xs in (* drop trailing space *)
- search_paren toks
-
-(* this is for the case where braces are added around an if branch *)
-let paren_then_brace toks =
- let rec search_paren = function
- [] -> []
- | ((T2(_,Ctx,_)) as x)::xs ->
- if List.mem (str_of_token2 x) [")"]
- then x :: search_paren(search_plus xs)
- else x :: search_paren xs
- | x::xs -> x :: search_paren xs
- and search_plus xs =
- let (spaces, rest) = Common.span is_whitespace xs in
- match rest with
- (* move the brace up to the previous line *)
- ((Cocci2("{",_,_,_,_)) as x) :: (((Cocci2 _) :: _) as rest) ->
- (C2 " ") :: x :: spaces @ rest
- | _ -> xs in
- search_paren toks
-
-let is_ident_like s = s ==~ Common.regexp_alpha
-
-let rec drop_space_at_endline = function
- [] -> []
- | [x] -> [x]
- | (C2 " ") ::
- ((((T2(Parser_c.TCommentSpace _,Ctx,_)) | Cocci2("\n",_,_,_,_) |
- (T2(Parser_c.TCommentNewline _,Ctx,_))) :: _) as rest) ->
- (* when unparse_cocci doesn't know whether space is needed *)
- drop_space_at_endline rest
- | ((T2(Parser_c.TCommentSpace _,Ctx,_i)) as a)::rest ->
- let (outer_spaces,rest) = Common.span is_space rest in
- let minus_or_comment_or_space_nocpp = function
- T2(_,Min adj,_) -> true
- | (T2(Parser_c.TCommentSpace _,Ctx,_i)) -> true
- | (T2(Parser_c.TCommentNewline _,Ctx,_i)) -> false
- | x -> false in
- let (minus,rest) = Common.span minus_or_comment_or_space_nocpp rest in
- let fail _ = a :: outer_spaces @ minus @ (drop_space_at_endline rest) in
- if List.exists (function T2(_,Min adj,_) -> true | _ -> false) minus
- then
- match rest with
- ((T2(Parser_c.TCommentNewline _,Ctx,_i)) as a)::rest ->
- (* drop trailing spaces *)
- minus@a::(drop_space_at_endline rest)
- | _ -> fail()
- else fail()
- | a :: rest ->
- a :: drop_space_at_endline rest
-
-(* if a removed ( is between two tokens, then add a space *)
-let rec paren_to_space = function
- [] -> []
- | [x] -> [x]
- | [x;y] -> [x;y]
- | ((T2(_,Ctx,_)) as a)::((T2(t,Min _,_)) as b)::((T2(_,Ctx,_)) as c)::rest
- when not (is_whitespace a) && TH.str_of_tok t = "(" ->
- a :: b :: (C2 " ") :: (paren_to_space (c :: rest))
- | a :: rest -> a :: (paren_to_space rest)
-
-let rec add_space xs =
- match xs with
- | [] -> []
- | [x] -> [x]
- | (Cocci2(sx,lnx,_,rcolx,_) as x)::((Cocci2(sy,lny,lcoly,_,_)) as y)::xs
- when !Flag_parsing_c.spacing = Flag_parsing_c.SMPL &&
- not (lnx = -1) && lnx = lny && not (rcolx = -1) && rcolx < lcoly ->
- (* this only works within a line. could consider whether
- something should be done to add newlines too, rather than
- printing them explicitly in unparse_cocci. *)
- x::C2 (String.make (lcoly-rcolx) ' ')::add_space (y::xs)
- | (Cocci2(sx,lnx,_,rcolx,_) as x)::((Cocci2(sy,lny,lcoly,_,_)) as y)::xs
- when !Flag_parsing_c.spacing = Flag_parsing_c.SMPL &&
- not (lnx = -1) && lnx < lny && not (rcolx = -1) ->
- (* this only works within a line. could consider whether
- something should be done to add newlines too, rather than
- printing them explicitly in unparse_cocci. *)
- x::C2 (String.make (lny-lnx) '\n')::
- C2 (String.make (lcoly-1) ' '):: (* -1 is for the + *)
- add_space (y::xs)
- | ((T2(_,Ctx,_)) as x)::((Cocci2 _) as y)::xs -> (* add space on boundary *)
- let sx = str_of_token2 x in
- let sy = str_of_token2 y in
- if is_ident_like sx && (is_ident_like sy or List.mem sy ["="])
- then x::C2 " "::(add_space (y::xs))
- else x::(add_space (y::xs))
- | x::y::xs -> (* not boundary, not sure if it is possible *)
- let sx = str_of_token2 x in
- let sy = str_of_token2 y in
- if is_ident_like sx && is_ident_like sy
- then x::C2 " "::(add_space (y::xs))
- else x::(add_space (y::xs))
-
-(* A fake comma is added at the end of an unordered initlist or a enum
-decl, if the initlist or enum doesn't already end in a comma. This is only
-needed if there is + code, ie if we see Cocci after it in the code sequence *)
-
-let rec drop_end_comma = function
- [] -> []
- | [x] -> [x]
- | ((Comma ",") as x) :: rest ->
- let (newlines,rest2) = Common.span is_whitespace rest in
- (match rest2 with
- (Cocci2 _) :: _ -> x :: drop_end_comma rest
- | _ -> drop_end_comma rest)
- | x :: xs -> x :: drop_end_comma xs
-
-(* The following only works for the outermost function call. Stack records
-the column of all open parentheses. Space_cell contains the most recent
-comma in the outermost function call. The goal is to decide whether this
-should be followed by a space or a newline and indent. *)
-let add_newlines toks tabbing_unit =
- let create_indent n =
- let (tu,tlen) =
- match tabbing_unit with
- Some ("\t",_) -> ("\t",8)
- | Some ("",_) -> ("\t",8) (* not sure why... *)
- | Some (s,_) -> (s,String.length s) (* assuming only spaces *)
- | None -> ("\t",8) in
- let rec loop seen =
- if seen + tlen <= n
- then tu ^ loop (seen + tlen)
- else String.make (n-seen) ' ' in
- loop 0 in
- let check_for_newline count x = function
- Some (start,space_cell) when count > Flag_parsing_c.max_width ->
- space_cell := "\n"^(create_indent x);
- Some (x + (count - start))
- | _ -> None in
- (* the following is for strings that may contain newline *)
- let string_length s count =
- let l = list_of_string s in
- List.fold_left
- (function count ->
- function
- '\t' -> count + 8
- | '\n' -> 0
- | c -> count + 1)
- count l in
- let rec loop info count = function
- [] -> []
- | ((T2(tok,_,_)) as a)::xs ->
- a :: loop info (string_length (TH.str_of_tok tok) count) xs
- | ((Cocci2(s,line,lcol,rcol,hint)) as a)::xs ->
- let (stack,space_cell) = info in
- let rest =
- match hint with
- None -> loop info (string_length s count) xs
- | Some Unparse_cocci.StartBox ->
- let count = string_length s count in
- loop (count::stack,space_cell) count xs
- | Some Unparse_cocci.EndBox ->
- let count = string_length s count in
- (match stack with
- [x] ->
- (match check_for_newline count x space_cell with
- Some count -> loop ([],None) count xs
- | None -> loop ([],None) count xs)
- | _ -> loop (List.tl stack,space_cell) count xs)
- | Some (Unparse_cocci.SpaceOrNewline sp) ->
- let count = string_length s (count + 1 (*space*)) in
- (match stack with
- [x] ->
- (match check_for_newline count x space_cell with
- Some count -> loop (stack,Some (x,sp)) count xs
- | None -> loop (stack,Some (count,sp)) count xs)
- | _ -> loop info count xs) in
- a :: rest
- | ((C2(s)) as a)::xs -> a :: loop info (string_length s count) xs
- | ((Comma(s)) as a)::xs -> a :: loop info (string_length s count) xs
- | Fake2 _ :: _ | Indent_cocci2 :: _
- | Unindent_cocci2 _::_ | EatSpace2::_ ->
- failwith "unexpected fake, indent, unindent, or eatspace" in
- let redo_spaces prev = function
- Cocci2(s,line,lcol,rcol,Some (Unparse_cocci.SpaceOrNewline sp)) ->
- C2 !sp :: Cocci2(s,line,lcol,rcol,None) :: prev
- | t -> t::prev in
- (match !Flag_parsing_c.spacing with
- Flag_parsing_c.SMPL -> toks
- | _ -> List.rev (List.fold_left redo_spaces [] (loop ([],None) 0 toks)))
-
-(* When insert some new code, because of a + in a SP, we must add this
- * code at the right place, with the good indentation. So each time we
- * encounter some spacing info, with some newline, we maintain the
- * current indentation level used.
- *
- * TODO problems: not accurate. ex: TODO
- *
- * TODO: if in #define region, should add a \ \n
- *)
-let new_tabbing2 space =
- (list_of_string space)
- +> List.rev
- +> Common.take_until (fun c -> c =<= '\n')
- +> List.rev
- +> List.map string_of_char
- +> String.concat ""
-
-let new_tabbing a =
- Common.profile_code "C unparsing.new_tabbing" (fun () -> new_tabbing2 a)
-
-
-let rec adjust_indentation xs =
-
- let _current_tabbing = ref ([] : string list) in
- let tabbing_unit = ref None in
-
- let string_of_list l = String.concat "" (List.map string_of_char l) in
-
- (* try to pick a tabbing unit for the plus code *)
- let adjust_tabbing_unit old_tab new_tab =
- if !tabbing_unit =*= None && String.length new_tab > String.length old_tab
- then
- let old_tab = list_of_string old_tab in
- let new_tab = list_of_string new_tab in
- let rec loop = function
- ([],new_tab) ->
- tabbing_unit := Some(string_of_list new_tab,List.rev new_tab)
- | (_,[]) -> failwith "not possible"
- | (o::os,n::ns) -> loop (os,ns) in (* could check for equality *)
- loop (old_tab,new_tab) in
-
-(*
- let remtab tu current_tab =
- let current_tab = List.rev(list_of_string current_tab) in
- let rec loop = function
- ([],new_tab) -> string_of_list (List.rev new_tab)
- | (_,[]) -> (-*weird; tabbing unit used up more than the current tab*-)
- ""
- | (t::ts,n::ns) when t =<= n -> loop (ts,ns)
- | (_,ns) -> (-* mismatch; remove what we can *-)
- string_of_list (List.rev ns) in
- loop (tu,current_tab) in
-*)
-
- let rec find_first_tab started = function
- [] -> ()
- | ((T2 (tok,_,_)) as x)::xs when str_of_token2 x =$= "{" ->
- find_first_tab true xs
-(* patch: coccinelle *)
- | ((T2 (Parser_c.TCommentNewline s, _, _)) as x)::_
- when started ->
- let s = str_of_token2 x +> new_tabbing in
- tabbing_unit := Some (s,List.rev (list_of_string s))
- | x::xs -> find_first_tab started xs in
- find_first_tab false xs;
-
- let rec balanced ct = function
- [] -> ct >= 0
- | ((T2(tok,_,_)) as x)::xs ->
- (match str_of_token2 x with
- "(" -> balanced (ct+1) xs
- | ")" -> balanced (ct-1) xs
- | _ -> balanced ct xs)
- | x::xs -> balanced ct xs in
-
- let update_tabbing started s x =
- let old_tabbing = !_current_tabbing in
- str_of_token2 x +> new_tabbing +> (fun s -> _current_tabbing := [s]);
- (* only trust the indentation after the first { *)
- if started
- then
- adjust_tabbing_unit
- (String.concat "" old_tabbing)
- (String.concat "" !_current_tabbing) in
-
- let rec aux started xs =
- match xs with
- | [] -> []
-(* patch: coccinelle *)
- | ((T2 (Parser_c.TCommentNewline s,_,_)) as x)::
- Unindent_cocci2(false)::xs ->
- update_tabbing started s x;
- (C2 "\n")::aux started xs
- | (Cocci2("\n",_,_,_,_))::Unindent_cocci2(false)::xs ->
- (C2 "\n")::aux started xs
- | ((T2 (tok,_,_)) as x)::(T2 (Parser_c.TCommentNewline s, _, _))::
- ((Cocci2 ("{",_,_,_,_)) as a)::xs
- when started && str_of_token2 x =$= ")" ->
- (* to be done for if, etc, but not for a function header *)
- x::(C2 " ")::a::(aux started xs)
- | ((T2 (Parser_c.TCommentNewline s, _, _)) as x)::xs
- when
- balanced 0 (fst(Common.span (function x -> not(is_newline x)) xs)) ->
- update_tabbing started s x;
- let coccis_rest = Common.span all_coccis xs in
- (match coccis_rest with
- (_::_,((T2 (tok,_,_)) as y)::_) when str_of_token2 y =$= "}" ->
- (* the case where cocci code has been added before a close } *)
- x::aux started (Indent_cocci2::xs)
- | _ -> x::aux started xs)
- | Indent_cocci2::((Cocci2(sy,lny,lcoly,_,_)) as y)::xs
- when !Flag_parsing_c.spacing = Flag_parsing_c.SMPL ->
- let tu = String.make (lcoly-1) ' ' in
- _current_tabbing := tu::(!_current_tabbing);
- C2 (tu)::aux started (y::xs)
- | Indent_cocci2::xs ->
- (match !tabbing_unit with
- None -> aux started xs
- | Some (tu,_) ->
- _current_tabbing := tu::(!_current_tabbing);
- (* can't be C2, for later phases *)
- Cocci2 (tu,-1,-1,-1,None)::aux started xs)
- | Unindent_cocci2(permanent)::xs ->
- (match !_current_tabbing with
- [] -> aux started xs
- | _::new_tabbing ->
- let s = String.concat "" new_tabbing in
- _current_tabbing := new_tabbing;
- Cocci2 (s,-1,-1,-1,None)::aux started xs)
- (* border between existing code and cocci code *)
- | ((T2 (tok,_,_)) as x)::((Cocci2("\n",_,_,_,_)) as y)::xs
- when str_of_token2 x =$= "{" ->
- x::aux true (y::Indent_cocci2::xs)
- | ((Cocci2 _) as x)::((T2 (tok,_,_)) as y)::xs
- when str_of_token2 y =$= "}" ->
- x::aux started (Unindent_cocci2 true::y::xs)
- (* starting the body of the function *)
- | ((T2 (tok,_,_)) as x)::xs when str_of_token2 x =$= "{" -> x::aux true xs
- | ((Cocci2("{",_,_,_,_)) as a)::xs -> a::aux true xs
- | ((Cocci2("\n",_,_,_,_)) as x)::xs ->
- (* dont inline in expr because of weird eval order of ocaml *)
- let s = String.concat "" !_current_tabbing in
- (* can't be C2, for later phases *)
- x::Cocci2 (s,-1,-1,-1,None)::aux started xs
- | x::xs -> x::aux started xs in
- (aux false xs,!tabbing_unit)
-
-
-let rec find_paren_comma = function
- | [] -> ()
-
- (* do nothing if was like this in original file *)
- | ({ str = "("; idx = Some p1 } as _x1)::({ str = ","; idx = Some p2} as x2)
- ::xs when p2 =|= p1 + 1 ->
- find_paren_comma (x2::xs)
-
- | ({ str = ","; idx = Some p1 } as _x1)::({ str = ","; idx = Some p2} as x2)
- ::xs when p2 =|= p1 + 1 ->
- find_paren_comma (x2::xs)
-
- | ({ str = ","; idx = Some p1 } as _x1)::({ str = ")"; idx = Some p2} as x2)
- ::xs when p2 =|= p1 + 1 ->
- find_paren_comma (x2::xs)
-
- (* otherwise yes can adjust *)
- | ({ str = "(" } as _x1)::({ str = ","} as x2)::xs ->
- x2.remove <- true;
- find_paren_comma (x2::xs)
- | ({ str = "," } as x1)::({ str = ","} as x2)::xs ->
- x1.remove <- true;
- find_paren_comma (x2::xs)
-
- | ({ str = "," } as x1)::({ str = ")"} as x2)::xs ->
- x1.remove <- true;
- find_paren_comma (x2::xs)
-
- | x::xs ->
- find_paren_comma xs
-
-
-let fix_tokens toks =
- let toks = toks +> List.map mk_token_extended in
-
- let cleaner = toks +> Common.exclude (function
- | {tok2 = T2 (t,_,_)} -> TH.is_real_comment t (* I want the ifdef *)
- | _ -> false
- ) in
- find_paren_comma cleaner;
-
- let toks = rebuild_tokens_extented toks in
- toks +> List.map (fun x -> x.tok2)
-
-
-
-(*****************************************************************************)
-(* Final unparsing (and debugging support) *)
-(*****************************************************************************)
-
-(* for debugging *)
-type kind_token2 = KFake | KCocci | KC | KExpanded | KOrigin
-
-let kind_of_token2 = function
- | Fake2 _ -> KFake
- | Cocci2 _ -> KCocci
- | C2 _ -> KC
- | Comma _ -> KC
- | T2 (t,_,_) ->
- (match TH.pinfo_of_tok t with
- | ExpandedTok _ -> KExpanded
- | OriginTok _ -> KOrigin
- | FakeTok _ -> raise Impossible (* now a Fake2 *)
- | AbstractLineTok _ -> raise Impossible (* now a KC *)
- )
- | Unindent_cocci2 _ | Indent_cocci2 | EatSpace2 -> raise Impossible
-
-let end_mark = "!"
-
-let start_mark = function
- | KFake -> "!F!"
- | KCocci -> "!S!"
- | KC -> "!A!"
- | KExpanded -> "!E!"
- | KOrigin -> ""
-
-let print_all_tokens2 pr xs =
- if !Flag_parsing_c.debug_unparsing
- then
- let current_kind = ref KOrigin in
- xs +> List.iter (fun t ->
- let newkind = kind_of_token2 t in
- if newkind =*= !current_kind
- then pr (str_of_token2 t)
- else begin
- pr (end_mark);
- pr (start_mark newkind);
- pr (str_of_token2 t);
- current_kind := newkind
- end
- );
- else
- xs +> List.iter (fun x -> pr (str_of_token2 x))
-
-
-
-
-(*****************************************************************************)
-(* Entry points *)
-(*****************************************************************************)
-
-(* old: PPviatok was made in the beginning to allow to pretty print a
- * complete C file, including a modified C file by transformation.ml,
- * even if we don't handle yet in pretty_print_c.ml, ast_to_flow (and
- * maybe flow_to_ast) all the cases. Indeed we don't need to do some
- * fancy stuff when a function was not modified at all. Just need to
- * print the list of token as-is. But now pretty_print_c.ml handles
- * almost everything so maybe less useful. Maybe PPviatok allows to
- * optimize a little the pretty printing.
- *
- * update: now have PPviastr which goes even faster than PPviatok, so
- * PPviatok has disappeared.
- *)
-
-type ppmethod = PPnormal | PPviastr
-
-
-
-
-(* The pp_program function will call pretty_print_c.ml with a special
- * function to print the leaf components, the tokens. When we want to
- * print a token, we need to print also maybe the space and comments that
- * were close to it in the original file (and that was omitted during the
- * parsing phase), and honor what the cocci-info attached to the token says.
- * Maybe we will not print the token if it's a MINUS-token, and maybe we will
- * print it and also print some cocci-code attached in a PLUS to it.
- * So we will also maybe call unparse_cocci. Because the cocci-code may
- * contain metavariables, unparse_cocci will in fact sometimes call back
- * pretty_print_c (which will this time don't call back again unparse_cocci)
- *)
-
-let pp_program2 xs outfile =
- Common.with_open_outfile outfile (fun (pr,chan) ->
- let pr s =
- if !Flag_parsing_c.debug_unparsing
- then begin pr2_no_nl s; flush stderr end
- else pr s
- (* flush chan; *)
- (* Common.pr2 ("UNPARSING: >" ^ s ^ "<"); *)
- in
-
- xs +> List.iter (fun ((e,(str, toks_e)), ppmethod) ->
- (* here can still work on ast *)
- let e = remove_useless_fakeInfo_struct e in
-
- match ppmethod with
- | PPnormal ->
- (* now work on tokens *)
- (* phase1: just get all the tokens, all the information *)
- assert(toks_e +> List.for_all (fun t ->
- TH.is_origin t or TH.is_expanded t
- ));
- let toks = get_fakeInfo_and_tokens e toks_e in
- let toks = displace_fake_nodes toks in
- (* assert Origin;ExpandedTok;Faketok *)
- let toks = expand_mcode toks in
-
- (* assert Origin;ExpandedTok; + Cocci + C (was AbstractLineTok)
- * and no tag information, just NOTHING. *)
-
- let toks =
- if !Flag.sgrep_mode2
- then
- (* nothing else to do for sgrep *)
- drop_expanded(drop_fake(drop_minus toks))
- else
- (* phase2: can now start to filter and adjust *)
- (let (toks,tu) = adjust_indentation toks in
- let toks = adjust_eat_space toks in
- let toks = adjust_before_semicolon toks in(*before remove minus*)
- let toks = adjust_after_paren toks in(*also before remove minus*)
- let toks = drop_space_at_endline toks in
- let toks = paren_to_space toks in
- let toks = drop_end_comma toks in
- let toks = remove_minus_and_between_and_expanded_and_fake toks in
- (* assert Origin + Cocci + C and no minus *)
- let toks = add_space toks in
- let toks = add_newlines toks tu in
- let toks = paren_then_brace toks in
- let toks = fix_tokens toks in
- toks) in
-
- (* in theory here could reparse and rework the ast! or
- * apply some SP. Not before cos julia may have generated
- * not parsable file. Need do unparsing_tricks call before being
- * ready to reparse. *)
- print_all_tokens2 pr toks;
-
- | PPviastr -> pr str
- )
- )
-
-let pp_program a b =
- Common.profile_code "C unparsing" (fun () -> pp_program2 a b)
-
-
-let pp_program_default xs outfile =
- let xs' = xs +> List.map (fun x -> x, PPnormal) in
- pp_program xs' outfile
+(* Yoann Padioleau, Julia Lawall
+ *
+ * Copyright (C) 2012, INRIA.
+ * Copyright (C) 2010, 2011, University of Copenhagen DIKU and INRIA.
+ * Copyright (C) 2006, 2007, 2008, 2009 Ecole des Mines de Nantes and DIKU
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License (GPL)
+ * version 2 as published by the Free Software Foundation.
+ *
+ * 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
+ * file license.txt for more details.
+ *
+ *
+ * Modifications by Julia Lawall for better newline handling.
+ *)
+open Common
+
+module TH = Token_helpers
+
+(* should keep comments and directives in between adjacent deleted terms,
+but not comments and directives within deleted terms. should use the
+labels found in the control-flow graph *)
+
+
+
+(*****************************************************************************)
+(* Wrappers *)
+(*****************************************************************************)
+let pr2, pr2_once = mk_pr2_wrappers Flag_parsing_c.verbose_unparsing
+
+(*****************************************************************************)
+(* Types used during the intermediate phases of the unparsing *)
+(*****************************************************************************)
+
+type token1 =
+ | Fake1 of Ast_c.info
+ | T1 of Parser_c.token
+
+(* The cocci_tag of the token should always be a NOTHING. The mark of
+ * the token can only be OriginTok or ExpandedTok. Why not get rid of
+ * token and get something simpler ? because we need to know if the
+ * info is a TCommentCpp or TCommentSpace, etc for some of the further
+ * analysis so easier to keep with the token.
+ *
+ * This type contains the whole information. Have all the tokens with this
+ * type.
+ *)
+type min =
+ | Min of (int list (* match numbers from witness trees *) *
+ Ast_cocci.adjacency (* adjacency information *))
+ | Ctx
+
+type token2 =
+ | T2 of Parser_c.token * min
+ * int option (* orig index, abstracting away comments and space *)
+ * Unparse_cocci.nlhint option
+ | Fake2 of min
+ | Cocci2 of string * int (* line *) * int (* lcol *) * int (* rcol *)
+ * Unparse_cocci.nlhint option
+ | C2 of string
+ | Comma of string
+ | Indent_cocci2
+ | Unindent_cocci2 of bool (* true for permanent, false for temporary *)
+ | EatSpace2
+
+(* not used yet *)
+type token3 =
+ | T3 of Parser_c.token
+ | Cocci3 of string
+ | C3 of string
+
+
+(* similar to the tech in parsing_hack *)
+type token_extended =
+ { tok2 : token2;
+ str : string;
+ idx : int option; (* to know if 2 tokens were consecutive in orig file *)
+ mutable new_tokens_before : token2 list;
+ mutable remove : bool;
+ }
+
+
+(*****************************************************************************)
+(* Helpers *)
+(*****************************************************************************)
+
+let info_of_token1 t =
+ match t with
+ | Fake1 info -> info
+ | T1 tok -> TH.info_of_tok tok
+
+let print_token1 = function
+ | T1 tok -> TH.str_of_tok tok
+ | Fake1 info -> "fake"
+
+let str_of_token2 = function
+ | T2 (t,_,_,_) -> TH.str_of_tok t
+ | Cocci2 (s,_,_,_,_)
+ | C2 s
+ | Comma s -> s
+ | Fake2 _
+ | Indent_cocci2
+ | Unindent_cocci2 _
+ | EatSpace2 -> ""
+
+let print_token2 = function
+ | T2 (t,b,_,_) ->
+ let t_str =
+ match t with
+ | Parser_c.TCommentSpace _ -> " sp "
+ | Parser_c.TCommentNewline _ -> " nl "
+ | Parser_c.TCommentCpp _ -> " cp "
+ | Parser_c.TCommentMisc _ -> " misc "
+ | Parser_c.TComment _ -> " comment "
+ | _ -> "" in
+ let b_str =
+ match b with
+ | Min (index,adj) ->
+ Printf.sprintf "-.%d[%s]"
+ (match adj with Ast_cocci.ADJ n -> n | _ -> -1)
+ (String.concat " " (List.map string_of_int index))
+ | Ctx -> "" in
+ "T2:"^b_str^t_str^TH.str_of_tok t
+ | Fake2 b ->
+ let b_str =
+ match b with
+ | Min (index,adj) ->
+ Printf.sprintf "-%d[%s]"
+ (match adj with Ast_cocci.ADJ n -> n | _ -> -1)
+ (String.concat " " (List.map string_of_int index))
+ | Ctx -> "" in
+ b_str^"fake"
+ | Cocci2 (s,_,lc,rc,_) -> Printf.sprintf "Cocci2:%d:%d%s" lc rc s
+ | C2 s -> "C2:"^s
+ | Comma s -> "Comma:"^s
+ | Indent_cocci2 -> "Indent"
+ | Unindent_cocci2 _ -> "Unindent"
+ | EatSpace2 -> "EatSpace"
+
+(*
+let simple_print_all_tokens pr l =
+ List.iter (function x -> Printf.printf "|%s| " (pr x)) l;
+ Printf.printf "\n"
+*)
+
+let str_of_token3 = function
+ | T3 t -> TH.str_of_tok t
+ | Cocci3 s | C3 s -> s
+
+
+
+let mk_token_extended x =
+ let origidx =
+ match x with
+ | T2 (_,_,idx,_) -> idx
+ | _ -> None in
+ { tok2 = x;
+ str = str_of_token2 x;
+ idx = origidx;
+ new_tokens_before = [];
+ remove = false;
+ }
+
+let rebuild_tokens_extented toks_ext =
+ let _tokens = ref [] in
+ toks_ext +> List.iter (fun tok ->
+ tok.new_tokens_before +> List.iter (fun x -> push2 x _tokens);
+ if not tok.remove then push2 tok.tok2 _tokens;
+ );
+ let tokens = List.rev !_tokens in
+ (tokens +> List.map mk_token_extended)
+
+
+let mcode_contain_plus = function
+ | Ast_cocci.CONTEXT (_,Ast_cocci.NOTHING) -> false
+ | Ast_cocci.CONTEXT _ -> true
+ (* patch: when need full coccinelle transformation *)
+ | Ast_cocci.MINUS (_,_,_,Ast_cocci.NOREPLACEMENT) -> false
+ | Ast_cocci.MINUS (_,_,_,Ast_cocci.REPLACEMENT _) -> true(*REPL is not empty*)
+ | Ast_cocci.PLUS _ -> raise (Impossible 132)
+
+let contain_plus info =
+ let mck = Ast_c.mcode_of_info info in
+ mcode_contain_plus mck
+
+(*****************************************************************************)
+(* Last fix on the ast *)
+(*****************************************************************************)
+
+(* Because of the ugly trick to handle initialiser, I generate fake ','
+ * for the last initializer element, but if there is nothing around it,
+ * I don't want in the end to print it.
+ *)
+
+let remove_useless_fakeInfo_struct program =
+ let bigf = { Visitor_c.default_visitor_c_s with
+ Visitor_c.kini_s = (fun (k,bigf) ini ->
+ match k ini with
+ | Ast_c.InitList args, ii ->
+ (match ii with
+ | [_;_] -> ini
+ | i1 :: i2 :: iicommaopt :: tl when
+ (not (contain_plus iicommaopt))
+ && (not (contain_plus i2))
+ && (Ast_c.is_fake iicommaopt) ->
+ (* sometimes the guy put a normal iicommaopt *)
+ Ast_c.InitList args, (i1 :: i2 :: tl)
+ | ii -> Ast_c.InitList args, ii
+ )
+ | x -> x)
+ } in
+ Visitor_c.vk_toplevel_s bigf program
+
+
+(*****************************************************************************)
+(* Tokens1 generation *)
+(*****************************************************************************)
+
+let get_fakeInfo_and_tokens celem toks =
+ let toks_in = ref toks in
+ let toks_out = ref [] in
+
+ (* todo? verify good order of position ? *)
+ let pr_elem info =
+ match Ast_c.pinfo_of_info info with
+ | Ast_c.FakeTok _ ->
+ push2 (Fake1 info) toks_out
+ | Ast_c.OriginTok _ | Ast_c.ExpandedTok _ ->
+ (* get the associated comments/space/cppcomment tokens *)
+ let (before, x, after) =
+ !toks_in +> split_when (fun tok ->
+ info =*= TH.info_of_tok tok)
+ in
+ assert(info =*= TH.info_of_tok x);
+ (*old: assert(before +> List.for_all (TH.is_comment)); *)
+ before +> List.iter (fun x ->
+ if not (TH.is_comment x)
+ then pr2 ("WEIRD: not a comment:" ^ TH.str_of_tok x)
+ (* case such as int asm d3("x"); not yet in ast *)
+ );
+ before +> List.iter (fun x -> push2 (T1 x) toks_out);
+ push2 (T1 x) toks_out;
+ toks_in := after;
+ | Ast_c.AbstractLineTok _ ->
+ (* can be called on type info when for instance use -type_c *)
+ if !Flag_parsing_c.pretty_print_type_info
+ then push2 (Fake1 info) toks_out
+ else raise (Impossible 134) (* at this stage *)
+ in
+
+ let pr_space _ = () in (* use the spacing that is there already *)
+
+ Pretty_print_c.pp_program_gen pr_elem pr_space celem;
+
+ if not (null !toks_in)
+ then failwith "WEIRD: unparsing not finished";
+
+ List.rev !toks_out
+
+(* Fake nodes that have BEFORE code or are - should be moved over any subsequent
+whitespace and newlines, but not any comments, to get as close to the affected
+code as possible. Similarly, fake nodes that have AFTER code should be moved
+backwards. No fake nodes should have both before and after code. *)
+
+let displace_fake_nodes toks =
+ let is_fake = function Fake1 _ -> true | _ -> false in
+ let is_whitespace = function
+ | T1(Parser_c.TCommentSpace _)
+ (* patch: cocci *)
+ | T1(Parser_c.TCommentNewline _) -> true
+ | _ -> false in
+ let rec loop toks =
+ let fake_info =
+ try Some (split_when is_fake toks)
+ with Not_found -> None in
+ match fake_info with
+ | Some(bef,((Fake1 info) as fake),aft) ->
+ (match !(info.Ast_c.cocci_tag) with
+ | Some x ->
+ (match x with
+ | (Ast_cocci.MINUS(_,_,_,Ast_cocci.REPLACEMENT _),_)
+ (* for , replacement is more likely to be like after, but not clear...
+ but treating it as after breaks a lot of tests. *)
+
+ | (Ast_cocci.CONTEXT(_,Ast_cocci.BEFORE _),_) ->
+ (* move the fake node forwards *)
+ let (whitespace,rest) = span is_whitespace aft in
+ bef @ whitespace @ fake :: (loop rest)
+
+ | (Ast_cocci.CONTEXT(_,Ast_cocci.AFTER _),_) ->
+ (* move the fake node backwards *)
+ let revbef = List.rev bef in
+ let (revwhitespace,revprev) = span is_whitespace revbef in
+ let whitespace = List.rev revwhitespace in
+ let prev = List.rev revprev in
+ prev @ fake :: (loop (whitespace @ aft))
+ | (Ast_cocci.CONTEXT(_,Ast_cocci.BEFOREAFTER _),_) ->
+ failwith "fake node should not be before-after"
+ | (Ast_cocci.CONTEXT(_,Ast_cocci.NOTHING),_)
+ | _ -> bef @ fake :: (loop aft) (* old: was removed when have simpler yacfe *)
+ )
+ | None ->
+ bef @ fake :: (loop aft)
+ )
+ | None -> toks
+ | _ -> raise (Impossible 135) in
+ loop toks
+
+(*****************************************************************************)
+(* Tokens2 generation *)
+(*****************************************************************************)
+
+let comment2t2 = function
+ | (Token_c.TCommentCpp
+ (* not sure iif the following list is exhaustive or complete *)
+ (Token_c.CppAttr|Token_c.CppMacro|Token_c.CppPassingCosWouldGetError),
+ (info : Token_c.info)) ->
+ C2(info.Common.str)
+ | (Token_c.TCommentCpp x,(info : Token_c.info)) ->
+ C2("\n"^info.Common.str^"\n")
+ | x -> failwith (Printf.sprintf "unexpected comment %s" (Dumper.dump x))
+
+let expand_mcode toks =
+ let toks_out = ref [] in
+
+ let index = ref 0 in
+
+ let add_elem t minus =
+ match t with
+ | Fake1 info ->
+ let str = Ast_c.str_of_info info in
+ let isminus = match minus with Min _ -> true | Ctx -> false in
+ (* don't add fake string if the thing should be removed *)
+ if str =$= "" or isminus
+ then push2 (Fake2 minus) toks_out
+ (* fx the fake "," at the end of a structure or enum.
+ no idea what other fake info there can be... *)
+ else push2 (Comma str) toks_out
+
+ | T1 tok ->
+ (*let (a,b) = !((TH.info_of_tok tok).cocci_tag) in*)
+ (* no tag on expandedTok ! *)
+ let modified = function
+ | None -> false
+ | Some (Ast_cocci.CONTEXT(pos,Ast_cocci.NOTHING),l) -> false
+ | _ -> true in
+ (if TH.is_expanded tok &&
+ modified !((TH.info_of_tok tok).Ast_c.cocci_tag)
+ (*!((TH.info_of_tok tok).cocci_tag) <> Ast_c.emptyAnnot*)
+ then
+ failwith
+ (Printf.sprintf
+ "expanded token %s on line %d is either modified or stored in a metavariable"
+ (TH.str_of_tok tok) (TH.line_of_tok tok)));
+
+ let tok' = tok +> TH.visitor_info_of_tok (fun i ->
+ { i with Ast_c.cocci_tag = ref Ast_c.emptyAnnot; }
+ ) in
+
+ let optindex =
+ if TH.is_origin tok && not (TH.is_real_comment tok)
+ then
+ begin
+ incr index;
+ Some !index
+ end
+ else None
+ in
+
+ push2 (T2 (tok', minus, optindex, None)) toks_out
+ in
+
+ let expand_info t =
+ let (mcode,env) =
+ Ast_c.mcode_and_env_of_cocciref ((info_of_token1 t).Ast_c.cocci_tag) in
+
+ let pr_cocci s ln col rcol hint =
+ push2 (Cocci2 (s,ln,col,rcol,hint)) toks_out in
+ let pr_c info =
+ (match Ast_c.pinfo_of_info info with
+ | Ast_c.AbstractLineTok _ ->
+ push2 (C2 (Ast_c.str_of_info info)) toks_out
+ | Ast_c.FakeTok (s,_) ->
+ push2 (C2 s) toks_out
+ | _ ->
+ Printf.fprintf stderr "line: %s\n" (Dumper.dump info);
+ failwith "not an abstract line"
+ );
+ (!(info.Ast_c.comments_tag)).Ast_c.mafter +>
+ List.iter (fun x -> push2 (comment2t2 x) toks_out) in
+
+ let pr_barrier ln col = (* marks a position, used around C code *)
+ push2 (Cocci2 ("",ln,col,col,None)) toks_out in
+ let pr_nobarrier ln col = () in (* not needed for linux spacing *)
+
+ let pr_cspace _ = push2 (C2 " ") toks_out in
+
+ let pr_space _ = () (* rely on add_space in cocci code *) in
+ let pr_arity _ = () (* not interested *) in
+
+ let indent _ = push2 Indent_cocci2 toks_out in
+ let unindent x = push2 (Unindent_cocci2 x) toks_out in
+ let eat_space _ = push2 EatSpace2 toks_out in
+
+ let args_pp =
+ (env, pr_cocci, pr_c, pr_cspace,
+ (match !Flag_parsing_c.spacing with
+ | Flag_parsing_c.SMPL -> pr_space | _ -> pr_cspace),
+ pr_arity,
+ (match !Flag_parsing_c.spacing with
+ | Flag_parsing_c.SMPL -> pr_barrier | _ -> pr_nobarrier),
+ indent, unindent, eat_space) in
+
+(* old: when for yacfe with partial cocci:
+ * add_elem t false;
+ *)
+
+(* patch: when need full coccinelle transformation *)
+ let unparser = Unparse_cocci.pp_list_list_any args_pp false in
+ match mcode with
+ | Ast_cocci.MINUS (_,inst,adj,any_xxs) ->
+ (* Why adding ? because I want to have all the information, the whole
+ * set of tokens, so I can then process and remove the
+ * is_between_two_minus for instance *)
+ add_elem t (Min (inst,adj));
+ (match any_xxs with
+ | Ast_cocci.NOREPLACEMENT -> ()
+ | Ast_cocci.REPLACEMENT(any_xxs,_) ->
+ unparser any_xxs Unparse_cocci.InPlace
+ )
+ | Ast_cocci.CONTEXT (_,any_befaft) ->
+ (match any_befaft with
+ | Ast_cocci.NOTHING ->
+ add_elem t Ctx
+ | Ast_cocci.BEFORE (xxs,_) ->
+ unparser xxs Unparse_cocci.Before;
+ add_elem t Ctx
+ | Ast_cocci.AFTER (xxs,_) ->
+ add_elem t Ctx;
+ unparser xxs Unparse_cocci.After;
+ | Ast_cocci.BEFOREAFTER (xxs, yys, _) ->
+ unparser xxs Unparse_cocci.Before;
+ add_elem t Ctx;
+ unparser yys Unparse_cocci.After;
+ )
+ | Ast_cocci.PLUS _ -> raise (Impossible 136)
+ in
+
+ toks +> List.iter expand_info;
+ List.rev !toks_out
+
+
+(*****************************************************************************)
+(* Tokens2 processing, filtering, adjusting *)
+(*****************************************************************************)
+
+let is_space = function
+ | T2(Parser_c.TCommentSpace _,_b,_i,_h) -> true (* only whitespace *)
+ | _ -> false
+
+let is_newline = function
+ | T2(Parser_c.TCommentNewline _,_b,_i,_h) -> true
+ | _ -> false
+
+let is_whitespace x =
+ is_space x or is_newline x
+
+let is_minusable_comment = function
+ | (T2 (t,_b,_i,_h)) ->
+ (match t with
+ | Parser_c.TCommentSpace _ (* only whitespace *)
+ (* patch: coccinelle *)
+ | Parser_c.TCommentNewline _ (* newline plus whitespace *) -> true
+ | Parser_c.TComment _ when !Flag_parsing_c.keep_comments -> false
+ | Parser_c.TComment _
+ | Parser_c.TCommentCpp (Token_c.CppAttr, _)
+ | Parser_c.TCommentCpp (Token_c.CppMacro, _)
+ | Parser_c.TCommentCpp (Token_c.CppIfDirective _, _)
+ | Parser_c.TCommentCpp (Token_c.CppDirective, _) -> (* result was false *)
+ true
+ (*
+ | Parser_c.TCommentMisc _
+ | Parser_c.TCommentCpp (Token_c.CppPassingCosWouldGetError, _) ->
+ false
+ *)
+ | _ -> false
+ )
+ | _ -> false
+
+let is_minusable_comment_nocpp = function
+ | (T2 (t,_b,_i,_h)) ->
+ (match t with
+ | Parser_c.TCommentSpace _ (* only whitespace *)
+ (* patch: coccinelle *)
+ | Parser_c.TCommentNewline _ (* newline plus whitespace *) -> true
+ | Parser_c.TComment _ when !Flag_parsing_c.keep_comments -> false
+ | Parser_c.TComment _ -> true
+ (*
+ | Parser_c.TCommentCpp (Token_c.CppAttr, _)
+ | Parser_c.TCommentCpp (Token_c.CppMacro, _)
+ | Parser_c.TCommentCpp (Token_c.CppIfDirective _, _)
+ | Parser_c.TCommentCpp (Token_c.CppDirective, _) ->
+ false
+
+ | Parser_c.TCommentMisc _
+ | Parser_c.TCommentCpp (Token_c.CppPassingCosWouldGetError, _) ->
+ false
+ *)
+ | _ -> false
+ )
+ | _ -> false
+
+let all_coccis = function
+ | Cocci2 _ | C2 _ | Comma _ | Indent_cocci2
+ | Unindent_cocci2 _ | EatSpace2 -> true
+ | _ -> false
+
+(* previously gave up if the first character was a newline, but not clear why *)
+let is_minusable_comment_or_plus x =
+ is_minusable_comment x or all_coccis x
+
+let set_minus_comment adj = function
+ | T2 (t,Ctx,idx,hint) ->
+ let str = TH.str_of_tok t in
+ (match t with
+ | Parser_c.TCommentSpace _
+ (* patch: coccinelle *)
+ | Parser_c.TCommentNewline _ -> ()
+
+ | Parser_c.TComment _
+ | Parser_c.TCommentCpp (Token_c.CppAttr, _)
+ | Parser_c.TCommentCpp (Token_c.CppMacro, _)
+ | Parser_c.TCommentCpp (Token_c.CppIfDirective _, _)
+ | Parser_c.TCommentCpp (Token_c.CppDirective, _) ->
+ pr2 (Printf.sprintf "%d: ERASING_COMMENTS: %s"
+ (TH.line_of_tok t) str)
+ | _ -> raise (Impossible 137)
+ );
+ T2 (t, Min adj, idx, hint)
+ (* patch: coccinelle *)
+ | T2 (t, Min adj, idx, hint) as x -> x
+ | Fake2 _ as x -> x
+ | _ -> raise (Impossible 138)
+
+(* don't touch ifdefs, done after *)
+let set_minus_comment_or_plus adj = function
+ | Cocci2 _ | C2 _ | Comma _ | Indent_cocci2
+ | Unindent_cocci2 _ | EatSpace2 as x -> x
+ | x -> set_minus_comment adj x
+
+let is_minus = function
+ | T2 (_, Min _, _, _) -> true
+ | _ -> false
+
+let drop_minus xs =
+ xs +> exclude is_minus
+
+let drop_expanded xs =
+ xs +> exclude (function
+ | T2 (t,_,_,_) when TH.is_expanded t -> true
+ | _ -> false
+ )
+
+let drop_fake xs =
+ xs +> exclude (function
+ | Fake2 _ -> true
+ | _ -> false
+ )
+
+let remove_minus_and_between_and_expanded_and_fake xs =
+
+ (* get rid of expanded tok *)
+ let xs = drop_expanded xs in
+
+ let minus_or_comment x =
+ is_minus x or is_minusable_comment x in
+
+ let minus_or_comment_nocpp x =
+ is_minus x or is_minusable_comment_nocpp x in
+
+ let common_adj (index1,adj1) (index2,adj2) =
+ let same_adj = (* same adjacency info *)
+ match (adj1,adj2) with
+ | (Ast_cocci.ADJ adj1,Ast_cocci.ADJ adj2) -> adj1 = adj2
+ | (Ast_cocci.ALLMINUS,_) | (_,Ast_cocci.ALLMINUS) -> true in
+ same_adj &&
+ (* non-empty intersection of witness trees *)
+ not ((inter_set index1 index2) = []) in
+
+ (* new idea: collects regions not containing non-space context code
+ if two adjacent adjacent minus tokens satisfy common_adj then delete
+ all spaces, comments etc between them
+ if two adjacent minus tokens do not satisfy common_adj only delete
+ the spaces between them if there are no comments, etc.
+ if the region contain no plus code and is both preceded and followed
+ by a newline, delete the initial newline. *)
+
+ let rec adjust_around_minus = function
+ | [] -> []
+ | (T2(Parser_c.TCommentNewline c,_b,_i,_h) as x)::
+ ((Fake2(Min adj1) | T2(_,Min adj1,_,_)) as t1)::xs ->
+ let (minus_list,rest) = span not_context (t1::xs) in
+ let contains_plus = List.exists is_plus minus_list in
+ let x =
+ match List.rev minus_list with
+ | (T2(Parser_c.TCommentNewline c,_b,_i,_h))::rest
+ when List.for_all minus_or_comment minus_list ->
+ set_minus_comment_or_plus adj1 x
+ | _ -> x in
+ x :: adjust_within_minus contains_plus minus_list
+ @ adjust_around_minus rest
+ | ((Fake2(Min adj1) | T2(_,Min adj1,_,_)) as t1)::xs ->
+ let (minus_list,rest) = span not_context (t1::xs) in
+ let contains_plus = List.exists is_plus minus_list in
+ adjust_within_minus contains_plus minus_list
+ @ adjust_around_minus rest
+ | x::xs ->
+ x :: adjust_around_minus xs
+ and adjust_within_minus cp (* contains plus *) = function
+ | ((Fake2(Min adj1) | T2(_,Min adj1,_,_)) as t1)::xs ->
+ let not_minus = function T2(_,Min _,_,_) -> false | _ -> true in
+ let (not_minus_list,rest) = span not_minus xs in
+ t1 ::
+ (match rest with
+ | ((Fake2(Min adj2) | T2(_,Min adj2,_,_)) as t2)::xs ->
+ if common_adj adj1 adj2
+ || not cp && List.for_all is_whitespace not_minus_list
+ then
+ (List.map (set_minus_comment_or_plus adj1) not_minus_list)
+ @ (adjust_within_minus cp (t2::xs))
+ else
+ not_minus_list
+ @ (adjust_within_minus cp (t2::xs))
+ | _ ->
+ if cp
+ then xs
+ else
+ (* remove spaces after removed stuff, eg a comma after a
+ function argument *)
+ (let (spaces,rest) = span is_space xs in
+ (List.map (set_minus_comment_or_plus adj1) spaces)
+ @ rest)
+ )
+ | xs -> failwith "should always start with minus"
+ and not_context = function
+ | (T2(_,Ctx,_,_) as x) when not (is_minusable_comment x) -> false
+ | _ -> true
+ and is_plus = function
+ | C2 _ | Comma _ | Cocci2 _ -> true
+ | _ -> false in
+
+ let xs = adjust_around_minus xs in
+
+ (* get rid of fake tok *)
+ let xs = drop_fake xs in
+
+ (* this drops blank lines after a brace introduced by removing code *)
+ let minus_or_comment_nonl = function
+ | T2(_,Min adj,_,_) -> true
+ | T2(Parser_c.TCommentNewline _,_b,_i,_h) -> false
+ | x -> is_minusable_comment x in
+
+ let rec adjust_after_brace = function
+ | [] -> []
+ | ((T2(_,Ctx,_,_)) as x)::((T2(_,Min adj,_,_)::_) as xs)
+ when str_of_token2 x =$= "{" ->
+ let (between_minus,rest) = span minus_or_comment_nonl xs in
+ let (newlines,rest) = span is_whitespace rest in
+ let (drop_newlines,last_newline) =
+ let rec loop = function
+ | [] -> ([],[])
+ | ((T2(Parser_c.TCommentNewline _,_b,_i,_h)) as x) :: rest ->
+ (List.rev rest,[x])
+ | x::xs ->
+ let (drop_newlines,last_newline) = loop xs in
+ (drop_newlines,x::last_newline) in
+ loop (List.rev newlines) in
+ x :: between_minus
+ @ List.map (set_minus_comment adj) drop_newlines
+ @ last_newline
+ @ adjust_after_brace rest
+ | x::xs -> x :: (adjust_after_brace xs) in
+
+ let xs = adjust_after_brace xs in
+
+ (* search backwards from context } over spaces until reaching a newline.
+ then go back over all minus code until reaching some context or + code.
+ get rid of all intervening spaces, newlines, and comments
+ input is reversed *)
+ let rec adjust_before_brace = function
+ | [] -> []
+ | ((T2(t,Ctx,_,_)) as x)::xs
+ when str_of_token2 x =$= "}" or is_newline x ->
+ let (outer_spaces,rest) = span is_space xs in
+ x :: outer_spaces @
+ (match rest with
+ | ((T2 (Parser_c.TCommentNewline _,Ctx,_i,_h)) as h) ::
+ (* the rest of this code is the same as from_newline below
+ but merging them seems to be error prone... *)
+ ((T2 (t, Min adj, idx, hint)) as m) :: rest ->
+ let (spaces,rest) = span minus_or_comment_nocpp rest in
+ h :: m ::
+ (List.map (set_minus_comment adj) spaces) @
+ (adjust_before_brace rest)
+ | _ -> adjust_before_brace rest
+ )
+ | x::xs -> x :: (adjust_before_brace xs) in
+
+ let from_newline = function
+ | ((T2 (t, Min adj, idx, hint)) as m) :: rest ->
+ let (spaces,rest) = span minus_or_comment_nocpp rest in
+ m ::
+ (List.map (set_minus_comment adj) spaces) @
+ (adjust_before_brace rest)
+ | ((T2 (t0,Ctx, idx0,h0)) as m0) ::
+ ((T2 (t,Min adj,idx,h)) as m) :: rest
+ when TH.str_of_tok t0 = "" ->
+ (* This is for the case of a #define that is completely deleted,
+ because a #define has a strange EOL token at the end.
+ We hope there i no other kind of token that is represented by
+ "", but it seems like changing the kind of token might break
+ the end of entity recognition in the C parser.
+ See parsing_hacks.ml *)
+ let (spaces,rest) = span minus_or_comment_nocpp rest in
+ m0 :: m ::
+ (List.map (set_minus_comment adj) spaces) @
+ (adjust_before_brace rest)
+ | rest -> adjust_before_brace rest in
+
+ let xs = List.rev (from_newline (List.rev xs)) in
+
+ let cleanup_ifdefs toks =
+ (* TODO: these functions are horrid, but using tokens caused circularity *)
+ let is_ifdef = function
+ | T2((Parser_c.TCommentCpp
+ (Token_c.CppIfDirective Token_c.IfDef, _)),m,idx,_) -> true
+ | T2((Parser_c.TCommentCpp
+ (Token_c.CppIfDirective Token_c.IfDef0, _)),m,idx,_) -> true
+ | t -> false in
+ let is_else = function
+ | T2((Parser_c.TCommentCpp
+ (Token_c.CppIfDirective Token_c.Else, _)),m,idx,_) -> true
+ | _ -> false in
+ let is_endif = function
+ | T2((Parser_c.TCommentCpp
+ (Token_c.CppIfDirective Token_c.Endif, _)),m,idx,_) -> true
+ | _ -> false in
+ let add t = function
+ | l::rest -> (t::l)::rest
+ | _ -> failwith "not possible" in
+ let rec parse_ifdef acc_keywords acc_code stack = function
+ | [] -> (None,acc_keywords,acc_code)
+ | t::rest when is_else t ->
+ (match stack with
+ | [] -> parse_ifdef (t::acc_keywords) ([]::acc_code) stack rest
+ | _ -> parse_ifdef acc_keywords (add t acc_code) stack rest
+ )
+ | t::rest when is_endif t ->
+ (match stack with
+ | [] -> ((Some (t,rest)),acc_keywords,acc_code)
+ | _::stack -> parse_ifdef acc_keywords (add t acc_code) stack rest
+ )
+ | t::rest when is_ifdef t ->
+ parse_ifdef acc_keywords (add t acc_code) (()::stack) rest
+ | t::rest -> parse_ifdef acc_keywords (add t acc_code) stack rest in
+ let unminus = function
+ | T2 (t,Min adj,idx,hint) -> T2 (t,Ctx,idx,hint)
+ | x -> x in
+ let rec loop = function
+ | [] -> []
+ | t::rest when is_ifdef t ->
+ let (ender,acc_keywords,acc_code) =
+ parse_ifdef [t] [[]] [] rest in
+ let acc_code = List.map loop acc_code in
+ let merge = (* args reversed *)
+ List.fold_left2
+ (fun prev kwd code -> kwd :: (List.rev code) @ prev)
+ [] in
+ (match ender with
+ | None -> merge (List.map unminus acc_keywords) acc_code
+ | Some(endif,rest) ->
+ let rest = loop rest in
+ if List.for_all is_minus (endif :: acc_keywords)
+ then (merge acc_keywords acc_code) @ (endif :: rest)
+ else
+ (merge (List.map unminus acc_keywords) acc_code) @
+ ((unminus endif) :: rest)
+ )
+ | x::xs -> x :: loop xs in
+ loop toks in
+
+ let xs = cleanup_ifdefs xs in
+ let xs = drop_minus xs in
+ xs
+
+(* things that should not be followed by space - boundary between SmPL
+code and C code *)
+let adjust_eat_space toks =
+ let rec loop = function
+ | [] -> []
+ | EatSpace2 :: x :: rest when is_space x -> loop rest
+ | EatSpace2 :: rest -> loop rest
+ | x :: xs -> x :: loop xs in
+ loop toks
+
+(* normally, in C code, a semicolon is not preceded by a space or newline *)
+let adjust_before_semicolon toks =
+ let toks = List.rev toks in
+ let rec search_semic = function
+ | [] -> []
+ | ((T2(_,Ctx,_,_) | Cocci2 _) as x)::xs
+ when List.mem (str_of_token2 x) [";";")";","] ->
+ x :: search_semic (search_minus false xs)
+ | x::xs -> x :: search_semic xs
+ and search_minus seen_minus xs =
+ let (spaces, rest) = span is_space xs in
+ (* only delete spaces if something is actually deleted *)
+ match rest with
+ | ((T2(_,Min _,_,_)) as a)::rerest -> a :: search_minus true rerest
+ | _ -> if seen_minus then rest else xs in
+ List.rev (search_semic toks)
+
+(* normally, in C code, a ( is not followed by a space or newline *)
+let adjust_after_paren toks =
+ let rec search_paren = function
+ | [] -> []
+ | ((T2(_,Ctx,_,_) | Cocci2 _) as x)::xs
+ when List.mem (str_of_token2 x) ["("] (* other things? *) ->
+ x :: search_paren (search_minus false xs)
+ | x::xs -> x :: search_paren xs
+ and search_minus seen_minus xs =
+ let (spaces, rest) = span is_whitespace xs in
+ (* only delete spaces if something is actually deleted *)
+ match rest with
+ | ((T2(_,Min _,_,_)) as a)::rerest -> (* minus *)
+ a :: search_minus true rerest
+ | ((T2(_,Ctx,_,_)) as a)::rerest
+ when seen_minus && str_of_token2 a = "," ->
+ (* comma after ( will be deleted, so consider it as minus code
+ already *)
+ a :: search_minus true rerest
+ | _ -> if seen_minus then rest else xs in (* drop trailing space *)
+ search_paren toks
+
+(* this is for the case where braces are added around an if branch *)
+let paren_then_brace toks =
+ let rec search_paren = function
+ | [] -> []
+ | ((T2(_,Ctx,_,_)) as x)::xs
+ when List.mem (str_of_token2 x) [")"] ->
+ x :: search_paren (search_plus xs)
+ | x::xs -> x :: search_paren xs
+ and search_plus xs =
+ let (spaces, rest) = span is_space xs in
+ let (nls, rest) = span is_newline rest in
+ match rest with
+ (* move the brace up to the previous line *)
+ | ((Cocci2("{",_,_,_,_)) as x) :: (((Cocci2 _) :: _) as rest) ->
+ spaces @ x :: nls @ rest
+ | _ -> xs in
+ search_paren toks
+
+let is_ident_like s = s ==~ regexp_alpha
+
+let rec drop_space_at_endline = function
+ | [] -> []
+ | [x] -> [x]
+ | (C2 " ") ::
+ ((((T2(Parser_c.TCommentSpace _,Ctx,_,_)) | Cocci2("\n",_,_,_,_) |
+ (T2(Parser_c.TCommentNewline _,Ctx,_,_))) :: _) as rest) ->
+ (* when unparse_cocci doesn't know whether space is needed *)
+ drop_space_at_endline rest
+ | ((T2(Parser_c.TCommentSpace _,Ctx,_i,_h)) as a)::rest ->
+ let (outer_spaces,rest) = span is_space rest in
+ let minus_or_comment_or_space_nocpp = function
+ | T2(_,Min adj,_,_) -> true
+ | (T2(Parser_c.TCommentSpace _,Ctx,_i,_)) -> true
+ | (T2(Parser_c.TCommentNewline _,Ctx,_i,_)) -> false
+ | x -> false in
+ let (minus,rest) = span minus_or_comment_or_space_nocpp rest in
+ let fail _ = a :: outer_spaces @ minus @ (drop_space_at_endline rest) in
+ if List.exists is_minus minus
+ then
+ match rest with
+ | ((T2(Parser_c.TCommentNewline _,Ctx,_i,_h)) as a)::rest ->
+ (* drop trailing spaces *)
+ minus @ a :: (drop_space_at_endline rest)
+ | _ -> fail ()
+ else fail ()
+ | a :: rest ->
+ a :: drop_space_at_endline rest
+
+(* if a removed ( is between two tokens, then add a space *)
+let rec paren_to_space = function
+ | [] -> []
+ | [x] -> [x]
+ | [x;y] -> [x;y]
+ | ((T2(_,Ctx,_,_)) as a)::
+ ((T2(t,Min _,_,_)) as b)::
+ ((T2(_,Ctx,_,_)) as c)::rest
+ when not (is_whitespace a) && TH.str_of_tok t = "(" ->
+ a :: b :: (C2 " ") :: (paren_to_space (c :: rest))
+ | a :: rest -> a :: (paren_to_space rest)
+
+let rec add_space xs =
+ match xs with
+ | [] -> []
+ | [x] -> [x]
+ | (Cocci2(sx,lnx,_,rcolx,_) as x)::((Cocci2(sy,lny,lcoly,_,_)) as y)::xs
+ when !Flag_parsing_c.spacing = Flag_parsing_c.SMPL &&
+ not (lnx = -1) && not (rcolx = -1) && lnx = lny && rcolx < lcoly ->
+ (* this only works within a line. could consider whether
+ something should be done to add newlines too, rather than
+ printing them explicitly in unparse_cocci. *)
+ x::C2 (String.make (lcoly-rcolx) ' ')::add_space (y::xs)
+ | (Cocci2(sx,lnx,_,rcolx,_) as x)::((Cocci2(sy,lny,lcoly,_,_)) as y)::xs
+ when !Flag_parsing_c.spacing = Flag_parsing_c.SMPL &&
+ not (lnx = -1) && not (rcolx = -1) && lnx < lny ->
+ (* this only works within a line. could consider whether
+ something should be done to add newlines too, rather than
+ printing them explicitly in unparse_cocci. *)
+ x::C2 (String.make (lny-lnx) '\n')::
+ C2 (String.make (lcoly-1) ' '):: (* -1 is for the + *)
+ add_space (y::xs)
+ | ((T2(_,Ctx,_,_)) as x)::((Cocci2 _) as y)::xs -> (* add space on boundary *)
+ let sx = str_of_token2 x in
+ let sy = str_of_token2 y in
+ if is_ident_like sx && (is_ident_like sy or List.mem sy ["="])
+ then x::C2 " "::(add_space (y::xs))
+ else x::(add_space (y::xs))
+ | x::y::xs -> (* not boundary, not sure if it is possible *)
+ let sx = str_of_token2 x in
+ let sy = str_of_token2 y in
+ if is_ident_like sx && is_ident_like sy
+ then x::C2 " "::(add_space (y::xs))
+ else x::(add_space (y::xs))
+
+(* A fake comma is added at the end of an unordered initlist or a enum
+decl, if the initlist or enum doesn't already end in a comma. This is only
+needed if there is + code, ie if we see Cocci after it in the code sequence *)
+
+let rec drop_end_comma = function
+ | [] -> []
+ | [x] -> [x]
+ | ((Comma ",") as x) :: rest ->
+ let (newlines,rest2) = span is_whitespace rest in
+ (match rest2 with
+ | (Cocci2 _) :: _ -> x :: drop_end_comma rest
+ | _ -> drop_end_comma rest
+ )
+ | x :: xs -> x :: drop_end_comma xs
+
+(* The following only works for the outermost function call. Stack records
+the column of all open parentheses. Space_cell contains the most recent
+comma in the outermost function call. The goal is to decide whether this
+should be followed by a space or a newline and indent. *)
+let add_newlines toks tabbing_unit =
+ (* the following is for strings that may contain newline or tabs *)
+ let string_length s count =
+ let l = list_of_string s in
+ List.fold_left
+ (function count ->
+ function
+ | '\t' -> count + 8
+ | '\n' -> 0
+ | c -> count + 1)
+ count l in
+ let create_indent n =
+ let (tu,tlen) =
+ match tabbing_unit with
+ | Some ("\t",_) -> ("\t",8)
+ | Some ("",_) -> ("\t",8) (* not sure why... *)
+ | Some (s,_) -> (s,string_length s 0) (* assuming only tabs or spaces *)
+ | None -> ("\t",8) in
+ let rec loop seen =
+ if seen + tlen <= n
+ then tu ^ loop (seen + tlen)
+ else String.make (n-seen) ' ' in
+ loop 0 in
+ let check_for_newline count x = function
+ | Some (start,space_cell) when count > Flag_parsing_c.max_width ->
+ space_cell := "\n"^(create_indent x);
+ Some (x + (count - start))
+ | _ -> None in
+ let start_box stack space_cell count s =
+ let count = string_length s count in
+ (count,count::stack,space_cell) in
+ let end_box stack space_cell count s =
+ (* this assumes that start_box and end_box are matched, but this is not
+ necessarily the case, if ( is modified and ) is context code *)
+ let count = string_length s count in
+ match stack with
+ | [x] ->
+ (match check_for_newline count x space_cell with
+ | Some count -> (count,[],None)
+ | None -> (count,[],None)
+ )
+ | [] -> (count,stack,space_cell)
+ | _ -> (count,List.tl stack,space_cell) in
+ let rec loop ((stack,space_cell) as info) count = function
+ | [] -> []
+ | ((Cocci2(s,line,lcol,rcol,hint)) as a):: (* hint can't be start *)
+ (T2(commatok,Ctx,idx,_))::
+ (T2(((Parser_c.TCommentSpace _) as sptok),Ctx,_,_)) ::
+ (((T2(codetok,Ctx,_,_)) :: _) as xs)
+ when
+ (TH.str_of_tok commatok) = "," &&
+ (TH.str_of_tok sptok) = " " &&
+ ((List.length stack = 1) or (* not super elegant... *)
+ (* check if the Cocci2 token is a ), need double treatment *)
+ (List.length stack = 2) && (hint = Some Unparse_cocci.EndBox)) ->
+ (* something large added before a comma *)
+ let stack = (* do the work of end_box in the length 2 case *)
+ if List.length stack = 2
+ then List.tl stack
+ else stack in
+ let x = List.hd stack in
+ let sp = ref " " in
+ let cocci_count = string_length s count in
+ let space_cell = Some (cocci_count+1,sp) in (* count before space *)
+ let newcount = cocci_count + 2 in (* count incuding space *)
+ let future_count =
+ string_length (TH.str_of_tok codetok) newcount in
+ let b = T2(commatok,Ctx,idx,
+ Some (Unparse_cocci.SpaceOrNewline sp)) in
+ (match check_for_newline future_count x space_cell with
+ | Some count -> a :: b :: loop (stack,Some (x,sp)) count xs
+ | None -> a :: b :: loop (stack,Some (newcount,sp)) newcount xs
+ )
+ | (T2(commatok,Ctx,_,_))::
+ (T2(((Parser_c.TCommentSpace _) as sptok),Ctx,idx,_)) ::
+ (((Cocci2(s,line,lcol,rcol,hint))::_) as xs)
+ when (TH.str_of_tok commatok) = "," && (TH.str_of_tok sptok) = " " &&
+ List.length stack = 1 (* not super elegant... *) ->
+ (* something large added after a comma *)
+ let x = List.hd stack in
+ let sp = ref " " in
+ let space_cell = Some (count+1,sp) in (* count before space *)
+ let newcount = count + 2 in (* count incuding space *)
+ let future_count = string_length s newcount in
+ let a = T2(commatok,Ctx,idx,
+ Some (Unparse_cocci.SpaceOrNewline sp)) in
+ (match check_for_newline future_count x space_cell with
+ | Some count -> a :: loop (stack,Some (x,sp)) count xs
+ | None -> a :: loop (stack,Some (newcount,sp)) newcount xs
+ )
+ | ((T2(tok,Ctx,idx,_)) as a)::xs ->
+ (* let (stack,space_cell) = info in *)
+ (match TH.str_of_tok tok with
+ | "=" as s ->
+ let (spaces,rest) = span is_space xs in
+ (match rest with
+ | ((T2(tok,Ctx,_,_)) as b)::ixs ->
+ (match TH.str_of_tok tok with
+ | "{" ->
+ let newcount =
+ List.fold_left
+ (function prev ->
+ function
+ | (T2(tok,_b,_i,_h)) ->
+ string_length (TH.str_of_tok tok) prev
+ | _ -> failwith "not possible")
+ count spaces in
+ let front = a :: spaces @ [b] in
+ let (newcount,newstack,newspacecell) =
+ start_box stack space_cell newcount "{" in
+ front @ loop (newstack,newspacecell) newcount ixs
+ | s -> a :: loop info (string_length s count) xs
+ )
+ | _ -> a :: loop info (string_length s count) xs
+ )
+ | "(" as s ->
+ let (newcount,newstack,newspacecell) =
+ start_box stack space_cell count s in
+ a :: loop (newstack,newspacecell) newcount xs
+ | ")" as s ->
+ let (newcount,newstack,newspacecell) =
+ end_box stack space_cell count s in
+ a :: loop (newstack,newspacecell) newcount xs
+ | "{" as s when not (stack = []) ->
+ (* [] case means statement braces *)
+ let (newcount,newstack,newspacecell) =
+ start_box stack space_cell count s in
+ a :: loop (newstack,newspacecell) newcount xs
+ | "}" as s when not (stack = []) ->
+ (* [] case means statement braces *)
+ let (newcount,newstack,newspacecell) =
+ end_box stack space_cell count s in
+ a :: loop (newstack,newspacecell) newcount xs
+ | s -> a :: loop info (string_length s count) xs
+ )
+ | ((Cocci2(s,line,lcol,rcol,hint)) as a)::xs ->
+ let (stack,space_cell) = info in
+ let rest =
+ match hint with
+ | None -> loop info (string_length s count) xs
+ | Some Unparse_cocci.StartBox ->
+ let (newcount,newstack,newspacecell) =
+ start_box stack space_cell count s in
+ loop (newstack,newspacecell) newcount xs
+ | Some Unparse_cocci.EndBox ->
+ let (newcount,newstack,newspacecell) =
+ end_box stack space_cell count s in
+ loop (newstack,newspacecell) newcount xs
+ | Some (Unparse_cocci.SpaceOrNewline sp) ->
+ let count = string_length s (count + 1 (*space*)) in
+ (match stack with
+ | [x] ->
+ (match check_for_newline count x space_cell with
+ | Some count -> loop (stack,Some (x,sp)) count xs
+ | None -> loop (stack,Some (count,sp)) count xs
+ )
+ | _ -> loop info count xs
+ ) in
+ a :: rest
+ | ((T2(tok,_,_,_)) as a)::xs ->
+ a :: loop info (string_length (TH.str_of_tok tok) count) xs
+ | ((C2(s)) as a)::xs -> a :: loop info (string_length s count) xs
+ | ((Comma(s)) as a)::xs -> a :: loop info (string_length s count) xs
+ | Fake2 _ :: _ | Indent_cocci2 :: _
+ | Unindent_cocci2 _::_ | EatSpace2::_ ->
+ failwith "unexpected fake, indent, unindent, or eatspace" in
+ let redo_spaces prev = function
+ | Cocci2(s,line,lcol,rcol,Some (Unparse_cocci.SpaceOrNewline sp)) ->
+ C2 !sp :: Cocci2(s,line,lcol,rcol,None) :: prev
+ | T2(tok,min,idx,Some (Unparse_cocci.SpaceOrNewline sp)) ->
+ C2 !sp :: T2(tok,min,idx,None) :: prev
+ | t -> t::prev in
+ (match !Flag_parsing_c.spacing with
+ | Flag_parsing_c.SMPL -> toks
+ | _ -> List.rev (List.fold_left redo_spaces [] (loop ([],None) 0 toks))
+ )
+
+(* When insert some new code, because of a + in a SP, we must add this
+* code at the right place, with the good indentation. So each time we
+* encounter some spacing info, with some newline, we maintain the
+* current indentation level used.
+*
+* TODO problems: not accurate. ex: TODO
+*
+* TODO: if in #define region, should add a \ \n
+*)
+let new_tabbing2 space =
+ list_of_string space
+ +> List.rev
+ +> take_until (fun c -> c =<= '\n')
+ +> List.rev
+ +> List.map string_of_char
+ +> String.concat ""
+
+let new_tabbing a =
+ profile_code "C unparsing.new_tabbing" (fun () -> new_tabbing2 a)
+
+
+let rec adjust_indentation xs =
+
+ let _current_tabbing = ref ([] : string list) in
+ let tabbing_unit = ref None in
+
+ let string_of_list l = String.concat "" (List.map string_of_char l) in
+
+ (* try to pick a tabbing unit for the plus code *)
+ let adjust_tabbing_unit old_tab new_tab =
+ if !tabbing_unit =*= None && String.length new_tab > String.length old_tab
+ then
+ let old_tab = list_of_string old_tab in
+ let new_tab = list_of_string new_tab in
+ let rec loop = function
+ | ([],new_tab) ->
+ tabbing_unit := Some(string_of_list new_tab,List.rev new_tab)
+ | (_,[]) -> failwith "not possible"
+ | (o::os,n::ns) -> loop (os,ns) in (* could check for equality *)
+ loop (old_tab,new_tab) in
+
+(*
+let remtab tu current_tab =
+let current_tab = List.rev(list_of_string current_tab) in
+let rec loop = function
+([],new_tab) -> string_of_list (List.rev new_tab)
+| (_,[]) -> (-*weird; tabbing unit used up more than the current tab*-)
+""
+| (t::ts,n::ns) when t =<= n -> loop (ts,ns)
+| (_,ns) -> (-* mismatch; remove what we can *-)
+string_of_list (List.rev ns) in
+loop (tu,current_tab) in
+*)
+
+ let rec find_first_tab started = function
+ | [] -> ()
+ | ((T2 (tok,_,_,_)) as x)::xs when str_of_token2 x =$= "{" ->
+ find_first_tab true xs
+ (* patch: coccinelle *)
+ | ((T2 (Parser_c.TCommentNewline s, _, _, _)) as x)::_
+ when started ->
+ let s = str_of_token2 x +> new_tabbing in
+ tabbing_unit := Some (s,List.rev (list_of_string s))
+ | x::xs -> find_first_tab started xs in
+ find_first_tab false xs;
+
+ let rec balanced ct = function
+ | [] -> ct >= 0
+ | ((T2(tok,_,_,_)) as x)::xs ->
+ (match str_of_token2 x with
+ | "(" -> balanced (ct+1) xs
+ | ")" -> balanced (ct-1) xs
+ | _ -> balanced ct xs
+ )
+ | x::xs -> balanced ct xs in
+
+ let update_tabbing started s x =
+ let old_tabbing = !_current_tabbing in
+ str_of_token2 x +> new_tabbing +> (fun s -> _current_tabbing := [s]);
+ (* only trust the indentation after the first { *)
+ if started
+ then
+ adjust_tabbing_unit
+ (String.concat "" old_tabbing)
+ (String.concat "" !_current_tabbing) in
+
+ let rec aux started xs =
+ match xs with
+ | [] -> []
+ (* patch: coccinelle *)
+ | ((T2 (Parser_c.TCommentNewline s,_,_,_)) as x)::
+ Unindent_cocci2(false)::xs ->
+ update_tabbing started s x;
+ (C2 "\n")::aux started xs
+ | (Cocci2("\n",_,_,_,_))::Unindent_cocci2(false)::xs ->
+ (C2 "\n")::aux started xs
+ | ((T2 (tok,_,_,_)) as x)::(T2 (Parser_c.TCommentNewline s, _, _, _))::
+ ((Cocci2 ("{",_,_,_,_)) as a)::xs
+ when started && str_of_token2 x =$= ")" ->
+ (* to be done for if, etc, but not for a function header *)
+ x::(C2 " ")::a::(aux started xs)
+ | ((T2 (Parser_c.TCommentNewline s, _, _, _)) as x)::xs
+ when
+ balanced 0 (fst(span (function x -> not(is_newline x)) xs)) ->
+ update_tabbing started s x;
+ let coccis_rest = span all_coccis xs in
+ (match coccis_rest with
+ | (_::_,((T2 (tok,_,_,_)) as y)::_) when str_of_token2 y =$= "}" ->
+ (* the case where cocci code has been added before a close } *)
+ x::aux started (Indent_cocci2::xs)
+ | _ -> x::aux started xs
+ )
+ | Indent_cocci2::((Cocci2(sy,lny,lcoly,_,_)) as y)::xs
+ when !Flag_parsing_c.spacing = Flag_parsing_c.SMPL ->
+ let tu = String.make (lcoly-1) ' ' in
+ _current_tabbing := tu::(!_current_tabbing);
+ C2 (tu)::aux started (y::xs)
+ | Indent_cocci2::xs ->
+ (match !tabbing_unit with
+ | None -> aux started xs
+ | Some (tu,_) ->
+ _current_tabbing := tu::(!_current_tabbing);
+ (* can't be C2, for later phases *)
+ Cocci2 (tu,-1,-1,-1,None)::aux started xs
+ )
+ | Unindent_cocci2(permanent)::((Cocci2("\n",_,_,_,_)) as x)::xs ->
+ (* seems only relevant if there is a following cocci newline *)
+ (match !_current_tabbing with
+ | [] -> aux started xs
+ | _::new_tabbing ->
+ let s = String.concat "" new_tabbing in
+ _current_tabbing := new_tabbing;
+ x::Cocci2 (s,-1,-1,-1,None)::aux started xs
+ )
+ | Unindent_cocci2(permanent)::xs -> aux started xs
+ (* border between existing code and cocci code *)
+ | ((T2 (tok,_,_,_)) as x)::((Cocci2("\n",_,_,_,_)) as y)::xs
+ when str_of_token2 x =$= "{" ->
+ x::aux true (y::Indent_cocci2::xs)
+ | ((Cocci2 _) as x)::((T2 (tok,_,_,_)) as y)::xs
+ when str_of_token2 y =$= "}" ->
+ x::aux started (Unindent_cocci2 true::y::xs)
+ (* starting the body of the function *)
+ | ((T2 (tok,_,_,_)) as x)::xs when str_of_token2 x =$= "{" ->
+ x::aux true xs
+ | ((Cocci2("{",_,_,_,_)) as a)::xs -> a::aux true xs
+ | ((Cocci2("\n",_,_,_,_)) as x)::xs ->
+ (* dont inline in expr because of weird eval order of ocaml *)
+ let s = String.concat "" !_current_tabbing in
+ (* can't be C2, for later phases *)
+ x::Cocci2 (s,-1,-1,-1,None)::aux started xs
+ | x::xs -> x::aux started xs in
+ (aux false xs,!tabbing_unit)
+
+
+let rec find_paren_comma = function
+ | [] -> ()
+
+ (* do nothing if was like this in original file *)
+ | { str = "("; idx = Some p1 } :: ({ str = ","; idx = Some p2} :: _ as xs)
+ | { str = ","; idx = Some p1 } :: ({ str = ","; idx = Some p2} :: _ as xs)
+ | { str = ","; idx = Some p1 } :: ({ str = ")"; idx = Some p2} :: _ as xs)
+ when p2 =|= p1 + 1 ->
+ find_paren_comma xs
+
+ (* otherwise yes can adjust *)
+ | { str = "(" } :: (({ str = ","} as rem) :: _ as xs)
+ | ({ str = "," } as rem) :: ({ str = ","} :: _ as xs)
+ | ({ str = "," } as rem) :: ({ str = ")"} :: _ as xs) ->
+ rem.remove <- true;
+ find_paren_comma xs
+
+ | x::xs ->
+ find_paren_comma xs
+
+
+let fix_tokens toks =
+ let toks = toks +> List.map mk_token_extended in
+
+ let cleaner = toks +> exclude (function
+ | {tok2 = T2 (t,_,_,_)} -> TH.is_real_comment t (* I want the ifdef *)
+ | _ -> false
+ ) in
+ find_paren_comma cleaner;
+
+ let toks = rebuild_tokens_extented toks in
+ toks +> List.map (fun x -> x.tok2)
+
+
+(*****************************************************************************)
+(* Final unparsing (and debugging support) *)
+(*****************************************************************************)
+
+(* for debugging *)
+type kind_token2 = KFake | KCocci | KC | KExpanded | KOrigin
+
+let kind_of_token2 = function
+ | Fake2 _ -> KFake
+ | Cocci2 _ -> KCocci
+ | C2 _ -> KC
+ | Comma _ -> KC
+ | T2 (t,_,_,_) ->
+ (match TH.pinfo_of_tok t with
+ | Ast_c.ExpandedTok _ -> KExpanded
+ | Ast_c.OriginTok _ -> KOrigin
+ | Ast_c.FakeTok _ -> raise (Impossible 139) (* now a Fake2 *)
+ | Ast_c.AbstractLineTok _ -> raise (Impossible 140) (* now a KC *)
+ )
+ | Unindent_cocci2 _ | Indent_cocci2 | EatSpace2 -> raise (Impossible 141)
+
+let end_mark = "!"
+
+let start_mark = function
+ | KFake -> "!F!"
+ | KCocci -> "!S!"
+ | KC -> "!A!"
+ | KExpanded -> "!E!"
+ | KOrigin -> ""
+
+let print_all_tokens2 pr xs =
+ if !Flag_parsing_c.debug_unparsing
+ then
+ let current_kind = ref KOrigin in
+ xs +> List.iter (fun t ->
+ let newkind = kind_of_token2 t in
+ if newkind =*= !current_kind
+ then pr (str_of_token2 t)
+ else
+ begin
+ pr (end_mark);
+ pr (start_mark newkind);
+ pr (str_of_token2 t);
+ current_kind := newkind
+ end
+ );
+ else
+ let to_whitespace s =
+ let r = String.copy s in
+ for i = 1 to String.length r do
+ let c = String.get r (i-1) in
+ match c with
+ | ' ' | '\t' | '\r' | '\n' -> ()
+ | _ -> String.set r (i-1) ' '
+ done;
+ r in
+ let hiding_level = ref 0 in
+ let handle_token t =
+ let s = str_of_token2 t in
+ let hide_current =
+ match t with
+ | T2 (t,_,_,_) ->
+ let i = TH.info_of_tok t in
+ (match Ast_c.get_annot_info i Token_annot.Exclude_start with
+ | None -> ()
+ | Some _ -> hiding_level := !hiding_level + 1
+ );
+ let hide_current = !hiding_level > 0 in
+ (match Ast_c.get_annot_info i Token_annot.Exclude_end with
+ | None -> ()
+ | Some _ -> hiding_level := max (!hiding_level - 1) 0
+ );
+ hide_current
+ | _ -> !hiding_level > 0 in
+ if hide_current then to_whitespace s else s in
+ xs +> List.iter (fun x -> pr (handle_token x))
+
+
+
+
+
+(*****************************************************************************)
+(* Entry points *)
+(*****************************************************************************)
+
+(* old: PPviatok was made in the beginning to allow to pretty print a
+ * complete C file, including a modified C file by transformation.ml,
+ * even if we don't handle yet in pretty_print_c.ml, ast_to_flow (and
+ * maybe flow_to_ast) all the cases. Indeed we don't need to do some
+ * fancy stuff when a function was not modified at all. Just need to
+ * print the list of token as-is. But now pretty_print_c.ml handles
+ * almost everything so maybe less useful. Maybe PPviatok allows to
+ * optimize a little the pretty printing.
+ *
+ * update: now have PPviastr which goes even faster than PPviatok, so
+ * PPviatok has disappeared.
+ *)
+
+type ppmethod = PPnormal | PPviastr
+
+
+
+
+(* The pp_program function will call pretty_print_c.ml with a special
+ * function to print the leaf components, the tokens. When we want to
+ * print a token, we need to print also maybe the space and comments that
+ * were close to it in the original file (and that was omitted during the
+ * parsing phase), and honor what the cocci-info attached to the token says.
+ * Maybe we will not print the token if it's a MINUS-token, and maybe we will
+ * print it and also print some cocci-code attached in a PLUS to it.
+ * So we will also maybe call unparse_cocci. Because the cocci-code may
+ * contain metavariables, unparse_cocci will in fact sometimes call back
+ * pretty_print_c (which will this time don't call back again unparse_cocci)
+ *)
+
+let pp_program2 xs outfile =
+ with_open_outfile outfile (fun (pr,chan) ->
+ let pr s =
+ if !Flag_parsing_c.debug_unparsing
+ then begin pr2_no_nl s; flush stderr end
+ else pr s
+(* flush chan; *)
+(* Common.pr2 ("UNPARSING: >" ^ s ^ "<"); *)
+ in
+
+ xs +> List.iter (fun ((e,(str, toks_e)), ppmethod) ->
+ (* here can still work on ast *)
+ let e = remove_useless_fakeInfo_struct e in
+
+ match ppmethod with
+ | PPnormal ->
+ (* now work on tokens *)
+ (* phase1: just get all the tokens, all the information *)
+ assert(toks_e +> List.for_all (fun t ->
+ TH.is_origin t or TH.is_expanded t
+ ));
+ let toks = get_fakeInfo_and_tokens e toks_e in
+ let toks = displace_fake_nodes toks in
+ (* assert Origin;ExpandedTok;Faketok *)
+ let toks = expand_mcode toks in
+
+ (* assert Origin;ExpandedTok; + Cocci + C (was AbstractLineTok)
+ * and no tag information, just NOTHING. *)
+
+ let toks =
+ if !Flag.sgrep_mode2
+ then
+ (* nothing else to do for sgrep *)
+ drop_expanded(drop_fake(drop_minus toks))
+ else
+ begin
+ (* phase2: can now start to filter and adjust *)
+ let (toks,tu) = adjust_indentation toks in
+ let toks = adjust_eat_space toks in
+ let toks = adjust_before_semicolon toks in(*before remove minus*)
+ let toks = adjust_after_paren toks in(*also before remove minus*)
+ let toks = drop_space_at_endline toks in
+ let toks = paren_to_space toks in
+ let toks = drop_end_comma toks in
+ let toks = remove_minus_and_between_and_expanded_and_fake toks in
+ (* assert Origin + Cocci + C and no minus *)
+ let toks = add_space toks in
+ let toks = add_newlines toks tu in
+ let toks = paren_then_brace toks in
+ let toks = fix_tokens toks in
+ toks
+ end in
+
+ (* in theory here could reparse and rework the ast! or
+ * apply some SP. Not before cos julia may have generated
+ * not parsable file. Need do unparsing_tricks call before
+ * being ready to reparse. *)
+ print_all_tokens2 pr toks;
+
+ | PPviastr -> pr str
+ )
+ )
+
+let pp_program a b =
+ profile_code "C unparsing" (fun () -> pp_program2 a b)
+
+
+let pp_program_default xs outfile =
+ let xs' = xs +> List.map (fun x -> x, PPnormal) in
+ pp_program xs' outfile
(*
+ * Copyright (C) 2012, INRIA.
* Copyright (C) 2010, University of Copenhagen DIKU and INRIA.
* Copyright (C) 2006, 2007 Julia Lawall
*
| Some x -> pr_space(); fn x in
let print_between = Common.print_between in
+let rec param_print_between between fn = function
+ | [] -> ()
+ | [x] -> fn x
+ | x::xs -> fn x; between x; param_print_between between fn xs in
+
+
let outdent _ = () (* should go to leftmost col, does nothing now *) in
let pretty_print_c =
(* --------------------------------------------------------------------- *)
-let handle_metavar name fn =
+let lookup_metavar name =
let ((_,b) as s,info,mc,pos) = name in
let line = info.Ast.line in
let lcol = info.Ast.column in
- match Common.optionise (fun () -> List.assoc s env) with
+ let rcol = if lcol = unknown then unknown else lcol + (String.length b) in
+ let res = Common.optionise (fun () -> List.assoc s env) in
+ (res,b,line,lcol,rcol) in
+
+let handle_metavar name fn =
+ let (res,name_string,line,lcol,rcol) = lookup_metavar name in
+ match res with
None ->
- let name_string (_,s) = s in
if generating
- then
- mcode (function _ -> print_string (name_string s)) name
+ then mcode (function _ -> print_string name_string) name
else
failwith
(Printf.sprintf "SP line %d: Not found a value in env for: %s"
- line (name_string s))
+ line name_string)
| Some e ->
pr_barrier line lcol;
(if generating
(* call mcode to preserve the -+ annotation *)
mcode (fun _ _ _ -> fn e) name
else fn e);
- let rcol =
- if lcol = unknown then unknown else lcol + (String.length b) in
pr_barrier line rcol
in
(* --------------------------------------------------------------------- *)
let dots between fn d =
match Ast.unwrap d with
- Ast.DOTS(l) -> print_between between fn l
- | Ast.CIRCLES(l) -> print_between between fn l
- | Ast.STARS(l) -> print_between between fn l
+ Ast.DOTS(l) -> param_print_between between fn l
+ | Ast.CIRCLES(l) -> param_print_between between fn l
+ | Ast.STARS(l) -> param_print_between between fn l
in
let nest_dots starter ender fn f d =
| Ast.MetaId(name,_,_,_) ->
handle_metavar name (function
| (Ast_c.MetaIdVal (id,_)) -> print_text id
- | _ -> raise Impossible
+ | _ -> raise (Impossible 142)
)
| Ast.MetaFunc(name,_,_,_) ->
handle_metavar name (function
| (Ast_c.MetaFuncVal id) -> print_text id
- | _ -> raise Impossible
+ | _ -> raise (Impossible 143)
)
| Ast.MetaLocalFunc(name,_,_,_) ->
handle_metavar name (function
| (Ast_c.MetaLocalFuncVal id) -> print_text id
- | _ -> raise Impossible
+ | _ -> raise (Impossible 144)
)
| Ast.AsIdent(id,asid) -> ident id
handle_metavar name (function
| Ast_c.MetaExprVal (exp,_) ->
pretty_print_c.Pretty_print_c.expression exp
- | _ -> raise Impossible
+ | _ -> raise (Impossible 145)
)
| Ast.MetaExprList (name,_,_,_) ->
pretty_print_c.Pretty_print_c.arg_list args
| Ast_c.MetaParamListVal _ ->
failwith "have meta param list matching meta exp list\n";
- | _ -> raise Impossible
+ | _ -> raise (Impossible 146)
)
| Ast.AsExpr(expr,asexpr) -> expression expr
handle_metavar name (function
Ast_c.MetaTypeVal exp ->
pretty_print_c.Pretty_print_c.ty exp
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 147))
and baseType = function
Ast.VoidType -> print_string "void"
and ft_space ty =
match Ast.unwrap ty with
Ast.Type(_,cv,ty) ->
- (match Ast.unwrap ty with
- Ast.Pointer(_,_) -> ()
- | Ast.MetaType(name,_,_) ->
- (match List.assoc (Ast.unwrap_mcode name) env with
- Ast_c.MetaTypeVal (tq,ty) ->
- (match Ast_c.unwrap ty with
- Ast_c.Pointer(_,_) -> ()
- | _ -> pr_space())
- | _ -> pr_space())
- | _ -> pr_space())
+ let isptr =
+ match Ast.unwrap ty with
+ Ast.Pointer(_,_) -> true
+ | Ast.MetaType(name,_,_) ->
+ let (res,name_string,line,lcol,rcol) = lookup_metavar name in
+ (match res with
+ None ->
+ failwith
+ (Printf.sprintf "variable %s not known on SP line %d\n"
+ name_string line)
+ | Some (Ast_c.MetaTypeVal (tq,ty)) ->
+ (match Ast_c.unwrap ty with
+ Ast_c.Pointer(_,_) -> true
+ | _ -> false)
+ | _ -> false)
+ | _ -> false in
+ if isptr then () else pr_space()
| _ -> pr_space()
-
+
and declaration d =
match Ast.unwrap d with
Ast.MetaDecl(name,_,_) ->
(function
Ast_c.MetaDeclVal d ->
pretty_print_c.Pretty_print_c.decl d
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 148))
| Ast.MetaField(name,_,_) ->
handle_metavar name
(function
Ast_c.MetaFieldVal f ->
pretty_print_c.Pretty_print_c.field f
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 149))
| Ast.MetaFieldList(name,_,_,_) ->
handle_metavar name
(function
Ast_c.MetaFieldListVal f ->
print_between force_newline pretty_print_c.Pretty_print_c.field f
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 150))
| Ast.AsDecl(decl,asdecl) -> declaration decl
mcode print_string sem
| Ast.MacroDecl(name,lp,args,rp,sem) ->
ident name; mcode print_string_box lp;
- dots (function _ -> ()) expression args;
+ dots (function _ -> ()) arg_expression args;
close_box(); mcode print_string rp; mcode print_string sem
| Ast.MacroDeclInit(name,lp,args,rp,eq,ini,sem) ->
ident name; mcode print_string_box lp;
- dots (function _ -> ()) expression args;
+ dots (function _ -> ()) arg_expression args;
close_box(); mcode print_string rp;
pr_space(); mcode print_string eq;
pr_space(); initialiser true ini; mcode print_string sem
handle_metavar name (function
Ast_c.MetaInitVal ini ->
pretty_print_c.Pretty_print_c.init ini
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 151))
| Ast.MetaInitList(name,_,_,_) ->
handle_metavar name (function
Ast_c.MetaInitListVal ini ->
pretty_print_c.Pretty_print_c.init_list ini
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 152))
| Ast.AsInit(init,asinit) -> initialiser nlcomma init
| Ast.InitExpr(exp) -> expression exp
| Ast.ArInitList(lb,initlist,rb) ->
(function
Ast_c.MetaParamVal p ->
pretty_print_c.Pretty_print_c.param p
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 153))
| Ast.MetaParamList(name,_,_,_) ->
handle_metavar name
(function
Ast_c.MetaParamListVal p ->
pretty_print_c.Pretty_print_c.paramlist p
- | _ -> raise Impossible)
+ | _ -> raise (Impossible 154))
| Ast.PComma(cm) -> mcode print_string cm
| Ast.Pdots(dots) | Ast.Pcircles(dots) when generating ->
| Ast.IteratorHeader(nm,lp,args,rp) ->
pr_arity arity;
ident nm; pr_space(); mcode print_string_box lp;
- dots (function _ -> ()) expression args; close_box();
+ dots (function _ -> ()) arg_expression args; close_box();
mcode print_string rp
| Ast.SwitchHeader(switch,lp,exp,rp) ->
else raise CantBeInPlus
| Ast.MetaRuleElem(name,_,_) ->
- raise Impossible
+ raise (Impossible 155)
| Ast.MetaStmt(name,_,_,_) ->
handle_metavar name (function
| Ast_c.MetaStmtVal stm ->
pretty_print_c.Pretty_print_c.statement stm
- | _ -> raise Impossible
+ | _ -> raise (Impossible 156)
)
| Ast.MetaStmtList(name,_,_) ->
failwith
| Ast.FAttr(attr) -> mcode print_string attr; pr_space() in
let indent_if_needed s f =
- match Ast.unwrap s with
- Ast.Seq(lbrace,body,rbrace) -> pr_space(); f()
- | _ ->
+ let isseq =
+ match Ast.unwrap s with
+ Ast.Seq(lbrace,body,rbrace) -> true
+ | Ast.Atomic s ->
+ (match Ast.unwrap s with
+ | Ast.MetaStmt(name,_,_,_) ->
+ let (res,name_string,line,lcol,rcol) = lookup_metavar name in
+ (match res with
+ None ->
+ failwith
+ (Printf.sprintf "variable %s not known on SP line %d\n"
+ name_string line)
+ | Some (Ast_c.MetaStmtVal stm) ->
+ (match Ast_c.unwrap stm with
+ Ast_c.Compound _ -> true
+ | _ -> false)
+ | _ -> failwith "bad metavariable value")
+ | _ -> false)
+ | _ -> false in
+ if isseq
+ then begin pr_space(); f() end
+ else
+ begin
(*no newline at the end - someone else will do that*)
- start_block(); f(); unindent true in
+ start_block(); f(); unindent true
+ end in
let rec statement arity s =
match Ast.unwrap s with
(* this is not '...', but a list of expr/statement/params, and
normally there should be no '...' inside them *)
- | Ast.ExprDotsTag(x) -> dots (function _ -> ()) expression x; false
+ | Ast.ExprDotsTag(x) ->
+ let check_comma cm =
+ match Ast.unwrap cm with
+ Ast.EComma(cm) -> pr_space()
+ | _ -> () in
+ dots check_comma expression x; false
| Ast.ParamDotsTag(x) -> parameter_list x; false
| Ast.StmtDotsTag(x) -> dots force_newline (statement "") x; false
| Ast.DeclDotsTag(x) -> dots force_newline declaration x; false
Ast_c.AbstractLineTok _ -> pr (Ast_c.str_of_info info)
| Ast_c.FakeTok (s,_) -> pr s
| _ ->
- Printf.printf "line: %s\n" (Common.dump info);
+ Printf.printf "line: %s\n" (Dumper.dump info);
error rule "not an abstract line" in
let pr_space _ = pr " " in
Unparse_cocci.pp_list_list_any
| DefineText (s, ii) -> vk_ii bigf ii
| DefineEmpty -> ()
| DefineInit ini -> vk_ini bigf ini
-
+ (* christia: added multi *)
+ | DefineMulti stmts ->
+ List.fold_left (fun () d -> vk_statement bigf d) () stmts
| DefineTodo ->
pr2_once "DefineTodo";
()
| DefineText (s, ii) -> DefineText (s, iif ii)
| DefineEmpty -> DefineEmpty
| DefineInit ini -> DefineInit (vk_ini_s bigf ini)
+ (* christia: added multi *)
+ | DefineMulti ds ->
+ DefineMulti (List.map (vk_statement_s bigf) ds)
| DefineTodo ->
pr2_once "DefineTodo";
parse_aux.ml disjdistr.ml \
$(LEXER_SOURCES:.mll=.ml) $(PARSER_SOURCES:.mly=.ml) \
$(CLI_LEXER_SOURCES:.mll=.ml) $(SCRIPT_LEXER_SOURCES:.mll=.ml) \
-get_constants2.ml id_utils.ml adjacency.ml parse_cocci.ml command_line.ml
+get_constants2.ml id_utils.ml adjacency.ml commas_on_lists.ml \
+parse_cocci.ml command_line.ml
LIBS=../commons/commons.cma ../globals/globals.cma
SYSLIBS = str.cma unix.cma
OPTOBJS = $(OBJS:.cmo=.cmx)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
all: $(LIB)
local: $(EXEC)
$(EXEC): $(OBJS) main.cmo $(LIBS)
$(OCAMLC) $(OCAMLCFLAGS) $(INCLUDES) -o $(EXEC) $(SYSLIBS) $(LIBS) $(OBJS) main.cmo
+else
+all:
+ cd .. && $(OCAMLBUILD) parsing_cocci/parsing_cocci.cma
+
+all.opt:
+ cd .. && $(OCAMLBUILD) parsing_cocci/parsing_cocci.cmxa
+
+$(EXEC):
+ cd .. && $(OCAMLBUILD) parsing_cocci/main.byte
+ cp ../_build/parsing_cocci/main.byte $(EXEC)
+
+clean::
+ cd .. && $(OCAMLBUILD) -clean
+ rm -f $(TARGET) $(TARGET).byte $(TARGET).native
+endif
clean::
rm -f $(LIB)
$(LEXER_SOURCES:.mll=.ml) : $(LEXER_SOURCES)
$(OCAMLLEX) $(LEXER_SOURCES)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
$(PARSER_SOURCES:.mly=.ml) $(PARSER_SOURCES:.mly=.mli) : $(PARSER_SOURCES)
$(MENHIR) --ocamlc "${OCAMLC}" --ocamldep "${OCAMLDEP}" --table --base parser_cocci_menhir $(PARSER_SOURCES)
+else
+$(PARSER_SOURCES:.mly=.ml) $(PARSER_SOURCES:.mly=.mli) : $(PARSER_SOURCES)
+ cd .. && $(OCAMLBUILD) parsing_cocci/$@
+ cp ../_build/parsing_cocci/$@ $@
+endif
$(CLI_LEXER_SOURCES:.mll=.ml): $(CLI_LEXER_SOURCES)
$(OCAMLLEX) $(CLI_LEXER_SOURCES)
$(OCAMLLEX) $(SCRIPT_LEXER_SOURCES)
distclean:: clean
- @echo cleaning generated parsers and lexers
- rm -f $(GENERATED)
+ if test -z "${KEEP_GENERATED}"; then \
+ @echo cleaning generated parsers and lexers; \
+ rm -f $(GENERATED); fi
# clean rule for others files
clean::
$(OCAMLDEP) *.mli *.ml > .depend
lexer_cocci.ml: lexer_cocci.mll
-parser_cocci_menhir.ml: parser_cocci_menhir.mly lexer_cocci.mll
-parser_cocci_menhir.mli: parser_cocci_menhir.mly lexer_cocci.mll
lexer_script.ml: lexer_script.mll
lexer_cli.ml: lexer_cli.mll
+parser_cocci_menhir.ml: parser_cocci_menhir.mly lexer_cocci.mll
+parser_cocci_menhir.mli: parser_cocci_menhir.mly lexer_cocci.mll
+
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
+endif
include ../Makefile.common
| Ast0.CONTEXT _ -> counter := !counter + 1; x
| _ -> failwith "unexpected mcode for ...")
| _ -> mcode x in
+ let statement r k s =
+ let s = k s in
+ (* a case for each kind of term that has a fake node *)
+ Ast0.rewrap s
+ (match Ast0.unwrap s with
+ Ast0.IfThen(iff,lp,exp,rp,branch,(info,mc,_)) ->
+ Ast0.IfThen(iff,lp,exp,rp,branch,(info,mc,!counter))
+ | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(info,mc,_)) ->
+ Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(info,mc,!counter))
+ | Ast0.While(wh,lp,exp,rp,body,(info,mc,_)) ->
+ Ast0.While(wh,lp,exp,rp,body,(info,mc,!counter))
+ | Ast0.For(fr,lp,first,exp2,sem2,exp3,rp,body,(info,mc,_)) ->
+ Ast0.For(fr,lp,first,exp2,sem2,exp3,rp,body,(info,mc,!counter))
+ | Ast0.Iterator(nm,lp,args,rp,body,(info,mc,_)) ->
+ Ast0.Iterator(nm,lp,args,rp,body,(info,mc,!counter))
+ | s -> s) in
let fn =
V0.rebuilder
{V0.rebuilder_functions with
VT0.rebuilder_sign_mcode = mcode;
VT0.rebuilder_struct_mcode = mcode;
VT0.rebuilder_storage_mcode = mcode;
- VT0.rebuilder_inc_mcode = mcode;} in
+ VT0.rebuilder_inc_mcode = mcode;
+ VT0.rebuilder_stmtfn = statement;} in
List.map fn.VT0.rebuilder_rec_top_level p
([],_) | (_,Ast0.PLUS _) -> None
| (l,_) -> Some(l,(a,b,{info with Ast0.strings_after = []},mcodekind,d,e))
-let update_before pragmas (info,x) =
+let update_before pragmas (info,x,adj) =
({info with Ast0.strings_before = pragmas @ info.Ast0.strings_before},
- Ast0.PLUS Ast.ONE) (* not sure what the arg should be... one seems safe *)
+ Ast0.PLUS Ast.ONE,adj)(*not sure what the arg should be... one seems safe*)
let update_after pragmas (info,x) =
({info with Ast0.strings_after = info.Ast0.strings_after @ pragmas},
- Ast0.PLUS Ast.ONE) (* not sure what the arg should be... one seems safe *)
+ Ast0.PLUS Ast.ONE) (*not sure what the arg should be... one seems safe*)
let rec right_decl d =
match Ast0.unwrap d with
then fail expr "opt only allowed in the last disjunct"
| _ -> ());
Ast0.rewrap expr (Ast0.DisjExpr(starter,exps,mids,ender))
- | Ast0.NestExpr(starter,exp_dots,ender,whencode,multi) ->
+ | Ast0.NestExpr(starter,exp_dots,ender,whencode,multi) ->
let res =
- Ast0.NestExpr(starter,
- dots (top_expression true Ast0.NONE) exp_dots,
- ender,whencode,multi) in
+ Ast0.NestExpr(starter,
+ dots (top_expression true Ast0.NONE) exp_dots,
+ ender,whencode,multi) in
Ast0.rewrap expr res
- | Ast0.Edots(dots,whencode) ->
+ | Ast0.Edots(dots,whencode) ->
let arity = exp_same (mcode2line dots) [mcode2arity dots] in
let dots = mcode dots in
let whencode = get_option (expression Ast0.NONE) whencode in
(* adjacency index is incremented when we skip over dots or nest delimiters
it is used in deciding how much to remove, when two adjacent code tokens are
removed. *)
+type adjacency = int
+
+type fake_mcode = info * mcodekind * adjacency
+
type 'a mcode =
'a * arity * info * mcodekind * anything list ref (* pos, - only *) *
- int (* adjacency_index *)
+ adjacency (* adjacency_index *)
(* int ref is an index *)
and 'a wrap =
{ node : 'a;
(* Statement*)
and base_statement =
+ (*Decl and FunDecl don't need adjacency. Delete all comments in any case*)
Decl of (info * mcodekind) (* before the decl *) * declaration
| Seq of string mcode (* { *) * statement dots *
string mcode (* } *)
| ExprStatement of expression option * string mcode (*;*)
| IfThen of string mcode (* if *) * string mcode (* ( *) *
expression * string mcode (* ) *) *
- statement * (info * mcodekind) (* after info *)
+ statement * fake_mcode (* after info *)
| IfThenElse of string mcode (* if *) * string mcode (* ( *) *
expression * string mcode (* ) *) *
statement * string mcode (* else *) * statement *
- (info * mcodekind)
+ fake_mcode (* after info *)
| While of string mcode (* while *) * string mcode (* ( *) *
expression * string mcode (* ) *) *
- statement * (info * mcodekind) (* after info *)
+ statement * fake_mcode (* after info *)
| Do of string mcode (* do *) * statement *
string mcode (* while *) * string mcode (* ( *) *
expression * string mcode (* ) *) *
| For of string mcode (* for *) * string mcode (* ( *) * forinfo *
expression option * string mcode (*;*) *
expression option * string mcode (* ) *) * statement *
- (info * mcodekind) (* after info *)
+ fake_mcode (* after info *)
| Iterator of ident (* name *) * string mcode (* ( *) *
expression dots * string mcode (* ) *) *
- statement * (info * mcodekind) (* after info *)
+ statement * fake_mcode (* after info *)
| Switch of string mcode (* switch *) * string mcode (* ( *) *
expression * string mcode (* ) *) * string mcode (* { *) *
statement (*decl*) dots *
strings_after : (Ast_cocci.added_string * position_info) list;
isSymbolIdent : bool; (* is the token a symbol identifier or not *) }
+type adjacency = int
+
+type fake_mcode = info * mcodekind * adjacency
+
type 'a mcode =
'a * arity * info * mcodekind * anything list ref (* pos, - only *) *
- int (* adjacency_index *)
+ adjacency (* adjacency_index *)
and 'a wrap =
{ node : 'a;
| ExprStatement of expression option * string mcode (*;*)
| IfThen of string mcode (* if *) * string mcode (* ( *) *
expression * string mcode (* ) *) *
- statement * (info * mcodekind)
+ statement * fake_mcode (* after info *)
| IfThenElse of string mcode (* if *) * string mcode (* ( *) *
expression * string mcode (* ) *) *
statement * string mcode (* else *) * statement *
- (info * mcodekind)
+ fake_mcode (* after info *)
| While of string mcode (* while *) * string mcode (* ( *) *
expression * string mcode (* ) *) *
- statement * (info * mcodekind) (* after info *)
+ statement * fake_mcode (* after info *)
| Do of string mcode (* do *) * statement *
string mcode (* while *) * string mcode (* ( *) *
expression * string mcode (* ) *) *
| For of string mcode (* for *) * string mcode (* ( *) * forinfo *
expression option * string mcode (*;*) *
expression option * string mcode (* ) *) * statement *
- (info * mcodekind) (* after info *)
+ fake_mcode (* after info *)
| Iterator of ident (* name *) * string mcode (* ( *) *
expression dots * string mcode (* ) *) *
- statement * (info * mcodekind) (* after info *)
+ statement * fake_mcode (* after info *)
| Switch of string mcode (* switch *) * string mcode (* ( *) *
expression * string mcode (* ) *) * string mcode (* { *) *
statement (*decl*) dots *
Ast.CONTEXT(Ast.NoPos,befaft)
| Ast0.MIXED(_) -> failwith "not possible for mcode"
+let convert_fake_mcode (_,mc,adj) = convert_mcodekind adj mc
+
let convert_allminus_mcodekind allminus = function
Ast0.CONTEXT(befaft) ->
let (befaft,_,_) = !befaft in
| Ast0.CIRCLES(x) -> Ast.CIRCLES(List.map fn x)
| Ast0.STARS(x) -> Ast.STARS(List.map fn x))
-(* commas in dotted lists, here due to polymorphism restrictions *)
-
-let add_comma is_comma is_dots make_comma itemlist =
- match Ast0.unwrap itemlist with
- Ast0.DOTS(x) ->
- (match List.rev x with
- [] -> itemlist
-(* Not sure if comma is needed if the list is just ...; leave it there for
-now. See list_matcher in cocci_vs_c.ml in first try_matches case. *)
-(* | [e] when is_dots e -> itemlist*)
- | e::es ->
- if is_comma e
- then itemlist
- else
- let comma =
- match Ast0.get_mcodekind e with
- Ast0.MINUS(_) -> (Ast0.make_minus_mcode ",")
- | _ -> (Ast0.make_mcode ",") in
- Ast0.rewrap itemlist
- (Ast0.DOTS
- (List.rev (Ast0.rewrap e (make_comma comma) :: (e::es)))))
- | _ -> failwith "not possible"
-
-let add_exp_comma =
- add_comma
- (function x -> match Ast0.unwrap x with Ast0.EComma _ -> true | _ -> false)
- (function x -> match Ast0.unwrap x with Ast0.Edots _ -> true | _ -> false)
- (function x -> Ast0.EComma x)
-
-and add_init_comma =
- add_comma
- (function x -> match Ast0.unwrap x with Ast0.IComma _ -> true | _ -> false)
- (function x -> match Ast0.unwrap x with Ast0.Idots _ -> true | _ -> false)
- (function x -> Ast0.IComma x)
-
(* --------------------------------------------------------------------- *)
(* Identifier *)
| Ast0.EnumName(kind,name) ->
Ast.EnumName(mcode kind,get_option ident name)
| Ast0.EnumDef(ty,lb,ids,rb) ->
- let ids = add_exp_comma ids in
Ast.EnumDef(typeC allminus ty,mcode lb,dots expression ids,mcode rb)
| Ast0.StructUnionName(kind,name) ->
Ast.StructUnionName(mcode kind,get_option ident name)
Ast.AsInit(initialiser init,initialiser asinit)
| Ast0.InitExpr(exp) -> Ast.InitExpr(expression exp)
| Ast0.InitList(lb,initlist,rb,true) ->
- let initlist = add_init_comma initlist in
Ast.ArInitList(mcode lb,dots initialiser initlist,mcode rb)
| Ast0.InitList(lb,initlist,rb,false) ->
- let initlist = add_init_comma initlist in
let (whencode,initlist,allminus) = strip_idots initlist in
Ast.StrInitList
(allminus,mcode lb,List.map initialiser initlist,mcode rb,
tokenwrap rbrace s (Ast.SeqEnd(rbrace)))
| Ast0.ExprStatement(exp,sem) ->
Ast.Atomic(rewrap_rule_elem s
- (Ast.ExprStatement(get_option expression exp,mcode sem)))
- | Ast0.IfThen(iff,lp,exp,rp,branch,(_,aft)) ->
+ (Ast.ExprStatement
+ (get_option expression exp,mcode sem)))
+ | Ast0.IfThen(iff,lp,exp,rp,branch,aft) ->
Ast.IfThen
(rewrap_rule_elem s
(Ast.IfHeader(mcode iff,mcode lp,expression exp,mcode rp)),
statement Ast.NotSequencible branch,
- ([],[],[],convert_mcodekind (-1) aft))
- | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(_,aft)) ->
+ ([],[],[],convert_fake_mcode aft))
+ | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft) ->
let els = mcode els in
Ast.IfThenElse
(rewrap_rule_elem s
statement Ast.NotSequencible branch1,
tokenwrap els s (Ast.Else(els)),
statement Ast.NotSequencible branch2,
- ([],[],[],convert_mcodekind (-1) aft))
- | Ast0.While(wh,lp,exp,rp,body,(_,aft)) ->
+ ([],[],[],convert_fake_mcode aft))
+ | Ast0.While(wh,lp,exp,rp,body,aft) ->
Ast.While(rewrap_rule_elem s
(Ast.WhileHeader
(mcode wh,mcode lp,expression exp,mcode rp)),
statement Ast.NotSequencible body,
- ([],[],[],convert_mcodekind (-1) aft))
+ ([],[],[],convert_fake_mcode aft))
| Ast0.Do(d,body,wh,lp,exp,rp,sem) ->
let wh = mcode wh in
Ast.Do(rewrap_rule_elem s (Ast.DoHeader(mcode d)),
tokenwrap wh s
(Ast.WhileTail(wh,mcode lp,expression exp,mcode rp,
mcode sem)))
- | Ast0.For(fr,lp,first,exp2,sem2,exp3,rp,body,(_,aft)) ->
+ | Ast0.For(fr,lp,first,exp2,sem2,exp3,rp,body,aft) ->
let fr = mcode fr in
let lp = mcode lp in
let first = forinfo first in
let body = statement Ast.NotSequencible body in
Ast.For(rewrap_rule_elem s
(Ast.ForHeader(fr,lp,first,exp2,sem2,exp3,rp)),
- body,([],[],[],convert_mcodekind (-1) aft))
- | Ast0.Iterator(nm,lp,args,rp,body,(_,aft)) ->
+ body,([],[],[],convert_fake_mcode aft))
+ | Ast0.Iterator(nm,lp,args,rp,body,aft) ->
Ast.Iterator(rewrap_rule_elem s
(Ast.IteratorHeader
(ident nm,mcode lp,
dots expression args,
mcode rp)),
statement Ast.NotSequencible body,
- ([],[],[],convert_mcodekind (-1) aft))
+ ([],[],[],convert_fake_mcode aft))
| Ast0.Switch(switch,lp,exp,rp,lb,decls,cases,rb) ->
let switch = mcode switch in
let lp = mcode lp in
--- /dev/null
+(*
+ * Copyright 2012, INRIA
+ * Julia Lawall, Gilles Muller
+ * Copyright 2010-2011, INRIA, University of Copenhagen
+ * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
+ * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
+ * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
+ * This file is part of Coccinelle.
+ *
+ * Coccinelle 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, according to version 2 of the License.
+ *
+ * Coccinelle 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 Coccinelle. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * The authors reserve the right to distribute this or future versions of
+ * Coccinelle under other licenses.
+ *)
+
+
+# 0 "./commas_on_lists.ml"
+module Ast0 = Ast0_cocci
+module V0 = Visitor_ast0
+module VT0 = Visitor_ast0_types
+
+(* Add commas in init lists or exp lists, if needed. This must be done
+before the adjacency calculation so that the commas get the right
+adjacency numbers. This is needed for correct formatting in unparse_c.ml *)
+
+(* commas in dotted lists, here due to polymorphism restrictions *)
+
+let add_comma is_comma is_dots make_comma itemlist =
+ match Ast0.unwrap itemlist with
+ Ast0.DOTS(x) ->
+ (match List.rev x with
+ [] -> itemlist
+(* Not sure if comma is needed if the list is just ...; leave it there for
+now. See list_matcher in cocci_vs_c.ml in first try_matches case. *)
+(* | [e] when is_dots e -> itemlist*)
+ | e::es ->
+ if is_comma e
+ then itemlist
+ else
+ let comma =
+ match Ast0.get_mcodekind e with
+ Ast0.MINUS(_) -> (Ast0.make_minus_mcode ",")
+ | _ -> (Ast0.make_mcode ",") in
+ Ast0.rewrap itemlist
+ (Ast0.DOTS
+ (List.rev (Ast0.rewrap e (make_comma comma) :: (e::es)))))
+ | _ -> failwith "not possible"
+
+let add_exp_comma =
+ add_comma
+ (function x -> match Ast0.unwrap x with Ast0.EComma _ -> true | _ -> false)
+ (function x -> match Ast0.unwrap x with Ast0.Edots _ -> true | _ -> false)
+ (function x -> Ast0.EComma x)
+
+and add_init_comma =
+ add_comma
+ (function x -> match Ast0.unwrap x with Ast0.IComma _ -> true | _ -> false)
+ (function x -> match Ast0.unwrap x with Ast0.Idots _ -> true | _ -> false)
+ (function x -> Ast0.IComma x)
+
+(* --------------------------------------------------------------------- *)
+(* special cases for terms that contain comma-separated lists where the
+trailing comma is allowed but not required *)
+
+let base_typeC r k t =
+ let t = k t in
+ match Ast0.unwrap t with
+ Ast0.EnumDef(ty,lb,ids,rb) ->
+ let ids = add_exp_comma ids in
+ Ast0.rewrap t (Ast0.EnumDef(ty,lb,ids,rb))
+ | _ -> t
+
+let initialiser r k i =
+ let i = k i in
+ match Ast0.unwrap i with
+ Ast0.InitList(lb,initlist,rb,ordered) ->
+ let initlist = add_init_comma initlist in
+ Ast0.rewrap i (Ast0.InitList(lb,initlist,rb,ordered))
+ | _ -> i
+
+let process p =
+ let fn =
+ V0.rebuilder
+ {V0.rebuilder_functions with
+ VT0.rebuilder_tyfn = base_typeC;
+ VT0.rebuilder_initfn = initialiser} in
+ List.map fn.VT0.rebuilder_rec_top_level p
--- /dev/null
+(*
+ * Copyright 2012, INRIA
+ * Julia Lawall, Gilles Muller
+ * Copyright 2010-2011, INRIA, University of Copenhagen
+ * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
+ * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
+ * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
+ * This file is part of Coccinelle.
+ *
+ * Coccinelle 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, according to version 2 of the License.
+ *
+ * Coccinelle 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 Coccinelle. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * The authors reserve the right to distribute this or future versions of
+ * Coccinelle under other licenses.
+ *)
+
+
+# 0 "./commas_on_lists.mli"
+val process : Ast0_cocci.rule -> Ast0_cocci.rule
let sem = normal_mcode sem in
let promoted_sem = promote_mcode sem in
mkres s (Ast0.ExprStatement(None,sem)) promoted_sem promoted_sem
- | Ast0.IfThen(iff,lp,exp,rp,branch,(_,aft)) ->
+ | Ast0.IfThen(iff,lp,exp,rp,branch,(_,aft,adj)) ->
let iff = normal_mcode iff in
let lp = normal_mcode lp in
let exp = expression exp in
let rp = normal_mcode rp in
let branch = statement branch in
let right = promote_to_statement branch aft in
- mkres s (Ast0.IfThen(iff,lp,exp,rp,branch,(Ast0.get_info right,aft)))
+ mkres s
+ (Ast0.IfThen(iff,lp,exp,rp,branch,(Ast0.get_info right,aft,adj)))
(promote_mcode iff) right
- | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(_,aft)) ->
+ | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(_,aft,adj)) ->
let iff = normal_mcode iff in
let lp = normal_mcode lp in
let exp = expression exp in
let right = promote_to_statement branch2 aft in
mkres s
(Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,
- (Ast0.get_info right,aft)))
+ (Ast0.get_info right,aft,adj)))
(promote_mcode iff) right
- | Ast0.While(wh,lp,exp,rp,body,(_,aft)) ->
+ | Ast0.While(wh,lp,exp,rp,body,(_,aft,adj)) ->
let wh = normal_mcode wh in
let lp = normal_mcode lp in
let exp = expression exp in
let rp = normal_mcode rp in
let body = statement body in
let right = promote_to_statement body aft in
- mkres s (Ast0.While(wh,lp,exp,rp,body,(Ast0.get_info right,aft)))
+ mkres s (Ast0.While(wh,lp,exp,rp,body,(Ast0.get_info right,aft,adj)))
(promote_mcode wh) right
| Ast0.Do(d,body,wh,lp,exp,rp,sem) ->
let d = normal_mcode d in
let rp = normal_mcode rp in
mkres s (Ast0.Do(d,body,wh,lp,exp,rp,sem))
(promote_mcode d) (promote_mcode sem)
- | Ast0.For(fr,lp,first,exp2,sem2,exp3,rp,body,(_,aft)) ->
+ | Ast0.For(fr,lp,first,exp2,sem2,exp3,rp,body,(_,aft,adj)) ->
let fr = normal_mcode fr in
let lp = normal_mcode lp in
let first =
let body = statement body in
let right = promote_to_statement body aft in
mkres s (Ast0.For(fr,lp,first,exp2,sem2,exp3,rp,body,
- (Ast0.get_info right,aft)))
+ (Ast0.get_info right,aft,adj)))
(promote_mcode fr) right
- | Ast0.Iterator(nm,lp,args,rp,body,(_,aft)) ->
+ | Ast0.Iterator(nm,lp,args,rp,body,(_,aft,adj)) ->
let nm = ident nm in
let lp = normal_mcode lp in
let args = dots is_exp_dots (Some(promote_mcode lp)) expression args in
let rp = normal_mcode rp in
let body = statement body in
let right = promote_to_statement body aft in
- mkres s (Ast0.Iterator(nm,lp,args,rp,body,(Ast0.get_info right,aft)))
+ mkres s
+ (Ast0.Iterator(nm,lp,args,rp,body,(Ast0.get_info right,aft,adj)))
nm right
| Ast0.Switch(switch,lp,exp,rp,lb,decls,cases,rb) ->
let switch = normal_mcode switch in
| Ast0.FunDecl((info,bef),_,_,_,_,_,_,_,_)
| Ast0.Decl((info,bef),_) ->
bind (nc_mcode ((),(),info,bef,(),-1)) (k s)
- | Ast0.IfThen(_,_,_,_,_,(info,aft))
- | Ast0.IfThenElse(_,_,_,_,_,_,_,(info,aft))
- | Ast0.Iterator(_,_,_,_,_,(info,aft))
- | Ast0.While(_,_,_,_,_,(info,aft))
- | Ast0.For(_,_,_,_,_,_,_,_,(info,aft)) ->
- bind (k s) (nc_mcode ((),(),info,aft,(),-1))
+ | Ast0.IfThen(_,_,_,_,_,(info,aft,adj))
+ | Ast0.IfThenElse(_,_,_,_,_,_,_,(info,aft,adj))
+ | Ast0.Iterator(_,_,_,_,_,(info,aft,adj))
+ | Ast0.While(_,_,_,_,_,(info,aft,adj))
+ | Ast0.For(_,_,_,_,_,_,_,_,(info,aft,adj)) ->
+ bind (k s) (nc_mcode ((),(),info,aft,(),adj))
| _ -> k s
) in
| Ast0.CONTEXT _ -> let (bef,aft) = extract_strings info in bef@aft
| _ -> [] in
- let info (i,_) = let (bef,aft) = extract_strings i in bef@aft in
+ let info (i,_,_) = let (bef,aft) = extract_strings i in bef@aft in
+ let pre_info (i,_) = let (bef,aft) = extract_strings i in bef@aft in
let do_nothing fn r k e =
match Ast0.get_mcodekind e with
| Ast0.Ty(ty) -> r.VT0.combiner_rec_typeC ty
| Ast0.TopInit(init) -> r.VT0.combiner_rec_initialiser init
| Ast0.Decl(bef,decl) ->
- (info bef) @ (do_nothing mk_statement r k e)
+ (pre_info bef) @ (do_nothing mk_statement r k e)
| Ast0.FunDecl(bef,fi,name,lp,params,rp,lbrace,body,rbrace) ->
- (info bef) @ (do_nothing mk_statement r k e)
+ (pre_info bef) @ (do_nothing mk_statement r k e)
| Ast0.IfThen(iff,lp,exp,rp,branch1,aft) ->
(do_nothing mk_statement r k e) @ (info aft)
| Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft) ->
Ast0.CONTEXT(mc) -> let (ba,_,_) = !mc in [ba]
| _ -> [] in
- let info (_,mc) =
+ let pre_info (_,mc) =
+ match mc with
+ Ast0.CONTEXT(mc) -> let (ba,_,_) = !mc in [ba]
+ | _ -> [] in
+
+ let info (_,mc,_) =
match mc with
Ast0.CONTEXT(mc) -> let (ba,_,_) = !mc in [ba]
| _ -> [] in
let stmt r k e =
match Ast0.unwrap e with
Ast0.Decl(bef,decl) ->
- (info bef) @ (donothing r k e)
+ (pre_info bef) @ (donothing r k e)
| Ast0.FunDecl(bef,fi,name,lp,params,rp,lbrace,body,rbrace) ->
- (info bef) @ (donothing r k e)
+ (pre_info bef) @ (donothing r k e)
| Ast0.IfThen(iff,lp,exp,rp,branch1,aft) ->
(donothing r k e) @ (info aft)
| Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft) ->
(* sort of unpleasant to convert the token representation to a string
but we can't make a list of mcodes otherwise because the types are all
different *)
- [(Common.dump (Ast0.unwrap_mcode x),Ast0.get_pos_ref x)] in
+ [(Dumper.dump (Ast0.unwrap_mcode x),Ast0.get_pos_ref x)] in
let donothing r k e = k e in
let bind x y = x @ y in
let option_default = [] in
(match Ast0.unwrap s with
Ast0.Decl((info,mc),decl) ->
Ast0.Decl((info,copy_mcodekind mc),decl)
- | Ast0.IfThen(iff,lp,tst,rp,branch,(info,mc)) ->
- Ast0.IfThen(iff,lp,tst,rp,branch,(info,copy_mcodekind mc))
- | Ast0.IfThenElse(iff,lp,tst,rp,branch1,els,branch2,(info,mc)) ->
+ | Ast0.IfThen(iff,lp,tst,rp,branch,(info,mc,adj)) ->
+ Ast0.IfThen(iff,lp,tst,rp,branch,(info,copy_mcodekind mc,adj))
+ | Ast0.IfThenElse(iff,lp,tst,rp,branch1,els,branch2,(info,mc,adj))->
Ast0.IfThenElse(iff,lp,tst,rp,branch1,els,branch2,
- (info,copy_mcodekind mc))
- | Ast0.While(whl,lp,exp,rp,body,(info,mc)) ->
- Ast0.While(whl,lp,exp,rp,body,(info,copy_mcodekind mc))
- | Ast0.For(fr,lp,first,e2,sem2,e3,rp,body,(info,mc)) ->
+ (info,copy_mcodekind mc,adj))
+ | Ast0.While(whl,lp,exp,rp,body,(info,mc,adj)) ->
+ Ast0.While(whl,lp,exp,rp,body,(info,copy_mcodekind mc,adj))
+ | Ast0.For(fr,lp,first,e2,sem2,e3,rp,body,(info,mc,adj)) ->
Ast0.For(fr,lp,first,e2,sem2,e3,rp,body,
- (info,copy_mcodekind mc))
- | Ast0.Iterator(nm,lp,args,rp,body,(info,mc)) ->
- Ast0.Iterator(nm,lp,args,rp,body,(info,copy_mcodekind mc))
+ (info,copy_mcodekind mc,adj))
+ | Ast0.Iterator(nm,lp,args,rp,body,(info,mc,adj)) ->
+ Ast0.Iterator(nm,lp,args,rp,body,(info,copy_mcodekind mc,adj))
| Ast0.FunDecl
((info,mc),fninfo,name,lp,params,rp,lbrace,body,rbrace) ->
Ast0.FunDecl
| Ast0.Decl((info,bef1),_) ->
merge_plus bef bef1
| _ -> merge_plus bef (Ast0.get_mcodekind e))
- | Ast0.IfThen(_,_,_,_,_,(info,aft))
- | Ast0.IfThenElse(_,_,_,_,_,_,_,(info,aft))
- | Ast0.While(_,_,_,_,_,(info,aft))
- | Ast0.For(_,_,_,_,_,_,_,_,(info,aft))
- | Ast0.Iterator(_,_,_,_,_,(info,aft)) ->
+ | Ast0.IfThen(_,_,_,_,_,(_,aft,_))
+ | Ast0.IfThenElse(_,_,_,_,_,_,_,(_,aft,_))
+ | Ast0.While(_,_,_,_,_,(_,aft,_))
+ | Ast0.For(_,_,_,_,_,_,_,_,(_,aft,_))
+ | Ast0.Iterator(_,_,_,_,_,(_,aft,_)) ->
(match Ast0.unwrap e with
- Ast0.IfThen(_,_,_,_,_,(info,aft1))
- | Ast0.IfThenElse(_,_,_,_,_,_,_,(info,aft1))
- | Ast0.While(_,_,_,_,_,(info,aft1))
- | Ast0.For(_,_,_,_,_,_,_,_,(info,aft1))
- | Ast0.Iterator(_,_,_,_,_,(info,aft1)) ->
+ Ast0.IfThen(_,_,_,_,_,(_,aft1,_))
+ | Ast0.IfThenElse(_,_,_,_,_,_,_,(_,aft1,_))
+ | Ast0.While(_,_,_,_,_,(_,aft1,_))
+ | Ast0.For(_,_,_,_,_,_,_,_,(_,aft1,_))
+ | Ast0.Iterator(_,_,_,_,_,(_,aft1,_)) ->
merge_plus aft aft1
| _ -> merge_plus aft (Ast0.get_mcodekind e))
| _ -> ()));
# 487 "lexer_cocci.ml"
let __ocaml_lex_tables = {
Lexing.lex_base =
- "\000\000\175\255\176\255\081\000\119\000\181\255\182\255\192\000\
- \219\000\206\255\078\000\035\000\090\000\220\255\080\000\081\000\
- \224\255\225\255\228\255\229\255\230\255\231\255\233\255\082\000\
- \105\000\237\255\239\255\101\000\102\000\140\000\162\000\033\001\
- \108\001\095\000\097\000\084\000\183\001\138\000\255\255\041\002\
- \102\000\167\000\186\255\213\255\026\002\101\002\176\002\251\002\
- \070\003\145\003\220\003\039\004\114\004\189\004\008\005\122\005\
- \112\000\152\000\168\000\242\000\243\000\251\255\177\255\205\255\
- \249\255\204\255\248\255\197\005\016\006\091\006\166\006\241\006\
- \084\005\107\000\117\000\092\000\244\255\242\255\012\002\094\005\
- \060\007\093\000\117\000\135\000\141\000\144\000\245\255\145\000\
- \147\000\243\255\208\255\178\255\216\255\149\000\227\255\245\000\
- \215\255\153\000\019\001\232\255\234\255\236\255\198\255\210\255\
- \214\255\212\255\199\255\211\255\209\255\203\255\136\000\207\255\
- \097\000\089\000\116\000\123\000\104\000\112\000\109\007\193\255\
- \131\000\131\000\132\000\060\001\162\007\237\007\133\000\132\000\
- \128\000\149\000\061\001\095\008\178\008\190\255\039\007\153\000\
- \145\000\169\000\188\000\214\000\110\007\055\002\090\001\165\001\
- \189\255\056\002\188\255\056\001\155\005\110\007\154\005\084\001\
- \111\007\113\007\085\001\202\000\217\000\213\000\219\000\222\000\
- \086\001\087\001\224\000\228\000\119\001\221\000\219\000\159\001\
- \237\000\232\000\238\000\028\001\160\001\016\001\026\001\161\001\
- \046\007\096\001\253\008\124\007\147\007\085\008\024\009\066\008\
- \095\008\094\009\168\001\179\255\234\001\255\255\034\009\252\255\
- \164\009\107\007\134\007\254\255\187\009\253\255\235\001\254\255\
- \053\009\255\255\251\255\226\009\062\009\085\009\253\255\249\009\
- \252\255\042\007\254\255\025\010\255\255\251\255\049\010\132\009\
- \155\009\253\255\072\010\252\255\163\004\252\255\253\255\254\255\
- \119\001\255\255";
+ "\000\000\170\255\171\255\081\000\119\000\176\255\177\255\192\000\
+ \023\001\052\001\038\000\078\000\067\000\103\000\220\255\081\000\
+ \082\000\224\255\225\255\228\255\229\255\230\255\231\255\233\255\
+ \084\000\106\000\237\255\239\255\101\000\116\000\140\000\122\001\
+ \144\001\231\001\087\000\090\000\085\000\062\002\138\000\255\255\
+ \176\002\106\000\146\000\186\255\213\255\096\000\159\002\246\002\
+ \077\003\164\003\251\003\082\004\169\004\000\005\087\005\174\005\
+ \005\006\092\006\206\006\115\000\170\000\117\000\119\000\149\000\
+ \037\007\101\000\124\007\211\007\013\008\100\008\158\008\105\000\
+ \055\000\245\008\126\000\129\000\076\009\163\009\133\000\250\009\
+ \081\010\139\010\226\010\251\255\172\255\205\255\249\255\204\255\
+ \248\255\057\011\144\011\231\011\062\012\149\012\134\001\146\000\
+ \150\000\132\000\244\255\242\255\148\002\220\001\051\002\134\000\
+ \136\000\157\000\159\000\160\000\245\255\163\000\165\000\243\255\
+ \208\255\173\255\216\255\169\000\227\255\205\000\215\255\174\000\
+ \208\000\232\255\234\255\236\255\198\255\210\255\214\255\212\255\
+ \199\255\211\255\209\255\203\255\158\000\207\255\207\012\038\013\
+ \163\000\096\013\183\013\164\000\014\014\101\014\159\014\246\014\
+ \118\000\110\000\121\000\123\000\125\000\122\000\122\006\193\255\
+ \134\000\136\000\136\000\053\001\104\015\179\015\149\000\148\000\
+ \144\000\154\000\054\001\037\016\120\016\190\255\017\015\184\000\
+ \176\000\168\000\186\000\187\000\209\006\216\001\034\001\036\001\
+ \189\255\225\002\188\255\153\001\114\002\116\002\203\002\155\001\
+ \208\002\205\002\156\001\202\000\220\000\043\001\219\000\221\000\
+ \027\002\028\002\218\000\223\000\115\002\227\000\000\001\201\002\
+ \018\001\013\001\038\001\053\001\202\002\041\001\053\001\209\002\
+ \038\015\130\001\195\016\241\003\119\007\068\009\222\016\071\004\
+ \158\004\036\017\219\001\174\255\067\001\255\255\080\015\252\255\
+ \106\017\069\003\245\004\254\255\129\017\253\255\228\005\254\255\
+ \010\016\255\255\251\255\167\017\076\005\163\005\253\255\190\017\
+ \252\255\231\005\254\255\043\016\255\255\251\255\228\017\250\005\
+ \084\006\253\255\251\017\252\255\046\004\252\255\253\255\254\255\
+ \108\001\255\255";
Lexing.lex_backtrk =
- "\255\255\255\255\255\255\076\000\076\000\255\255\255\255\072\000\
- \080\000\255\255\055\000\061\000\060\000\255\255\034\000\032\000\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\020\000\
- \080\000\255\255\255\255\015\000\014\000\054\000\029\000\072\000\
- \072\000\017\000\038\000\005\000\072\000\033\000\255\255\001\000\
- \255\255\002\000\255\255\255\255\072\000\072\000\072\000\072\000\
+ "\255\255\255\255\255\255\081\000\081\000\255\255\255\255\073\000\
+ \072\000\085\000\049\000\055\000\061\000\060\000\255\255\034\000\
+ \032\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \020\000\085\000\255\255\255\255\015\000\014\000\054\000\029\000\
+ \072\000\072\000\017\000\038\000\005\000\072\000\033\000\255\255\
+ \001\000\255\255\002\000\255\255\255\255\255\255\255\255\072\000\
\072\000\072\000\072\000\072\000\072\000\072\000\072\000\072\000\
- \255\255\255\255\255\255\255\255\003\000\255\255\255\255\255\255\
- \255\255\255\255\255\255\072\000\072\000\008\000\072\000\072\000\
- \075\000\255\255\009\000\255\255\255\255\255\255\255\255\075\000\
- \255\255\053\000\059\000\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\037\000\255\255\070\000\
- \255\255\036\000\071\000\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\058\000\255\255\
+ \072\000\072\000\072\000\255\255\255\255\255\255\255\255\003\000\
+ \255\255\075\000\255\255\076\000\255\255\074\000\255\255\255\255\
+ \255\255\255\255\074\000\255\255\255\255\255\255\076\000\255\255\
+ \076\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\072\000\072\000\008\000\072\000\072\000\080\000\255\255\
+ \009\000\255\255\255\255\255\255\255\255\080\000\255\255\053\000\
+ \059\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\037\000\255\255\070\000\255\255\036\000\
+ \071\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\058\000\255\255\255\255\077\000\
+ \255\255\255\255\255\255\077\000\255\255\077\000\255\255\255\255\
\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\255\255\255\255\255\255\255\255\255\255\063\000\255\255\255\255\
\255\255\255\255\255\255\255\255\064\000\255\255\068\000\255\255\
\068\000\068\000\068\000\255\255\255\255\255\255\255\255\255\255\
\068\000\068\000\255\255\255\255\068\000\255\255\255\255\068\000\
\255\255\255\255\255\255\255\255\068\000\255\255\255\255\068\000\
- \076\000\076\000\255\255\075\000\255\255\255\255\076\000\075\000\
- \255\255\076\000\076\000\255\255\255\255\255\255\000\000\255\255\
+ \081\000\081\000\255\255\080\000\255\255\255\255\081\000\080\000\
+ \255\255\081\000\081\000\255\255\255\255\255\255\000\000\255\255\
\003\000\001\000\001\000\255\255\002\000\255\255\255\255\255\255\
\001\000\255\255\255\255\004\000\002\000\002\000\255\255\003\000\
\255\255\255\255\255\255\001\000\255\255\255\255\004\000\002\000\
\004\000\255\255";
Lexing.lex_default =
"\001\000\000\000\000\000\255\255\255\255\000\000\000\000\255\255\
- \255\255\000\000\255\255\255\255\255\255\000\000\255\255\255\255\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\255\255\
- \255\255\000\000\000\000\255\255\255\255\255\255\255\255\255\255\
\255\255\255\255\255\255\255\255\255\255\255\255\000\000\255\255\
- \255\255\041\000\000\000\000\000\255\255\255\255\255\255\255\255\
+ \255\255\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \255\255\255\255\000\000\000\000\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\000\000\
+ \255\255\255\255\042\000\000\000\000\000\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\061\000\061\000\061\000\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\000\000\000\000\000\000\000\000\000\000\
+ \000\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\000\000\000\000\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\000\000\255\255\255\255\000\000\
+ \000\000\000\000\000\000\255\255\000\000\117\000\000\000\255\255\
+ \120\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\255\255\000\000\255\255\255\255\
\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\058\000\058\000\058\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\000\000\000\000\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\000\000\255\255\
- \255\255\000\000\000\000\000\000\000\000\255\255\000\000\095\000\
- \000\000\255\255\098\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\255\255\000\000\
\255\255\255\255\255\255\255\255\255\255\255\255\255\255\000\000\
\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\000\000\147\000\255\255\
- \255\255\255\255\255\255\255\255\255\255\145\000\143\000\143\000\
- \000\000\145\000\000\000\147\000\147\000\147\000\147\000\151\000\
- \147\000\147\000\154\000\255\255\255\255\255\255\255\255\255\255\
- \160\000\161\000\255\255\255\255\164\000\255\255\255\255\167\000\
- \255\255\255\255\255\255\255\255\172\000\255\255\255\255\175\000\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\000\000\189\000\000\000\191\000\000\000\
- \255\255\255\255\255\255\000\000\255\255\000\000\199\000\000\000\
- \202\000\000\000\000\000\255\255\255\255\255\255\000\000\255\255\
- \000\000\210\000\000\000\213\000\000\000\000\000\255\255\255\255\
- \255\255\000\000\255\255\000\000\221\000\000\000\000\000\000\000\
+ \255\255\255\255\255\255\255\255\255\255\000\000\179\000\255\255\
+ \255\255\255\255\255\255\255\255\255\255\177\000\175\000\175\000\
+ \000\000\177\000\000\000\179\000\179\000\179\000\179\000\183\000\
+ \179\000\179\000\186\000\255\255\255\255\255\255\255\255\255\255\
+ \192\000\193\000\255\255\255\255\196\000\255\255\255\255\199\000\
+ \255\255\255\255\255\255\255\255\204\000\255\255\255\255\207\000\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\000\000\221\000\000\000\223\000\000\000\
+ \255\255\255\255\255\255\000\000\255\255\000\000\231\000\000\000\
+ \234\000\000\000\000\000\255\255\255\255\255\255\000\000\255\255\
+ \000\000\242\000\000\000\245\000\000\000\000\000\255\255\255\255\
+ \255\255\000\000\255\255\000\000\253\000\000\000\000\000\000\000\
\255\255\000\000";
Lexing.lex_trans =
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\039\000\038\000\038\000\038\000\038\000\000\000\000\000\
+ \000\000\040\000\039\000\039\000\039\000\039\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \039\000\033\000\005\000\008\000\000\000\014\000\012\000\006\000\
- \025\000\022\000\015\000\027\000\017\000\028\000\030\000\037\000\
+ \040\000\034\000\005\000\009\000\007\000\015\000\013\000\006\000\
+ \026\000\023\000\016\000\028\000\018\000\029\000\031\000\038\000\
\004\000\003\000\003\000\003\000\003\000\003\000\003\000\003\000\
- \003\000\003\000\009\000\016\000\029\000\034\000\010\000\026\000\
- \035\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\032\000\
- \007\000\007\000\007\000\021\000\024\000\020\000\011\000\036\000\
- \108\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\031\000\
- \007\000\007\000\007\000\019\000\023\000\018\000\013\000\179\000\
- \106\000\003\000\003\000\003\000\003\000\003\000\003\000\003\000\
- \003\000\003\000\003\000\109\000\110\000\105\000\104\000\103\000\
- \097\000\101\000\099\000\093\000\061\000\041\000\180\000\107\000\
- \058\000\074\000\077\000\091\000\065\000\176\000\063\000\062\000\
- \075\000\057\000\096\000\092\000\094\000\179\000\177\000\182\000\
- \182\000\182\000\182\000\182\000\182\000\182\000\182\000\181\000\
- \181\000\255\255\090\000\076\000\042\000\087\000\180\000\083\000\
- \057\000\041\000\084\000\085\000\180\000\176\000\086\000\088\000\
- \056\000\089\000\095\000\176\000\098\000\111\000\177\000\043\000\
- \082\000\081\000\173\000\168\000\177\000\126\000\102\000\178\000\
- \073\000\059\000\072\000\072\000\072\000\072\000\072\000\072\000\
- \072\000\072\000\072\000\072\000\180\000\066\000\120\000\064\000\
- \157\000\134\000\156\000\176\000\118\000\100\000\155\000\121\000\
- \122\000\135\000\123\000\127\000\177\000\128\000\129\000\178\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\130\000\118\000\136\000\137\000\119\000\255\255\
+ \003\000\003\000\010\000\017\000\030\000\035\000\011\000\027\000\
+ \036\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\033\000\
+ \008\000\008\000\008\000\022\000\025\000\021\000\012\000\037\000\
+ \134\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\032\000\
+ \008\000\008\000\008\000\020\000\024\000\019\000\014\000\211\000\
+ \130\000\003\000\003\000\003\000\003\000\003\000\003\000\003\000\
+ \003\000\003\000\003\000\131\000\132\000\128\000\127\000\126\000\
+ \119\000\125\000\123\000\121\000\087\000\083\000\212\000\085\000\
+ \084\000\042\000\066\000\061\000\255\255\208\000\062\000\045\000\
+ \063\000\115\000\118\000\072\000\129\000\211\000\209\000\214\000\
+ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\213\000\
+ \213\000\114\000\116\000\060\000\043\000\068\000\212\000\105\000\
+ \071\000\042\000\106\000\079\000\212\000\208\000\063\000\075\000\
+ \096\000\097\000\099\000\208\000\113\000\112\000\209\000\044\000\
+ \104\000\103\000\060\000\109\000\209\000\107\000\108\000\210\000\
+ \124\000\110\000\059\000\111\000\098\000\088\000\117\000\255\255\
+ \086\000\120\000\255\255\133\000\212\000\140\000\136\000\205\000\
+ \200\000\166\000\158\000\208\000\007\000\189\000\122\000\188\000\
+ \152\000\167\000\153\000\187\000\209\000\154\000\155\000\210\000\
+ \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
+ \007\000\007\000\045\000\159\000\046\000\160\000\161\000\162\000\
\002\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
\007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
\007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\060\000\060\000\255\255\138\000\007\000\
- \139\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\140\000\165\000\162\000\158\000\116\000\
- \114\000\161\000\255\255\160\000\115\000\124\000\131\000\112\000\
- \159\000\163\000\164\000\113\000\166\000\167\000\169\000\170\000\
- \117\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\171\000\124\000\131\000\255\255\255\255\
- \255\255\255\255\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\255\255\172\000\174\000\175\000\
- \007\000\255\255\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\070\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\225\000\255\255\
- \255\255\255\255\255\255\255\255\186\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\067\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\144\000\
- \000\000\000\000\000\000\007\000\186\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\000\000\255\255\255\255\187\000\255\255\000\000\000\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\201\000\255\255\187\000\000\000\044\000\000\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\039\000\038\000\038\000\038\000\038\000\080\000\
- \255\255\080\000\000\000\000\000\079\000\079\000\079\000\079\000\
- \079\000\079\000\079\000\079\000\079\000\079\000\190\000\200\000\
- \000\000\039\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\255\255\255\255\255\255\255\255\
- \040\000\000\000\255\255\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\255\255\146\000\255\255\
- \000\000\007\000\000\000\045\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\255\255\
- \255\255\255\255\000\000\000\000\000\000\255\255\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \000\000\000\000\000\000\000\000\007\000\000\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\046\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\255\255\255\255\000\000\000\000\000\000\000\000\
- \000\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\000\000\000\000\000\000\000\000\007\000\
- \000\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\047\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\000\000\000\000\255\255\
- \255\255\000\000\000\000\000\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\000\000\000\000\
- \000\000\000\000\007\000\000\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\048\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\000\000\000\000\000\000\000\000\007\000\000\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\049\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\000\000\000\000\000\000\000\000\
- \007\000\000\000\007\000\050\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\000\000\
- \000\000\000\000\000\000\007\000\000\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\051\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\000\000\000\000\000\000\000\000\007\000\000\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\052\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\000\000\223\000\223\000\223\000\
- \223\000\000\000\000\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\224\000\222\000\000\000\
- \000\000\007\000\000\000\007\000\007\000\007\000\007\000\053\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \000\000\000\000\000\000\000\000\054\000\000\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\000\000\000\000\000\000\000\000\055\000\
- \000\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\057\000\072\000\072\000\072\000\072\000\
- \072\000\072\000\072\000\072\000\072\000\072\000\079\000\079\000\
- \079\000\079\000\079\000\079\000\079\000\079\000\079\000\079\000\
- \000\000\078\000\057\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\056\000\255\255\255\255\255\255\000\000\000\000\
- \000\000\000\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\000\000\000\000\000\000\000\000\
- \000\000\078\000\000\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\000\000\000\000\000\000\
- \000\000\007\000\000\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\152\000\
- \151\000\000\000\000\000\000\000\000\000\000\000\007\000\007\000\
- \007\000\007\000\068\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \000\000\000\000\000\000\000\000\007\000\000\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\069\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\000\000\000\000\000\000\000\000\007\000\
- \000\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\000\000\000\000\000\000\
- \000\000\000\000\255\255\255\255\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\000\000\000\000\
- \000\000\000\000\007\000\000\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\000\000\000\000\000\000\000\000\007\000\000\000\007\000\
- \007\000\007\000\007\000\071\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\255\255\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\212\000\000\000\000\000\000\000\
- \007\000\000\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\069\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\079\000\079\000\079\000\079\000\
- \079\000\079\000\079\000\079\000\079\000\079\000\118\000\140\000\
- \255\255\255\255\187\000\255\255\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\187\000\000\000\000\000\211\000\000\000\
- \000\000\000\000\000\000\149\000\000\000\118\000\140\000\000\000\
- \142\000\000\000\000\000\000\000\000\000\148\000\000\000\000\000\
- \000\000\000\000\187\000\194\000\194\000\194\000\194\000\194\000\
- \194\000\194\000\194\000\187\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\141\000\124\000\179\000\179\000\179\000\179\000\
- \179\000\179\000\179\000\179\000\179\000\179\000\195\000\195\000\
- \195\000\195\000\195\000\195\000\195\000\195\000\184\000\000\000\
- \184\000\078\000\124\000\183\000\183\000\183\000\183\000\183\000\
- \183\000\183\000\183\000\183\000\183\000\000\000\000\000\000\000\
- \000\000\116\000\114\000\150\000\153\000\000\000\115\000\154\000\
- \000\000\112\000\000\000\000\000\000\000\113\000\000\000\000\000\
- \000\000\078\000\117\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\000\000\000\000\000\000\
- \000\000\125\000\000\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\255\255\
- \000\000\000\000\255\255\000\000\000\000\000\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \000\000\000\000\000\000\000\000\125\000\000\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \131\000\000\000\000\000\000\000\000\000\000\000\255\255\255\255\
- \000\000\255\255\183\000\183\000\183\000\183\000\183\000\183\000\
- \183\000\183\000\183\000\183\000\000\000\000\000\000\000\131\000\
- \000\000\000\000\000\000\179\000\000\000\181\000\181\000\181\000\
- \181\000\181\000\181\000\181\000\181\000\181\000\181\000\183\000\
- \183\000\183\000\183\000\183\000\183\000\183\000\183\000\183\000\
- \183\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\180\000\000\000\000\000\000\000\132\000\000\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\133\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\000\000\000\000\000\000\
- \000\000\132\000\000\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\185\000\185\000\185\000\
- \185\000\185\000\185\000\185\000\185\000\185\000\185\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\185\000\185\000\
- \185\000\185\000\185\000\185\000\000\000\000\000\179\000\000\000\
- \182\000\182\000\182\000\182\000\182\000\182\000\182\000\182\000\
- \181\000\181\000\193\000\193\000\193\000\193\000\193\000\193\000\
- \193\000\193\000\000\000\000\000\000\000\180\000\185\000\185\000\
- \185\000\185\000\185\000\185\000\176\000\204\000\204\000\204\000\
- \204\000\204\000\204\000\204\000\204\000\177\000\205\000\205\000\
- \205\000\205\000\205\000\205\000\205\000\205\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\180\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\176\000\206\000\206\000\206\000\
- \206\000\206\000\206\000\206\000\206\000\177\000\185\000\185\000\
- \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\
- \000\000\000\000\192\000\000\000\000\000\000\000\000\000\185\000\
- \185\000\185\000\185\000\185\000\185\000\000\000\000\000\000\000\
- \000\000\000\000\176\000\000\000\000\000\203\000\000\000\000\000\
- \000\000\000\000\000\000\177\000\216\000\216\000\216\000\216\000\
- \216\000\216\000\216\000\216\000\000\000\000\000\000\000\185\000\
- \185\000\185\000\185\000\185\000\185\000\000\000\000\000\000\000\
- \000\000\000\000\176\000\217\000\217\000\217\000\217\000\217\000\
- \217\000\217\000\217\000\177\000\196\000\196\000\196\000\196\000\
- \196\000\196\000\196\000\196\000\196\000\196\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\196\000\196\000\196\000\
- \196\000\196\000\196\000\197\000\197\000\197\000\197\000\197\000\
- \197\000\197\000\197\000\197\000\197\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\197\000\197\000\197\000\197\000\
- \197\000\197\000\000\000\000\000\000\000\196\000\196\000\196\000\
- \196\000\196\000\196\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\207\000\207\000\207\000\207\000\207\000\207\000\
- \207\000\207\000\207\000\207\000\197\000\197\000\197\000\197\000\
- \197\000\197\000\255\255\207\000\207\000\207\000\207\000\207\000\
- \207\000\208\000\208\000\208\000\208\000\208\000\208\000\208\000\
- \208\000\208\000\208\000\000\000\000\000\255\255\000\000\000\000\
- \000\000\000\000\208\000\208\000\208\000\208\000\208\000\208\000\
- \000\000\000\000\000\000\207\000\207\000\207\000\207\000\207\000\
- \207\000\215\000\215\000\215\000\215\000\215\000\215\000\215\000\
+ \007\000\007\000\007\000\168\000\169\000\170\000\171\000\007\000\
+ \172\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
+ \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
+ \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
+ \007\000\007\000\007\000\007\000\197\000\150\000\156\000\163\000\
+ \194\000\193\000\192\000\195\000\255\255\196\000\176\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\045\000\198\000\046\000\150\000\156\000\163\000\151\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\199\000\201\000\202\000\255\255\008\000\255\255\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\255\255\203\000\190\000\255\255\204\000\206\000\
+ \148\000\146\000\207\000\001\001\000\000\147\000\191\000\222\000\
+ \144\000\000\000\000\000\255\255\145\000\255\255\255\255\000\000\
+ \095\000\149\000\094\000\094\000\094\000\094\000\094\000\094\000\
+ \094\000\094\000\094\000\094\000\007\000\000\000\094\000\094\000\
+ \094\000\094\000\094\000\094\000\094\000\094\000\094\000\094\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\045\000\100\000\046\000\255\255\218\000\000\000\
+ \255\255\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\100\000\000\000\000\000\218\000\008\000\
+ \000\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \092\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\007\000\101\000\101\000\101\000\101\000\
+ \101\000\101\000\101\000\101\000\101\000\101\000\255\255\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\045\000\255\255\046\000\255\255\255\255\255\255\219\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\089\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\000\000\255\255\000\000\000\000\008\000\219\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\007\000\101\000\101\000\101\000\101\000\101\000\
+ \101\000\101\000\101\000\101\000\101\000\000\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \045\000\000\000\046\000\000\000\255\255\255\255\255\255\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\255\255\000\000\255\255\255\255\047\000\000\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\040\000\039\000\039\000\039\000\039\000\000\000\102\000\
+ \000\000\102\000\000\000\064\000\101\000\101\000\101\000\101\000\
+ \101\000\101\000\101\000\101\000\101\000\101\000\000\000\000\000\
+ \040\000\000\000\000\000\255\255\255\255\255\255\184\000\255\255\
+ \255\255\182\000\255\255\255\255\000\000\000\000\000\000\041\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\000\000\000\000\000\000\000\000\064\000\000\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\007\000\255\255\255\255\064\000\000\000\178\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \045\000\183\000\046\000\186\000\000\000\185\000\000\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\000\000\000\000\000\000\000\000\008\000\000\000\048\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\007\000\255\255\255\255\255\255\226\000\226\000\226\000\
+ \226\000\226\000\226\000\226\000\226\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\045\000\
+ \000\000\046\000\000\000\000\000\000\000\000\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \000\000\000\000\000\000\000\000\008\000\000\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\049\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \007\000\255\255\255\255\255\255\000\000\255\255\000\000\000\000\
+ \255\255\255\255\000\000\000\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\045\000\000\000\
+ \046\000\255\255\000\000\000\000\000\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\000\000\
+ \000\000\000\000\000\000\008\000\000\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \050\000\008\000\008\000\008\000\008\000\008\000\008\000\007\000\
+ \000\000\211\000\211\000\211\000\211\000\211\000\211\000\211\000\
+ \211\000\211\000\211\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\045\000\100\000\046\000\
+ \255\000\255\000\255\000\255\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\100\000\000\000\
+ \000\001\254\000\008\000\000\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\051\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\007\000\215\000\
+ \215\000\215\000\215\000\215\000\215\000\215\000\215\000\215\000\
+ \215\000\000\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\045\000\000\000\046\000\000\000\
+ \000\000\000\000\000\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\000\000\000\000\000\000\
+ \000\000\008\000\000\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\052\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\007\000\215\000\215\000\
+ \215\000\215\000\215\000\215\000\215\000\215\000\215\000\215\000\
+ \000\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\045\000\000\000\046\000\000\000\000\000\
+ \000\000\000\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\000\000\000\000\000\000\000\000\
+ \008\000\000\000\008\000\053\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\007\000\227\000\227\000\227\000\
+ \227\000\227\000\227\000\227\000\227\000\000\000\255\255\000\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\045\000\000\000\046\000\000\000\000\000\000\000\
+ \000\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\000\000\000\000\000\000\000\000\008\000\
+ \000\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\054\000\008\000\008\000\
+ \008\000\008\000\008\000\007\000\237\000\237\000\237\000\237\000\
+ \237\000\237\000\237\000\237\000\000\000\000\000\000\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\045\000\000\000\046\000\000\000\000\000\000\000\000\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\000\000\000\000\000\000\000\000\008\000\000\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\055\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\007\000\238\000\238\000\238\000\238\000\238\000\
+ \238\000\238\000\238\000\000\000\000\000\000\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \045\000\000\000\046\000\000\000\000\000\000\000\000\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\244\000\000\000\233\000\000\000\008\000\000\000\008\000\
+ \008\000\008\000\008\000\056\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\007\000\248\000\248\000\248\000\248\000\248\000\248\000\
+ \248\000\248\000\000\000\000\000\000\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\045\000\
+ \232\000\046\000\000\000\243\000\000\000\000\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \000\000\000\000\000\000\000\000\057\000\000\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \007\000\000\000\000\000\150\000\249\000\249\000\249\000\249\000\
+ \249\000\249\000\249\000\249\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\045\000\000\000\
+ \046\000\000\000\150\000\000\000\000\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\000\000\
+ \000\000\000\000\000\000\058\000\000\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\060\000\
+ \000\000\000\000\172\000\000\000\000\000\000\000\148\000\146\000\
+ \000\000\000\000\000\000\147\000\255\255\000\000\144\000\255\255\
+ \000\000\000\000\145\000\000\000\000\000\000\000\060\000\149\000\
+ \000\000\172\000\007\000\174\000\000\000\000\000\059\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \045\000\000\000\046\000\000\000\000\000\173\000\000\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\000\000\000\000\000\000\000\000\008\000\000\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\064\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\000\000\
+ \000\000\000\000\000\000\065\000\000\000\000\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \000\000\000\000\000\000\000\000\064\000\000\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \067\000\000\000\216\000\064\000\216\000\000\000\000\000\215\000\
+ \215\000\215\000\215\000\215\000\215\000\215\000\215\000\215\000\
\215\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\208\000\208\000\208\000\208\000\208\000\208\000\
- \000\000\218\000\218\000\218\000\218\000\218\000\218\000\218\000\
- \218\000\218\000\218\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\218\000\218\000\218\000\218\000\218\000\218\000\
- \219\000\219\000\219\000\219\000\219\000\219\000\219\000\219\000\
- \219\000\219\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\219\000\219\000\219\000\219\000\219\000\219\000\000\000\
- \000\000\214\000\218\000\218\000\218\000\218\000\218\000\218\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\219\000\219\000\219\000\219\000\219\000\219\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\255\255\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000";
+ \000\000\000\000\000\000\000\000\000\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\067\000\000\000\
+ \000\000\000\000\000\000\067\000\000\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \000\000\000\000\068\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\075\000\000\000\076\000\
+ \000\000\000\000\000\000\000\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\000\000\000\000\
+ \000\000\069\000\067\000\000\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
+ \000\000\000\000\000\000\000\000\069\000\000\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
+ \069\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\069\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\071\000\000\000\
+ \070\000\000\000\000\000\000\000\000\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\000\000\
+ \000\000\000\000\073\000\069\000\000\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\000\000\000\000\000\000\000\000\073\000\000\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\000\000\000\000\073\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\000\000\
+ \000\000\000\000\000\000\074\000\000\000\000\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \000\000\000\000\000\000\000\000\073\000\000\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \077\000\000\000\211\000\073\000\213\000\213\000\213\000\213\000\
+ \213\000\213\000\213\000\213\000\213\000\213\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\212\000\000\000\000\000\000\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\000\000\
+ \000\000\212\000\000\000\077\000\000\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \000\000\000\000\077\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\000\000\000\000\000\000\
+ \000\000\078\000\000\000\000\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\000\000\000\000\
+ \000\000\000\000\077\000\000\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\080\000\000\000\
+ \000\000\077\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\000\000\000\000\000\000\
+ \000\000\080\000\000\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\075\000\000\000\081\000\000\000\000\000\
+ \000\000\000\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\000\000\000\000\000\000\082\000\
+ \080\000\000\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\000\000\000\000\
+ \000\000\000\000\082\000\000\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\000\000\
+ \000\000\082\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\000\000\000\000\000\000\000\000\
+ \078\000\000\000\000\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\000\000\000\000\000\000\
+ \000\000\082\000\000\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\007\000\000\000\000\000\
+ \082\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\045\000\000\000\046\000\000\000\000\000\
+ \000\000\000\000\008\000\008\000\008\000\008\000\090\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\000\000\000\000\000\000\000\000\
+ \008\000\000\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\007\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\045\000\000\000\046\000\000\000\000\000\000\000\
+ \000\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\091\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\000\000\000\000\000\000\000\000\008\000\
+ \000\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\007\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\045\000\000\000\046\000\000\000\000\000\000\000\000\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\000\000\000\000\000\000\000\000\008\000\000\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\007\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \045\000\000\000\046\000\000\000\000\000\000\000\000\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\000\000\000\000\000\000\000\000\008\000\000\000\008\000\
+ \008\000\008\000\008\000\093\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\007\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\045\000\
+ \000\000\046\000\000\000\000\000\000\000\000\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \000\000\000\000\000\000\135\000\008\000\000\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\091\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\000\000\000\000\000\000\000\000\135\000\000\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \136\000\000\000\137\000\000\000\000\000\000\000\000\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\000\000\000\000\000\000\138\000\135\000\000\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\000\000\000\000\000\000\000\000\138\000\
+ \000\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\000\000\000\000\138\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\000\000\000\000\000\000\000\000\139\000\000\000\000\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\000\000\000\000\000\000\000\000\138\000\000\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\141\000\000\000\000\000\138\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\000\000\000\000\000\000\000\000\141\000\000\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\136\000\
+ \000\000\142\000\000\000\000\000\000\000\000\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \000\000\000\000\000\000\143\000\141\000\000\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\000\000\000\000\000\000\000\000\143\000\000\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\255\255\000\000\143\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \000\000\000\000\000\000\000\000\139\000\000\000\000\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\000\000\000\000\000\000\000\000\143\000\000\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\156\000\219\000\000\000\143\000\181\000\000\000\000\000\
+ \000\000\000\000\000\000\219\000\000\000\000\000\000\000\180\000\
+ \225\000\225\000\225\000\225\000\225\000\225\000\225\000\225\000\
+ \156\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\219\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\219\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\000\000\000\000\000\000\000\000\157\000\
+ \224\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\000\000\000\000\
+ \000\000\255\255\157\000\000\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\163\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\236\000\236\000\236\000\236\000\236\000\236\000\
+ \236\000\236\000\000\000\000\000\000\000\163\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \255\255\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\247\000\247\000\247\000\247\000\247\000\
+ \247\000\247\000\247\000\000\000\000\000\000\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \000\000\000\000\235\000\000\000\164\000\000\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \165\000\000\000\000\000\246\000\000\000\000\000\000\000\000\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\000\000\000\000\000\000\000\000\164\000\
+ \000\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\217\000\217\000\217\000\217\000\217\000\
+ \217\000\217\000\217\000\217\000\217\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\217\000\217\000\217\000\217\000\
+ \217\000\217\000\255\255\000\000\211\000\000\000\214\000\214\000\
+ \214\000\214\000\214\000\214\000\214\000\214\000\213\000\213\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\212\000\217\000\217\000\217\000\217\000\
+ \217\000\217\000\208\000\255\255\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\209\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\212\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\208\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\209\000\217\000\217\000\217\000\217\000\
+ \217\000\217\000\217\000\217\000\217\000\217\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\217\000\217\000\217\000\
+ \217\000\217\000\217\000\000\000\000\000\000\000\000\000\000\000\
+ \208\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\209\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\217\000\217\000\217\000\
+ \217\000\217\000\217\000\000\000\000\000\000\000\000\000\000\000\
+ \208\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\209\000\228\000\228\000\228\000\228\000\228\000\228\000\
+ \228\000\228\000\228\000\228\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\228\000\228\000\228\000\228\000\228\000\
+ \228\000\229\000\229\000\229\000\229\000\229\000\229\000\229\000\
+ \229\000\229\000\229\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\229\000\229\000\229\000\229\000\229\000\229\000\
+ \000\000\000\000\000\000\228\000\228\000\228\000\228\000\228\000\
+ \228\000\000\000\000\000\000\000\000\000\000\000\000\000\239\000\
+ \239\000\239\000\239\000\239\000\239\000\239\000\239\000\239\000\
+ \239\000\000\000\229\000\229\000\229\000\229\000\229\000\229\000\
+ \239\000\239\000\239\000\239\000\239\000\239\000\240\000\240\000\
+ \240\000\240\000\240\000\240\000\240\000\240\000\240\000\240\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\240\000\
+ \240\000\240\000\240\000\240\000\240\000\000\000\000\000\000\000\
+ \239\000\239\000\239\000\239\000\239\000\239\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\250\000\250\000\250\000\250\000\
+ \250\000\250\000\250\000\250\000\250\000\250\000\000\000\240\000\
+ \240\000\240\000\240\000\240\000\240\000\250\000\250\000\250\000\
+ \250\000\250\000\250\000\251\000\251\000\251\000\251\000\251\000\
+ \251\000\251\000\251\000\251\000\251\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\251\000\251\000\251\000\251\000\
+ \251\000\251\000\000\000\000\000\000\000\250\000\250\000\250\000\
+ \250\000\250\000\250\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\251\000\251\000\251\000\251\000\
+ \251\000\251\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000";
Lexing.lex_check =
"\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\255\255\000\000\000\000\000\000\000\000\000\000\255\255\255\255\
\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \000\000\000\000\000\000\000\000\255\255\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \011\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \010\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\000\
\012\000\003\000\003\000\003\000\003\000\003\000\003\000\003\000\
- \003\000\003\000\003\000\010\000\010\000\014\000\015\000\023\000\
- \027\000\024\000\024\000\028\000\035\000\040\000\003\000\012\000\
- \056\000\073\000\075\000\081\000\033\000\003\000\034\000\034\000\
- \074\000\057\000\027\000\028\000\028\000\004\000\003\000\004\000\
+ \003\000\003\000\003\000\011\000\011\000\013\000\015\000\016\000\
+ \028\000\024\000\025\000\025\000\034\000\036\000\003\000\035\000\
+ \035\000\041\000\045\000\059\000\042\000\003\000\061\000\065\000\
+ \062\000\029\000\028\000\071\000\013\000\004\000\003\000\004\000\
\004\000\004\000\004\000\004\000\004\000\004\000\004\000\004\000\
- \004\000\041\000\082\000\074\000\037\000\083\000\003\000\029\000\
- \057\000\037\000\029\000\084\000\004\000\003\000\085\000\087\000\
- \057\000\088\000\093\000\004\000\097\000\110\000\003\000\037\000\
- \029\000\029\000\112\000\113\000\004\000\116\000\023\000\004\000\
- \030\000\058\000\030\000\030\000\030\000\030\000\030\000\030\000\
- \030\000\030\000\030\000\030\000\004\000\033\000\117\000\034\000\
- \114\000\115\000\114\000\004\000\008\000\024\000\114\000\120\000\
- \121\000\115\000\122\000\126\000\004\000\127\000\128\000\004\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\129\000\008\000\135\000\136\000\008\000\095\000\
+ \004\000\029\000\029\000\060\000\038\000\072\000\003\000\030\000\
+ \074\000\038\000\030\000\075\000\004\000\003\000\063\000\078\000\
+ \095\000\096\000\097\000\004\000\103\000\104\000\003\000\038\000\
+ \030\000\030\000\060\000\105\000\004\000\106\000\107\000\004\000\
+ \024\000\109\000\060\000\110\000\096\000\034\000\115\000\117\000\
+ \035\000\119\000\120\000\132\000\004\000\136\000\139\000\144\000\
+ \145\000\147\000\148\000\004\000\007\000\146\000\025\000\146\000\
+ \149\000\147\000\152\000\146\000\004\000\153\000\154\000\004\000\
+ \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
+ \007\000\007\000\007\000\158\000\007\000\159\000\160\000\161\000\
\000\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
\007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
\007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\059\000\060\000\098\000\137\000\007\000\
- \138\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
- \007\000\007\000\007\000\139\000\155\000\156\000\157\000\008\000\
- \008\000\158\000\147\000\159\000\008\000\123\000\130\000\008\000\
- \157\000\162\000\163\000\008\000\165\000\166\000\168\000\169\000\
- \008\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\
- \031\000\031\000\031\000\170\000\123\000\130\000\151\000\154\000\
- \160\000\161\000\031\000\031\000\031\000\031\000\031\000\031\000\
- \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\
- \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\
- \031\000\031\000\031\000\031\000\142\000\171\000\173\000\174\000\
- \031\000\164\000\031\000\031\000\031\000\031\000\031\000\031\000\
- \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\
- \031\000\031\000\031\000\031\000\031\000\031\000\031\000\031\000\
- \031\000\031\000\031\000\031\000\032\000\032\000\032\000\032\000\
- \032\000\032\000\032\000\032\000\032\000\032\000\224\000\041\000\
- \058\000\167\000\172\000\175\000\177\000\032\000\032\000\032\000\
+ \007\000\007\000\007\000\167\000\168\000\169\000\170\000\007\000\
+ \171\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
+ \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
+ \007\000\007\000\007\000\007\000\007\000\007\000\007\000\007\000\
+ \007\000\007\000\007\000\008\000\187\000\009\000\155\000\162\000\
+ \188\000\190\000\191\000\194\000\174\000\195\000\175\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\197\000\008\000\009\000\155\000\162\000\009\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\198\000\200\000\201\000\061\000\008\000\062\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\008\000\008\000\008\000\008\000\008\000\008\000\
+ \008\000\008\000\042\000\202\000\189\000\063\000\203\000\205\000\
+ \009\000\009\000\206\000\000\001\255\255\009\000\189\000\220\000\
+ \009\000\255\255\255\255\179\000\009\000\183\000\186\000\255\255\
+ \031\000\009\000\031\000\031\000\031\000\031\000\031\000\031\000\
+ \031\000\031\000\031\000\031\000\032\000\255\255\094\000\094\000\
+ \094\000\094\000\094\000\094\000\094\000\094\000\094\000\094\000\
+ \032\000\032\000\032\000\032\000\032\000\032\000\032\000\032\000\
+ \032\000\032\000\032\000\094\000\032\000\117\000\209\000\255\255\
+ \120\000\032\000\032\000\032\000\032\000\032\000\032\000\032\000\
\032\000\032\000\032\000\032\000\032\000\032\000\032\000\032\000\
\032\000\032\000\032\000\032\000\032\000\032\000\032\000\032\000\
- \032\000\032\000\032\000\032\000\032\000\032\000\032\000\143\000\
- \255\255\255\255\255\255\032\000\177\000\032\000\032\000\032\000\
+ \032\000\032\000\032\000\094\000\255\255\255\255\209\000\032\000\
+ \255\255\032\000\032\000\032\000\032\000\032\000\032\000\032\000\
\032\000\032\000\032\000\032\000\032\000\032\000\032\000\032\000\
\032\000\032\000\032\000\032\000\032\000\032\000\032\000\032\000\
- \032\000\032\000\032\000\032\000\032\000\032\000\032\000\036\000\
- \036\000\036\000\036\000\036\000\036\000\036\000\036\000\036\000\
- \036\000\255\255\059\000\060\000\186\000\095\000\255\255\255\255\
- \036\000\036\000\036\000\036\000\036\000\036\000\036\000\036\000\
- \036\000\036\000\036\000\036\000\036\000\036\000\036\000\036\000\
- \036\000\036\000\036\000\036\000\036\000\036\000\036\000\036\000\
- \036\000\036\000\198\000\098\000\186\000\255\255\036\000\255\255\
- \036\000\036\000\036\000\036\000\036\000\036\000\036\000\036\000\
- \036\000\036\000\036\000\036\000\036\000\036\000\036\000\036\000\
- \036\000\036\000\036\000\036\000\036\000\036\000\036\000\036\000\
- \036\000\036\000\039\000\039\000\039\000\039\000\039\000\078\000\
- \147\000\078\000\255\255\255\255\078\000\078\000\078\000\078\000\
- \078\000\078\000\078\000\078\000\078\000\078\000\188\000\198\000\
- \255\255\039\000\044\000\044\000\044\000\044\000\044\000\044\000\
- \044\000\044\000\044\000\044\000\151\000\154\000\160\000\161\000\
- \039\000\255\255\142\000\044\000\044\000\044\000\044\000\044\000\
- \044\000\044\000\044\000\044\000\044\000\044\000\044\000\044\000\
- \044\000\044\000\044\000\044\000\044\000\044\000\044\000\044\000\
- \044\000\044\000\044\000\044\000\044\000\141\000\145\000\164\000\
- \255\255\044\000\255\255\044\000\044\000\044\000\044\000\044\000\
- \044\000\044\000\044\000\044\000\044\000\044\000\044\000\044\000\
- \044\000\044\000\044\000\044\000\044\000\044\000\044\000\044\000\
- \044\000\044\000\044\000\044\000\044\000\045\000\045\000\045\000\
- \045\000\045\000\045\000\045\000\045\000\045\000\045\000\167\000\
- \172\000\175\000\255\255\255\255\255\255\143\000\045\000\045\000\
- \045\000\045\000\045\000\045\000\045\000\045\000\045\000\045\000\
- \045\000\045\000\045\000\045\000\045\000\045\000\045\000\045\000\
- \045\000\045\000\045\000\045\000\045\000\045\000\045\000\045\000\
- \255\255\255\255\255\255\255\255\045\000\255\255\045\000\045\000\
- \045\000\045\000\045\000\045\000\045\000\045\000\045\000\045\000\
- \045\000\045\000\045\000\045\000\045\000\045\000\045\000\045\000\
- \045\000\045\000\045\000\045\000\045\000\045\000\045\000\045\000\
+ \032\000\032\000\032\000\033\000\101\000\101\000\101\000\101\000\
+ \101\000\101\000\101\000\101\000\101\000\101\000\173\000\033\000\
+ \033\000\033\000\033\000\033\000\033\000\033\000\033\000\033\000\
+ \033\000\033\000\174\000\033\000\175\000\192\000\193\000\218\000\
+ \033\000\033\000\033\000\033\000\033\000\033\000\033\000\033\000\
+ \033\000\033\000\033\000\033\000\033\000\033\000\033\000\033\000\
+ \033\000\033\000\033\000\033\000\033\000\033\000\033\000\033\000\
+ \033\000\033\000\255\255\220\000\255\255\255\255\033\000\218\000\
+ \033\000\033\000\033\000\033\000\033\000\033\000\033\000\033\000\
+ \033\000\033\000\033\000\033\000\033\000\033\000\033\000\033\000\
+ \033\000\033\000\033\000\033\000\033\000\033\000\033\000\033\000\
+ \033\000\033\000\037\000\102\000\102\000\102\000\102\000\102\000\
+ \102\000\102\000\102\000\102\000\102\000\255\255\037\000\037\000\
+ \037\000\037\000\037\000\037\000\037\000\037\000\037\000\037\000\
+ \037\000\255\255\037\000\255\255\180\000\196\000\181\000\037\000\
+ \037\000\037\000\037\000\037\000\037\000\037\000\037\000\037\000\
+ \037\000\037\000\037\000\037\000\037\000\037\000\037\000\037\000\
+ \037\000\037\000\037\000\037\000\037\000\037\000\037\000\037\000\
+ \037\000\179\000\255\255\183\000\186\000\037\000\255\255\037\000\
+ \037\000\037\000\037\000\037\000\037\000\037\000\037\000\037\000\
+ \037\000\037\000\037\000\037\000\037\000\037\000\037\000\037\000\
+ \037\000\037\000\037\000\037\000\037\000\037\000\037\000\037\000\
+ \037\000\040\000\040\000\040\000\040\000\040\000\255\255\100\000\
+ \255\255\100\000\255\255\046\000\100\000\100\000\100\000\100\000\
+ \100\000\100\000\100\000\100\000\100\000\100\000\255\255\255\255\
+ \040\000\255\255\255\255\199\000\204\000\182\000\180\000\185\000\
+ \173\000\181\000\184\000\207\000\255\255\255\255\255\255\040\000\
\046\000\046\000\046\000\046\000\046\000\046\000\046\000\046\000\
- \046\000\046\000\188\000\198\000\255\255\255\255\255\255\255\255\
- \255\255\046\000\046\000\046\000\046\000\046\000\046\000\046\000\
\046\000\046\000\046\000\046\000\046\000\046\000\046\000\046\000\
\046\000\046\000\046\000\046\000\046\000\046\000\046\000\046\000\
- \046\000\046\000\046\000\255\255\255\255\255\255\255\255\046\000\
- \255\255\046\000\046\000\046\000\046\000\046\000\046\000\046\000\
+ \046\000\046\000\255\255\255\255\255\255\255\255\046\000\255\255\
\046\000\046\000\046\000\046\000\046\000\046\000\046\000\046\000\
\046\000\046\000\046\000\046\000\046\000\046\000\046\000\046\000\
- \046\000\046\000\046\000\047\000\047\000\047\000\047\000\047\000\
- \047\000\047\000\047\000\047\000\047\000\255\255\255\255\141\000\
- \145\000\255\255\255\255\255\255\047\000\047\000\047\000\047\000\
+ \046\000\046\000\046\000\046\000\046\000\046\000\046\000\046\000\
+ \046\000\046\000\047\000\192\000\193\000\046\000\255\255\177\000\
+ \255\255\255\255\255\255\255\255\255\255\255\255\047\000\047\000\
+ \047\000\047\000\047\000\047\000\047\000\047\000\047\000\047\000\
+ \047\000\182\000\047\000\185\000\255\255\184\000\255\255\047\000\
+ \047\000\047\000\047\000\047\000\047\000\047\000\047\000\047\000\
\047\000\047\000\047\000\047\000\047\000\047\000\047\000\047\000\
\047\000\047\000\047\000\047\000\047\000\047\000\047\000\047\000\
- \047\000\047\000\047\000\047\000\047\000\047\000\255\255\255\255\
- \255\255\255\255\047\000\255\255\047\000\047\000\047\000\047\000\
+ \047\000\255\255\255\255\255\255\255\255\047\000\255\255\047\000\
\047\000\047\000\047\000\047\000\047\000\047\000\047\000\047\000\
\047\000\047\000\047\000\047\000\047\000\047\000\047\000\047\000\
- \047\000\047\000\047\000\047\000\047\000\047\000\048\000\048\000\
+ \047\000\047\000\047\000\047\000\047\000\047\000\047\000\047\000\
+ \047\000\048\000\180\000\196\000\181\000\225\000\225\000\225\000\
+ \225\000\225\000\225\000\225\000\225\000\048\000\048\000\048\000\
\048\000\048\000\048\000\048\000\048\000\048\000\048\000\048\000\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\048\000\
+ \255\255\048\000\255\255\255\255\255\255\255\255\048\000\048\000\
\048\000\048\000\048\000\048\000\048\000\048\000\048\000\048\000\
\048\000\048\000\048\000\048\000\048\000\048\000\048\000\048\000\
\048\000\048\000\048\000\048\000\048\000\048\000\048\000\048\000\
- \048\000\255\255\255\255\255\255\255\255\048\000\255\255\048\000\
+ \255\255\255\255\255\255\255\255\048\000\255\255\048\000\048\000\
\048\000\048\000\048\000\048\000\048\000\048\000\048\000\048\000\
\048\000\048\000\048\000\048\000\048\000\048\000\048\000\048\000\
\048\000\048\000\048\000\048\000\048\000\048\000\048\000\048\000\
- \048\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\
- \049\000\049\000\049\000\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\049\000\049\000\049\000\049\000\049\000\049\000\
+ \049\000\199\000\204\000\182\000\255\255\185\000\255\255\255\255\
+ \184\000\207\000\255\255\255\255\049\000\049\000\049\000\049\000\
+ \049\000\049\000\049\000\049\000\049\000\049\000\049\000\255\255\
+ \049\000\177\000\255\255\255\255\255\255\049\000\049\000\049\000\
\049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\
\049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\
- \049\000\049\000\049\000\049\000\255\255\255\255\255\255\255\255\
- \049\000\255\255\049\000\049\000\049\000\049\000\049\000\049\000\
+ \049\000\049\000\049\000\049\000\049\000\049\000\049\000\255\255\
+ \255\255\255\255\255\255\049\000\255\255\049\000\049\000\049\000\
\049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\
\049\000\049\000\049\000\049\000\049\000\049\000\049\000\049\000\
- \049\000\049\000\049\000\049\000\050\000\050\000\050\000\050\000\
- \050\000\050\000\050\000\050\000\050\000\050\000\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\050\000\050\000\050\000\
+ \049\000\049\000\049\000\049\000\049\000\049\000\049\000\050\000\
+ \255\255\211\000\211\000\211\000\211\000\211\000\211\000\211\000\
+ \211\000\211\000\211\000\050\000\050\000\050\000\050\000\050\000\
+ \050\000\050\000\050\000\050\000\050\000\050\000\211\000\050\000\
+ \252\000\252\000\252\000\252\000\050\000\050\000\050\000\050\000\
\050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\
\050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\
- \050\000\050\000\050\000\050\000\050\000\050\000\050\000\255\255\
- \255\255\255\255\255\255\050\000\255\255\050\000\050\000\050\000\
+ \050\000\050\000\050\000\050\000\050\000\050\000\211\000\255\255\
+ \252\000\252\000\050\000\255\255\050\000\050\000\050\000\050\000\
\050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\
\050\000\050\000\050\000\050\000\050\000\050\000\050\000\050\000\
- \050\000\050\000\050\000\050\000\050\000\050\000\050\000\051\000\
- \051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\
- \051\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \050\000\050\000\050\000\050\000\050\000\050\000\051\000\215\000\
+ \215\000\215\000\215\000\215\000\215\000\215\000\215\000\215\000\
+ \215\000\255\255\051\000\051\000\051\000\051\000\051\000\051\000\
+ \051\000\051\000\051\000\051\000\051\000\255\255\051\000\255\255\
+ \255\255\255\255\255\255\051\000\051\000\051\000\051\000\051\000\
\051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\
\051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\
+ \051\000\051\000\051\000\051\000\051\000\255\255\255\255\255\255\
+ \255\255\051\000\255\255\051\000\051\000\051\000\051\000\051\000\
\051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\
- \051\000\051\000\255\255\255\255\255\255\255\255\051\000\255\255\
\051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\
- \051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\
- \051\000\051\000\051\000\051\000\051\000\051\000\051\000\051\000\
- \051\000\051\000\052\000\052\000\052\000\052\000\052\000\052\000\
- \052\000\052\000\052\000\052\000\255\255\220\000\220\000\220\000\
- \220\000\255\255\255\255\052\000\052\000\052\000\052\000\052\000\
+ \051\000\051\000\051\000\051\000\051\000\052\000\216\000\216\000\
+ \216\000\216\000\216\000\216\000\216\000\216\000\216\000\216\000\
+ \255\255\052\000\052\000\052\000\052\000\052\000\052\000\052\000\
+ \052\000\052\000\052\000\052\000\255\255\052\000\255\255\255\255\
+ \255\255\255\255\052\000\052\000\052\000\052\000\052\000\052\000\
\052\000\052\000\052\000\052\000\052\000\052\000\052\000\052\000\
\052\000\052\000\052\000\052\000\052\000\052\000\052\000\052\000\
- \052\000\052\000\052\000\052\000\052\000\220\000\220\000\255\255\
- \255\255\052\000\255\255\052\000\052\000\052\000\052\000\052\000\
+ \052\000\052\000\052\000\052\000\255\255\255\255\255\255\255\255\
+ \052\000\255\255\052\000\052\000\052\000\052\000\052\000\052\000\
\052\000\052\000\052\000\052\000\052\000\052\000\052\000\052\000\
\052\000\052\000\052\000\052\000\052\000\052\000\052\000\052\000\
- \052\000\052\000\052\000\052\000\052\000\053\000\053\000\053\000\
- \053\000\053\000\053\000\053\000\053\000\053\000\053\000\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\053\000\053\000\
+ \052\000\052\000\052\000\052\000\053\000\226\000\226\000\226\000\
+ \226\000\226\000\226\000\226\000\226\000\255\255\252\000\255\255\
\053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\
+ \053\000\053\000\053\000\255\255\053\000\255\255\255\255\255\255\
+ \255\255\053\000\053\000\053\000\053\000\053\000\053\000\053\000\
\053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\
\053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\
- \255\255\255\255\255\255\255\255\053\000\255\255\053\000\053\000\
- \053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\
+ \053\000\053\000\053\000\255\255\255\255\255\255\255\255\053\000\
+ \255\255\053\000\053\000\053\000\053\000\053\000\053\000\053\000\
\053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\
\053\000\053\000\053\000\053\000\053\000\053\000\053\000\053\000\
+ \053\000\053\000\053\000\054\000\236\000\236\000\236\000\236\000\
+ \236\000\236\000\236\000\236\000\255\255\255\255\255\255\054\000\
\054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\
- \054\000\054\000\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\054\000\054\000\054\000\054\000\054\000\054\000\054\000\
+ \054\000\054\000\255\255\054\000\255\255\255\255\255\255\255\255\
\054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\
\054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\
- \054\000\054\000\054\000\255\255\255\255\255\255\255\255\054\000\
- \255\255\054\000\054\000\054\000\054\000\054\000\054\000\054\000\
\054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\
+ \054\000\054\000\255\255\255\255\255\255\255\255\054\000\255\255\
\054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\
- \054\000\054\000\054\000\055\000\072\000\072\000\072\000\072\000\
- \072\000\072\000\072\000\072\000\072\000\072\000\079\000\079\000\
- \079\000\079\000\079\000\079\000\079\000\079\000\079\000\079\000\
- \255\255\072\000\055\000\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\055\000\220\000\150\000\148\000\255\255\255\255\
- \255\255\255\255\055\000\055\000\055\000\055\000\055\000\055\000\
- \055\000\055\000\055\000\055\000\255\255\255\255\255\255\255\255\
- \255\255\072\000\255\255\055\000\055\000\055\000\055\000\055\000\
+ \054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\
+ \054\000\054\000\054\000\054\000\054\000\054\000\054\000\054\000\
+ \054\000\054\000\055\000\237\000\237\000\237\000\237\000\237\000\
+ \237\000\237\000\237\000\255\255\255\255\255\255\055\000\055\000\
\055\000\055\000\055\000\055\000\055\000\055\000\055\000\055\000\
+ \055\000\255\255\055\000\255\255\255\255\255\255\255\255\055\000\
\055\000\055\000\055\000\055\000\055\000\055\000\055\000\055\000\
- \055\000\055\000\055\000\055\000\055\000\255\255\255\255\255\255\
- \255\255\055\000\255\255\055\000\055\000\055\000\055\000\055\000\
\055\000\055\000\055\000\055\000\055\000\055\000\055\000\055\000\
\055\000\055\000\055\000\055\000\055\000\055\000\055\000\055\000\
- \055\000\055\000\055\000\055\000\055\000\067\000\067\000\067\000\
- \067\000\067\000\067\000\067\000\067\000\067\000\067\000\148\000\
- \150\000\255\255\255\255\255\255\255\255\255\255\067\000\067\000\
- \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
- \067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \055\000\241\000\255\255\230\000\255\255\055\000\255\255\055\000\
+ \055\000\055\000\055\000\055\000\055\000\055\000\055\000\055\000\
+ \055\000\055\000\055\000\055\000\055\000\055\000\055\000\055\000\
+ \055\000\055\000\055\000\055\000\055\000\055\000\055\000\055\000\
+ \055\000\056\000\247\000\247\000\247\000\247\000\247\000\247\000\
+ \247\000\247\000\255\255\255\255\255\255\056\000\056\000\056\000\
+ \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\
+ \230\000\056\000\255\255\241\000\255\255\255\255\056\000\056\000\
+ \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\
+ \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\
+ \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\
+ \255\255\255\255\255\255\255\255\056\000\255\255\056\000\056\000\
+ \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\
+ \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\
+ \056\000\056\000\056\000\056\000\056\000\056\000\056\000\056\000\
+ \057\000\255\255\255\255\150\000\248\000\248\000\248\000\248\000\
+ \248\000\248\000\248\000\248\000\057\000\057\000\057\000\057\000\
+ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\255\255\
+ \057\000\255\255\150\000\255\255\255\255\057\000\057\000\057\000\
+ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\
+ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\
+ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\255\255\
+ \255\255\255\255\255\255\057\000\255\255\057\000\057\000\057\000\
+ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\
+ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\057\000\
+ \057\000\057\000\057\000\057\000\057\000\057\000\057\000\058\000\
+ \255\255\255\255\172\000\255\255\255\255\255\255\150\000\150\000\
+ \255\255\255\255\255\255\150\000\230\000\255\255\150\000\241\000\
+ \255\255\255\255\150\000\255\255\255\255\255\255\058\000\150\000\
+ \255\255\172\000\058\000\172\000\255\255\255\255\058\000\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\058\000\058\000\
+ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\
+ \058\000\255\255\058\000\255\255\255\255\172\000\255\255\058\000\
+ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\
+ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\
+ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\
+ \058\000\255\255\255\255\255\255\255\255\058\000\255\255\058\000\
+ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\
+ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\
+ \058\000\058\000\058\000\058\000\058\000\058\000\058\000\058\000\
+ \058\000\064\000\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\255\255\
+ \255\255\255\255\255\255\064\000\255\255\255\255\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \255\255\255\255\255\255\255\255\064\000\255\255\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \064\000\064\000\064\000\064\000\064\000\064\000\064\000\064\000\
+ \066\000\255\255\212\000\064\000\212\000\255\255\255\255\212\000\
+ \212\000\212\000\212\000\212\000\212\000\212\000\212\000\212\000\
+ \212\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\066\000\066\000\066\000\
+ \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\
+ \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\
+ \066\000\066\000\066\000\066\000\066\000\066\000\066\000\255\255\
+ \255\255\255\255\255\255\066\000\255\255\066\000\066\000\066\000\
+ \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\
+ \066\000\066\000\066\000\066\000\066\000\066\000\066\000\066\000\
+ \066\000\066\000\066\000\066\000\066\000\066\000\066\000\067\000\
+ \255\255\255\255\066\000\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\255\255\067\000\
+ \255\255\255\255\255\255\255\255\067\000\067\000\067\000\067\000\
\067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
- \255\255\255\255\255\255\255\255\067\000\255\255\067\000\067\000\
\067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\255\255\255\255\
+ \255\255\068\000\067\000\255\255\067\000\067\000\067\000\067\000\
\067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
\067\000\067\000\067\000\067\000\067\000\067\000\067\000\067\000\
+ \067\000\067\000\067\000\067\000\067\000\067\000\068\000\068\000\
\068\000\068\000\068\000\068\000\068\000\068\000\068\000\068\000\
- \068\000\068\000\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\068\000\068\000\068\000\068\000\068\000\068\000\068\000\
\068\000\068\000\068\000\068\000\068\000\068\000\068\000\068\000\
\068\000\068\000\068\000\068\000\068\000\068\000\068\000\068\000\
- \068\000\068\000\068\000\255\255\255\255\255\255\255\255\068\000\
- \255\255\068\000\068\000\068\000\068\000\068\000\068\000\068\000\
+ \255\255\255\255\255\255\255\255\068\000\255\255\068\000\068\000\
\068\000\068\000\068\000\068\000\068\000\068\000\068\000\068\000\
\068\000\068\000\068\000\068\000\068\000\068\000\068\000\068\000\
- \068\000\068\000\068\000\069\000\069\000\069\000\069\000\069\000\
- \069\000\069\000\069\000\069\000\069\000\255\255\255\255\255\255\
- \255\255\255\255\150\000\148\000\069\000\069\000\069\000\069\000\
+ \068\000\068\000\068\000\068\000\068\000\068\000\068\000\068\000\
+ \069\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\069\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\255\255\
+ \069\000\255\255\255\255\255\255\255\255\069\000\069\000\069\000\
\069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
\069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
- \069\000\069\000\069\000\069\000\069\000\069\000\255\255\255\255\
- \255\255\255\255\069\000\255\255\069\000\069\000\069\000\069\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\255\255\
+ \255\255\255\255\070\000\069\000\255\255\069\000\069\000\069\000\
\069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
\069\000\069\000\069\000\069\000\069\000\069\000\069\000\069\000\
- \069\000\069\000\069\000\069\000\069\000\069\000\070\000\070\000\
- \070\000\070\000\070\000\070\000\070\000\070\000\070\000\070\000\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\070\000\
+ \069\000\069\000\069\000\069\000\069\000\069\000\069\000\070\000\
\070\000\070\000\070\000\070\000\070\000\070\000\070\000\070\000\
\070\000\070\000\070\000\070\000\070\000\070\000\070\000\070\000\
\070\000\070\000\070\000\070\000\070\000\070\000\070\000\070\000\
\070\000\070\000\070\000\070\000\070\000\070\000\070\000\070\000\
\070\000\070\000\070\000\070\000\070\000\070\000\070\000\070\000\
\070\000\070\000\070\000\070\000\070\000\070\000\070\000\070\000\
- \070\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\
- \071\000\071\000\071\000\255\255\255\255\255\255\255\255\255\255\
- \255\255\134\000\071\000\071\000\071\000\071\000\071\000\071\000\
- \071\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\
- \071\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\
- \071\000\071\000\071\000\071\000\209\000\255\255\255\255\255\255\
- \071\000\255\255\071\000\071\000\071\000\071\000\071\000\071\000\
- \071\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\
- \071\000\071\000\071\000\071\000\071\000\071\000\071\000\071\000\
- \071\000\071\000\071\000\071\000\080\000\080\000\080\000\080\000\
- \080\000\080\000\080\000\080\000\080\000\080\000\118\000\140\000\
- \149\000\152\000\176\000\153\000\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\176\000\255\255\255\255\209\000\255\255\
- \255\255\255\255\255\255\134\000\255\255\118\000\140\000\255\255\
- \140\000\255\255\255\255\255\255\255\255\134\000\255\255\255\255\
- \255\255\255\255\176\000\193\000\193\000\193\000\193\000\193\000\
- \193\000\193\000\193\000\176\000\255\255\255\255\255\255\255\255\
- \255\255\255\255\140\000\124\000\179\000\179\000\179\000\179\000\
- \179\000\179\000\179\000\179\000\179\000\179\000\194\000\194\000\
- \194\000\194\000\194\000\194\000\194\000\194\000\180\000\255\255\
- \180\000\179\000\124\000\180\000\180\000\180\000\180\000\180\000\
- \180\000\180\000\180\000\180\000\180\000\255\255\255\255\255\255\
- \255\255\118\000\118\000\149\000\152\000\255\255\118\000\153\000\
- \255\255\118\000\255\255\255\255\255\255\118\000\255\255\255\255\
- \255\255\179\000\118\000\124\000\124\000\124\000\124\000\124\000\
- \124\000\124\000\124\000\124\000\124\000\124\000\124\000\124\000\
- \124\000\124\000\124\000\124\000\124\000\124\000\124\000\124\000\
- \124\000\124\000\124\000\124\000\124\000\255\255\255\255\255\255\
- \255\255\124\000\255\255\124\000\124\000\124\000\124\000\124\000\
- \124\000\124\000\124\000\124\000\124\000\124\000\124\000\124\000\
- \124\000\124\000\124\000\124\000\124\000\124\000\124\000\124\000\
- \124\000\124\000\124\000\124\000\124\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\134\000\
- \255\255\255\255\209\000\255\255\255\255\255\255\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \255\255\255\255\255\255\255\255\125\000\255\255\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \125\000\125\000\125\000\125\000\125\000\125\000\125\000\125\000\
- \131\000\255\255\255\255\255\255\255\255\255\255\149\000\152\000\
- \255\255\153\000\183\000\183\000\183\000\183\000\183\000\183\000\
- \183\000\183\000\183\000\183\000\255\255\255\255\255\255\131\000\
- \255\255\255\255\255\255\181\000\255\255\181\000\181\000\181\000\
- \181\000\181\000\181\000\181\000\181\000\181\000\181\000\184\000\
- \184\000\184\000\184\000\184\000\184\000\184\000\184\000\184\000\
- \184\000\255\255\181\000\255\255\255\255\255\255\255\255\255\255\
- \131\000\131\000\131\000\131\000\131\000\131\000\131\000\131\000\
- \131\000\131\000\131\000\131\000\131\000\131\000\131\000\131\000\
- \131\000\131\000\131\000\131\000\131\000\131\000\131\000\131\000\
- \131\000\131\000\181\000\255\255\255\255\255\255\131\000\255\255\
- \131\000\131\000\131\000\131\000\131\000\131\000\131\000\131\000\
- \131\000\131\000\131\000\131\000\131\000\131\000\131\000\131\000\
- \131\000\131\000\131\000\131\000\131\000\131\000\131\000\131\000\
- \131\000\131\000\132\000\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\255\255\255\255\255\255\
- \255\255\132\000\255\255\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\132\000\132\000\132\000\
- \132\000\132\000\132\000\132\000\132\000\178\000\178\000\178\000\
- \178\000\178\000\178\000\178\000\178\000\178\000\178\000\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\178\000\178\000\
- \178\000\178\000\178\000\178\000\255\255\255\255\182\000\255\255\
- \182\000\182\000\182\000\182\000\182\000\182\000\182\000\182\000\
- \182\000\182\000\190\000\190\000\190\000\190\000\190\000\190\000\
- \190\000\190\000\255\255\255\255\255\255\182\000\178\000\178\000\
- \178\000\178\000\178\000\178\000\182\000\200\000\200\000\200\000\
- \200\000\200\000\200\000\200\000\200\000\182\000\204\000\204\000\
- \204\000\204\000\204\000\204\000\204\000\204\000\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\182\000\255\255\255\255\
- \255\255\255\255\255\255\255\255\182\000\205\000\205\000\205\000\
- \205\000\205\000\205\000\205\000\205\000\182\000\185\000\185\000\
- \185\000\185\000\185\000\185\000\185\000\185\000\185\000\185\000\
- \255\255\255\255\190\000\255\255\255\255\255\255\255\255\185\000\
- \185\000\185\000\185\000\185\000\185\000\255\255\255\255\255\255\
- \255\255\255\255\185\000\255\255\255\255\200\000\255\255\255\255\
- \255\255\255\255\255\255\185\000\215\000\215\000\215\000\215\000\
- \215\000\215\000\215\000\215\000\255\255\255\255\255\255\185\000\
- \185\000\185\000\185\000\185\000\185\000\255\255\255\255\255\255\
- \255\255\255\255\185\000\216\000\216\000\216\000\216\000\216\000\
- \216\000\216\000\216\000\185\000\192\000\192\000\192\000\192\000\
- \192\000\192\000\192\000\192\000\192\000\192\000\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\192\000\192\000\192\000\
- \192\000\192\000\192\000\196\000\196\000\196\000\196\000\196\000\
- \196\000\196\000\196\000\196\000\196\000\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\196\000\196\000\196\000\196\000\
- \196\000\196\000\255\255\255\255\255\255\192\000\192\000\192\000\
- \192\000\192\000\192\000\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\203\000\203\000\203\000\203\000\203\000\203\000\
- \203\000\203\000\203\000\203\000\196\000\196\000\196\000\196\000\
- \196\000\196\000\190\000\203\000\203\000\203\000\203\000\203\000\
- \203\000\207\000\207\000\207\000\207\000\207\000\207\000\207\000\
- \207\000\207\000\207\000\255\255\255\255\200\000\255\255\255\255\
- \255\255\255\255\207\000\207\000\207\000\207\000\207\000\207\000\
- \255\255\255\255\255\255\203\000\203\000\203\000\203\000\203\000\
- \203\000\211\000\211\000\211\000\211\000\211\000\211\000\211\000\
- \211\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\207\000\207\000\207\000\207\000\207\000\207\000\
- \255\255\214\000\214\000\214\000\214\000\214\000\214\000\214\000\
- \214\000\214\000\214\000\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\214\000\214\000\214\000\214\000\214\000\214\000\
- \218\000\218\000\218\000\218\000\218\000\218\000\218\000\218\000\
- \218\000\218\000\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\218\000\218\000\218\000\218\000\218\000\218\000\255\255\
- \255\255\211\000\214\000\214\000\214\000\214\000\214\000\214\000\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\218\000\218\000\218\000\218\000\218\000\218\000\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\211\000\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255";
+ \070\000\073\000\255\255\255\255\070\000\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\255\255\
+ \255\255\255\255\255\255\073\000\255\255\255\255\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \255\255\255\255\255\255\255\255\073\000\255\255\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \073\000\073\000\073\000\073\000\073\000\073\000\073\000\073\000\
+ \076\000\255\255\213\000\073\000\213\000\213\000\213\000\213\000\
+ \213\000\213\000\213\000\213\000\213\000\213\000\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\213\000\255\255\255\255\255\255\076\000\076\000\076\000\
+ \076\000\076\000\076\000\076\000\076\000\076\000\076\000\076\000\
+ \076\000\076\000\076\000\076\000\076\000\076\000\076\000\076\000\
+ \076\000\076\000\076\000\076\000\076\000\076\000\076\000\255\255\
+ \255\255\213\000\255\255\076\000\255\255\076\000\076\000\076\000\
+ \076\000\076\000\076\000\076\000\076\000\076\000\076\000\076\000\
+ \076\000\076\000\076\000\076\000\076\000\076\000\076\000\076\000\
+ \076\000\076\000\076\000\076\000\076\000\076\000\076\000\077\000\
+ \255\255\255\255\076\000\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\255\255\255\255\255\255\
+ \255\255\077\000\255\255\255\255\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\255\255\255\255\
+ \255\255\255\255\077\000\255\255\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\077\000\077\000\
+ \077\000\077\000\077\000\077\000\077\000\077\000\079\000\255\255\
+ \255\255\077\000\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\079\000\079\000\079\000\079\000\079\000\
+ \079\000\079\000\079\000\079\000\079\000\079\000\079\000\079\000\
+ \079\000\079\000\079\000\079\000\079\000\079\000\079\000\079\000\
+ \079\000\079\000\079\000\079\000\079\000\255\255\255\255\255\255\
+ \255\255\079\000\255\255\079\000\079\000\079\000\079\000\079\000\
+ \079\000\079\000\079\000\079\000\079\000\079\000\079\000\079\000\
+ \079\000\079\000\079\000\079\000\079\000\079\000\079\000\079\000\
+ \079\000\079\000\079\000\079\000\079\000\080\000\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\255\255\080\000\255\255\255\255\
+ \255\255\255\255\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\255\255\255\255\255\255\081\000\
+ \080\000\255\255\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\080\000\080\000\080\000\080\000\
+ \080\000\080\000\080\000\080\000\081\000\081\000\081\000\081\000\
+ \081\000\081\000\081\000\081\000\081\000\081\000\081\000\081\000\
+ \081\000\081\000\081\000\081\000\081\000\081\000\081\000\081\000\
+ \081\000\081\000\081\000\081\000\081\000\081\000\255\255\255\255\
+ \255\255\255\255\081\000\255\255\081\000\081\000\081\000\081\000\
+ \081\000\081\000\081\000\081\000\081\000\081\000\081\000\081\000\
+ \081\000\081\000\081\000\081\000\081\000\081\000\081\000\081\000\
+ \081\000\081\000\081\000\081\000\081\000\081\000\082\000\255\255\
+ \255\255\081\000\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\255\255\255\255\255\255\255\255\
+ \082\000\255\255\255\255\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\255\255\255\255\255\255\
+ \255\255\082\000\255\255\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\082\000\082\000\082\000\
+ \082\000\082\000\082\000\082\000\082\000\089\000\255\255\255\255\
+ \082\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\089\000\089\000\089\000\089\000\089\000\089\000\089\000\
+ \089\000\089\000\089\000\089\000\255\255\089\000\255\255\255\255\
+ \255\255\255\255\089\000\089\000\089\000\089\000\089\000\089\000\
+ \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\
+ \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\
+ \089\000\089\000\089\000\089\000\255\255\255\255\255\255\255\255\
+ \089\000\255\255\089\000\089\000\089\000\089\000\089\000\089\000\
+ \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\
+ \089\000\089\000\089\000\089\000\089\000\089\000\089\000\089\000\
+ \089\000\089\000\089\000\089\000\090\000\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \090\000\090\000\090\000\090\000\090\000\090\000\090\000\090\000\
+ \090\000\090\000\090\000\255\255\090\000\255\255\255\255\255\255\
+ \255\255\090\000\090\000\090\000\090\000\090\000\090\000\090\000\
+ \090\000\090\000\090\000\090\000\090\000\090\000\090\000\090\000\
+ \090\000\090\000\090\000\090\000\090\000\090\000\090\000\090\000\
+ \090\000\090\000\090\000\255\255\255\255\255\255\255\255\090\000\
+ \255\255\090\000\090\000\090\000\090\000\090\000\090\000\090\000\
+ \090\000\090\000\090\000\090\000\090\000\090\000\090\000\090\000\
+ \090\000\090\000\090\000\090\000\090\000\090\000\090\000\090\000\
+ \090\000\090\000\090\000\091\000\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\091\000\
+ \091\000\091\000\091\000\091\000\091\000\091\000\091\000\091\000\
+ \091\000\091\000\255\255\091\000\255\255\255\255\255\255\255\255\
+ \091\000\091\000\091\000\091\000\091\000\091\000\091\000\091\000\
+ \091\000\091\000\091\000\091\000\091\000\091\000\091\000\091\000\
+ \091\000\091\000\091\000\091\000\091\000\091\000\091\000\091\000\
+ \091\000\091\000\255\255\255\255\255\255\255\255\091\000\255\255\
+ \091\000\091\000\091\000\091\000\091\000\091\000\091\000\091\000\
+ \091\000\091\000\091\000\091\000\091\000\091\000\091\000\091\000\
+ \091\000\091\000\091\000\091\000\091\000\091\000\091\000\091\000\
+ \091\000\091\000\092\000\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\092\000\092\000\
+ \092\000\092\000\092\000\092\000\092\000\092\000\092\000\092\000\
+ \092\000\255\255\092\000\255\255\255\255\255\255\255\255\092\000\
+ \092\000\092\000\092\000\092\000\092\000\092\000\092\000\092\000\
+ \092\000\092\000\092\000\092\000\092\000\092\000\092\000\092\000\
+ \092\000\092\000\092\000\092\000\092\000\092\000\092\000\092\000\
+ \092\000\255\255\255\255\255\255\255\255\092\000\255\255\092\000\
+ \092\000\092\000\092\000\092\000\092\000\092\000\092\000\092\000\
+ \092\000\092\000\092\000\092\000\092\000\092\000\092\000\092\000\
+ \092\000\092\000\092\000\092\000\092\000\092\000\092\000\092\000\
+ \092\000\093\000\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\093\000\093\000\093\000\
+ \093\000\093\000\093\000\093\000\093\000\093\000\093\000\093\000\
+ \255\255\093\000\255\255\255\255\255\255\255\255\093\000\093\000\
+ \093\000\093\000\093\000\093\000\093\000\093\000\093\000\093\000\
+ \093\000\093\000\093\000\093\000\093\000\093\000\093\000\093\000\
+ \093\000\093\000\093\000\093\000\093\000\093\000\093\000\093\000\
+ \255\255\255\255\255\255\134\000\093\000\255\255\093\000\093\000\
+ \093\000\093\000\093\000\093\000\093\000\093\000\093\000\093\000\
+ \093\000\093\000\093\000\093\000\093\000\093\000\093\000\093\000\
+ \093\000\093\000\093\000\093\000\093\000\093\000\093\000\093\000\
+ \134\000\134\000\134\000\134\000\134\000\134\000\134\000\134\000\
+ \134\000\134\000\134\000\134\000\134\000\134\000\134\000\134\000\
+ \134\000\134\000\134\000\134\000\134\000\134\000\134\000\134\000\
+ \134\000\134\000\255\255\255\255\255\255\255\255\134\000\255\255\
+ \134\000\134\000\134\000\134\000\134\000\134\000\134\000\134\000\
+ \134\000\134\000\134\000\134\000\134\000\134\000\134\000\134\000\
+ \134\000\134\000\134\000\134\000\134\000\134\000\134\000\134\000\
+ \134\000\134\000\135\000\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\255\255\135\000\255\255\255\255\255\255\255\255\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\255\255\255\255\255\255\137\000\135\000\255\255\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\135\000\135\000\135\000\135\000\135\000\135\000\135\000\
+ \135\000\137\000\137\000\137\000\137\000\137\000\137\000\137\000\
+ \137\000\137\000\137\000\137\000\137\000\137\000\137\000\137\000\
+ \137\000\137\000\137\000\137\000\137\000\137\000\137\000\137\000\
+ \137\000\137\000\137\000\255\255\255\255\255\255\255\255\137\000\
+ \255\255\137\000\137\000\137\000\137\000\137\000\137\000\137\000\
+ \137\000\137\000\137\000\137\000\137\000\137\000\137\000\137\000\
+ \137\000\137\000\137\000\137\000\137\000\137\000\137\000\137\000\
+ \137\000\137\000\137\000\138\000\255\255\255\255\137\000\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\255\255\255\255\255\255\255\255\138\000\255\255\255\255\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\255\255\255\255\255\255\255\255\138\000\255\255\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\138\000\138\000\138\000\138\000\138\000\138\000\
+ \138\000\138\000\140\000\255\255\255\255\138\000\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\140\000\
+ \140\000\140\000\140\000\140\000\140\000\140\000\140\000\140\000\
+ \140\000\140\000\140\000\140\000\140\000\140\000\140\000\140\000\
+ \140\000\140\000\140\000\140\000\140\000\140\000\140\000\140\000\
+ \140\000\255\255\255\255\255\255\255\255\140\000\255\255\140\000\
+ \140\000\140\000\140\000\140\000\140\000\140\000\140\000\140\000\
+ \140\000\140\000\140\000\140\000\140\000\140\000\140\000\140\000\
+ \140\000\140\000\140\000\140\000\140\000\140\000\140\000\140\000\
+ \140\000\141\000\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \255\255\141\000\255\255\255\255\255\255\255\255\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \255\255\255\255\255\255\142\000\141\000\255\255\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \141\000\141\000\141\000\141\000\141\000\141\000\141\000\141\000\
+ \142\000\142\000\142\000\142\000\142\000\142\000\142\000\142\000\
+ \142\000\142\000\142\000\142\000\142\000\142\000\142\000\142\000\
+ \142\000\142\000\142\000\142\000\142\000\142\000\142\000\142\000\
+ \142\000\142\000\255\255\255\255\255\255\255\255\142\000\255\255\
+ \142\000\142\000\142\000\142\000\142\000\142\000\142\000\142\000\
+ \142\000\142\000\142\000\142\000\142\000\142\000\142\000\142\000\
+ \142\000\142\000\142\000\142\000\142\000\142\000\142\000\142\000\
+ \142\000\142\000\143\000\166\000\255\255\142\000\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \255\255\255\255\255\255\255\255\143\000\255\255\255\255\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\255\255\255\255\255\255\255\255\143\000\255\255\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\143\000\143\000\143\000\143\000\143\000\143\000\143\000\
+ \143\000\156\000\208\000\255\255\143\000\166\000\255\255\255\255\
+ \255\255\255\255\255\255\208\000\255\255\255\255\255\255\166\000\
+ \222\000\222\000\222\000\222\000\222\000\222\000\222\000\222\000\
+ \156\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\208\000\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\208\000\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\156\000\156\000\156\000\156\000\156\000\156\000\156\000\
+ \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\
+ \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\
+ \156\000\156\000\156\000\255\255\255\255\255\255\255\255\156\000\
+ \222\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\
+ \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\
+ \156\000\156\000\156\000\156\000\156\000\156\000\156\000\156\000\
+ \156\000\156\000\156\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\255\255\255\255\
+ \255\255\166\000\157\000\255\255\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\
+ \157\000\157\000\157\000\157\000\157\000\157\000\163\000\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\232\000\232\000\232\000\232\000\232\000\232\000\
+ \232\000\232\000\255\255\255\255\255\255\163\000\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \222\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\243\000\243\000\243\000\243\000\243\000\
+ \243\000\243\000\243\000\255\255\255\255\255\255\163\000\163\000\
+ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\
+ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\
+ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\
+ \255\255\255\255\232\000\255\255\163\000\255\255\163\000\163\000\
+ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\
+ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\
+ \163\000\163\000\163\000\163\000\163\000\163\000\163\000\163\000\
+ \164\000\255\255\255\255\243\000\255\255\255\255\255\255\255\255\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\255\255\255\255\255\255\255\255\164\000\
+ \255\255\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\164\000\164\000\164\000\164\000\164\000\
+ \164\000\164\000\164\000\210\000\210\000\210\000\210\000\210\000\
+ \210\000\210\000\210\000\210\000\210\000\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\210\000\210\000\210\000\210\000\
+ \210\000\210\000\232\000\255\255\214\000\255\255\214\000\214\000\
+ \214\000\214\000\214\000\214\000\214\000\214\000\214\000\214\000\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\214\000\210\000\210\000\210\000\210\000\
+ \210\000\210\000\214\000\243\000\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\214\000\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\214\000\255\255\255\255\255\255\255\255\
+ \255\255\255\255\214\000\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\214\000\217\000\217\000\217\000\217\000\
+ \217\000\217\000\217\000\217\000\217\000\217\000\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\217\000\217\000\217\000\
+ \217\000\217\000\217\000\255\255\255\255\255\255\255\255\255\255\
+ \217\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\217\000\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\217\000\217\000\217\000\
+ \217\000\217\000\217\000\255\255\255\255\255\255\255\255\255\255\
+ \217\000\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\217\000\224\000\224\000\224\000\224\000\224\000\224\000\
+ \224\000\224\000\224\000\224\000\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\224\000\224\000\224\000\224\000\224\000\
+ \224\000\228\000\228\000\228\000\228\000\228\000\228\000\228\000\
+ \228\000\228\000\228\000\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\228\000\228\000\228\000\228\000\228\000\228\000\
+ \255\255\255\255\255\255\224\000\224\000\224\000\224\000\224\000\
+ \224\000\255\255\255\255\255\255\255\255\255\255\255\255\235\000\
+ \235\000\235\000\235\000\235\000\235\000\235\000\235\000\235\000\
+ \235\000\255\255\228\000\228\000\228\000\228\000\228\000\228\000\
+ \235\000\235\000\235\000\235\000\235\000\235\000\239\000\239\000\
+ \239\000\239\000\239\000\239\000\239\000\239\000\239\000\239\000\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\239\000\
+ \239\000\239\000\239\000\239\000\239\000\255\255\255\255\255\255\
+ \235\000\235\000\235\000\235\000\235\000\235\000\255\255\255\255\
+ \255\255\255\255\255\255\255\255\246\000\246\000\246\000\246\000\
+ \246\000\246\000\246\000\246\000\246\000\246\000\255\255\239\000\
+ \239\000\239\000\239\000\239\000\239\000\246\000\246\000\246\000\
+ \246\000\246\000\246\000\250\000\250\000\250\000\250\000\250\000\
+ \250\000\250\000\250\000\250\000\250\000\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\250\000\250\000\250\000\250\000\
+ \250\000\250\000\255\255\255\255\255\255\246\000\246\000\246\000\
+ \246\000\246\000\246\000\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\250\000\250\000\250\000\250\000\
+ \250\000\250\000\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
+ \255\255\255\255\255\255\255\255";
Lexing.lex_base_code =
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
- \000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
+ \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000";
Lexing.lex_trans_code =
"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\
\000\000\000\000\000\000\000\000\000\000\000\000";
Lexing.lex_check_code =
"\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \255\255\000\000\039\000\123\000\124\000\130\000\131\000\255\255\
+ \255\255\000\000\040\000\155\000\156\000\162\000\163\000\255\255\
\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
- \000\000\039\000\123\000\124\000\130\000\131\000\255\255\255\255\
+ \000\000\040\000\155\000\156\000\162\000\163\000\255\255\255\255\
\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\255\
| _ -> reset_line lexbuf; token lexbuf
end
else (reset_line lexbuf; token lexbuf) )
-# 1489 "lexer_cocci.ml"
+# 2005 "lexer_cocci.ml"
| 1 ->
# 522 "lexer_cocci.mll"
( start_line false; token lexbuf )
-# 1494 "lexer_cocci.ml"
+# 2010 "lexer_cocci.ml"
| 2 ->
let
# 524 "lexer_cocci.mll"
after
-# 1500 "lexer_cocci.ml"
+# 2016 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in
# 524 "lexer_cocci.mll"
(
start_line true;
TPragma (Ast.Indent str, get_current_line_type lexbuf)
| _ -> start_line false; token lexbuf )
-# 1513 "lexer_cocci.ml"
+# 2029 "lexer_cocci.ml"
| 3 ->
# 536 "lexer_cocci.mll"
start_line true;
TPragma (Ast.Space (tok lexbuf), get_current_line_type lexbuf)
| _ -> failwith "attributes only allowedin + code" )
-# 1522 "lexer_cocci.ml"
+# 2038 "lexer_cocci.ml"
| 4 ->
# 542 "lexer_cocci.mll"
( start_line true; TArobArob )
-# 1527 "lexer_cocci.ml"
+# 2043 "lexer_cocci.ml"
| 5 ->
# 543 "lexer_cocci.mll"
then (start_line true; TArob)
else (check_minus_context_linetype "@";
TPArob (get_current_line_type lexbuf)) )
-# 1536 "lexer_cocci.ml"
+# 2052 "lexer_cocci.ml"
| 6 ->
# 549 "lexer_cocci.mll"
( start_line true; TTildeEq (get_current_line_type lexbuf) )
-# 1541 "lexer_cocci.ml"
+# 2057 "lexer_cocci.ml"
| 7 ->
# 550 "lexer_cocci.mll"
( start_line true; TTildeExclEq (get_current_line_type lexbuf) )
-# 1546 "lexer_cocci.ml"
+# 2062 "lexer_cocci.ml"
| 8 ->
# 552 "lexer_cocci.mll"
( start_line true; check_minus_context_linetype (tok lexbuf);
TWhen (get_current_line_type lexbuf) )
-# 1552 "lexer_cocci.ml"
+# 2068 "lexer_cocci.ml"
| 9 ->
# 556 "lexer_cocci.mll"
( start_line true; check_minus_context_linetype (tok lexbuf);
TEllipsis (get_current_line_type lexbuf) )
-# 1558 "lexer_cocci.ml"
+# 2074 "lexer_cocci.ml"
| 10 ->
# 567 "lexer_cocci.mll"
( start_line true; check_context_linetype (tok lexbuf);
TOEllipsis (get_current_line_type lexbuf) )
-# 1564 "lexer_cocci.ml"
+# 2080 "lexer_cocci.ml"
| 11 ->
# 569 "lexer_cocci.mll"
( start_line true; check_context_linetype (tok lexbuf);
TCEllipsis (get_current_line_type lexbuf) )
-# 1570 "lexer_cocci.ml"
+# 2086 "lexer_cocci.ml"
| 12 ->
# 571 "lexer_cocci.mll"
( start_line true; check_minus_context_linetype (tok lexbuf);
TPOEllipsis (get_current_line_type lexbuf) )
-# 1576 "lexer_cocci.ml"
+# 2092 "lexer_cocci.ml"
| 13 ->
# 573 "lexer_cocci.mll"
( start_line true; check_minus_context_linetype (tok lexbuf);
TPCEllipsis (get_current_line_type lexbuf) )
-# 1582 "lexer_cocci.ml"
+# 2098 "lexer_cocci.ml"
| 14 ->
# 586 "lexer_cocci.mll"
then (start_line true; TMinus (get_current_line_type lexbuf))
else (patch_or_match PATCH;
add_current_line_type D.MINUS; token lexbuf) )
-# 1591 "lexer_cocci.ml"
+# 2107 "lexer_cocci.ml"
| 15 ->
# 591 "lexer_cocci.mll"
then TPlus0
else (patch_or_match PATCH;
add_current_line_type D.PLUS; token lexbuf) )
-# 1602 "lexer_cocci.ml"
+# 2118 "lexer_cocci.ml"
| 16 ->
# 598 "lexer_cocci.mll"
else if !Data.in_meta
then TWhy0
else (add_current_line_type D.OPT; token lexbuf) )
-# 1612 "lexer_cocci.ml"
+# 2128 "lexer_cocci.ml"
| 17 ->
# 604 "lexer_cocci.mll"
else if !Data.in_meta
then TBang0
else (add_current_line_type D.UNIQUE; token lexbuf) )
-# 1622 "lexer_cocci.ml"
+# 2138 "lexer_cocci.ml"
| 18 ->
# 610 "lexer_cocci.mll"
else
(start_line true; check_context_linetype (tok lexbuf);
TOPar0 (get_current_line_type lexbuf)))
-# 1631 "lexer_cocci.ml"
+# 2147 "lexer_cocci.ml"
| 19 ->
# 615 "lexer_cocci.mll"
( start_line true;
TOPar0 (contextify(get_current_line_type lexbuf)) )
-# 1637 "lexer_cocci.ml"
+# 2153 "lexer_cocci.ml"
| 20 ->
# 617 "lexer_cocci.mll"
else (start_line true;
check_context_linetype (tok lexbuf);
TMid0 (get_current_line_type lexbuf)))
-# 1646 "lexer_cocci.ml"
+# 2162 "lexer_cocci.ml"
| 21 ->
# 622 "lexer_cocci.mll"
( start_line true;
TMid0 (contextify(get_current_line_type lexbuf)) )
-# 1652 "lexer_cocci.ml"
+# 2168 "lexer_cocci.ml"
| 22 ->
# 624 "lexer_cocci.mll"
else
(start_line true; check_context_linetype (tok lexbuf);
TCPar0 (get_current_line_type lexbuf)))
-# 1661 "lexer_cocci.ml"
+# 2177 "lexer_cocci.ml"
| 23 ->
# 629 "lexer_cocci.mll"
( start_line true;
TCPar0 (contextify(get_current_line_type lexbuf)) )
-# 1667 "lexer_cocci.ml"
+# 2183 "lexer_cocci.ml"
| 24 ->
# 632 "lexer_cocci.mll"
( start_line true; TOCro (get_current_line_type lexbuf) )
-# 1672 "lexer_cocci.ml"
+# 2188 "lexer_cocci.ml"
| 25 ->
# 633 "lexer_cocci.mll"
( start_line true; TCCro (get_current_line_type lexbuf) )
-# 1677 "lexer_cocci.ml"
+# 2193 "lexer_cocci.ml"
| 26 ->
# 634 "lexer_cocci.mll"
( start_line true; TOBrace (get_current_line_type lexbuf) )
-# 1682 "lexer_cocci.ml"
+# 2198 "lexer_cocci.ml"
| 27 ->
# 635 "lexer_cocci.mll"
( start_line true; TCBrace (get_current_line_type lexbuf) )
-# 1687 "lexer_cocci.ml"
+# 2203 "lexer_cocci.ml"
| 28 ->
# 637 "lexer_cocci.mll"
( start_line true; TPtrOp (get_current_line_type lexbuf) )
-# 1692 "lexer_cocci.ml"
+# 2208 "lexer_cocci.ml"
| 29 ->
# 638 "lexer_cocci.mll"
( start_line true; TDot (get_current_line_type lexbuf) )
-# 1697 "lexer_cocci.ml"
+# 2213 "lexer_cocci.ml"
| 30 ->
# 639 "lexer_cocci.mll"
( start_line true; TComma (get_current_line_type lexbuf) )
-# 1702 "lexer_cocci.ml"
+# 2218 "lexer_cocci.ml"
| 31 ->
# 640 "lexer_cocci.mll"
if !Data.in_meta
then TMPtVirg (* works better with tokens_all *)
else TPtVirg (get_current_line_type lexbuf) )
-# 1710 "lexer_cocci.ml"
+# 2226 "lexer_cocci.ml"
| 32 ->
# 646 "lexer_cocci.mll"
else
(patch_or_match MATCH;
add_current_line_type D.MINUS; token lexbuf) )
-# 1721 "lexer_cocci.ml"
+# 2237 "lexer_cocci.ml"
| 33 ->
# 653 "lexer_cocci.mll"
( start_line true;
TDmOp (Ast.Div,get_current_line_type lexbuf) )
-# 1727 "lexer_cocci.ml"
+# 2243 "lexer_cocci.ml"
| 34 ->
# 655 "lexer_cocci.mll"
( start_line true;
TDmOp (Ast.Mod,get_current_line_type lexbuf) )
-# 1733 "lexer_cocci.ml"
+# 2249 "lexer_cocci.ml"
| 35 ->
# 657 "lexer_cocci.mll"
( start_line true; TTilde (get_current_line_type lexbuf) )
-# 1738 "lexer_cocci.ml"
+# 2254 "lexer_cocci.ml"
| 36 ->
# 659 "lexer_cocci.mll"
(start_line true; TInc (get_current_line_type lexbuf))
else (patch_or_match PATCH;
add_current_line_type D.PLUSPLUS; token lexbuf) )
-# 1748 "lexer_cocci.ml"
+# 2264 "lexer_cocci.ml"
| 37 ->
# 665 "lexer_cocci.mll"
( start_line true; TDec (get_current_line_type lexbuf) )
-# 1753 "lexer_cocci.ml"
+# 2269 "lexer_cocci.ml"
| 38 ->
# 667 "lexer_cocci.mll"
( start_line true; TEq (get_current_line_type lexbuf) )
-# 1758 "lexer_cocci.ml"
+# 2274 "lexer_cocci.ml"
| 39 ->
# 669 "lexer_cocci.mll"
( start_line true; mkassign Ast.Minus lexbuf )
-# 1763 "lexer_cocci.ml"
+# 2279 "lexer_cocci.ml"
| 40 ->
# 670 "lexer_cocci.mll"
( start_line true; mkassign Ast.Plus lexbuf )
-# 1768 "lexer_cocci.ml"
+# 2284 "lexer_cocci.ml"
| 41 ->
# 672 "lexer_cocci.mll"
( start_line true; mkassign Ast.Mul lexbuf )
-# 1773 "lexer_cocci.ml"
+# 2289 "lexer_cocci.ml"
| 42 ->
# 673 "lexer_cocci.mll"
( start_line true; mkassign Ast.Div lexbuf )
-# 1778 "lexer_cocci.ml"
+# 2294 "lexer_cocci.ml"
| 43 ->
# 674 "lexer_cocci.mll"
( start_line true; mkassign Ast.Mod lexbuf )
-# 1783 "lexer_cocci.ml"
+# 2299 "lexer_cocci.ml"
| 44 ->
# 676 "lexer_cocci.mll"
( start_line true; mkassign Ast.And lexbuf )
-# 1788 "lexer_cocci.ml"
+# 2304 "lexer_cocci.ml"
| 45 ->
# 677 "lexer_cocci.mll"
( start_line true; mkassign Ast.Or lexbuf )
-# 1793 "lexer_cocci.ml"
+# 2309 "lexer_cocci.ml"
| 46 ->
# 678 "lexer_cocci.mll"
( start_line true; mkassign Ast.Xor lexbuf )
-# 1798 "lexer_cocci.ml"
+# 2314 "lexer_cocci.ml"
| 47 ->
# 680 "lexer_cocci.mll"
( start_line true; mkassign Ast.DecLeft lexbuf )
-# 1803 "lexer_cocci.ml"
+# 2319 "lexer_cocci.ml"
| 48 ->
# 681 "lexer_cocci.mll"
( start_line true; mkassign Ast.DecRight lexbuf )
-# 1808 "lexer_cocci.ml"
+# 2324 "lexer_cocci.ml"
| 49 ->
# 683 "lexer_cocci.mll"
( start_line true; TDotDot (get_current_line_type lexbuf) )
-# 1813 "lexer_cocci.ml"
+# 2329 "lexer_cocci.ml"
| 50 ->
# 685 "lexer_cocci.mll"
( start_line true; TEqEq (get_current_line_type lexbuf) )
-# 1818 "lexer_cocci.ml"
+# 2334 "lexer_cocci.ml"
| 51 ->
# 686 "lexer_cocci.mll"
( start_line true; TNotEq (get_current_line_type lexbuf) )
-# 1823 "lexer_cocci.ml"
+# 2339 "lexer_cocci.ml"
| 52 ->
# 687 "lexer_cocci.mll"
( start_line true;
TLogOp(Ast.SupEq,get_current_line_type lexbuf) )
-# 1829 "lexer_cocci.ml"
+# 2345 "lexer_cocci.ml"
| 53 ->
# 689 "lexer_cocci.mll"
if !Data.in_meta
then TSub(get_current_line_type lexbuf)
else TLogOp(Ast.InfEq,get_current_line_type lexbuf) )
-# 1837 "lexer_cocci.ml"
+# 2353 "lexer_cocci.ml"
| 54 ->
# 693 "lexer_cocci.mll"
( start_line true;
TLogOp(Ast.Inf,get_current_line_type lexbuf) )
-# 1843 "lexer_cocci.ml"
+# 2359 "lexer_cocci.ml"
| 55 ->
# 695 "lexer_cocci.mll"
( start_line true;
TLogOp(Ast.Sup,get_current_line_type lexbuf) )
-# 1849 "lexer_cocci.ml"
+# 2365 "lexer_cocci.ml"
| 56 ->
# 698 "lexer_cocci.mll"
( start_line true; TAndLog (get_current_line_type lexbuf) )
-# 1854 "lexer_cocci.ml"
+# 2370 "lexer_cocci.ml"
| 57 ->
# 699 "lexer_cocci.mll"
( start_line true; TOrLog (get_current_line_type lexbuf) )
-# 1859 "lexer_cocci.ml"
+# 2375 "lexer_cocci.ml"
| 58 ->
# 701 "lexer_cocci.mll"
( start_line true;
TShROp(Ast.DecRight,get_current_line_type lexbuf) )
-# 1865 "lexer_cocci.ml"
+# 2381 "lexer_cocci.ml"
| 59 ->
# 703 "lexer_cocci.mll"
( start_line true;
TShLOp(Ast.DecLeft,get_current_line_type lexbuf) )
-# 1871 "lexer_cocci.ml"
+# 2387 "lexer_cocci.ml"
| 60 ->
# 706 "lexer_cocci.mll"
( start_line true; TAnd (get_current_line_type lexbuf) )
-# 1876 "lexer_cocci.ml"
+# 2392 "lexer_cocci.ml"
| 61 ->
# 707 "lexer_cocci.mll"
( start_line true; TXor(get_current_line_type lexbuf) )
-# 1881 "lexer_cocci.ml"
+# 2397 "lexer_cocci.ml"
| 62 ->
# 709 "lexer_cocci.mll"
( start_line true; TCppConcatOp )
-# 1886 "lexer_cocci.ml"
+# 2402 "lexer_cocci.ml"
| 63 ->
let
# 710 "lexer_cocci.mll"
def
-# 1892 "lexer_cocci.ml"
+# 2408 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_mem.(0)
and
# 711 "lexer_cocci.mll"
ident
-# 1897 "lexer_cocci.ml"
+# 2413 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in
# 712 "lexer_cocci.mll"
( start_line true;
(lt,
check_var ident
(arity,line,lline,offset+off,col+off,[],[],[])) )
-# 1909 "lexer_cocci.ml"
+# 2425 "lexer_cocci.ml"
| 64 ->
let
# 721 "lexer_cocci.mll"
def
-# 1915 "lexer_cocci.ml"
+# 2431 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_mem.(0)
and
# 722 "lexer_cocci.mll"
ident
-# 1920 "lexer_cocci.ml"
+# 2436 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in
# 723 "lexer_cocci.mll"
( start_line true;
(lt,
check_var ident
(arity,line,lline,offset+off,col+off,[],[],[])) )
-# 1932 "lexer_cocci.ml"
+# 2448 "lexer_cocci.ml"
| 65 ->
let
# 732 "lexer_cocci.mll"
def
-# 1938 "lexer_cocci.ml"
+# 2454 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_mem.(0)
and
# 733 "lexer_cocci.mll"
ident
-# 1943 "lexer_cocci.ml"
+# 2459 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) (lexbuf.Lexing.lex_curr_pos + -1) in
# 735 "lexer_cocci.mll"
( start_line true;
(arity,line,lline,offset+off,col+off,strbef,straft,pos),
offset + off + (String.length ident),
col + off + (String.length ident)) )
-# 1957 "lexer_cocci.ml"
+# 2473 "lexer_cocci.ml"
| 66 ->
# 747 "lexer_cocci.mll"
( TIncludeL
(let str = tok lexbuf in
- let start = String.index str '"' in
- let finish = String.rindex str '"' in
+ let start = String.index str '\"' in
+ let finish = String.rindex str '\"' in
start_line true;
(process_include start finish str,get_current_line_type lexbuf)) )
-# 1967 "lexer_cocci.ml"
+# 2483 "lexer_cocci.ml"
| 67 ->
# 754 "lexer_cocci.mll"
let finish = String.rindex str '>' in
start_line true;
(process_include start finish str,get_current_line_type lexbuf)) )
-# 1977 "lexer_cocci.ml"
+# 2493 "lexer_cocci.ml"
| 68 ->
# 769 "lexer_cocci.mll"
( start_line true; check_plus_linetype (tok lexbuf);
TPragma (Ast.Noindent(tok lexbuf), get_current_line_type lexbuf) )
-# 1983 "lexer_cocci.ml"
+# 2499 "lexer_cocci.ml"
| 69 ->
# 772 "lexer_cocci.mll"
TPragma (Ast.Indent("/*"^(comment check_comment lexbuf)),
get_current_line_type lexbuf)
| _ -> let _ = comment (fun _ -> ()) lexbuf in token lexbuf )
-# 1997 "lexer_cocci.ml"
+# 2513 "lexer_cocci.ml"
| 70 ->
# 783 "lexer_cocci.mll"
(let str = tok lexbuf in
(drop_spaces(String.sub str 3 (String.length str - 3)),
(get_current_line_type lexbuf))) )
-# 2008 "lexer_cocci.ml"
+# 2524 "lexer_cocci.ml"
| 71 ->
# 791 "lexer_cocci.mll"
(let str = tok lexbuf in
(drop_spaces(String.sub str 3 (String.length str - 3)),
(get_current_line_type lexbuf))) )
-# 2019 "lexer_cocci.ml"
+# 2535 "lexer_cocci.ml"
| 72 ->
# 800 "lexer_cocci.mll"
( start_line true; id_tokens lexbuf )
-# 2024 "lexer_cocci.ml"
+# 2540 "lexer_cocci.ml"
| 73 ->
-# 802 "lexer_cocci.mll"
- ( start_line true;
- TChar(char lexbuf,get_current_line_type lexbuf) )
-# 2030 "lexer_cocci.ml"
+# 804 "lexer_cocci.mll"
+ ( start_line true; id_tokens lexbuf )
+# 2545 "lexer_cocci.ml"
| 74 ->
-# 804 "lexer_cocci.mll"
+# 811 "lexer_cocci.mll"
+ (
+ start_line true;
+ if not !Flag.c_plus_plus
+ then Common.pr2_once "< and > not allowed in C identifiers, try -c++ option";
+ id_tokens lexbuf
+ )
+# 2555 "lexer_cocci.ml"
+
+ | 75 ->
+# 820 "lexer_cocci.mll"
+ (
+ start_line true;
+ if not !Flag.c_plus_plus
+ then Common.pr2_once "< and > not allowed in C identifiers, try -c++ option";
+ id_tokens lexbuf
+ )
+# 2565 "lexer_cocci.ml"
+
+ | 76 ->
+# 834 "lexer_cocci.mll"
+ (
+ start_line true;
+ if not !Flag.c_plus_plus
+ then Common.pr2_once "~ and :: not allowed in C identifiers, try -c++ option";
+ id_tokens lexbuf
+ )
+# 2575 "lexer_cocci.ml"
+
+ | 77 ->
+# 845 "lexer_cocci.mll"
+ (
+ start_line true;
+ if not !Flag.c_plus_plus
+ then Common.pr2_once "~ and :: not allowed in C identifiers, try -c++ option";
+ id_tokens lexbuf
+ )
+# 2585 "lexer_cocci.ml"
+
+ | 78 ->
+# 854 "lexer_cocci.mll"
( start_line true;
+ TChar(char lexbuf,get_current_line_type lexbuf) )
+# 2591 "lexer_cocci.ml"
+
+ | 79 ->
+# 856 "lexer_cocci.mll"
+ ( start_line true;
TString(string lexbuf,(get_current_line_type lexbuf)) )
-# 2036 "lexer_cocci.ml"
+# 2597 "lexer_cocci.ml"
- | 75 ->
+ | 80 ->
let
-# 806 "lexer_cocci.mll"
+# 858 "lexer_cocci.mll"
x
-# 2042 "lexer_cocci.ml"
+# 2603 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
-# 806 "lexer_cocci.mll"
+# 858 "lexer_cocci.mll"
( start_line true;
TFloat(x,(get_current_line_type lexbuf)) )
-# 2047 "lexer_cocci.ml"
+# 2608 "lexer_cocci.ml"
- | 76 ->
+ | 81 ->
let
-# 816 "lexer_cocci.mll"
+# 868 "lexer_cocci.mll"
x
-# 2053 "lexer_cocci.ml"
+# 2614 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
-# 816 "lexer_cocci.mll"
+# 868 "lexer_cocci.mll"
( start_line true; TInt(x,(get_current_line_type lexbuf)) )
-# 2057 "lexer_cocci.ml"
+# 2618 "lexer_cocci.ml"
- | 77 ->
-# 818 "lexer_cocci.mll"
+ | 82 ->
+# 870 "lexer_cocci.mll"
( TIso )
-# 2062 "lexer_cocci.ml"
+# 2623 "lexer_cocci.ml"
- | 78 ->
-# 819 "lexer_cocci.mll"
+ | 83 ->
+# 871 "lexer_cocci.mll"
( TRightIso )
-# 2067 "lexer_cocci.ml"
+# 2628 "lexer_cocci.ml"
- | 79 ->
-# 821 "lexer_cocci.mll"
+ | 84 ->
+# 873 "lexer_cocci.mll"
( EOF )
-# 2072 "lexer_cocci.ml"
+# 2633 "lexer_cocci.ml"
- | 80 ->
-# 823 "lexer_cocci.mll"
+ | 85 ->
+# 875 "lexer_cocci.mll"
( lexerr "unrecognised symbol, in token rule: " (tok lexbuf) )
-# 2077 "lexer_cocci.ml"
+# 2638 "lexer_cocci.ml"
| __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_token_rec lexbuf __ocaml_lex_state
and char lexbuf =
- __ocaml_lex_char_rec lexbuf 188
+ __ocaml_lex_char_rec lexbuf 220
and __ocaml_lex_char_rec lexbuf __ocaml_lex_state =
match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
| 0 ->
let
-# 827 "lexer_cocci.mll"
+# 879 "lexer_cocci.mll"
x
-# 2089 "lexer_cocci.ml"
+# 2650 "lexer_cocci.ml"
= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in
-# 827 "lexer_cocci.mll"
+# 879 "lexer_cocci.mll"
( String.make 1 x ^ restchars lexbuf )
-# 2093 "lexer_cocci.ml"
+# 2654 "lexer_cocci.ml"
| 1 ->
let
-# 829 "lexer_cocci.mll"
+# 881 "lexer_cocci.mll"
x
-# 2099 "lexer_cocci.ml"
+# 2660 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
-# 829 "lexer_cocci.mll"
+# 881 "lexer_cocci.mll"
( x ^ restchars lexbuf )
-# 2103 "lexer_cocci.ml"
+# 2664 "lexer_cocci.ml"
| 2 ->
let
-# 833 "lexer_cocci.mll"
+# 885 "lexer_cocci.mll"
x
-# 2109 "lexer_cocci.ml"
+# 2670 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
-# 833 "lexer_cocci.mll"
+# 885 "lexer_cocci.mll"
( x ^ restchars lexbuf )
-# 2113 "lexer_cocci.ml"
+# 2674 "lexer_cocci.ml"
| 3 ->
let
-# 834 "lexer_cocci.mll"
+# 886 "lexer_cocci.mll"
v
-# 2119 "lexer_cocci.ml"
+# 2680 "lexer_cocci.ml"
= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1)
and
-# 834 "lexer_cocci.mll"
+# 886 "lexer_cocci.mll"
x
-# 2124 "lexer_cocci.ml"
+# 2685 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos (lexbuf.Lexing.lex_start_pos + 2) in
-# 835 "lexer_cocci.mll"
+# 887 "lexer_cocci.mll"
(
(match v with (* Machine specific ? *)
| 'n' -> () | 't' -> () | 'v' -> () | 'b' -> () | 'r' -> ()
| 'f' -> () | 'a' -> ()
- | '\\' -> () | '?' -> () | '\'' -> () | '"' -> ()
+ | '\\' -> () | '?' -> () | '\'' -> () | '\"' -> ()
| 'e' -> () (* linuxext: ? *)
| _ ->
Common.pr2 ("LEXER: unrecognised symbol in char:"^tok lexbuf);
);
x ^ restchars lexbuf
)
-# 2138 "lexer_cocci.ml"
+# 2699 "lexer_cocci.ml"
| 4 ->
-# 847 "lexer_cocci.mll"
+# 899 "lexer_cocci.mll"
( Common.pr2 ("LEXER: unrecognised symbol in char:"^tok lexbuf);
tok lexbuf ^ restchars lexbuf
)
-# 2145 "lexer_cocci.ml"
+# 2706 "lexer_cocci.ml"
| __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_char_rec lexbuf __ocaml_lex_state
and restchars lexbuf =
- __ocaml_lex_restchars_rec lexbuf 198
+ __ocaml_lex_restchars_rec lexbuf 230
and __ocaml_lex_restchars_rec lexbuf __ocaml_lex_state =
match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
| 0 ->
-# 852 "lexer_cocci.mll"
+# 904 "lexer_cocci.mll"
( "" )
-# 2156 "lexer_cocci.ml"
+# 2717 "lexer_cocci.ml"
| 1 ->
let
-# 853 "lexer_cocci.mll"
+# 905 "lexer_cocci.mll"
x
-# 2162 "lexer_cocci.ml"
+# 2723 "lexer_cocci.ml"
= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in
-# 853 "lexer_cocci.mll"
+# 905 "lexer_cocci.mll"
( String.make 1 x ^ restchars lexbuf )
-# 2166 "lexer_cocci.ml"
+# 2727 "lexer_cocci.ml"
| 2 ->
let
-# 855 "lexer_cocci.mll"
+# 907 "lexer_cocci.mll"
x
-# 2172 "lexer_cocci.ml"
+# 2733 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
-# 855 "lexer_cocci.mll"
+# 907 "lexer_cocci.mll"
( x ^ restchars lexbuf )
-# 2176 "lexer_cocci.ml"
+# 2737 "lexer_cocci.ml"
| 3 ->
let
-# 859 "lexer_cocci.mll"
+# 911 "lexer_cocci.mll"
x
-# 2182 "lexer_cocci.ml"
+# 2743 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
-# 859 "lexer_cocci.mll"
+# 911 "lexer_cocci.mll"
( x ^ restchars lexbuf )
-# 2186 "lexer_cocci.ml"
+# 2747 "lexer_cocci.ml"
| 4 ->
let
-# 860 "lexer_cocci.mll"
+# 912 "lexer_cocci.mll"
v
-# 2192 "lexer_cocci.ml"
+# 2753 "lexer_cocci.ml"
= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1)
and
-# 860 "lexer_cocci.mll"
+# 912 "lexer_cocci.mll"
x
-# 2197 "lexer_cocci.ml"
+# 2758 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos (lexbuf.Lexing.lex_start_pos + 2) in
-# 861 "lexer_cocci.mll"
+# 913 "lexer_cocci.mll"
(
(match v with (* Machine specific ? *)
| 'n' -> () | 't' -> () | 'v' -> () | 'b' -> () | 'r' -> ()
| 'f' -> () | 'a' -> ()
- | '\\' -> () | '?' -> () | '\'' -> () | '"' -> ()
+ | '\\' -> () | '?' -> () | '\'' -> () | '\"' -> ()
| 'e' -> () (* linuxext: ? *)
| _ ->
Common.pr2 ("LEXER: unrecognised symbol in char:"^tok lexbuf);
);
x ^ restchars lexbuf
)
-# 2211 "lexer_cocci.ml"
+# 2772 "lexer_cocci.ml"
| 5 ->
-# 873 "lexer_cocci.mll"
+# 925 "lexer_cocci.mll"
( Common.pr2 ("LEXER: unrecognised symbol in char:"^tok lexbuf);
tok lexbuf ^ restchars lexbuf
)
-# 2218 "lexer_cocci.ml"
+# 2779 "lexer_cocci.ml"
| __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_restchars_rec lexbuf __ocaml_lex_state
and string lexbuf =
- __ocaml_lex_string_rec lexbuf 209
+ __ocaml_lex_string_rec lexbuf 241
and __ocaml_lex_string_rec lexbuf __ocaml_lex_state =
match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
| 0 ->
-# 878 "lexer_cocci.mll"
- ( "" )
-# 2229 "lexer_cocci.ml"
+# 930 "lexer_cocci.mll"
+ ( "" )
+# 2790 "lexer_cocci.ml"
| 1 ->
let
-# 879 "lexer_cocci.mll"
+# 931 "lexer_cocci.mll"
x
-# 2235 "lexer_cocci.ml"
+# 2796 "lexer_cocci.ml"
= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in
-# 879 "lexer_cocci.mll"
+# 931 "lexer_cocci.mll"
( Common.string_of_char x ^ string lexbuf )
-# 2239 "lexer_cocci.ml"
+# 2800 "lexer_cocci.ml"
| 2 ->
let
-# 880 "lexer_cocci.mll"
+# 932 "lexer_cocci.mll"
x
-# 2245 "lexer_cocci.ml"
+# 2806 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
-# 880 "lexer_cocci.mll"
+# 932 "lexer_cocci.mll"
( x ^ string lexbuf )
-# 2249 "lexer_cocci.ml"
+# 2810 "lexer_cocci.ml"
| 3 ->
let
-# 881 "lexer_cocci.mll"
+# 933 "lexer_cocci.mll"
x
-# 2255 "lexer_cocci.ml"
+# 2816 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in
-# 881 "lexer_cocci.mll"
+# 933 "lexer_cocci.mll"
( x ^ string lexbuf )
-# 2259 "lexer_cocci.ml"
+# 2820 "lexer_cocci.ml"
| 4 ->
let
-# 882 "lexer_cocci.mll"
+# 934 "lexer_cocci.mll"
v
-# 2265 "lexer_cocci.ml"
+# 2826 "lexer_cocci.ml"
= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1)
and
-# 882 "lexer_cocci.mll"
+# 934 "lexer_cocci.mll"
x
-# 2270 "lexer_cocci.ml"
+# 2831 "lexer_cocci.ml"
= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos (lexbuf.Lexing.lex_start_pos + 2) in
-# 883 "lexer_cocci.mll"
+# 935 "lexer_cocci.mll"
(
(match v with
| 'n' -> () | 't' -> () | 'v' -> () | 'b' -> () | 'r' -> ()
| 'f' -> () | 'a' -> ()
- | '\\' -> () | '?' -> () | '\'' -> () | '"' -> ()
+ | '\\' -> () | '?' -> () | '\'' -> () | '\"' -> ()
| 'e' -> ()
| '\n' -> ()
| '(' -> () | '|' -> () | ')' -> ()
);
x ^ string lexbuf
)
-# 2285 "lexer_cocci.ml"
+# 2846 "lexer_cocci.ml"
| 5 ->
-# 895 "lexer_cocci.mll"
+# 947 "lexer_cocci.mll"
( lexerr "unrecognised symbol: " (tok lexbuf) )
-# 2290 "lexer_cocci.ml"
+# 2851 "lexer_cocci.ml"
| __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_string_rec lexbuf __ocaml_lex_state
and comment check_comment lexbuf =
- __ocaml_lex_comment_rec check_comment lexbuf 220
+ __ocaml_lex_comment_rec check_comment lexbuf 252
and __ocaml_lex_comment_rec check_comment lexbuf __ocaml_lex_state =
match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
| 0 ->
-# 898 "lexer_cocci.mll"
+# 950 "lexer_cocci.mll"
( let s = tok lexbuf in check_comment s; start_line true; s )
-# 2301 "lexer_cocci.ml"
+# 2862 "lexer_cocci.ml"
| 1 ->
-# 900 "lexer_cocci.mll"
+# 952 "lexer_cocci.mll"
( let s = tok lexbuf in
(* even blank line should have a + *)
check_comment s;
reset_line lexbuf; s ^ comment check_comment lexbuf )
-# 2309 "lexer_cocci.ml"
+# 2870 "lexer_cocci.ml"
| 2 ->
-# 904 "lexer_cocci.mll"
+# 956 "lexer_cocci.mll"
( pass_zero();
if !current_line_started
then (start_line true;
let s = tok lexbuf in s^(comment check_comment lexbuf))
else (start_line true; comment check_comment lexbuf) )
-# 2318 "lexer_cocci.ml"
+# 2879 "lexer_cocci.ml"
| 3 ->
-# 911 "lexer_cocci.mll"
+# 963 "lexer_cocci.mll"
( let s = tok lexbuf in
check_comment s; start_line true; s ^ comment check_comment lexbuf )
-# 2324 "lexer_cocci.ml"
+# 2885 "lexer_cocci.ml"
| 4 ->
-# 914 "lexer_cocci.mll"
+# 966 "lexer_cocci.mll"
( let s = tok lexbuf in
check_comment s; start_line true; s ^ comment check_comment lexbuf )
-# 2330 "lexer_cocci.ml"
+# 2891 "lexer_cocci.ml"
| 5 ->
-# 917 "lexer_cocci.mll"
+# 969 "lexer_cocci.mll"
( start_line true; let s = tok lexbuf in
Common.pr2 ("LEXER: unrecognised symbol in comment:"^s);
s ^ comment check_comment lexbuf
)
-# 2338 "lexer_cocci.ml"
+# 2899 "lexer_cocci.ml"
| __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_comment_rec check_comment lexbuf __ocaml_lex_state
(arity,line,lline,offset+off,col+off,strbef,straft,pos),
offset + off + (String.length ident),
col + off + (String.length ident)) }
- | "#" [' ' '\t']* "include" [' ' '\t']* '"' [^ '"']+ '"'
+ | "#" [' ' '\t']* "include" [' ' '\t']* '\"' [^ '\"']+ '\"'
{ TIncludeL
(let str = tok lexbuf in
- let start = String.index str '"' in
- let finish = String.rindex str '"' in
+ let start = String.index str '\"' in
+ let finish = String.rindex str '\"' in
start_line true;
(process_include start finish str,get_current_line_type lexbuf)) }
| "#" [' ' '\t']* "include" [' ' '\t']* '<' [^ '>']+ '>'
| letter (letter | digit)*
{ start_line true; id_tokens lexbuf }
+ (* christia: testing *)
+ | (letter | '$') (letter | digit | '$') *
+ { start_line true; id_tokens lexbuf }
+
+ | (letter | '$') (letter | digit | '$') *
+ ('<' (letter | '$' | '~') (letter | digit | '$' | '~') * '>') ?
+ ("::~" (letter | '$') (letter | digit | '$') *
+ ('<' (letter | '$' | '~') (letter | digit | '$' | '~') * '>') ?) +
+
+ {
+ start_line true;
+ if not !Flag.c_plus_plus
+ then Common.pr2_once "< and > not allowed in C identifiers, try -c++ option";
+ id_tokens lexbuf
+ }
+ | ((letter | '$') (letter | digit | '$') * )
+ ('<' (letter | '$' | '~') (letter | digit | '$' | '~') * '>')
+
+ {
+ start_line true;
+ if not !Flag.c_plus_plus
+ then Common.pr2_once "< and > not allowed in C identifiers, try -c++ option";
+ id_tokens lexbuf
+ }
+
+ | (((letter | '$') (letter | digit | '$') * ))
+ ('<' (letter | '$' | '~') (letter | digit | '$' | '~') * '>') ?
+ "::" (((letter | '$') (letter | digit | '$') * ))
+ ('<' (letter | '$' | '~') (letter | digit | '$' | '~') * '>') ?
+ ("::" ((letter | '$') (letter | digit | '$') * )
+ ('<' (letter | '$' | '~') (letter | digit | '$' | '~') * '>') ?) *
+
+ {
+ start_line true;
+ if not !Flag.c_plus_plus
+ then Common.pr2_once "~ and :: not allowed in C identifiers, try -c++ option";
+ id_tokens lexbuf
+ }
+
+ | "::" ((letter | '$') (letter | digit | '$') * )
+ ('<' (letter | '$' | '~') (letter | digit | '$' | '~') * '>') ?
+ ("::" ((letter | '$') (letter | digit | '$') * )
+ ('<' (letter | '$' | '~') (letter | digit | '$' | '~') * '>') ?) *
+ {
+ start_line true;
+ if not !Flag.c_plus_plus
+ then Common.pr2_once "~ and :: not allowed in C identifiers, try -c++ option";
+ id_tokens lexbuf
+ }
+ (* christia: end *)
+
+
| "'" { start_line true;
TChar(char lexbuf,get_current_line_type lexbuf) }
- | '"' { start_line true;
+ | '\"' { start_line true;
TString(string lexbuf,(get_current_line_type lexbuf)) }
| (real as x) { start_line true;
TFloat(x,(get_current_line_type lexbuf)) }
(match v with (* Machine specific ? *)
| 'n' -> () | 't' -> () | 'v' -> () | 'b' -> () | 'r' -> ()
| 'f' -> () | 'a' -> ()
- | '\\' -> () | '?' -> () | '\'' -> () | '"' -> ()
+ | '\\' -> () | '?' -> () | '\'' -> () | '\"' -> ()
| 'e' -> () (* linuxext: ? *)
| _ ->
Common.pr2 ("LEXER: unrecognised symbol in char:"^tok lexbuf);
(match v with (* Machine specific ? *)
| 'n' -> () | 't' -> () | 'v' -> () | 'b' -> () | 'r' -> ()
| 'f' -> () | 'a' -> ()
- | '\\' -> () | '?' -> () | '\'' -> () | '"' -> ()
+ | '\\' -> () | '?' -> () | '\'' -> () | '\"' -> ()
| 'e' -> () (* linuxext: ? *)
| _ ->
Common.pr2 ("LEXER: unrecognised symbol in char:"^tok lexbuf);
}
and string = parse
- | '"' { "" }
+ | '\"' { "" }
| (_ as x) { Common.string_of_char x ^ string lexbuf }
| ("\\" (oct | oct oct | oct oct oct)) as x { x ^ string lexbuf }
| ("\\x" (hex | hex hex)) as x { x ^ string lexbuf }
(match v with
| 'n' -> () | 't' -> () | 'v' -> () | 'b' -> () | 'r' -> ()
| 'f' -> () | 'a' -> ()
- | '\\' -> () | '?' -> () | '\'' -> () | '"' -> ()
+ | '\\' -> () | '?' -> () | '\'' -> () | '\"' -> ()
| 'e' -> ()
| '\n' -> ()
| '(' -> () | '|' -> () | ')' -> ()
-# 0 "lexer_script.mll"
+(*
+ * Copyright 2012, INRIA
+ * Julia Lawall, Gilles Muller
+ * Copyright 2010-2011, INRIA, University of Copenhagen
+ * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
+ * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
+ * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
+ * This file is part of Coccinelle.
+ *
+ * Coccinelle 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, according to version 2 of the License.
+ *
+ * Coccinelle 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 Coccinelle. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * The authors reserve the right to distribute this or future versions of
+ * Coccinelle under other licenses.
+ *)
+
+
+# 0 "./lexer_script.ml"
+# 1 "lexer_script.mll"
open Parser_cocci_menhir
module D = Data
and __ocaml_lex_token_rec lexbuf __ocaml_lex_state =
match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
| 0 ->
-# 19 "lexer_script.mll"
+# 20 "lexer_script.mll"
( TScriptData (tok lexbuf) )
# 118 "lexer_script.ml"
| 1 ->
-# 21 "lexer_script.mll"
+# 22 "lexer_script.mll"
( inc_line();
let text = tok lexbuf in
let text =
# 131 "lexer_script.ml"
| 2 ->
-# 30 "lexer_script.mll"
+# 31 "lexer_script.mll"
( TArobArob )
# 136 "lexer_script.ml"
| 3 ->
-# 31 "lexer_script.mll"
+# 32 "lexer_script.mll"
( TArob )
# 141 "lexer_script.ml"
| 4 ->
-# 32 "lexer_script.mll"
+# 33 "lexer_script.mll"
( TScriptData (tok lexbuf) )
# 146 "lexer_script.ml"
| 5 ->
-# 33 "lexer_script.mll"
+# 34 "lexer_script.mll"
( token lexbuf )
# 151 "lexer_script.ml"
| 6 ->
-# 34 "lexer_script.mll"
+# 35 "lexer_script.mll"
( TScriptData (Printf.sprintf "\"%s\"" (string lexbuf)) )
# 156 "lexer_script.ml"
| 7 ->
-# 35 "lexer_script.mll"
+# 36 "lexer_script.mll"
( TScriptData (Printf.sprintf "'%s'" (cstring lexbuf)) )
# 161 "lexer_script.ml"
| 8 ->
-# 36 "lexer_script.mll"
+# 37 "lexer_script.mll"
( EOF )
# 166 "lexer_script.ml"
| 9 ->
-# 37 "lexer_script.mll"
+# 38 "lexer_script.mll"
( raise (Lexical ("unrecognised symbol, in token rule:"^tok lexbuf)) )
# 171 "lexer_script.ml"
and __ocaml_lex_string_rec lexbuf __ocaml_lex_state =
match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
| 0 ->
-# 41 "lexer_script.mll"
+# 42 "lexer_script.mll"
( "" )
# 182 "lexer_script.ml"
| 1 ->
let
-# 42 "lexer_script.mll"
+# 43 "lexer_script.mll"
x
# 188 "lexer_script.ml"
= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in
-# 42 "lexer_script.mll"
+# 43 "lexer_script.mll"
( (String.make 1 x) ^ string lexbuf )
# 192 "lexer_script.ml"
and __ocaml_lex_cstring_rec lexbuf __ocaml_lex_state =
match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with
| 0 ->
-# 45 "lexer_script.mll"
+# 46 "lexer_script.mll"
( "" )
# 203 "lexer_script.ml"
| 1 ->
let
-# 46 "lexer_script.mll"
+# 47 "lexer_script.mll"
x
# 209 "lexer_script.ml"
= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in
-# 46 "lexer_script.mll"
+# 47 "lexer_script.mll"
( (String.make 1 x) ^ cstring lexbuf )
# 213 "lexer_script.ml"
let exp_stm exp pv =
Ast0.wrap(Ast0.ExprStatement (exp, clt2mcode ";" pv))
+let make_fake_mcode _ = (Ast0.default_info(),Ast0.context_befaft(),-1)
+
let ifthen iff lp tst rp thn =
Ast0.wrap(Ast0.IfThen(clt2mcode "if" iff,
- clt2mcode "(" lp,tst,clt2mcode ")" rp,thn,
- (Ast0.default_info(),Ast0.context_befaft())))
+ clt2mcode "(" lp,tst,clt2mcode ")" rp,thn,make_fake_mcode()))
let ifthenelse iff lp tst rp thn e els =
Ast0.wrap(Ast0.IfThenElse(clt2mcode "if" iff,
clt2mcode "(" lp,tst,clt2mcode ")" rp,thn,
- clt2mcode "else" e,els,
- (Ast0.default_info(),Ast0.context_befaft())))
+ clt2mcode "else" e,els,make_fake_mcode()))
let forloop fr lp e1 sc1 e2 sc2 e3 rp s =
Ast0.wrap(Ast0.For(clt2mcode "for" fr,clt2mcode "(" lp,
Ast0.wrap(Ast0.ForExp(e1,clt2mcode ";" sc1)),e2,
clt2mcode ";" sc2,e3,clt2mcode ")" rp,s,
- (Ast0.default_info(),Ast0.context_befaft())))
+ make_fake_mcode()))
let forloop2 fr lp decl e2 sc2 e3 rp s =
let bef = (Ast0.default_info(),Ast0.context_befaft()) in
Ast0.wrap(Ast0.For(clt2mcode "for" fr,clt2mcode "(" lp,
Ast0.wrap(Ast0.ForDecl (bef,decl)),e2,
clt2mcode ";" sc2,e3,clt2mcode ")" rp,s,
- (Ast0.default_info(),Ast0.context_befaft())))
+ make_fake_mcode()))
let whileloop w lp e rp s =
Ast0.wrap(Ast0.While(clt2mcode "while" w,clt2mcode "(" lp,
- e,clt2mcode ")" rp,s,
- (Ast0.default_info(),Ast0.context_befaft())))
+ e,clt2mcode ")" rp,s,make_fake_mcode()))
let doloop d s w lp e rp pv =
Ast0.wrap(Ast0.Do(clt2mcode "do" d,s,clt2mcode "while" w,
let iterator i lp e rp s =
Ast0.wrap(Ast0.Iterator(i,clt2mcode "(" lp,e,clt2mcode ")" rp,s,
- (Ast0.default_info(),Ast0.context_befaft())))
+ make_fake_mcode()))
let switch s lp e rp lb d c rb =
let d =
(* ----------------------------------------------------------------------- *)
-(* In a nest, if the nest is -, all of the nested code must also be -.
-All are converted to context, because the next takes care of the -. *)
+(* In a nest, if the nest is -, all of the nested code must also be -. *)
let check_nests tokens =
let is_minus t =
let (line_type,a,b,c,d,e,f,g) = get_clt t in
List.mem line_type [D.MINUS;D.OPTMINUS;D.UNIQUEMINUS] in
- let drop_minus t =
+ let check_minus t =
let clt = try Some(get_clt t) with Failure _ -> None in
match clt with
Some (line_type,a,b,c,d,e,f,g) ->
(match line_type with
- D.MINUS -> update_clt t (D.CONTEXT,a,b,c,d,e,f,g)
- | D.OPTMINUS -> update_clt t (D.OPT,a,b,c,d,e,f,g)
- | D.UNIQUEMINUS -> update_clt t (D.UNIQUE,a,b,c,d,e,f,g)
+ D.MINUS | D.OPTMINUS | D.UNIQUEMINUS -> t
| _ -> failwith "minus token expected")
| None -> t in
let rec outside = function
and inside stack = function
[] -> failwith "missing nest end"
| ((PC.TPCEllipsis(clt),q) as t)::r ->
- (drop_minus t)
+ (check_minus t)
:: (if stack = 0 then outside r else inside (stack - 1) r)
| ((PC.TPOEllipsis(clt),q) as t)::r ->
- (drop_minus t) :: (inside (stack + 1) r)
- | t :: r -> (drop_minus t) :: (inside stack r) in
+ (check_minus t) :: (inside (stack + 1) r)
+ | t :: r -> (check_minus t) :: (inside stack r) in
outside tokens
let check_parentheses tokens =
let reinit _ =
PC.reinit (function _ -> PC.TArobArob (* a handy token *))
(Lexing.from_function
- (function buf -> function n -> raise Common.Impossible))
+ (function buf -> function n -> raise (Common.Impossible 157)))
let parse_one str parsefn file toks =
let all_tokens = ref toks in
let lexbuf_fake =
Lexing.from_function
- (function buf -> function n -> raise Common.Impossible)
+ (function buf -> function n -> raise (Common.Impossible 158))
in
reinit();
some restrictions on the -+ code *)
([],_) | (_,Ast.Generated) -> ([],minus)
| _ -> Iso_pattern.apply_isos chosen_isos minus rule_name in
+ (* must be before adj *)
+ let minus = Commas_on_lists.process minus in
(* after iso, because iso can intro ... *)
let minus = Adjacency.compute_adjacency minus in
let minus = Comm_assoc.comm_assoc minus rule_name dropiso in
+(*
+ * Copyright 2012, INRIA
+ * Julia Lawall, Gilles Muller
+ * Copyright 2010-2011, INRIA, University of Copenhagen
+ * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
+ * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
+ * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
+ * This file is part of Coccinelle.
+ *
+ * Coccinelle 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, according to version 2 of the License.
+ *
+ * Coccinelle 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 Coccinelle. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * The authors reserve the right to distribute this or future versions of
+ * Coccinelle under other licenses.
+ *)
+
+
+# 0 "./parser_cocci_menhir.ml"
exception Error
type token =
| Tvolatile of (
-# 122 "parser_cocci_menhir.mly"
+# 96 "parser_cocci_menhir.mly"
(Data.clt)
# 8 "parser_cocci_menhir.ml"
)
| Tvoid of (
-# 118 "parser_cocci_menhir.mly"
+# 92 "parser_cocci_menhir.mly"
(Data.clt)
# 13 "parser_cocci_menhir.ml"
)
| Tunsigned of (
-# 119 "parser_cocci_menhir.mly"
+# 93 "parser_cocci_menhir.mly"
(Data.clt)
# 18 "parser_cocci_menhir.ml"
)
| Tunion of (
-# 118 "parser_cocci_menhir.mly"
+# 92 "parser_cocci_menhir.mly"
(Data.clt)
# 23 "parser_cocci_menhir.ml"
)
| Ttypedef of (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
# 28 "parser_cocci_menhir.ml"
)
| Tstruct of (
-# 118 "parser_cocci_menhir.mly"
+# 92 "parser_cocci_menhir.mly"
(Data.clt)
# 33 "parser_cocci_menhir.ml"
)
| Tstatic of (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
# 38 "parser_cocci_menhir.ml"
)
| Tssize_t of (
-# 117 "parser_cocci_menhir.mly"
+# 91 "parser_cocci_menhir.mly"
(Data.clt)
# 43 "parser_cocci_menhir.ml"
)
| Tsize_t of (
-# 117 "parser_cocci_menhir.mly"
+# 91 "parser_cocci_menhir.mly"
(Data.clt)
# 48 "parser_cocci_menhir.ml"
)
| Tsigned of (
-# 119 "parser_cocci_menhir.mly"
+# 93 "parser_cocci_menhir.mly"
(Data.clt)
# 53 "parser_cocci_menhir.ml"
)
| Tshort of (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
# 58 "parser_cocci_menhir.ml"
)
| Tregister of (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
# 63 "parser_cocci_menhir.ml"
)
| Tptrdiff_t of (
-# 117 "parser_cocci_menhir.mly"
+# 91 "parser_cocci_menhir.mly"
(Data.clt)
# 68 "parser_cocci_menhir.ml"
)
| Tlong of (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
# 73 "parser_cocci_menhir.ml"
)
| Tlist
| Tint of (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
# 79 "parser_cocci_menhir.ml"
)
| Tinline of (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
# 84 "parser_cocci_menhir.ml"
)
| Tfloat of (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
# 89 "parser_cocci_menhir.ml"
)
| Textern of (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
# 94 "parser_cocci_menhir.ml"
)
| Tenum of (
-# 118 "parser_cocci_menhir.mly"
+# 92 "parser_cocci_menhir.mly"
(Data.clt)
# 99 "parser_cocci_menhir.ml"
)
| Tdouble of (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
# 104 "parser_cocci_menhir.ml"
)
| Tconst of (
-# 122 "parser_cocci_menhir.mly"
+# 96 "parser_cocci_menhir.mly"
(Data.clt)
# 109 "parser_cocci_menhir.ml"
)
| Tchar of (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
# 114 "parser_cocci_menhir.ml"
)
| Tauto of (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
# 119 "parser_cocci_menhir.ml"
)
| Tattr of (
-# 123 "parser_cocci_menhir.mly"
+# 97 "parser_cocci_menhir.mly"
(string * Data.clt)
# 124 "parser_cocci_menhir.ml"
)
| TXor of (
-# 164 "parser_cocci_menhir.mly"
+# 138 "parser_cocci_menhir.mly"
(Data.clt)
# 129 "parser_cocci_menhir.ml"
)
| TWords
| TWhy0
| TWhy of (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 136 "parser_cocci_menhir.ml"
)
| TWhile of (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
# 141 "parser_cocci_menhir.ml"
)
| TWhenTrue of (
-# 146 "parser_cocci_menhir.mly"
+# 120 "parser_cocci_menhir.mly"
(Data.clt)
# 146 "parser_cocci_menhir.ml"
)
| TWhenFalse of (
-# 146 "parser_cocci_menhir.mly"
+# 120 "parser_cocci_menhir.mly"
(Data.clt)
# 151 "parser_cocci_menhir.ml"
)
| TWhen of (
-# 146 "parser_cocci_menhir.mly"
+# 120 "parser_cocci_menhir.mly"
(Data.clt)
# 156 "parser_cocci_menhir.ml"
)
| TUsing
| TUnderscore
| TUndef of (
-# 153 "parser_cocci_menhir.mly"
+# 127 "parser_cocci_menhir.mly"
(Data.clt * token)
# 164 "parser_cocci_menhir.ml"
)
| TTypedef
| TTypeId of (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
# 170 "parser_cocci_menhir.ml"
)
| TType
| TTildeExclEq of (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 176 "parser_cocci_menhir.ml"
)
| TTildeEq of (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 181 "parser_cocci_menhir.ml"
)
| TTilde of (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 186 "parser_cocci_menhir.ml"
)
| TSymbol
| TSymId of (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
# 192 "parser_cocci_menhir.ml"
)
| TSwitch of (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
# 197 "parser_cocci_menhir.ml"
)
| TSub of (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 202 "parser_cocci_menhir.ml"
)
| TString of (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
# 207 "parser_cocci_menhir.ml"
)
| TStrict of (
-# 146 "parser_cocci_menhir.mly"
+# 120 "parser_cocci_menhir.mly"
(Data.clt)
# 212 "parser_cocci_menhir.ml"
)
| TStatement
| TSizeof of (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
# 218 "parser_cocci_menhir.ml"
)
| TShROp of (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 223 "parser_cocci_menhir.ml"
)
| TShLOp of (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 228 "parser_cocci_menhir.ml"
)
| TScriptData of (
-# 143 "parser_cocci_menhir.mly"
+# 117 "parser_cocci_menhir.mly"
(string)
# 233 "parser_cocci_menhir.ml"
)
| TScript
| TRuleName of (
-# 114 "parser_cocci_menhir.mly"
+# 88 "parser_cocci_menhir.mly"
(string)
# 239 "parser_cocci_menhir.ml"
)
| TRightIso
| TReturn of (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
# 245 "parser_cocci_menhir.ml"
)
| TPure
| TPtrOp of (
-# 176 "parser_cocci_menhir.mly"
+# 150 "parser_cocci_menhir.mly"
(Data.clt)
# 251 "parser_cocci_menhir.ml"
)
| TPtVirg of (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 256 "parser_cocci_menhir.ml"
)
| TPragma of (
-# 128 "parser_cocci_menhir.mly"
+# 102 "parser_cocci_menhir.mly"
(Ast_cocci.added_string * Data.clt)
# 261 "parser_cocci_menhir.ml"
)
| TPosition
| TPosAny
| TPlusFile of (
-# 155 "parser_cocci_menhir.mly"
+# 129 "parser_cocci_menhir.mly"
(string * Data.clt)
# 268 "parser_cocci_menhir.ml"
)
| TPlus0
| TPlus of (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 274 "parser_cocci_menhir.ml"
)
| TPathIsoFile of (
-# 151 "parser_cocci_menhir.mly"
+# 125 "parser_cocci_menhir.mly"
(string)
# 279 "parser_cocci_menhir.ml"
)
| TParameter
| TPOEllipsis of (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 285 "parser_cocci_menhir.ml"
)
| TPCEllipsis of (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 290 "parser_cocci_menhir.ml"
)
| TPArob of (
-# 142 "parser_cocci_menhir.mly"
+# 116 "parser_cocci_menhir.mly"
(Data.clt)
# 295 "parser_cocci_menhir.ml"
)
| TOrLog of (
-# 161 "parser_cocci_menhir.mly"
+# 135 "parser_cocci_menhir.mly"
(Data.clt)
# 300 "parser_cocci_menhir.ml"
)
| TOr of (
-# 163 "parser_cocci_menhir.mly"
+# 137 "parser_cocci_menhir.mly"
(Data.clt)
# 305 "parser_cocci_menhir.ml"
)
| TOn
| TOPar0 of (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 311 "parser_cocci_menhir.ml"
)
| TOPar of (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 316 "parser_cocci_menhir.ml"
)
| TOInit of (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
# 321 "parser_cocci_menhir.ml"
)
| TOEllipsis of (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 326 "parser_cocci_menhir.ml"
)
| TOCro of (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
# 331 "parser_cocci_menhir.ml"
)
| TOBrace of (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
# 336 "parser_cocci_menhir.ml"
)
| TNothing
| TNotEq of (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 342 "parser_cocci_menhir.ml"
)
| TNever
| TName
| TMul of (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 349 "parser_cocci_menhir.ml"
)
| TMinusFile of (
-# 155 "parser_cocci_menhir.mly"
+# 129 "parser_cocci_menhir.mly"
(string * Data.clt)
# 354 "parser_cocci_menhir.ml"
)
| TMinus of (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 359 "parser_cocci_menhir.ml"
)
| TMid0 of (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 364 "parser_cocci_menhir.ml"
)
| TMetavariable
| TMetaType of (
-# 134 "parser_cocci_menhir.mly"
+# 108 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 370 "parser_cocci_menhir.ml"
)
| TMetaStmList of (
-# 134 "parser_cocci_menhir.mly"
+# 108 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 375 "parser_cocci_menhir.ml"
)
| TMetaStm of (
-# 134 "parser_cocci_menhir.mly"
+# 108 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 380 "parser_cocci_menhir.ml"
)
| TMetaPos of (
-# 139 "parser_cocci_menhir.mly"
+# 113 "parser_cocci_menhir.mly"
(Parse_aux.pos_info)
# 385 "parser_cocci_menhir.ml"
)
| TMetaParamList of (
-# 136 "parser_cocci_menhir.mly"
+# 110 "parser_cocci_menhir.mly"
(Parse_aux.list_info)
# 390 "parser_cocci_menhir.ml"
)
| TMetaParam of (
-# 134 "parser_cocci_menhir.mly"
+# 108 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 395 "parser_cocci_menhir.ml"
)
| TMetaLocalIdExp of (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
# 400 "parser_cocci_menhir.ml"
)
| TMetaLocalFunc of (
-# 131 "parser_cocci_menhir.mly"
+# 105 "parser_cocci_menhir.mly"
(Parse_aux.idinfo)
# 405 "parser_cocci_menhir.ml"
)
| TMetaIterator of (
-# 132 "parser_cocci_menhir.mly"
+# 106 "parser_cocci_menhir.mly"
(Parse_aux.idinfo)
# 410 "parser_cocci_menhir.ml"
)
| TMetaInitList of (
-# 136 "parser_cocci_menhir.mly"
+# 110 "parser_cocci_menhir.mly"
(Parse_aux.list_info)
# 415 "parser_cocci_menhir.ml"
)
| TMetaInit of (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 420 "parser_cocci_menhir.ml"
)
| TMetaIdExp of (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
# 425 "parser_cocci_menhir.ml"
)
| TMetaId of (
-# 130 "parser_cocci_menhir.mly"
+# 104 "parser_cocci_menhir.mly"
(Parse_aux.midinfo)
# 430 "parser_cocci_menhir.ml"
)
| TMetaFunc of (
-# 131 "parser_cocci_menhir.mly"
+# 105 "parser_cocci_menhir.mly"
(Parse_aux.idinfo)
# 435 "parser_cocci_menhir.ml"
)
| TMetaFieldList of (
-# 137 "parser_cocci_menhir.mly"
+# 111 "parser_cocci_menhir.mly"
(Parse_aux.list_info)
# 440 "parser_cocci_menhir.ml"
)
| TMetaField of (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 445 "parser_cocci_menhir.ml"
)
| TMetaExpList of (
-# 136 "parser_cocci_menhir.mly"
+# 110 "parser_cocci_menhir.mly"
(Parse_aux.list_info)
# 450 "parser_cocci_menhir.ml"
)
| TMetaExp of (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
# 455 "parser_cocci_menhir.ml"
)
| TMetaErr of (
-# 133 "parser_cocci_menhir.mly"
+# 107 "parser_cocci_menhir.mly"
(Parse_aux.expinfo)
# 460 "parser_cocci_menhir.ml"
)
| TMetaDeclarer of (
-# 132 "parser_cocci_menhir.mly"
+# 106 "parser_cocci_menhir.mly"
(Parse_aux.idinfo)
# 465 "parser_cocci_menhir.ml"
)
| TMetaDecl of (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 470 "parser_cocci_menhir.ml"
)
| TMetaConst of (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
# 475 "parser_cocci_menhir.ml"
)
| TMeta of (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 480 "parser_cocci_menhir.ml"
)
| TMPtVirg
| TLogOp of (
-# 167 "parser_cocci_menhir.mly"
+# 141 "parser_cocci_menhir.mly"
(Ast_cocci.logicalOp * Data.clt)
# 486 "parser_cocci_menhir.ml"
)
| TLocal
| TLineEnd of (
-# 146 "parser_cocci_menhir.mly"
+# 120 "parser_cocci_menhir.mly"
(Data.clt)
# 492 "parser_cocci_menhir.ml"
)
| TIteratorId of (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
# 497 "parser_cocci_menhir.ml"
)
| TIso
| TInvalid
| TInt of (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
# 513 "parser_cocci_menhir.ml"
)
| TInitialize
| TInitialiser
| TIncludeNL of (
-# 152 "parser_cocci_menhir.mly"
+# 126 "parser_cocci_menhir.mly"
(string * Data.clt)
# 520 "parser_cocci_menhir.ml"
)
| TIncludeL of (
-# 152 "parser_cocci_menhir.mly"
+# 126 "parser_cocci_menhir.mly"
(string * Data.clt)
# 525 "parser_cocci_menhir.ml"
)
| TInc of (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
# 530 "parser_cocci_menhir.ml"
)
| TIf of (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
# 535 "parser_cocci_menhir.ml"
)
| TIdentifier
| TIdent of (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
# 541 "parser_cocci_menhir.ml"
)
| TIdExpression
| TGoto of (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
# 547 "parser_cocci_menhir.ml"
)
| TGenerated
| TFunction
| TFunDecl of (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
# 554 "parser_cocci_menhir.ml"
)
| TFresh
| TForall
| TFor of (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
# 561 "parser_cocci_menhir.ml"
)
| TFloat of (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
# 566 "parser_cocci_menhir.ml"
)
| TEver
| TError
| TEqEq of (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 578 "parser_cocci_menhir.ml"
)
| TEq of (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 583 "parser_cocci_menhir.ml"
)
| TElse of (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
# 588 "parser_cocci_menhir.ml"
)
| TEllipsis of (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 593 "parser_cocci_menhir.ml"
)
| TDotDot of (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 598 "parser_cocci_menhir.ml"
)
| TDot of (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 603 "parser_cocci_menhir.ml"
)
| TDo of (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
# 608 "parser_cocci_menhir.ml"
)
| TDmOp of (
-# 169 "parser_cocci_menhir.mly"
+# 143 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 613 "parser_cocci_menhir.ml"
)
| TDisable
| TDepends
| TDefineParam of (
-# 154 "parser_cocci_menhir.mly"
+# 128 "parser_cocci_menhir.mly"
(Data.clt * token * int * int)
# 620 "parser_cocci_menhir.ml"
)
| TDefine of (
-# 153 "parser_cocci_menhir.mly"
+# 127 "parser_cocci_menhir.mly"
(Data.clt * token)
# 625 "parser_cocci_menhir.ml"
)
| TDefault of (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
# 630 "parser_cocci_menhir.ml"
)
| TDeclarerId of (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
# 635 "parser_cocci_menhir.ml"
)
| TDeclarer
| TDeclaration
| TDec of (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
# 642 "parser_cocci_menhir.ml"
)
| TCppConcatOp
| TContinue of (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
# 648 "parser_cocci_menhir.ml"
)
| TContext
| TConstant
| TComma of (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 655 "parser_cocci_menhir.ml"
)
| TChar of (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
# 660 "parser_cocci_menhir.ml"
)
| TCase of (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
# 665 "parser_cocci_menhir.ml"
)
| TCPar0 of (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 670 "parser_cocci_menhir.ml"
)
| TCPar of (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 675 "parser_cocci_menhir.ml"
)
| TCEllipsis of (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 680 "parser_cocci_menhir.ml"
)
| TCCro of (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
# 685 "parser_cocci_menhir.ml"
)
| TCBrace of (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
# 690 "parser_cocci_menhir.ml"
)
| TBreak of (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
# 695 "parser_cocci_menhir.ml"
)
| TBang0
| TBang of (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 701 "parser_cocci_menhir.ml"
)
| TAssign of (
-# 180 "parser_cocci_menhir.mly"
+# 154 "parser_cocci_menhir.mly"
(Ast_cocci.assignOp * Data.clt)
# 706 "parser_cocci_menhir.ml"
)
| TArobArob
| TArob
| TAny of (
-# 146 "parser_cocci_menhir.mly"
+# 120 "parser_cocci_menhir.mly"
(Data.clt)
# 713 "parser_cocci_menhir.ml"
)
| TAndLog of (
-# 162 "parser_cocci_menhir.mly"
+# 136 "parser_cocci_menhir.mly"
(Data.clt)
# 718 "parser_cocci_menhir.ml"
)
| TAnd of (
-# 165 "parser_cocci_menhir.mly"
+# 139 "parser_cocci_menhir.mly"
(Data.clt)
# 723 "parser_cocci_menhir.ml"
)
and _menhir_jeton = token
-# 27 "parser_cocci_menhir.mly"
+# 1 "parser_cocci_menhir.mly"
(* Not clear how to allow function declarations to specify a return type
Obj.repr _v
let default_reduction =
- (16, "\000\000\000\000\003\002\000\135\000\000\000\000\003V\001L\000\000\001J\001K\001I\000\000\001N\001M\000\001\000\000\001\134\000\000\000\000\000\151\002\028\000\000\000\000\003k\000\000\000\000\003r\003p\003l\003i\000\000\000\000\003n\003m\000\018\003\158\003\157\002!\002 \000\000\000\017\002\"\000\000\002\029\002\031\000\000\003\242\000\000\000\000\001\230\001\229\001\228\001\227\000\000\000\244\000\243\000\000\000\000\002\000\000\000\001\150\001\232\000\000\000\000\000\000\000\000\000\000\000\252\000\000\000\000\001\021\001E\001\020\001\019\001\018\001\017\001D\001C\001\016\001\015\002>\000\000\000\000\002=\000\000\000\000\000\000\000\163\000\000\000\000\000\162\002A\001\r\000\000\002$\000\000\000\000\000\000\002%\002\030\000\150\002*\000\000\000\000\000\000\003&\000\000\003\150\003\149\003\151\000\000\003\186\000\000\003\143\000\000\000\000\000\000\000\000\001\000\000\019\000\000\000\000\000\000\003\233\002\201\000\000\000\000\003\231\000\000\002\229\000\000\000\000\000\000\000\000\000\000\000\000\003\230\003\232\002\207\001?\002\206\001>\002\205\002\204\002\203\002\020\002\199\000\000\000\000\002\200\000\245\000\000\000\000\000\000\002\202\000\000\000\000\002\198\003\229\000\000\000\000\003\198\002\161\000\000\000\000\002\164\000\000\000\000\000\000\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\246\001=\002\197\002\210\000q\000\025\000s\000\000\000\000\000U\000\000\000\000\000\000\000\000\000\000\000\000\000V\000\000\000W\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000h\002\194\000t\000\000\000\000\000\145\000\248\002\127\002\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\027\000\000\000\000\000\000\000\000\000\000\000r\000j\000\000\000i\000\000\002\162\002\165\000\000\002\163\002\166\003\197\000\020\000\000\002\237\000\000\000\183\000\000\000\000\002\001\000\000\001\152\001\233\000\000\000\000\001\255\000\000\000\000\000\000\000\000\000\000\001\254\000\000\001\146\000\180\000\000\000\179\000\000\001\148\001\231\000\000\000\000\002\236\000\000\000\000\000\000\002\215\000\000\000\000\000\000\002\208\000\000\000\000\000\000\000\000\002\235\002\234\002\233\002\232\002\231\002\227\000\000\003\209\002\228\000\000\003\210\002\230\000\000\003\212\000\000\002\226\000\000\000}\002\177\000\000\000\000\002\180\000\000\000\000\000\015\000\000\000\000\000\000\000\000\000\000\000m\000\000\000l\000\155\002\238\002\225\000\014\000\016\000k\0007\000\185\000u\000\000\000\000\000\000\000\000\000\000\000\000\000\147\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0009\000\000\000\000\000\000\000\000\000\000\000\000\002/\0023\000\000\000\000\000\154\0020\001\004\001\002\000\000\002\183\000\000\000\000\002\178\002\181\000\000\002\179\002\182\003\211\000\000\000\000\002\196\001\026\000\000\002\022\000\000\000\000\000\000\000\000\000\000\000\250\002\027\000\000\000\000\001\166\002\195\000\000\000\000\002\223\000\000\000\000\002\222\000\000\000\000\000\000\000\000\000\000\002\021\000\000\000\000\000\000\000\000\000\240\000\239\000\000\000\000\002\221\001^\001]\002\220\000\000\002\219\002\218\002\217\001`\002\213\000\000\003\202\002\214\000\000\000\000\000\000\000\000\000\000\000\238\000\000\003\203\002\216\000\000\003\205\000\000\002\212\000\000\000\000\000{\002\169\000\000\000\000\002\172\000\000\000\000\002\175\000\000\000\000\002\170\002\173\000\000\002\171\002\174\002\224\002\211\003\204\000\000\001\b\001Y\000\000\000\000\000\000\000\000\001[\000\000\001\132\000(\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000*\000\000\000\000\000\000\000\000\001\\\000\000\001V\000\000\000\000\002D\000\000\000\000\000\000\000\167\000\000\000\000\000\166\002H\001_\001W\000\000\000\254\001U\002E\000\000\001Z\000\000\002\176\000|\000\000\002\168\003\206\000\000\002\184\000~\000\000\002\167\003\225\003\226\003\224\003\223\003\196\000\000\000\000\003\195\000\000\002\018\000\000\002\209\000\000\000\000\000z\000\000\000\000\000\000\003\213\000\000\002\019\000\000\000\000\000\000\003\227\000\000\000\000\000\000\003\199\000\000\000g\000\184\000\000\001~\000\000\003\155\003%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002d\000\189\000\190\000\000\000\000\000\000\000\000\000\000\002R\002c\002\b\000\000\000\000\000\000\000\000\000\000\001\012\000\194\000\000\002\t\000\000\000\000\000\000\000\000\000\188\000\000\000\186\000\175\000\000\000\000\000\174\002V\002S\000\000\000\000\003\154\000\000\003\153\000\000\000\000\000\000\003\156\003\144\003\145\000\000\002'\000\000\003\147\000\000\000\000\000\177\003\148\000\000\000\000\000\000\002(\003\185\000\000\000\000\002\007\000\000\001\164\001\240\000\000\003\152\000\000\000\000\002)\000\000\000\000\001d\000\000\001c\000\000\001r\000\000\001\136\000\000\000\000\000\000\001\183\000\000\003\189\000\000\000\000\002\004\001\184\000\000\001\158\001\237\003\190\000\000\003\193\003\192\000\000\000\000\003f\003\191\000\143\000\000\000\224\000\000\000\000\000\000\001|\003\188\000\000\003\187\003\139\003\141\003\142\003\140\000\000\000\000\000\000\000\000\000\000\001Q\000\000\000\000\000\000\000\000\000\000\000\192\000\204\000\191\000\000\000\000\000\132\000\000\000\000\000\000\000\216\000\000\003P\000\000\000\000\000\212\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\219\000\000\000\000\000\223\001$\001#\000\000\000\000\000\000\000\000\001B\000\000\000\000\000\000\000\000\000\209\000\000\000\206\000\000\000\000\000\000\000\000\000\000\000\217\000\000\000\213\000\000\000\000\000\000\000\000\000\214\000\000\000\210\000\000\000\000\000\000\000\000\002\243\000\000\000\000\000\000\000\000\003\220\000\000\003\130\000\000\003\129\000\000\000\000\000\000\000\000\003\240\000\000\000\000\000\000\003\241\000\000\000\022\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\000\002\249\002\248\002\247\002\246\002\245\002\241\000\000\003\216\002\242\000\000\003\217\002\244\000\000\003\219\000\000\002\240\000\000\000\127\002\185\000\000\000\000\002\188\000\000\000\000\002\191\000\000\000\000\002\186\002\189\000\000\002\187\002\190\002\252\002\239\003\218\000\000\000\000\000p\000\000\000o\000\000\002\251\000\000\001\234\000n\000F\001\025\000v\000\000\000\000\000\000\000\000\000\000\000\000\000\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\000\000\000\000\000\000\000\000\000\000\000\000\002\192\000\128\000\000\003\236\000\000\001\168\000\000\000\000\000\000\000\195\003w\001z\000\000\001y\001P\001O\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\134\000\000\000\000\002f\000\000\000\000\000\000\002n\000\000\000\000\002r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002u\000\000\000\000\002y\000\000\002h\000\000\000\000\002k\000\000\000\000\000\000\002o\000\000\000\000\002s\000\000\000\000\002l\000\000\000\000\002p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\159\000\247\000\000\000\000\0026\000\000\000\000\000\158\002:\0027\001\006\000\225\000\000\000\227\000\226\000\000\003\132\000\000\003\131\003s\000\000\000\000\000\000\000\000\000\000\003~\000\000\003x\000\000\003\133\000\000\000\000\000\000\000\000\003\127\003u\002\129\000\000\000\199\001R\000\000\003\136\000\000\001T\000\000\000\000\003\164\000\000\003\171\000\201\000\000\000\207\000\000\003\165\000\200\000\000\003\166\000\000\003\173\000\000\000\000\000\000\000\000\000\220\000\000\000\000\000\221\000\000\000\203\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\218\000\000\000\000\000\222\000\000\000\000\000\000\000\000\001A\000\000\000\000\000\000\000\208\000\000\000\205\000\000\000\000\000\000\000\000\000\000\000\215\000\000\000\211\000\197\000\196\000\000\003\174\003\175\000\000\003\176\000\000\003\177\000\000\001S\003{\000\000\000\000\000\000\000\000\000\000\003|\002i\000\000\000\000\000\000\000\000\002v\000\000\000\000\002w\000\000\002e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002t\000\000\000\000\002x\000\000\002g\000\000\000\000\002j\000\000\000\000\000\000\002m\000\000\000\000\002q\000\000\000\000\002\006\000\000\001\162\001\239\000\000\003t\000\000\000\000\000\000\003z\000\000\000\000\000\000\0016\000\000\0010\000\000\0011\000\000\001;\001/\001:\000\000\003\135\001<\000\000\000\202\000\000\000\000\000\000\000\000\0018\0013\002\002\000\000\0014\000\000\0015\000\000\001\154\001\235\000\000\000\000\000\000\002\014\000\000\002\012\000\000\000\000\002\016\002\n\000\000\002\017\002\011\000\000\003\137\002\023\000\000\000\198\000\000\000\000\002\003\000\000\001\156\001\236\000\000\003\237\000\000\003\234\000\000\003\235\000\023\000\024\000\000\000\000\0032\000\000\0031\000\000\000\000\0034\000\000\0033\000\000\000\000\002\005\000\000\0030\003/\000\000\001\160\001\238\000\000\0035\000\000\000\000\003\238\000\021\000\130\000\000\003\239\000\000\000\000\003L\000\000\000\000\003\138\000w\000\000\000\000\000\000\000x\000\000\003\128\000\000\001\128\000\000\001\130\003}\000\000\000\000\001l\000\000\001k\000\000\001s\000\000\001\144\000\000\000\000\000\000\001h\000\000\001g\000\000\001p\000\000\001\140\000\000\000\000\000\000\001o\000\000\000\000\001w\000\000\000\000\001j\001x\000\000\001i\000\000\001q\000\000\001\142\000\000\000\000\000\000\001m\000\000\000\000\000\000\001f\000\000\001e\000\000\001t\000\000\001\138\000\000\000\000\000\000\001n\000\002\000\000\000d\000\000\000\000\001\226\000e\000\000\000\000\003\012\003\016\003\020\003\b\003\025\003\005\000\000\000\000\003\017\003\024\003\t\003\023\003\007\003\022\003\011\003\003\003\n\003\019\003\006\003\r\003\004\003\015\003\021\003\018\003\014\001\189\001\188\000\141\000\000\000\000\003b\000\000\000\000\000\000\000\000\003G\003D\000\000\000\000\003H\003E\003F\003#\000\000\000\000\003h\003\027\003\026\003\028\000\000\001\206\000c\001u\000\003\000\000\000\000\002\255\000\000\002}\000\000\000\142\000\000\000\000\003d\000\000\000\000\000\000\000\134\000\000\000\000\003T\000\000\002`\002_\001\180\003$\000\000\001\221\000\000\003\000\000\000\000\000\000\136\000\000\000\000\003X\000\000\001\203\000\000\000\000\001\195\000\000\000\000\000\000\001\202\000\000\001\198\000\000\000\000\000\000\001\170\001\169\000\000\000\000\000\000\001\222\000\000\001\193\000\000\001\192\000\000\000\131\000\000\000\000\003N\000\000\000\000\001\187\000\000\000\000\001\191\000\000\000\000\000\139\000\000\000\000\003^\000\000\000\000\003-\000\000\003,\000\000\000\000\000\000\002^\002]\003*\002\135\003\031\003+\000\000\001\209\000\000\000\000\000\000\001\205\000\000\001\211\000\000\000\000\000\000\000\000\000\000\000\000\001\225\000\000\001\197\000\000\001\196\000\000\000\000\000\000\003!\000\140\000\000\000\000\003`\000\000\003 \000\000\001\207\000\000\000\000\001\208\000\000\000\000\000\000\000\000\000\000\000\000\001\224\000\000\001\201\000\000\001\200\000\000\000\000\001\030\000\000\001\029\000\000\000\000\000\000\000\000\000\000\001\223\000\000\001\194\000\000\001\028\000\000\002,\000\137\000\000\000\000\003Z\000\000\000\000\000\000\000\000\003\160\003\159\000\000\000\000\001H\001G\000\133\001F\000\000\000\000\003R\000\000\002X\002W\002Z\003\029\002\131\002Y\001\027\000\000\000\138\000\000\000\000\003\\\000\000\000\000\000\000\000\000\002\\\002[\003)\003'\002\133\003\030\003(\000\000\001\216\000\000\001\219\000\000\000\000\001\212\000\000\000\000\000\000\001\204\000\000\001\210\000\000\000\000\001\199\000\000\000\000\000\000\000\000\000\000\000\000\001\186\000\000\000\000\001\218\000\000\001\217\000\000\000\000\000\000\000\000\001\215\000\000\000\000\001\214\000\000\001\213\000\000\000\000\001\220\000\000\000\000\001v\000\004\000\000\001\190\000\005\000\000\000\000\001!\000\006\000\000\001\244\001\245\001\243\000\000\001\242\003\161\001\176\000\000\000\007\000\000\001\247\001\248\001\246\000\000\000\000\000\000\000\000\001&\000\000\000\000\000\000\000\000\001+\001-\001,\001'\001)\001(\000\000\000\000\000\000\000\000\000\000\003\167\003\180\000\000\003\168\000\000\003\169\000\000\000\000\003\162\000\000\000\000\000\000\000\000\003\179\000\000\000\000\003\178\001\252\001\251\000\000\000\000\001\178\001\241\001\249\000\000\000\000\000\000\000\000\000\000\002b\000\000\000\000\000\000\000\000\000\000\002K\002a\000\000\000\000\000\000\000\171\000\000\000\000\000\170\002O\002L\001\n\000\193\000\000\000\000\000\000\000\000\001@\001\"\000\000\003\183\000\000\003\184\000\000\000\000\002\026\002\024\000\000\002\025\000\b\000\000\000\t\000\000\002\150\002\151\002\149\000\000\002\148\000\000\000\n\000\000\002\153\002\154\002\152\000\000\002\156\000\000\000\000\000\000\002\142\000\000\000\000\002\144\000\000\002\138\000\000\002\140\000\000\002\145\000\000\002\146\000\000\002\139\002\137\002\157\001\182\002\147\000\000\002\159\000\000\002\158\000\000\002\160\000\000\003.\000\011\000\000\000\000\000\000\000\000\000\000\000\000\000\228\000\000\000\000\000\232\000\000\000\231\000\000\000\229\000\000\000\000\000\000\000\000\000\000\000\233\000\230\000\000\000\235\000\000\000\000\000\000\003:\000\000\0039\000\000\000\000\000\000\000\000\003;\000\000\000\000\001 \000\000\000\000\000\000\000\000\000\000\003J\000\129\000\000\000\000\000\242\000\000\001\023\001\022\000\000\001b\000\000\0038\001\174\001\172\000\000\000\000\000\000\000\000\003<\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0037\000\000\000\000\000\000\000\000\000\000\000\000\0036\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003C\000\000\000\000\003B\000\000\003?\000\000\000\000\000\000\000\000\000\000\003@\000\000\000\000\000\000\003A\000\r\000\000\003=\000\000\003>")
+ (16, "\000\000\000\000\003\003\000\135\000\000\000\000\003W\001L\000\000\001J\001K\001I\000\000\001N\001M\000\001\000\000\001\134\000\000\000\000\000\151\002\029\000\000\000\000\003l\000\000\000\000\003s\003q\003m\003j\000\000\000\000\003o\003n\000\018\003\159\003\158\002\"\002!\000\000\000\017\002#\000\000\002\030\002 \000\000\003\243\000\000\000\000\001\231\001\230\001\229\001\228\000\000\000\244\000\243\000\000\000\000\002\001\000\000\001\150\001\233\000\000\000\000\000\000\000\000\000\000\000\252\000\000\000\000\001\021\001E\001\020\001\019\001\018\001\017\001D\001C\001\016\001\015\002?\000\000\000\000\002>\000\000\000\000\000\000\000\163\000\000\000\000\000\162\002B\001\r\000\000\002%\000\000\000\000\000\000\002&\002\031\000\150\002+\000\000\000\000\000\000\003'\000\000\003\151\003\150\003\152\000\000\003\187\000\000\003\144\000\000\000\000\000\000\000\000\001\000\000\019\000\000\000\000\000\000\003\234\002\202\000\000\000\000\003\232\000\000\002\230\000\000\000\000\000\000\000\000\000\000\000\000\003\231\003\233\002\208\001?\002\207\001>\002\206\002\205\002\204\002\021\002\200\000\000\000\000\002\201\000\245\000\000\000\000\000\000\002\203\000\000\000\000\002\199\003\230\000\000\000\000\003\199\002\162\000\000\000\000\002\165\000\000\000\000\000\000\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\246\001=\002\198\002\211\000q\000\025\000s\000\000\000\000\000U\000\000\000\000\000\000\000\000\000\000\000\000\000V\000\000\000W\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000h\002\195\000t\000\000\000\000\000\145\000\248\002\128\002\194\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\027\000\000\000\000\000\000\000\000\000\000\000r\000j\000\000\000i\000\000\002\163\002\166\000\000\002\164\002\167\003\198\000\020\000\000\002\238\000\000\000\183\000\000\000\000\002\002\000\000\001\152\001\234\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\001\255\000\000\001\146\000\180\000\000\000\179\000\000\001\148\001\232\000\000\000\000\002\237\000\000\000\000\000\000\002\216\000\000\000\000\000\000\002\209\000\000\000\000\000\000\000\000\002\236\002\235\002\234\002\233\002\232\002\228\000\000\003\210\002\229\000\000\003\211\002\231\000\000\003\213\000\000\002\227\000\000\000}\002\178\000\000\000\000\002\181\000\000\000\000\000\015\000\000\000\000\000\000\000\000\000\000\000m\000\000\000l\000\155\002\239\002\226\000\014\000\016\000k\0007\000\185\000u\000\000\000\000\000\000\000\000\000\000\000\000\000\147\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0008\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0009\000\000\000\000\000\000\000\000\000\000\000\000\0020\0024\000\000\000\000\000\154\0021\001\004\001\002\000\000\002\184\000\000\000\000\002\179\002\182\000\000\002\180\002\183\003\212\000\000\000\000\002\197\001\026\000\000\002\023\000\000\000\000\000\000\000\000\000\000\000\250\002\028\000\000\000\000\001\166\002\196\000\000\000\000\002\224\000\000\000\000\002\223\000\000\000\000\000\000\000\000\000\000\002\022\000\000\000\000\000\000\000\000\000\240\000\239\000\000\000\000\002\222\001^\001]\002\221\000\000\002\220\002\219\002\218\001`\002\214\000\000\003\203\002\215\000\000\000\000\000\000\000\000\000\000\000\238\000\000\003\204\002\217\000\000\003\206\000\000\002\213\000\000\000\000\000{\002\170\000\000\000\000\002\173\000\000\000\000\002\176\000\000\000\000\002\171\002\174\000\000\002\172\002\175\002\225\002\212\003\205\000\000\001\b\001Y\000\000\000\000\000\000\000\000\001[\000\000\001\132\000(\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000*\000\000\000\000\000\000\000\000\001\\\000\000\001V\000\000\000\000\002E\000\000\000\000\000\000\000\167\000\000\000\000\000\166\002I\001_\001W\000\000\000\254\001U\002F\000\000\001Z\000\000\002\177\000|\000\000\002\169\003\207\000\000\002\185\000~\000\000\002\168\003\226\003\227\003\225\003\224\003\197\000\000\000\000\003\196\000\000\002\019\000\000\002\210\000\000\000\000\000z\000\000\000\000\000\000\003\214\000\000\002\020\000\000\000\000\000\000\003\228\000\000\000\000\000\000\003\200\000\000\000g\000\184\000\000\001~\000\000\003\156\003&\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002e\000\189\000\190\000\000\000\000\000\000\000\000\000\000\002S\002d\002\t\000\000\000\000\000\000\000\000\000\000\001\012\000\194\000\000\002\n\000\000\000\000\000\000\000\000\000\188\000\000\000\186\000\175\000\000\000\000\000\174\002W\002T\000\000\000\000\003\155\000\000\003\154\000\000\000\000\000\000\003\157\003\145\003\146\000\000\002(\000\000\003\148\000\000\000\000\000\177\003\149\000\000\000\000\000\000\002)\003\186\000\000\000\000\002\b\000\000\001\164\001\241\000\000\003\153\000\000\000\000\002*\000\000\000\000\001d\000\000\001c\000\000\001r\000\000\001\136\000\000\000\000\000\000\001\184\000\000\003\190\000\000\000\000\002\005\001\185\000\000\001\158\001\238\003\191\000\000\003\194\003\193\000\000\000\000\003g\003\192\000\143\000\000\000\224\000\000\000\000\000\000\001|\003\189\000\000\003\188\003\140\003\142\003\143\003\141\000\000\000\000\000\000\000\000\000\000\001Q\000\000\000\000\000\000\000\000\000\000\000\192\000\204\000\191\000\000\000\000\000\132\000\000\000\000\000\000\000\216\000\000\003Q\000\000\000\000\000\212\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\219\000\000\000\000\000\223\001$\001#\000\000\000\000\000\000\000\000\001B\000\000\000\000\000\000\000\000\000\209\000\000\000\206\000\000\000\000\000\000\000\000\000\000\000\217\000\000\000\213\000\000\000\000\000\000\000\000\000\214\000\000\000\210\000\000\000\000\000\000\000\000\002\244\000\000\000\000\000\000\000\000\003\221\000\000\003\131\000\000\003\130\000\000\000\000\000\000\000\000\003\241\000\000\000\000\000\000\003\242\000\000\000\022\000\000\000\000\000\000\000\000\002\251\000\000\000\000\000\000\002\250\002\249\002\248\002\247\002\246\002\242\000\000\003\217\002\243\000\000\003\218\002\245\000\000\003\220\000\000\002\241\000\000\000\127\002\186\000\000\000\000\002\189\000\000\000\000\002\192\000\000\000\000\002\187\002\190\000\000\002\188\002\191\002\253\002\240\003\219\000\000\000\000\000p\000\000\000o\000\000\002\252\000\000\001\235\000n\000F\001\025\000v\000\000\000\000\000\000\000\000\000\000\000\000\000\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000G\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000H\000\000\000\000\000\000\000\000\000\000\000\000\002\193\000\128\000\000\003\237\000\000\001\168\000\000\000\000\000\000\000\195\003x\001z\000\000\001y\001P\001O\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\135\000\000\000\000\002g\000\000\000\000\000\000\002o\000\000\000\000\002s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002v\000\000\000\000\002z\000\000\002i\000\000\000\000\002l\000\000\000\000\000\000\002p\000\000\000\000\002t\000\000\000\000\002m\000\000\000\000\002q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\159\000\247\000\000\000\000\0027\000\000\000\000\000\158\002;\0028\001\006\000\225\000\000\000\227\000\226\000\000\003\133\000\000\003\132\003t\000\000\000\000\000\000\000\000\000\000\003\127\000\000\003y\000\000\003\134\000\000\000\000\000\000\000\000\003\128\003v\002\130\000\000\000\199\001R\000\000\003\137\000\000\001T\000\000\000\000\003\165\000\000\003\172\000\201\000\000\000\207\000\000\003\166\000\200\000\000\003\167\000\000\003\174\000\000\000\000\000\000\000\000\000\220\000\000\000\000\000\221\000\000\000\203\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\218\000\000\000\000\000\222\000\000\000\000\000\000\000\000\001A\000\000\000\000\000\000\000\208\000\000\000\205\000\000\000\000\000\000\000\000\000\000\000\215\000\000\000\211\000\197\000\196\000\000\003\175\003\176\000\000\003\177\000\000\003\178\000\000\001S\003|\000\000\000\000\000\000\000\000\000\000\003}\002j\000\000\000\000\000\000\000\000\002w\000\000\000\000\002x\000\000\002f\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002u\000\000\000\000\002y\000\000\002h\000\000\000\000\002k\000\000\000\000\000\000\002n\000\000\000\000\002r\000\000\000\000\002\007\000\000\001\162\001\240\000\000\003u\000\000\000\000\000\000\003{\000\000\000\000\000\000\0016\000\000\0010\000\000\0011\000\000\001;\001/\001:\000\000\003\136\001<\000\000\000\202\000\000\000\000\000\000\000\000\0018\0013\002\003\000\000\0014\000\000\0015\000\000\001\154\001\236\000\000\000\000\000\000\002\015\000\000\002\r\000\000\000\000\002\017\002\011\000\000\002\018\002\012\000\000\003\138\002\024\000\000\000\198\000\000\000\000\002\004\000\000\001\156\001\237\000\000\003\238\000\000\003\235\000\000\003\236\000\023\000\024\000\000\000\000\0033\000\000\0032\000\000\000\000\0035\000\000\0034\000\000\000\000\002\006\000\000\0031\0030\000\000\001\160\001\239\000\000\0036\000\000\000\000\003\239\000\021\000\130\000\000\003\240\000\000\000\000\003M\000\000\000\000\003\139\000w\000\000\000\000\000\000\000x\000\000\003\129\000\000\001\128\000\000\001\130\003~\000\000\000\000\001l\000\000\001k\000\000\001s\000\000\001\144\000\000\000\000\000\000\001h\000\000\001g\000\000\001p\000\000\001\140\000\000\000\000\000\000\001o\000\000\000\000\001w\000\000\000\000\001j\001x\000\000\001i\000\000\001q\000\000\001\142\000\000\000\000\000\000\001m\000\000\000\000\000\000\001f\000\000\001e\000\000\001t\000\000\001\138\000\000\000\000\000\000\001n\000\002\000\000\000d\000\000\000\000\001\227\000e\000\000\000\000\003\r\003\017\003\021\003\t\003\026\003\006\000\000\000\000\003\018\003\025\003\n\003\024\003\b\003\023\003\012\003\004\003\011\003\020\003\007\003\014\003\005\003\016\003\022\003\019\003\015\001\190\001\189\000\141\000\000\000\000\003c\000\000\000\000\000\000\000\000\003H\003E\000\000\000\000\003I\003F\003G\003$\000\000\000\000\003i\003\028\003\027\003\029\000\000\001\207\000c\001u\000\003\000\000\000\000\003\000\000\000\002~\000\000\000\142\000\000\000\000\003e\000\000\000\000\000\000\000\134\000\000\000\000\003U\000\000\002a\002`\001\181\003%\000\000\001\222\000\000\003\001\000\000\000\000\000\136\000\000\000\000\003Y\000\000\001\204\000\000\000\000\001\196\000\000\000\000\000\000\001\203\000\000\001\199\000\000\000\000\000\000\000\000\000\000\001\171\001\170\001\169\000\000\000\000\000\000\001\223\000\000\001\194\000\000\001\193\000\000\000\131\000\000\000\000\003O\000\000\000\000\001\188\000\000\000\000\001\192\000\000\000\000\000\139\000\000\000\000\003_\000\000\000\000\003.\000\000\003-\000\000\000\000\000\000\002_\002^\003+\002\136\003 \003,\000\000\001\210\000\000\000\000\000\000\001\206\000\000\001\212\000\000\000\000\000\000\000\000\000\000\000\000\001\226\000\000\001\198\000\000\001\197\000\000\000\000\000\000\003\"\000\140\000\000\000\000\003a\000\000\003!\000\000\001\208\000\000\000\000\001\209\000\000\000\000\000\000\000\000\000\000\000\000\001\225\000\000\001\202\000\000\001\201\000\000\000\000\001\030\000\000\001\029\000\000\000\000\000\000\000\000\000\000\001\224\000\000\001\195\000\000\001\028\000\000\002-\000\137\000\000\000\000\003[\000\000\000\000\000\000\000\000\003\161\003\160\000\000\000\000\001H\001G\000\133\001F\000\000\000\000\003S\000\000\002Y\002X\002[\003\030\002\132\002Z\001\027\000\000\000\138\000\000\000\000\003]\000\000\000\000\000\000\000\000\002]\002\\\003*\003(\002\134\003\031\003)\000\000\001\217\000\000\001\220\000\000\000\000\001\213\000\000\000\000\000\000\001\205\000\000\001\211\000\000\000\000\001\200\000\000\000\000\000\000\000\000\000\000\000\000\001\187\000\000\000\000\001\219\000\000\001\218\000\000\000\000\000\000\000\000\001\216\000\000\000\000\001\215\000\000\001\214\000\000\000\000\001\221\000\000\000\000\001v\000\004\000\000\001\191\000\005\000\000\000\000\001!\000\006\000\000\001\245\001\246\001\244\000\000\001\243\003\162\001\177\000\000\000\007\000\000\001\248\001\249\001\247\000\000\000\000\000\000\000\000\001&\000\000\000\000\000\000\000\000\001+\001-\001,\001'\001)\001(\000\000\000\000\000\000\000\000\000\000\003\168\003\181\000\000\003\169\000\000\003\170\000\000\000\000\003\163\000\000\000\000\000\000\000\000\003\180\000\000\000\000\003\179\001\253\001\252\000\000\000\000\001\179\001\242\001\250\000\000\000\000\000\000\000\000\000\000\002c\000\000\000\000\000\000\000\000\000\000\002L\002b\000\000\000\000\000\000\000\171\000\000\000\000\000\170\002P\002M\001\n\000\193\000\000\000\000\000\000\000\000\001@\001\"\000\000\003\184\000\000\003\185\000\000\000\000\002\027\002\025\000\000\002\026\000\b\000\000\000\t\000\000\002\151\002\152\002\150\000\000\002\149\000\000\000\n\000\000\002\154\002\155\002\153\000\000\002\157\000\000\000\000\000\000\002\143\000\000\000\000\002\145\000\000\002\139\000\000\002\141\000\000\002\146\000\000\002\147\000\000\002\140\002\138\002\158\001\183\002\148\000\000\002\160\000\000\002\159\000\000\002\161\000\000\003/\000\011\000\000\000\000\000\000\000\000\000\000\000\000\000\228\000\000\000\000\000\232\000\000\000\231\000\000\000\229\000\000\000\000\000\000\000\000\000\000\000\233\000\230\000\000\000\235\000\000\000\000\000\000\003;\000\000\003:\000\000\000\000\000\000\000\000\003<\000\000\000\000\001 \000\000\000\000\000\000\000\000\000\000\003K\000\129\000\000\000\000\000\242\000\000\001\023\001\022\000\000\001b\000\000\0039\001\175\001\173\000\000\000\000\000\000\000\000\003=\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0038\000\000\000\000\000\000\000\000\000\000\000\000\0037\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003D\000\000\000\000\003C\000\000\003@\000\000\000\000\000\000\000\000\000\000\003A\000\000\000\000\000\000\003B\000\r\000\000\003>\000\000\003?")
let error =
- (194, "\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000 \000\002\000A\128\000\000\129\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\240\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\173\028\000\000@\012@\000\192\005\002\024\004@\b\002\016\000\000\000\t\144\196\004'C@\n0\131T\0162\025@\134\0014\002!\222\004\128\001\014d1\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000B\2444\000\163\b5A\003!\148\b`\019@\"\029\224H\000\016\230C\016\016\157\r\000(\194\rP@\200e\002\024\004\208\b\135x\018\000\0049\144\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\026\209\192\000\004\000\196\000\012\000P!\128D\000\128!\000\000\000\000\153\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004/S@\n0\131T\0162\025@\134\0014\002!\222\004\128\001\014d1\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\004\000\000\016\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\b \000\001\000@\000\000 \000\002\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \128\000\004\001\000\000\000\128\000\b\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\002\000\000 @\000\000\000\000\000\000@\000\000\000\000\000\0000\140\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\016\000\000\000\000\000\000\016\000\000\000 \128\000\004\001\000\000\000\128\000\b\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 @\000\000\000\000\000\000@\000\000\000\130\000\000\016\004\000\000\002\000\000\000\000\000\016\000\000\000\000\000\000\016\000\000\000 \128\000\004\001\000\000\000\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 @\000\000\000\000\000\000@\000\000\000\130\000\000\016\004\000\000\002\000\000 \000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\tP\208\002\140 \213\004\012\198P!\128M\000\136w\129 \000C\153\012@\000\000\000\000\001\000\000\000\002\b\000\000@\016\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \000@\000\000\000\000\000\000\000\000\000\000\000\000\001\tP\208\002\140 \213\004\012\198P!\128M\000\136w\129 \000C\153\012^\189\171\192\000A\000 \000\002\b\004\000\024\016\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\016\002\000\000 \000@\001\129\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\016\000\000\000!\000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000A\000 \000\002\b\004\000\024\016\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\001\004\016\002\000\000 \128@\001\129\000\000\000\128\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000A\000 \000\002\000\004\000\024\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\b\000\000\000\000\000\000\000\000\000\128\000\b\128\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\b\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\000\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\158\189\171\192\000E$ \004\131@\164\024\2270\000\bH\004\000\128\004\016\bg\175j\240\000\017I\b\001 \208)\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\000\000A\000\134\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\158\189\171\192\000E$ \004\131@\164\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\001\000\000\000\000\000\000\000@\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\000\012L\019e\146\192\000\000\020\000\129\000\000\027\160\016\159\029\192\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004RB\000H4\138A\142s\000\000\132\128@\b\000A \134z\246\175\000\001\020\144\128\018\r\002\144c\140\192\000! \016\002\000\016@!\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\00010M\150K\000\000\000P\002\004\000\000n\128B|w\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\006\200\000'\135p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000l\128\002xw\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\019 \000\158\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002|7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002|7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002|7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002|7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\003\000\016@!\128\000\000\000\000\000\000\017\000\000\000\016\000\000\001\000 \000\000\000\192\000&\131\016\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002|7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\b\000\000\001\000@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000@\000z\246\175\000\001\000\000\128\000\b\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\175j\208\000\016\000\b\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000J\004\000\000\000\002\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\018\129\000\000\000\000\128\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000B\0200\000\001\000\017\000\003\000\144\b`\017\000 \b@\000\000\000&C\020\016\133,\000\000@\004@\000\192$\002\024\004@\b\002\016\000\000\000\t\144\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\bP\192\000\004\000D\000\012\002@!\128D\000\128!\000\000\000\000\153\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004!C\000\000\016\001\016\0000\t\000\134\001\016\002\000\132\000\000\000\002d1\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\020\144\128\018\r\002\144c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\020\144\000\018\rB\128c\140\192\000! \016\000\000\016@!\128\000\000\000\000\005$\000\004\131x\160\027\2270\000\024H\004\002\160\004\016H`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134z\246\175\000\001\020\144\128\018\r\002\144c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000 \000\000\012\000\016`R\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131x\160\027\2270\000\024H\004\002\160\004\016H`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000\000\001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000@\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\000\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002@\000\000\192\129\022I(\000\000\001\000\000\016\000\001\170\001\b\193\024\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000E$ \004\131H\164\024\2310\000\bH\004\000\128\004\018\bg\175j\240\000\017I\b\001 \210)\0069\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\136\000\030\189\171\192\000E$ \004\131H\164\024\2310\000\bH\004\000\000\004\018\bg\175j\240\000\017I\b\001 \210)\0069\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000h\128\0020F\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\003\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\128\001\235\218\188\000\004RB\000H4\138A\142s\000\000\132\128@\b\000A \134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\128\001\235\218\188\000\004RB\000H4\138A\142s\000\000\132\128@\b\000A \134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000 \000\b@\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\000\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\002\000\000\004\000\000\000\000\000\016\005$\000\004\131@\160\024\2270\000\bH\004\000\000\004\016\b`\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\000\000A\000\134\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\002\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\175j\240\000\017I\b\001 \208)\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\001I\000\001\000\196(\0068\200\000\006\018\001\000\000\001\004\002\024\000\000\000\000\000R@\000H7\138\001\1903\000\001\132\128@*\000A\004\134\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\000\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\002\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131x\160\027\2270\000\024H\004\002\160\004\016H`\000\000\000\000\001I\000\001 \222(\006\248\204\000\006\018\001\000\168\001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\00010M\150K\000\000\000P\002\004\000\000n\128BTw\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \212(\006x\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000R@\000H7\138\001\1903\000\001\132\128@*\000A\004\134\000\000\000\000\000\004\000\000\000\b\000\000\001\000@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\004\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\003\019\004\217d\176\000\000\005\000 @\000\006\232\004%Gp\000\000\000\000\001I\000\001\000\192(\0068\200\000\006\018\001\000\000\001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\003\002\004\025$\160\000\000\004\000\000@\000\004(\004 @`\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\020\144\128\018\r\"\144c\156\192\000! \016\002\000\016H!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\003\003\004\025$\176\000\000\004\000\000@\000\006h\004$D`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\005$\000\004\131p\160\027\2270\000\024H\004\002 \004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000R@\000H7\n\001\1903\000\001\132\128@\"\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\002 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\000\005$\000\004\131x\160\027\2270\000\024H\004\002\160\004\016H`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\004\000\000\000\000\000\000\020\144\000\018\r\226\128o\140\192\000a \016\b\128\016A!\128\000\000\000\000\005$\000\004\131x\160\027\2270\000\024H\004\002\160\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\004\000\000\000\000\000\000\020\144\000\018\r\226\128o\140\192\000a \016\n\128\016A!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000R@\000H5\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000E$ \004\131@\164\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\144\000\0000\000E\129J\000\000\000@\000\000\000\000h\128\0020F\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004RB\000H4\nA\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\t\000\000\003\017\004\216T\176\000\000\005\000 \000\000\006\200\000'\199p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004RB\000H4\nA\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\t\000\000\003\017\004\216T\176\000\000\005\000 \000\000\006\200\000'\199p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\b\000\000\000\000\000\000\000\000\000\128\000\b\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\0000\000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\000\000\128\000\b \017\128\000@\000\000\000\000\002\000\000\b\000\030\189\171\192\000@\000 \000\002\b\004`\000\016\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\"\000\007\175j\240\000\016\000\b\000\000\130\001\024\000\004\000\000\000\000\000\000\000\000\128\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\136\000\030\189\171\192\000@\000 \000\002\b\004`\000\016\000\000\000\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\003\000\000\000@\016\000\000\b\000\000\000\000\"\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000@\000 \000\002\b\004`\000\016\000\000\000\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\000\000\128\000\b \017\128\000@\000\000\000\000\002\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\002 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\128\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000:\246\173\000\001\004\000\128\000\000\000\016\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\004\000\128\000\b \016\000`@\000\000 \000\002\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\175j\240\000\016@\b\000\000\130\001\000\006\004\000\000\002\000\000\000\000\000\016\001\235\218\188\000\004\016\002\000\000 \128@\001\129\000\000\000\128\000\b\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\149\r\000(\194\rP@\204e\002\024\004\208\b\135x\018\000\0049\144\197\235\218\188\000\004\016\002\000\000 \128@\001\129\000\000\000\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000@\000z\246\175\000\001\004\000\128\000\b\000\016\000`@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\0000\001\000\004\001\000\000\000\128\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\005\235\218\188\000\004\000\002\000\000 \000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000@\000 \000\002\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134z\246\175\000\001\000\000\128\000\b\000\016\000\000@\000\000\000\000\000\000\000\000\000\030\189\171\192\000@\000 \000\002\000\004\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\007\175j\240\000\016\000\b\000\000\128\001\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\004\000\000\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\001\000\000\000\000\000\004\000\000\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\235\218\180\000\004\000\002\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\140 \145\004\000\134\016\000\000I\000\bv\129 \000C\000\000\000\000@\004\000\163\b$A\000!\132\000\000\018@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\140 \145\004\000\134\016\000\000I\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\129\005\164\t\004\003\016\161\028\2270\128\025\234\012\000\017\133\016(`\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\191\128\001\004\000\128\000\b\000\016\000\003\000\000\000 \000\000\001\128!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\004\000\128\000\b\000\016\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\012\000\000!\128@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000@\000 \000\002\b\004`\000\016\000\000\000\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131P\160\025\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\018\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\128\000\000\000\000\000\000\005$\000\004\131P\160\025\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\175j\208\000\016@\b\000\000\000\001\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\128\000\000\000\000\000\000\005$\000\004\131P\160\025\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\b@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\001\255\250\254\b\020ZB\144H5\nq\206?\b\001\158\160\192\t\030Q\134\134\000\000\000$\000\004\012L\019m\146\192\001\000T\000\129 \000\027\160\016\148\029\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\025\235\218\188\000\004RB\000H4\nA\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\t\000\000\003\017\004\216T\176\000\000\005\000 \000\000\006\136\000\005\007p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\016H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\015\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\016\000\000\000\000\000\000\000@\136\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248 Qi\nA\000\196)\1998\252 \006z\131\000\004iD\n\025\255\250\254\b\020ZB\144H5\011q\206?\b\001\158\160\192\t\026QB\134z\246\175\000\001\020\144\128\018\r\002\144c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\020\144\000\016\012B\128c\140\128\000a \016\000\000\016@!\128\000\000\000\000\005$\000\004\003\000\160\024\227 \000\024H\004\000\000\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\001\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001\000\192(\0068\200\000\006\018\001\000\000\001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\003\019\004\217d\176\000\000\005\000 @\000\006\168\004\005\007p\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\020\144\128\018\r\"\144c\156\192\000! \016\002\000\016H!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\006\136\000\005\007p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\192\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H7\138\001\1903\000\001\132\128@*\000A\004\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\015\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\191\240\241E\164)\004\003\024\183\028\227\241\128\025\234L\000\017\229\028kp\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\127\254\191\130\005\022\144\164\018\rB\220s\143\194\000g\1680\002F\148P\161\159\255\175\224\129E\164)\004\131P\167\028\227\240\128\025\234\012\000\145\165\016h`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\191\240\129E\1649\004\195P\183\028\227\241\1289\234L\001\209\229\029kp\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\002\004\022\144$\016\012B\132s\140\194\000g\1680\000F\020@\161\128\000\000\000\129\005\164\t\004\003\016\161\028\2270\128\025\234\012\000\017\133\016(`\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\191\235\248\000\017I\bA \208)\0068\252\000\002\018\001\000 \t\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\004\000\128\000\b\000\016\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\0000\000\000\134\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\000\000\128\000\b \017\128\000@\000\000\000\000\002\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131P\160\025\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000:\246\173\000\001\004\000\128\000\000\000\016\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \212(\006x\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\001\003\003\004\027$\176\000@\020\000\000H\000\006(\004$\004`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\016H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\018\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\b\016Z@\144@1\n\017\2063\b\001\158\160\192\001\024Q\002\134\000\000\000\002\004\022\144$\016\012B\132s\140\194\000g\1680\000F\020@\161\128\000\000\000\000\001\000\000\000\000\b\000\000@\016\000\000\b\000\000\128\000\002\000\000\000\000\000\000\000@\000\000\000\002\000\000\016\004\000\000\002\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002 \000\000\000\000\000\000\004\000\000\000\000 \000\001\000@\000\000 \000\000\000\000\b\000\000\000\000\000\000\001\000\000\000\000\b\000\000@\016\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\136\000\000\000\000\000\000\001\000\000\000\000\b\000\000@\016\000\000\b\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002 \000\000\000\000\000\000\004\000\000\000\000 \000\001\000@\000\000 \000\002\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000E$ \004\131H\164\024\2310\000\bH\004\000\128\004\018\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\b\016Z@\144@1\n\017\2063\b\001\158\160\192\001\024Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144H5\nq\206?\024\001\158\160\192\t\026Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\239\252<Qi\nA\000\198-\1998\252`\006z\147\000\004yG\026\220\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248 Qi\nA\000\198)\1998\252`\006z\131\000\004iD\n\024\000\000\000\000\000\000\000\000\b\004\000\000\000\000\016\000\000\000\000\b\000\000\0001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\003\024\167\028\227\241\128\025\234\012\000\017\165\016+p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\004\012L\019m\146\192\001\000T\000\129 \000\027\160\016\020\029\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@ \016\000\000\000\000@\000\000\000\000 \000\000\000\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\131P\167\028\227\241\128\025\234\012\000\145\165\016+p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144@1\138q\206?\024\001\158\160\192\001\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\175j\240\000\017I\b\001 \210)\0069\204\000\002\018\001\000 \001\004\130\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \212(\006x\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001\000\003\000\000\b`\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\b\000\000\001\000@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H5\n\001\1583\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\189\171@\000A\000 \000\000\000\004\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144H5\nq\206?\024\001\158\160\192\t\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@ \016\000\000\000\000@\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\191\130\005\022\144\164\018\rB\156s\143\198\000g\1680\002F\148@\161\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000@\000\192\000\002\024\004@\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\001\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A \134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\129\005\164\t\004\003\016\161\028\2270\128\025\234\012\000\017\133\016(`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000E$ \004\131H\164\024\2310\000\bH\004\000\128\004\018\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131P\160\025\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\004\000\012\000\000!\128@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\175j\240\000\016\000\b\000\000\130\001\024\000\004\000\000\000\000\000 \000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \212(\006x\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H5\n\001\1583\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\175j\208\000\016@\b\000\000\000\001\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \212(\006x\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000 Ai\002A\000\196(G8\204 \006z\131\000\004aD\n\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\007\255\239\252 Qi\014A0\212-\1998\252`\014z\147\000dyGZ\220\000\000\000\b\016Z@\144@1\n\017\2063\b\001\158\160\192\001\024Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\003\024\183\028\227\240\128\025\234\012\000\017\229\028h`\000\000\000\000\000\000\000\000 \016\000\000\000\000\000\000\000\000\000 \000\000\000\001\255\250\254\b\020ZB\144@1\139q\206?\b\001\158\160\192\001\030Q\198\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\128@\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144H5\011q\206?\b\001\158\160\192\t\030Q\198\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\131P\183\028\227\240\128\025\234\012\000\145\229\028h`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\001\000\001\255\250\254\b\020ZB\144@1\139q\206?\b\001\158\160\192\001\026QB\134\000\000\000\000\000\000\000\000\002\001\000@\000\000\000\000\000\000\000\002\000\000\016\000\031\255\175\224\129E\164)\004\003\024\183\028\227\240\128\025\234\012\000\017\165\020(`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\128@\016\000\000\000\000\000\000\000\000\128\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144H5\011q\206?\b\001\158\160\192\t\026QB\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\004\000\012\000@!\128@\000\000 \000\000\000\000\016\000\000\000\000\000\000\000\000\016\000\192@\000\000\000\000\000 \000\000\000\128\000\001\000\023\255\235\248 Qi\nA\000\198)\1998\252 \006z\131\000\004iD\n\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000D\003\001\000\000\000\000\000\000\128\000\000\002\000\000\004\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248 Qi\014A0\212)\1998\252 \014z\131\000$iDJ\029\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248 Qi\014A0\212)\1998\252 \014z\131\000$iDJ\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\001\000\001\255\250\254\b\020ZB\144H5\011q\206?\b\001\158\160\192\t\026QB\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@ \016\000\000\000\000@\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\191\130\005\022\144\164\018\rB\156s\143\198\000g\1680\002F\148@\161\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000{\254\191\128\001\020\144\164\016\012\002\144c\143\128\000a \016\000\000\148@\161\128\000\000\000\000\005$\001\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\255\175\224\000E$)\004\003\000\164\024\227\224\000\024H\004\000\000%\016(`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\001\000\001\239\250\254\000\004RB\144@0\nA\142>\000\001\132\128@\000\002Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001\000\003\000\016\b`\016\000\000\b\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\016 \000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\031\255\175\224\129E\164)\004\131P\167\028\227\240\128\025\234\012\000\145\229\024h`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\b@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\000\004\016\002\000\000 \000@\000\012\000\000\000\128\000\000\006\000\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\005\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\003\024\167\028\227\240\128\025\234\012\000\017\165\016(`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000@\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\003\016\165\028\227\240\128\025\234\012\000\017\165\016(g\175j\240\000\017I\b\001\000\192)\0068\200\000\006\018\001\000\000\001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000_\255\175\224\129E\164)\004\003\016\165\028\227\240\128\025\234\012\000\017\165\016(`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\191\130\005\022\144\164\016\012B\148s\143\194\000g\1680\000F\148@\161\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248\000\016@\b\000\000\128\001\000\0000\000\000\002\000\000\000\b\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\001\127\254\191\128\001\004\000\128\000\b\000\016\000\003\000\000\000 \000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248\000\016@\b\000\000\128\001\000\0000\000\000\002\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\194\000\226\b$I\002\016\012\000\000\018@\002\020\161H\000\024\192\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\001\000\016\002\136 \017\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000 \000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\b\000\000\128\000\000\000\000\000\b\000 \000\000\000\000\000@\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\b\128\000\000\000\000\000\b\000 \000\000\000\000\000@\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\014\000\130D\016!\000\192\000\001$\000!H\020\128\001\140\000\000z\246\175\000\003\128 \128\004\b@0\000\000I\000\bR\005 \000c\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\024@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\b\000\000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\b\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\b\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 @\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\014\000\130@\016!\000\192\000\001$\000!H\020\128\001\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000\224\b \001\002\016\012\000\000\018@\002\020\129H\000\024@\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\129\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000@\004\000\162\b$A\000\001\000\000\000\n@\002\029\160H\000\016\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\004\000@\n \130D\016\002\016\000\000\000\164\000!\218\004\128\001\014\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000(v\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 @\007\175j\240\000\016\000\b\000\000\128\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000@\004\000\162\b$A\000\001\128\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000 \000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`\000\000\000\000\016\000\000\000 \000\000\000\000\000\000\000\128\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\162\b$A\000\017\000\000\000\002@\002\029\160H\000\016\192\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000@\004\000\186\b$A\000\005\000\000\000\n@\002\029\160H\000\016\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\004\000@\n \130D\016\002\016\000\000\000\164\000!\218\004\128\001\014\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000(v\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\b\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\b\000\000\000\004\000@\138 \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\024\000\000\000\000\004\000\000\000\b\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000@\004\000\162\b$A\000!\000\000\000\n@\002\029\160H\000\016\224\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\002\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000(\004 @\n \130D\016\000\024\000\000\000$\000!\218\004\128\001\012\000\000\000\001\000\016\002\136 \145\004\000\006\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\016@\000`\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\137 \145\004\000\148\000\000\000)\000\bv\129 \000C\128\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\n\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\006\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\016@\000`\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000 \000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\016\000\000\000 \000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000 \000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\004\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\128\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\b\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000 \000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000a\000\000\000\000\016\000\000\000 \000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\004\000@\011\160\130D\016\000P\000\000\000\164\000!\218\004\128\001\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\222\188@\014 \130D\016!\016@\000\001$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000@\004\000\162\b\004A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\016\001\000.\146\t\016@\t`\000\000\002\144\000\135h\018\000\0048\000\000\000\004\000@\n \130D\016\002\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000z\247\175\016\003\136 \145\004\bF\016\000\000I\000\bv\129 \000C\000\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\b\003\136 \145$\b@0\000\000I\000\bR\133 \000c\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\014\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\251\255\b\020ZB\144H=\014q\206?\b\001\158\164\192\t\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\191\240\129E\164)\004\131\208\167\028\227\240\128\025\234L\000\145\165\016+w\191\239\252\000\016\000\b\000\000\128\001\000\000\000\000\000\000\016\000\000\000\000\000\001\239\251\255\000\004\000\002\000\000 \000@\000\000\000\000\000\004\000\000\000\000\000\000{\254\255\192\001\000\000\128\000\b\000\016\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\133\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\004!C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\001\bP\192\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000B\0200\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\191\131\197\022\144\164\016\012b\156s\143\194\000g\1680\000F\148@\161\159\255\175\224\129E\164)\004\003\024\167\028\227\240\128\025\234\012\000\017\165\016(`\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\183\000\000\000\000\000\000\000\000\002\001\000\000\000\000\000\000\000\000\000\002\000\000\000\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\b\004\000\000\000\000\000\000\000\000\000\b\000\000\0001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\131P\167\028\227\240\128\025\234\012\000\145\165\016+p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H7\138\001\1903\000\001\132\128@*\000A\004\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248<Qi\nA\000\198)\1998\252 \006z\131\000\004iD\n\025\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\031\255\175\224\129E\164)\004\003\024\167\028\227\240\128\025\234\012\000\017\165\016+p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\015\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\127\254\191\130\005\022\144\164\016\012b\156s\143\194\000g\1680\000F\148@\161\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000{\254\255\192\001\004\000\128\000\b\000\016\000\000\000\000\000!\000\000\000\000\000\000\000B\0200\000\001\000\000\000\003\000\000\b`\016\000\000\b@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\002\024\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\000\000\128\000\b \017\128\000@\000\000\000\000\002\000\000\b\000\030\189\171\192\000@\000 \000\002\b\004`\000\016\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002 \000z\246\175\000\001\000\000\128\000\b \017\128\000@\000\000\000\000\000\000\000\b\000\030\189\171\192\000@\000 \000\002\b\004`\000\016\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\128\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\192\000\000\016\004\000\000\002\000\000\000\000\b\128\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\b\000\000\001\000@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\128\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144H5\nq\206?\b\001\158\160\192\t\026Q\006\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\b\004\000\000\000\000\000\000\000\000\000\b\000\000\0001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\131P\167\028\227\240\128\025\234\012\000\145\165\016+p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004!C\000\000\016\000\016\0000\000\000\134\001\000\000\000\132\000\000\000\000\0001\000\000\000\000\000\000\002\002\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \2088\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\239\252 Qi\nA \2449\1998\252 \006z\147\000$iD\n\220\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\255\194\005\022\144\164\018\015B\156s\143\194\000g\1690\002F\148@\173\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\239\252 Qi\nA\000\198)\1998\252 \006z\147\000\004iD\n\220\000\000\000\000\000\000\000\000\b\004\000\000\000\000\000\000\000\000\000\b\000\000\0001\127\254\255\194\005\022\144\164\016\012b\156s\143\194\000g\1690\000F\148@\173\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\239\252 Qi\nA \212)\1998\252 \006z\147\000$iD\n\221\255\251\255\b\020ZB\144@1\138q\206?\b\001\158\164\192\001\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\128@\000\000\000\000\000\000\000\000\000\128\000\000\003\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\251\255\b\020ZB\144H5\nq\206?\b\001\158\164\192\t\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\191\240\129E\164)\004\131P\167\028\227\240\128\025\234L\000\145\165\016+p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\251\255\b\020ZB\144H5\nq\206?\b\001\158\164\192\t\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000B\0200\000\001\000\001\000\003\000\000\b`\016\000\000\b@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\251\255\b\020ZB\144H5\nq\206?\b\001\158\164\192\t\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\128@\000\000\000\000\000\000\000\000\000\128\000\000\003\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\251\255\b\020ZB\144H5\nq\206?\b\001\158\164\192\t\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000B\0200\000\001\000\001\000\003\000\000\b`\016\000\000\b@\000\000\000\000\003\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\001\000\000\000\000\000\000\000\000\000\016$K\128\024\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000 \000\000\016\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\001\002\000\000\000\000\000\000\000\000\016\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\016 \000\000\000\000\000\000\000\001\000\000\000\000\128\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000@\128\000\000\000\000\000\000\000\004\000\000\000\002\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000 \004\000\000\000\000\000\000\000\128\000\004\b\000\000\000\000\000\000\000\000@\000\000\000 \000\000\000\000\004\000\000\000\000\016\000\000\000\000\000\000\000\000\016`\004\000\002\001@\000\000\000\000\000\000\b\000\000@\128\000\000\000\000\000\000\000\004\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\002\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\001\000\000\000\000\000\000\000\000\001\006\000@\000\000\020\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\0048\001\128\000\000@\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\016`\006\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\004\024\001\000\000\000@\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000A\128\016\000\128\004\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000A\128\016\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\006\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\0048\001\128\000\000@\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\001\006\000`\000\000\016\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000A\128\016\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016`\004\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\024\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\004\024\001\128\000\000@\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\001\006\000@\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000A\128\016\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016`\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")
+ (194, "\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000 \000\002\000A\128\000\000\129\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\240\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\017\173\028\000\000@\012@\000\192\005\002\024\004@\b\002\016\000\000\000\t\144\196\004'C@\n0\131T\0162\025@\134\0014\002!\222\004\128\001\014d1\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000B\2444\000\163\b5A\003!\148\b`\019@\"\029\224H\000\016\230C\016\016\157\r\000(\194\rP@\200e\002\024\004\208\b\135x\018\000\0049\144\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\026\209\192\000\004\000\196\000\012\000P!\128D\000\128!\000\000\000\000\153\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004/S@\n0\131T\0162\025@\134\0014\002!\222\004\128\001\014d1\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\004\000\000\016\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\b \000\001\000@\000\000 \000\002\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \128\000\004\001\000\000\000\128\000\b\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\002\000\000 @\000\000\000\000\000\000@\000\000\000\000\000\0000\140\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\016\000\000\000\000\000\000\016\000\000\000 \128\000\004\001\000\000\000\128\000\b\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 @\000\000\000\000\000\000@\000\000\000\130\000\000\016\004\000\000\002\000\000\000\000\000\016\000\000\000\000\000\000\016\000\000\000 \128\000\004\001\000\000\000\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 @\000\000\000\000\000\000@\000\000\000\130\000\000\016\004\000\000\002\000\000 \000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\tP\208\002\140 \213\004\012\198P!\128M\000\136w\129 \000C\153\012@\000\000\000\000\001\000\000\000\002\b\000\000@\016\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \000@\000\000\000\000\000\000\000\000\000\000\000\000\001\tP\208\002\140 \213\004\012\198P!\128M\000\136w\129 \000C\153\012^\189\171\192\000A\000 \000\002\b\004\000\024\016\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\016\002\000\000 \000@\001\129\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\016\000\000\000!\000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000A\000 \000\002\b\004\000\024\016\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\001\004\016\002\000\000 \128@\001\129\000\000\000\128\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000A\000 \000\002\000\004\000\024\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\b\000\000\000\000\000\000\000\000\000\128\000\b\128\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\b\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\000\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\158\189\171\192\000E$ \004\131@\164\024\2270\000\bH\004\000\128\004\016\bg\175j\240\000\017I\b\001 \208)\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\000\000A\000\134\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\158\189\171\192\000E$ \004\131@\164\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\001\000\000\000\000\000\000\000@\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\000\012L\019e\146\192\000\000\020\000\129\000\000\027\160\016\159\029\192\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004RB\000H4\138A\142s\000\000\132\128@\b\000A \134z\246\175\000\001\020\144\128\018\r\002\144c\140\192\000! \016\002\000\016@!\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\00010M\150K\000\000\000P\002\004\000\000n\128B|w\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\006\200\000'\135p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000l\128\002xw\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\019 \000\158\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002|7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002|7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002|7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002|7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\003\000\016@!\128\000\000\000\000\000\000\017\000\000\000\016\000\000\001\000 \000\000\000\192\000&\131\016\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002|7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\195p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\004\200\000'\131p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0001\016M\132K\000\000\000P\002\000\000\000L\128\002x7\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\b\000\000\001\000@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000@\000z\246\175\000\001\000\000\128\000\b\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\175j\208\000\016\000\b\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000J\004\000\000\000\002\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\018\129\000\000\000\000\128\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000B\0200\000\001\000\017\000\003\000\144\b`\017\000 \b@\000\000\000&C\020\016\133,\000\000@\004@\000\192$\002\024\004@\b\002\016\000\000\000\t\144\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\bP\192\000\004\000D\000\012\002@!\128D\000\128!\000\000\000\000\153\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004!C\000\000\016\001\016\0000\t\000\134\001\016\002\000\132\000\000\000\002d1\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\020\144\128\018\r\002\144c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\020\144\000\018\rB\128c\140\192\000! \016\000\000\016@!\128\000\000\000\000\005$\000\004\131x\160\027\2270\000\024H\004\002\160\004\016H`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134z\246\175\000\001\020\144\128\018\r\002\144c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000 \000\000\012\000\016`R\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131x\160\027\2270\000\024H\004\002\160\004\016H`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000\000\001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000@\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\000\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002@\000\000\192\129\022I(\000\000\001\000\000\016\000\001\170\001\b\193\024\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000E$ \004\131H\164\024\2310\000\bH\004\000\128\004\018\bg\175j\240\000\017I\b\001 \210)\0069\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\136\000\030\189\171\192\000E$ \004\131H\164\024\2310\000\bH\004\000\000\004\018\bg\175j\240\000\017I\b\001 \210)\0069\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000h\128\0020F\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\003\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\144\000\0000\000E\128J\000\000\000@\000\000\000\000H\128\0020\006\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\t\000\000\003\000\004X\004\160\000\000\004\000\000\000\000\004\136\000#\000`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\128\001\235\218\188\000\004RB\000H4\138A\142s\000\000\132\128@\b\000A \134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\128\001\235\218\188\000\004RB\000H4\138A\142s\000\000\132\128@\b\000A \134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000 \000\b@\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\000\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\002\000\000\004\000\000\000\000\000\016\005$\000\004\131@\160\024\2270\000\bH\004\000\000\004\016\b`\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\000\000A\000\134\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\002\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\175j\240\000\017I\b\001 \208)\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\001I\000\001\000\196(\0068\200\000\006\018\001\000\000\001\004\002\024\000\000\000\000\000R@\000H7\138\001\1903\000\001\132\128@*\000A\004\134\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\000\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\002\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131x\160\027\2270\000\024H\004\002\160\004\016H`\000\000\000\000\001I\000\001 \222(\006\248\204\000\006\018\001\000\168\001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\144\000\00010M\150K\000\000\000P\002\004\000\000n\128BTw\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \212(\006x\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000R@\000H7\138\001\1903\000\001\132\128@*\000A\004\134\000\000\000\000\000\004\000\000\000\b\000\000\001\000@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\004\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\003\019\004\217d\176\000\000\005\000 @\000\006\232\004%Gp\000\000\000\000\001I\000\001\000\192(\0068\200\000\006\018\001\000\000\001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\003\002\004\025$\160\000\000\004\000\000@\000\004(\004 @`\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\020\144\128\018\r\"\144c\156\192\000! \016\002\000\016H!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\003\003\004\025$\176\000\000\004\000\000@\000\006h\004$D`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\005$\000\004\131p\160\027\2270\000\024H\004\002 \004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000R@\000H7\n\001\1903\000\001\132\128@\"\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\002 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002\000\000\000\192\001\006\001(\000\000\001\000\000\000\000\001\002\000\b\016\024\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000 \000\000\012\000\016`\018\128\000\000\016\000\000\000\000\016 \000\129\001\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\000\005$\000\004\131x\160\027\2270\000\024H\004\002\160\004\016H`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\004\000\000\000\000\000\000\020\144\000\018\r\226\128o\140\192\000a \016\b\128\016A!\128\000\000\000\000\005$\000\004\131x\160\027\2270\000\024H\004\002\160\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\004\000\000\000\000\000\000\020\144\000\018\r\226\128o\140\192\000a \016\n\128\016A!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000R@\000H5\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000E$ \004\131@\164\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\144\000\0000\000E\129J\000\000\000@\000\000\000\000h\128\0020F\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004RB\000H4\nA\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\t\000\000\003\017\004\216T\176\000\000\005\000 \000\000\006\200\000'\199p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004RB\000H4\nA\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\t\000\000\003\017\004\216T\176\000\000\005\000 \000\000\006\200\000'\199p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\b\000\000\000\000\000\000\000\000\000\128\000\b\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\0000\000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\000\000\128\000\b \017\128\000@\000\000\000\000\002\000\000\b\000\030\189\171\192\000@\000 \000\002\b\004`\000\016\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\"\000\007\175j\240\000\016\000\b\000\000\130\001\024\000\004\000\000\000\000\000\000\000\000\128\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\136\000\030\189\171\192\000@\000 \000\002\b\004`\000\016\000\000\000\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\003\000\000\000@\016\000\000\b\000\000\000\000\"\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000@\000 \000\002\b\004`\000\016\000\000\000\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\000\000\128\000\b \017\128\000@\000\000\000\000\002\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\002 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\128\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000:\246\173\000\001\004\000\128\000\000\000\016\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\004\000\128\000\b \016\000`@\000\000 \000\002\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\175j\240\000\016@\b\000\000\130\001\000\006\004\000\000\002\000\000\000\000\000\016\001\235\218\188\000\004\016\002\000\000 \128@\001\129\000\000\000\128\000\b\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\149\r\000(\194\rP@\204e\002\024\004\208\b\135x\018\000\0049\144\197\235\218\188\000\004\016\002\000\000 \128@\001\129\000\000\000\128\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000@\000z\246\175\000\001\004\000\128\000\b\000\016\000`@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\0000\001\000\004\001\000\000\000\128\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\005\235\218\188\000\004\000\002\000\000 \000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000@\000 \000\002\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134z\246\175\000\001\000\000\128\000\b\000\016\000\000@\000\000\000\000\000\000\000\000\000\030\189\171\192\000@\000 \000\002\000\004\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\007\175j\240\000\016\000\b\000\000\128\001\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\004\000\000\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\001\000\000\000\000\000\004\000\000\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\235\218\180\000\004\000\002\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\140 \145\004\000\134\016\000\000I\000\bv\129 \000C\000\000\000\000@\004\000\163\b$A\000!\132\000\000\018@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\140 \145\004\000\134\016\000\000I\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\129\005\164\t\004\003\016\161\028\2270\128\025\234\012\000\017\133\016(`\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\191\128\001\004\000\128\000\b\000\016\000\003\000\000\000 \000\000\001\128!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\004\000\128\000\b\000\016\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\012\000\000!\128@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000@\000 \000\002\b\004`\000\016\000\000\000\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131P\160\025\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\018\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\128\000\000\000\000\000\000\005$\000\004\131P\160\025\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\175j\208\000\016@\b\000\000\000\001\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\128\000\000\000\000\000\000\005$\000\004\131P\160\025\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\b@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\001\255\250\254\b\020ZB\144H5\nq\206?\b\001\158\160\192\t\030Q\134\134\000\000\000$\000\004\012L\019m\146\192\001\000T\000\129 \000\027\160\016\148\029\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\025\235\218\188\000\004RB\000H4\nA\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\t\000\000\003\017\004\216T\176\000\000\005\000 \000\000\006\136\000\005\007p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\016H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\015\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\016\000\000\000\000\000\000\000@\136\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248 Qi\nA\000\196)\1998\252 \006z\131\000\004iD\n\025\255\250\254\b\020ZB\144H5\011q\206?\b\001\158\160\192\t\026QB\134z\246\175\000\001\020\144\128\018\r\002\144c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\020\144\000\016\012B\128c\140\128\000a \016\000\000\016@!\128\000\000\000\000\005$\000\004\003\000\160\024\227 \000\024H\004\000\000\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\001\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001\000\192(\0068\200\000\006\018\001\000\000\001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\003\019\004\217d\176\000\000\005\000 @\000\006\168\004\005\007p\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\020\144\128\018\r\"\144c\156\192\000! \016\002\000\016H!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\000\003\017\004\216D\176\000\000\005\000 \000\000\006\136\000\005\007p\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\192\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000$\000\000\012D\019a\018\192\000\000\020\000\128\000\000\018 \000\020\r\192\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\002@\000\000\196A6\017,\000\000\001@\b\000\000\001\"\000\001@\220\000\000\000\000\000R@\000H7\138\001\1903\000\001\132\128@*\000A\004\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\015\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\191\240\241E\164)\004\003\024\183\028\227\241\128\025\234L\000\017\229\028kp\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\127\254\191\130\005\022\144\164\018\rB\220s\143\194\000g\1680\002F\148P\161\159\255\175\224\129E\164)\004\131P\167\028\227\240\128\025\234\012\000\145\165\016h`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\191\240\129E\1649\004\195P\183\028\227\241\1289\234L\001\209\229\029kp\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\002\004\022\144$\016\012B\132s\140\194\000g\1680\000F\020@\161\128\000\000\000\129\005\164\t\004\003\016\161\028\2270\128\025\234\012\000\017\133\016(`\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\191\235\248\000\017I\bA \208)\0068\252\000\002\018\001\000 \t\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\004\000\128\000\b\000\016\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\0000\000\000\134\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000z\246\175\000\001\000\000\128\000\b \017\128\000@\000\000\000\000\002\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131P\160\025\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000:\246\173\000\001\004\000\128\000\000\000\016\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\000@\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \212(\006x\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\000\001\003\003\004\027$\176\000@\020\000\000H\000\006(\004$\004`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\016H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\018\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\b\016Z@\144@1\n\017\2063\b\001\158\160\192\001\024Q\002\134\000\000\000\002\004\022\144$\016\012B\132s\140\194\000g\1680\000F\020@\161\128\000\000\000\000\001\000\000\000\000\b\000\000@\016\000\000\b\000\000\128\000\002\000\000\000\000\000\000\000@\000\000\000\002\000\000\016\004\000\000\002\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002 \000\000\000\000\000\000\004\000\000\000\000 \000\001\000@\000\000 \000\000\000\000\b\000\000\000\000\000\000\001\000\000\000\000\b\000\000@\016\000\000\b\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\136\000\000\000\000\000\000\001\000\000\000\000\b\000\000@\016\000\000\b\000\000\128\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002 \000\000\000\000\000\000\004\000\000\000\000 \000\001\000@\000\000 \000\002\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000E$ \004\131H\164\024\2310\000\bH\004\000\128\004\018\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\b\016Z@\144@1\n\017\2063\b\001\158\160\192\001\024Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144H5\nq\206?\024\001\158\160\192\t\026Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\239\252<Qi\nA\000\198-\1998\252`\006z\147\000\004yG\026\220\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248 Qi\nA\000\198)\1998\252`\006z\131\000\004iD\n\024\000\000\000\000\000\000\000\000\b\004\000\000\000\000\016\000\000\000\000\b\000\000\0001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\003\024\167\028\227\241\128\025\234\012\000\017\165\016+p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000$\000\004\012L\019m\146\192\001\000T\000\129 \000\027\160\016\020\029\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@ \016\000\000\000\000@\000\000\000\000 \000\000\000\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\131P\167\028\227\241\128\025\234\012\000\145\165\016+p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144@1\138q\206?\024\001\158\160\192\001\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\175j\240\000\017I\b\001 \210)\0069\204\000\002\018\001\000 \001\004\130\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \212(\006x\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001\000\003\000\000\b`\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\b\000\000\001\000@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H5\n\001\1583\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\189\171@\000A\000 \000\000\000\004\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\128\000\000\016\004\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\002\000\000\000\000\000\000\000\020\144\000\018\rB\128g\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144H5\nq\206?\024\001\158\160\192\t\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@ \016\000\000\000\000@\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\191\130\005\022\144\164\018\rB\156s\143\198\000g\1680\002F\148@\161\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000@\000\192\000\002\024\004@\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\001\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A \134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\129\005\164\t\004\003\016\161\028\2270\128\025\234\012\000\017\133\016(`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000E$ \004\131H\164\024\2310\000\bH\004\000\128\004\018\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131P\160\025\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\004\000\012\000\000!\128@\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\175j\240\000\016\000\b\000\000\130\001\024\000\004\000\000\000\000\000 \000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \212(\006x\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H5\n\001\1583\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\175j\208\000\016@\b\000\000\000\001\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \212(\006x\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000 Ai\002A\000\196(G8\204 \006z\131\000\004aD\n\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\007\255\239\252 Qi\014A0\212-\1998\252`\014z\147\000dyGZ\220\000\000\000\b\016Z@\144@1\n\017\2063\b\001\158\160\192\001\024Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\003\024\183\028\227\240\128\025\234\012\000\017\229\028h`\000\000\000\000\000\000\000\000 \016\000\000\000\000\000\000\000\000\000 \000\000\000\001\255\250\254\b\020ZB\144@1\139q\206?\b\001\158\160\192\001\030Q\198\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\128@\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144H5\011q\206?\b\001\158\160\192\t\030Q\198\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\131P\183\028\227\240\128\025\234\012\000\145\229\028h`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\001\000\001\255\250\254\b\020ZB\144@1\139q\206?\b\001\158\160\192\001\026QB\134\000\000\000\000\000\000\000\000\002\001\000@\000\000\000\000\000\000\000\002\000\000\016\000\031\255\175\224\129E\164)\004\003\024\183\028\227\240\128\025\234\012\000\017\165\020(`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\128@\016\000\000\000\000\000\000\000\000\128\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144H5\011q\206?\b\001\158\160\192\t\026QB\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\004\000\012\000@!\128@\000\000 \000\000\000\000\016\000\000\000\000\000\000\000\000\016\000\192@\000\000\000\000\000 \000\000\000\128\000\001\000\023\255\235\248 Qi\nA\000\198)\1998\252 \006z\131\000\004iD\n\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000D\003\001\000\000\000\000\000\000\128\000\000\002\000\000\004\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248 Qi\014A0\212)\1998\252 \014z\131\000$iDJ\029\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248 Qi\014A0\212)\1998\252 \014z\131\000$iDJ\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\001\000\001\255\250\254\b\020ZB\144H5\011q\206?\b\001\158\160\192\t\026QB\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@ \016\000\000\000\000@\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\191\130\005\022\144\164\018\rB\156s\143\198\000g\1680\002F\148@\161\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000{\254\191\128\001\020\144\164\016\012\002\144c\143\128\000a \016\000\000\148@\161\128\000\000\000\000\005$\001\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\255\175\224\000E$)\004\003\000\164\024\227\224\000\024H\004\000\000%\016(`\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\001\000\001\239\250\254\000\004RB\144@0\nA\142>\000\001\132\128@\000\002Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\001\000\003\000\016\b`\016\000\000\b\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\016 \000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\031\255\175\224\129E\164)\004\131P\167\028\227\240\128\025\234\012\000\145\229\024h`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\b@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\000\004\016\002\000\000 \000@\000\012\000\000\000\128\000\000\006\000\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\005\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\003\024\167\028\227\240\128\025\234\012\000\017\165\016(`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000@\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\160\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\129E\164)\004\003\016\165\028\227\240\128\025\234\012\000\017\165\016(g\175j\240\000\017I\b\001\000\192)\0068\200\000\006\018\001\000\000\001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000_\255\175\224\129E\164)\004\003\016\165\028\227\240\128\025\234\012\000\017\165\016(`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\191\130\005\022\144\164\016\012B\148s\143\194\000g\1680\000F\148@\161\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248\000\016@\b\000\000\128\001\000\0000\000\000\002\000\000\000\b\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\001\127\254\191\128\001\004\000\128\000\b\000\016\000\003\000\000\000 \000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248\000\016@\b\000\000\128\001\000\0000\000\000\002\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\144\000\018\r\002\128c\140\192\000! \016\002\000\016@!\128\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\194\000\226\b$I\002\016\012\000\000\018@\002\020\161H\000\024\192\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\001\000\016\002\136 \017\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000 \000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\b\000\000\128\000\000\000\000\000\b\000 \000\000\000\000\000@\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\b\128\000\000\000\000\000\b\000 \000\000\000\000\000@\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\014\000\130D\016!\000\192\000\001$\000!H\020\128\001\140\000\000z\246\175\000\003\128 \128\004\b@0\000\000I\000\bR\005 \000c\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\024@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\b\000\000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\b\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\b\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 @\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\014\000\130@\016!\000\192\000\001$\000!H\020\128\001\132\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\189\171\192\000\224\b \001\002\016\012\000\000\018@\002\020\129H\000\024@\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\129\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000@\004\000\162\b$A\000\001\000\000\000\n@\002\029\160H\000\016\224\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\004\000@\n \130D\016\002\016\000\000\000\164\000!\218\004\128\001\014\000\000\000\001\000\016\"\136 \145\004\000\004\000\000\000\t\000(v\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\175j\240\000\016\000\b\000\000\128\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\129\000\030\189\171\192\000@\000 \000\002\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\001\000\016\002\136 \145\004\000\006\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\128\000\000\000\000\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\128\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\128\000\000\000\000@\000\000\000\128\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000D\000\000\000\t\000\bv\129 \000C\000\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\001\000\016\002\232 \145\004\000\020\000\000\000)\000\bv\129 \000C\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\016\001\000(\130\t\016@\b@\000\000\002\144\000\135h\018\000\0048\000\000\000\004\000@\138 \130D\016\000\016\000\000\000$\000\161\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\"\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000 \000\000\000\016\001\002(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000`\000\000\000\000\016\000\000\000 \000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\001\000\016\002\136 \145\004\000\132\000\000\000)\000\bv\129 \000C\128\000\000\000@\004\b\162\b$A\000\001\000\000\000\002@\n\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\160\016\129\000(\130\t\016@\000`\000\000\000\144\000\135h\018\000\0040\000\000\000\004\000@\n \130D\016\000\024\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\162\b$A\000\001\128\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000@\n$\130D\016\002P\000\000\000\164\000!\218\004\128\001\014\000\000\000\001\000\016\"\136 \145\004\000\004\000\000\000\t\000(v\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000@\n \130D\016\000\024\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\162\b$A\000\001\128\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\128\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000@\000\000\000\128\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\128\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\016\000\000\000\000\000\b\b\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\004\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\128\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\132\000\000\000\000@\000\000\000\128\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\001\000(\130\t\016@\000@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\016\001\000.\130\t\016@\001@\000\000\002\144\000\135h\018\000\0048\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\175z\241\0008\130\t\016@\132A\000\000\004\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\001\000\016\002\136 \017\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000@\004\000\186H$A\000%\128\000\000\n@\002\029\160H\000\016\224\000\000\000\016\001\000(\130\t\016@\b@\000\000\000\144\000\135h\018\000\0040\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\004\000\162\b$A\000\001\000\000\000\002@\002\029\160H\000\016\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\001\235\222\188@\014 \130D\016!\024@\000\001$\000!\218\004\128\001\012\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000@\n \130D\016\000\016\000\000\000$\000!\218\004\128\001\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\016\002\136 \145\004\000\004\000\000\000\t\000\bv\129 \000C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188 \014 \130D\144!\000\192\000\001$\000!J\020\128\001\140\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \2088\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \208(\0068\204\000\002\018\001\000 \001\004\002\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\239\252 Qi\nA \2449\1998\252 \006z\147\000$iD\n\220\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\255\194\005\022\144\164\018\015B\156s\143\194\000g\1690\002F\148@\173\222\255\191\240\000@\000 \000\002\000\004\000\000\000\000\000\000@\000\000\000\000\000\007\191\239\252\000\016\000\b\000\000\128\001\000\000\000\000\000\000\016\000\000\000\000\000\001\239\251\255\000\004\000\002\000\000 \000@\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000B\0200\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\016\133\012\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\004!C\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\001\bP\192\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\250\254\015\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\127\254\191\130\005\022\144\164\016\012b\156s\143\194\000g\1680\000F\148@\161\128\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248 Qi\nA\000\198)\1998\252 \006z\131\000\004iD\n\220\000\000\000\000\000\000\000\000\b\004\000\000\000\000\000\000\000\000\000\b\000\000\0001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@ \016\000\000\000\000\000\000\000\000\000 \000\000\000\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\191\130\005\022\144\164\018\rB\156s\143\194\000g\1680\002F\148@\173\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001I\000\001 \222(\006\248\204\000\006\018\001\000\168\001\004\018\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\175\224\241E\164)\004\003\024\167\028\227\240\128\025\234\012\000\017\165\016(g\255\235\248 Qi\nA\000\198)\1998\252 \006z\131\000\004iD\n\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\127\254\191\130\005\022\144\164\016\012b\156s\143\194\000g\1680\000F\148@\173\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248<Qi\nA\000\198)\1998\252 \006z\131\000\004iD\n\025\255\250\254\b\020ZB\144@1\138q\206?\b\001\158\160\192\001\026Q\002\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\239\251\255\000\004\016\002\000\000 \000@\000\000\000\000\000\132\000\000\000\000\000\000\001\bP\192\000\004\000\000\000\012\000\000!\128@\000\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\002\000\000\b`\016\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\b\000\000 \000z\246\175\000\001\000\000\128\000\b \017\128\000@\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\128\001\235\218\188\000\004\000\002\000\000 \128F\000\001\000\000\000\000\000\000\000\000 \000z\246\175\000\001\000\000\128\000\b \017\128\000@\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\"\000\007\175j\240\000\016\000\b\000\000\130\001\024\000\004\000\000\000\000\000 \000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\003\000\000\000@\016\000\000\b\000\000\000\000\"\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000 \000\000\004\001\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\"\000\007\175j\240\000\016\000\b\000\000\130\001\024\000\004\000\000\000\000\000 \000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\235\248 Qi\nA \212)\1998\252 \006z\131\000$iD\026\024\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@ \016\000\000\000\000\000\000\000\000\000 \000\000\000\196\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\191\130\005\022\144\164\018\rB\156s\143\194\000g\1680\002F\148@\173\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\133\012\000\000@\000@\000\192\000\002\024\004\000\000\002\016\000\000\000\000\000\196\000\000\000\000\000\000\b\b\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005$\000\004\131@\224\024\2270\000\bH\004\000\128\004\016\b`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R@\000H4\n\001\1423\000\000\132\128@\b\000A\000\134\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\191\240\129E\164)\004\131\208\231\028\227\240\128\025\234L\000\145\165\016+p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\255\251\255\b\020ZB\144H=\nq\206?\b\001\158\164\192\t\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\191\240\129E\164)\004\003\024\167\028\227\240\128\025\234L\000\017\165\016+p\000\000\000\000\000\000\000\000 \016\000\000\000\000\000\000\000\000\000 \000\000\000\197\255\251\255\b\020ZB\144@1\138q\206?\b\001\158\164\192\001\026Q\002\183\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\031\255\191\240\129E\164)\004\131P\167\028\227\240\128\025\234L\000\145\165\016+w\255\239\252 Qi\nA\000\198)\1998\252 \006z\147\000\004iD\n\220\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\002\001\000\000\000\000\000\000\000\000\000\002\000\000\000\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\239\252 Qi\nA \212)\1998\252 \006z\147\000$iD\n\220\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\127\254\255\194\005\022\144\164\018\rB\156s\143\194\000g\1690\002F\148@\173\192\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\239\252 Qi\nA \212)\1998\252 \006z\147\000$iD\n\220\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\bP\192\000\004\000\004\000\012\000\000!\128@\000\000!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\239\252 Qi\nA \212)\1998\252 \006z\147\000$iD\n\220\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\002\001\000\000\000\000\000\000\000\000\000\002\000\000\000\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\255\239\252 Qi\nA \212)\1998\252 \006z\147\000$iD\n\220\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\bP\192\000\004\000\004\000\012\000\000!\128@\000\000!\000\000\000\000\000\012@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\004\000\000\000\000\000\000\000\000\000@\145.\000`\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\128\000\000@\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\004\b\000\000\000\000\000\000\000\000@\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000@\128\000\000\000\000\000\000\000\004\000\000\000\002\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\001\002\000\000\000\000\000\000\000\000\016\000\000\000\b\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\128\016\000\000\000\000\000\000\002\000\000\016 \000\000\000\000\000\000\000\001\000\000\000\000\128\000\000\000\000\016\000\000\000\000@\000\000\000\000\000\000\000\000A\128\016\000\b\005\000\000\000\000\000\000\000 \000\001\002\000\000\000\000\000\000\000\000\016\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\b\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\004\000\000\000\000\000\000\000\000\004\024\001\000\000\000P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\016\224\006\000\000\001\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000A\128\024\000\000\004\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\016`\004\000\000\001\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\006\000@\002\000\016\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\006\000@\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\024\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\016\224\006\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\004\024\001\128\000\000@\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\001\006\000@\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000A\128\016\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016`\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\016`\006\000\000\001\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\004\024\001\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\006\000@\000\000\016\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000A\128\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\b\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\128\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000")
let action =
- ((16, "\002\130\000\185\000\000\000\000\022\134\000\185\000\000\000\000\000\026\000\000\000\000\000\000\000\213\000\000\000\000\000\000\002\130\000\000\000\005:*\000\000\000\000I\182\026P\000\000\025,\027t\000\000\000\000\000\000\000\000\000\213\0002\000\000\000\000\000\000\000\000\000\000\000\000\000\000J\142\000\000\000\000\025,\000\000\000\000\000\006\000\000\000\017\000\017\000\000\000\000\000\000\000\000\000\r\000\000\000\000\000\144\000\017\000\000\000\144\000\000\000\000\000\017\000\162\001\244\000\017\001\242\000\000\003\000\000R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\223\000\017\000\000\000I\002\220\000\017\000\000\000\005\001f\000\000\000\000\000\000\002\016\000\000\028\152\000\017\002\028\000\000\000\000\000\000\000\000:*\029\188?\184\000\000?\184\000\000\000\000\000\000\000\017\000\000?\184\000\000>\156\003\028?\184\003P\000\000\000\000\000\017\007fW\234\000\000\000\000[0[\200\000\000^\200\000\000\\`Vn%\254%\254^\200Vn\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\\\248%\254\000\000\000\000\\\248\\\248\\\248\000\000\\\248\000\006\000\000\000\000Vn\\\248\000\000\000\000/\026\000\017\000\000 b%\254Vn\000\0000jVn<\002Vn<\128Vn\000\000\000\000\000\000\000\000\000\000\000\000\000\000J\248Vn\000\000L\020Vn=\156Vn>\184Vn\000\000Vn\000\000Vn?\212Vn@\240VnB\012VnC(VnDDVnE`Vn!`Vn\000\000\000\000\000\000\003dVn\000\000\000\000\000\000\000\000VnL\156VnM\184VnN@VnO\\VnF|VnG\152VnH\180VnO\228VnQ\000Vn\000\000VnQ\136VnR\164VnS,Vn\000\000VnTHVnT\208Vn\000\000\000\000Vn\000\000\003\202\000\000\000\000\000\017\000\000\000\000\000\000\000\000\003\242\000\000\004\020\000\000\000\020Vn\000\000\000\020\000\000\000\000\000\194:*\000\000&\224\0032\0032m\164]\226\000\000m\164\000\000\000\000m\164\000\000\000\194\000\000\000\000%\254\004V\000\000\004x^\2005p\000\000_X%\254\004z\000\000\004\1384>5p^\200\000\000\000\000\000\000\000\000\000\000\000\000\\\248\000\000\000\000\\\248\000\000\000\000\\\248\000\000\000\006\000\000^\200\000\000\000\000n\006\000\017\000\000 b b\000\000\000\227$\226 b \230Vn\000\000Vn\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\023\028Vn\024\132Vn\005\nVn\000\000Vn$\"VnI\022Vnw\154Vnw\246VnxZVnx\182Vn\000\000Vny\026VnyvVny\218Vn\000\000Vnz6Vnz\154\000\175!\226\000\000\000\000\001X#b\000\000\000\000\000\000\000\000\004\228\000\000Vn\004\252\000\000\000\000\000\017\000\000\000\000\000\000\002\184^\200\000\000\000\000\006\000\000\000\000[`0\005\242Vn\005\240\000\000\000\000^\200\000[\000\000\000\000Vn\005v\000\000%\254\005\130\000\000\005\132n\1385p^\200\005\134\000\000Vn\000|Vn\005\138\000\000\000\0005p5p\000\000\000\000\000\000\000\0002\200\000\000\000\000\000\000\000\000\000\000\\\248\000\000\000\000\000\164\006\136Vn5p\000\017\000\000\\\248\000\000\000\000\\\248\000\000\000\006\000\0003\240n\138\000\000\000\000\"\172\000\017\000\000 b\005\208\000\000Vn\005\212\000\000\000\000\000\017\000\000\000\000\000\000\000\000\000\000-\140\000\000\000\000\006\0165p\006&5p\000\000\000\003\000\000\000\000\025\168Vn\026\204Vn\027\240Vn\029\020Vn\0308Vn8\168VnK0VnKTVn\000\000VnV\000Vn_fVna\224Vn\000\000VnkBVnk\194\000\000\006\004\000\000\001(6\\\000\000\002x845p\000\000\003\n7H\000\000\000\000\000\000\000\000\006\152\000\000\000\000\000\000\0068\000\000\006N\000\000\000\000\006T\000\000\000\000\006X\000\000\000\000\006b\000\000\000\000\000\000\000\000\000\000\000\000\006d\007,\000\000\006j\000\000\006r\000\000\006rW\234\000\000%\254\006tv\188\000\000\007X\000\000%\254\006\1309*\000\000%\254\006\132:F\000\000\006\132\000\000\000\000\007f\000\000\007x\000\000\000\000\001f\007H\000\017\006\142\007`EDED\000\000\000\000\000\000\003\\T,ED\003hG|\000\000\000\000\000\000\006h\007R\002\162\007fED\000\000\000\000\006\156\000\000\006\160\007pED\006\164\000\000\001N\000\000\000\000\003\196M\156\000\000\000\000\000\000\006\168\007\156\000\000\007\158\000\0001\234\000\017\007\160\000\000\000\000\000\000\006\174\000\000?\184\000\000D(A\240\000\000\000\000\030\224?\184\006\176\000\000\000\000\001\140?\184\000\000\001\140\000\000\000\000\006\194\000\000\002\162\006\192\000\000\001V:*\000\000:*\000\000\006\174\000\000\001V\000\000\019\1524\240:*\000\000\006\208\000\000\002\000:*\000\000\000\000\002\000\000\000\000\000\000\000\000\026\000\000\000\000\001<\000\026\000\000\000\000\000\000\007\194\000\000&\224'n'n\000\000\000\000'n\000\000\000\000\000\000\000\000\000\000\007\170Vn\006\222)X\007^\000\000\007\192Vn\006\244\007\188:*\000\000\000\000\000\000:*\000\017\000\000\000\017Vn\007\242\000\000\000\017\000\000\000\017\007\244\000\000\t.\007\196\000\017\007\014\007\222ED\007\018\001\154\000\000Vn\b\004\000\000\000\000\000\000\007\230ED\007\026\b\n\000\000\003\186\004>Vn\b\020\000\000\b\022\000\0001\234\000\017\004lVn\b(\000\000\b*\000\000\000\017\004\140Vn\b.\000\000\b6\000\000\0013\007t\t\n,n\000\000`\192%\254\007LW(\000\000X\130\000\000\b<\000\000\003\002\b\018Vn\007\208\000\000\b\022Vn\007\212\000\000\001p\000\000\t\n\t\n%\254\007X\000\000\007ZoLoL\000\000\000\000\000\000\000\000\000\000\000\000\\\248\000\000\000\000\\\248\000\000\000\000\\\248\000\000\000\006\000\000oL\000\000\000\000;b\000\017\000\000 b\007`\000\000Vn\007d\000\000\000\000\000\017\000\000\000\000\000\000\000\000\000\000Y<Vn\000\000Vn\000\000\007p\000\000\000\020\000\000\000\000\000\000\000\000\000\000c\014VncvVn\007\156Vn\000\000Vnd\146Vnd\250Vnf\022Vnf~Vng\154Vnh\002Vn\000\000Vni\030Vni\134Vnj\162Vn\000\000Vnk\nVnl&5p\007n\000\000\000\000\003\002\000\000\003\002\000\000\019\152\t\n\t\n\000\000\000\000\000\000\000\003\000\000\000\000\000\000\bFVn\007|)X*j\000\017\bl\000\000\bN\022\152\000\000:*\000\017\001\166\000\000Vn\br\000\000\n&\bD\000\017\007\138\bZED\007\142\004H\000\000Vn\b\128\000\000\004L\000\000Vn\b\132\000\0001\234\000\017\004\158\000\000Vn\b\174\000\000\000\017\005 \000\000Vn\b\196\000\000-\152\b\198Z\000\b\206Vn\007\226)X)X\001\022\001\022\003\228\001\226\001\022\000\000\000\000\004\012\004\026\000\000\004Z\n\"\000\000\000\000\000\000\000\000\000\000\007\228\000\000\000\000\b\214\000\000\b\216\000\000\000\000\t\026\b\196Vn\007\250\b\238\000\000\b\242\000\000\b0\000\000\b\218 b\b\014)X\000\000\000\000\000\000\007\136\000\000\000\000\003\002\000\000\b\146\000\000\015\018\0012\000\000\015\018\000\000\000\000-\152\000\000\011\182\000\000\000\000\012\014\000\000\015\018\000\000\b\230 b\b\026\005b\000\000Vn\t\016\000\000\0032\000\000\b\226\000\017\b0\t\000ED\b4\005n\000\000Vn\t$\000\000\t\006ED\bF\t6\000\000\0056Vn\t8\000\000\t:\000\0001\234\000\017\005<Vn\t>\000\000\tP\000\000\000\000\000\000\012\014\000\000\000\000\001:\000\000\t\n\000\000\0032\000\000\000\000Z\000\tXVn\bl)X\000\000\000\000\tB b\bx\005t\000\000Vn\tt\000\000\007\184\000\000\tD\000\017\b\144\t`ED\b\152\005v\000\000Vn\t\136\000\000\005|\000\000Vn\t\138\000\0001\234\000\017\005\198\000\000Vn\t\140\000\000\002\200*j\000\000\002\200\000\000\000\000\b\162\000\000\000\020\001\128)X\000\000\006\006\0007\006\006\000\000\0007\000\000\t\n\000\000\t\n\000\000\000\000\000\000\b\174\000\000\000\000\b\186\000\000\004V\007\136\0007\006\006\000\000\000\000\000\000\0007\000\000\t\n\000\000\004V\000\000\000\000\022|\020R\019\152\000\000\020R\000\000\n\140\019\152\000\000\000\000\n\140\000\000\000\000\b\186\000\000\000\000\b\192\000\000\004\244\t\n\000\000\004\244\000\000\000\000\t@\000\000\001:\000\000\t\n\000\000\000\000\000\000\024\024Z\152\000\000\t\178\000\000\024\024\t\184\000\000\t\186\000\000\005\146\024\024\000\000\t\188\000\000\000\000\005\146\000\000\000\000\b\210\000\000\023@\tP\000\000\000\000\000\000\tR\000\000\000\165\000\178\000\000\019\152\t\176\000\000\000\000Vn\t\002\t\n\000\000\b\214\000\000\0013\000\000:*\000\000\000\000\003\236\019\152\000\000\019\152\000\000\b\198\000\000\003\236\000\000Vn\003\240Vn\000\000Vn\000\000\b\200\000\000\003\240\000\000Vn\003\240\b\204\000\000\021\024+\234\000\000\003\250\021\024\000\000\000\000\021\024\000\000\b\206\000\000\003\250\000\000Vn\003\240\b\208\000\000:*\005\216:*\000\000:*\000\000\b\218\000\000\005\216\000\000Vn\003\240\b\220\000\000\000\000'~\000\000\000\185\t~\000\000\000\000\tT]\212\000\000\000\000\000\000\000\000\000\000\000\000\t(\006\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\004]\212\000\000\001\b\003P\t*\000\185\000\000\000\000\t2\000\185\000\000\000\000\000\000\000\000\001\024\003P\000\000\000\000\000\000\000\000\t\144\000\000\000\000\000\000\000\000/\0261j\000\000q&\000\000]\212\000\000\002v]\212\000\000\002\196\001\218\001\218\000\000\003\224\001\218\000\000\t\b\000\000\000\000\000\000\000\000\t\162\000\0002\200\000\0004\240]\212\000\000\000\029]\212\000\000\t\198\000\000]\212\t\202\000\000r\194]\212\t\222\000\000\t\224\000\000s\194]\212]\212\000\000\000\000\t^]\212\t\232\000\000\t\234\000\000\t\236\000\000:*\000\000\004\n:*\000\000\tf'n\000\000]\212\t\244\000\000\002\220]\212\000\000\004\154]\212\000\000\004\132\n|\000\000\n~\000\000b\030]\212\tr\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\000t\016a\156\n\n\000\000\n\020\000\000u\016p\012]\212\t\150]\212\n&\000\000\n(\000\000\n*\000\000]\212\t\208\000\185\000\000\000\000\005\154]\212\000\000\004\132\000\000\n0\000\000]\212\n2\000\000u^p\028]\212\t\176]\212\n:\000\000\n<\000\000\n>\000\000l\200'n\000\000'n\000\000b\030]\212\t\188]\212\nH\000\000\nL\000\000'n\000\000qt\000\000\000\000\005\166]\212\000\000\001\128\003\142\001\218\t\196\000\000\000\000\0032\0032\000\000\000\000\000\000\000\000\005\024\0032\000\000\t\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000]\212\000\000\005\236]\212\000\000\005Z\001f\000\185\t\208\000\000\000\000\000\000\000\000\000\000\000\000\000\000\n\\\000\000\nd\000\000]\212\nf\000\000v^a\156\nh\000\000\np\000\000]\212\nr\000\000(\226\n v\172U\206rt\t\246\000\000]\212\n\140\000\000\n\142\000\000\n^(\226]\212\n\150\000\000]\212\n\152\000\000\n\154\000\000]\212\n\156\000\000\000\185\n\b\000\000\000\000'~\000\000\000\000\0044\011\002\000\000\000\000\001C\000\000\000\000\000\000Vn\000\000\000\000\000\000\004\132\000\000\000J\000\000\000\000\000\000\006\006:*:*:*\000\000\003`\003`\003`\003`\000\000\000\000\000\000\000\000\000\000\000\000\003\002\019\152\n\248\016\148\0012\000\000\000\000\004P\000\000\012\014\000\0005p\n\026\000\000\003\002\019\152\n*\018\022\000\000\003\002\016\148\000\000\000\000\000\000:*6j\000\000\000\000\000\000\n\128\0032\011\bO@O@\000\000\004\230d,O@\005\164P\228\000\000\000\000\b\170\n\252\000\017\000\000\005\200R\136\000\000\000\000\000\000\000\000\000\000\nB\011\n\t\n\nH\000\000\000\000\004P\000\000\012\014\000\000\021r\000\027\000\000\000\000\011\002\000\000\000\000\0044\000\000\002\030\000\000\000\000\000\000Vn\000\000\004\132\000\000\002\198\000\000\000\000\000\000\007\136\000\000\r\144\005L\r\144\000\000\t\n\r\144\000\000\005\246\000\000\t\n\000\000\t\n\000\000\t\n\000\000\019\242\000\000\000\000\000\000\000\000\000\000\t\n\000\000\005\246\000\000\t\n\000\000*\196\000\000\000\000\n\140\n\130\000\185\002$\011.\005\202\000\000\005\202\011V\000\000\011Z\000\000\006\204\000\000\005\202\002\196\005\202\0110\005\202\000\000\000\000\003\170\000\000\0144\002$\nR\000\000\nV\000\000\n\156\000\185\002$\nd\000\000\n\140\011p\000\000\014\234\bd\011\132\000\225\011\132\000\000\000\000\b,\000\185\000\000\001D\000\000\000\000\000p\000\000\nn\000\000\000\000\000\000\n\172\000\185\002$\nr\000\000\000\000\n\140\014\234\bd\b,\001D\000p\nv\000\000\014\234\bd\b,\001D\000p\nx\000\000\006\170\002\012\n\148\000\185\n\144\006\220\003\230\n\186\000\185\000\000\n\190\000\185\000\000\011\030\000\000\n\164\004\140\n\160\006\220\011H\000\000\n\216\006\220\011`\000\000\000\000\006\220\000\000\011b\000\000"), (16, "\r\213\r\213\r\213\r\213\r\213\r\213\r\213\r\213\r\213\r\213\r\213\r\213\r\213\r\213\012:\r\213\r\213\r\213\r\213\r\213\r\213\r\213\r\213\r\213\r\213\019N\006\145\025#\025'\r\213\005\249\001\194\025+\r!\n\001\r)\r\213\000\190\r\213\r!\r!\026\151\r\213\012n\r\213\r\213\000\n\r\213\000\190\026\155\r\213\r!\014\014\r9\000\130\r\213\r\213\r\213\001\170\026\158\r\213\000&\004\217\0056\028\006\001N\r\213\b\193\000\198\r\213\r\213\n\001\b\233\001\198\000\254\r\213\r\213\r!\r\213\006\190\r\213\000*\0007\000;\000\194\r\213\000\190\r\213\r\213\005\254\r\213\r\213\r\213\b\177\0196\000\202\r\213\r\213\r\213\004:\rY\r\213\r\213\r\213\n\218\000\206\001\"\r\213\r\213\r\213\r\213\r\213\r\213\006f\001\006\007\022\r\213\r\213\000N\n\158\019\158\019\198\019\214\020\n\020\026\020B\n\222\r\213\r\213\r\213\000\n\015\218\r\213\r\213\r\213\r\213\006\145\r\213\012\150\r\213\001Z\000\n\r\213\001\030\001\"\r\213\r\213\b\249\011r\001&\001\002\000\n\004\217\001*\001.\006\t\r\213\r\213\007\145\007\"\r\213\000\234\021\198\000\134\r\213\r\213\r\213\r\213\011~\rY\r\213\0012\r\213\000\222\001j\b\237\r\213\r\213\r\213\000\n\r\213\002}\r\213\r\213\000\190\r\213\004R\r\213\r\213\006Y\r\213\r\213\r\213\r\225\r\225\r\225\r\225\r\225\r\225\r\225\r\225\r\225\r\225\r\225\r\225\r\225\r\225\028.\r\225\r\225\r\225\r\225\r\225\r\225\r\225\r\225\r\225\r\225\n\001\r\145\006\198\015*\r\225\012n\000\190\025K\025O\012n\n~\r\225\025S\r\225\014\014\012\150\018\186\r\225\014\014\r\225\r\225\023\182\r\225\018\190\000\202\r\225\006\210\005\129\012\133\001\238\r\225\r\225\r\225\006Q\000\206\r\225\r\153\000\198\tR\003\233\003\241\r\225\024*\000\254\r\225\r\225\003\233\003\241\011\178\012\154\r\225\r\225\014\165\r\225\014~\r\225\014\165\023\202\006I\000\n\r\225\019\"\r\225\r\225\000\202\r\225\r\225\r\225\000\190\nR\020\246\r\225\r\225\r\225\000\206\020\142\r\225\r\225\r\225\015.\028\158\n\134\r\225\r\225\r\225\r\225\r\225\r\225\n\005\028\"\012\133\r\225\r\225\015\218\021&\004]\028&\015\218\r\153\000\n\021~\004\017\r\225\r\225\r\225\0156\bF\r\225\r\225\r\225\r\225\018\186\r\225\t\005\r\225\001\n\n\230\r\225\018\190\001\002\r\225\r\225\018\194\014\165\014\165\005\241\000\202\n\186\014\165\005\241\006\014\017\190\r\225\004]\002]\r\225\000\206\000\006\000\"\r\225\r\225\r\225\r\225\011\182\002\129\r\225\006\025\r\225\001\018\014\130\n\005\r\225\r\225\r\225\r\129\r\225\019\"\r\225\r\225\006\137\r\225\000\n\r\225\r\225\000\190\r\225\r\225\r\225\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\000\n\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\000\190\000\n\000\198\tR\006\153\012r\012\130\012\146\003\193\000^\b\225\006\153\000f\006\153\000v\004R\027\162\006\153\r\137\006\153\006\153\000z\006\153\020\234\006q\006\153\021z\027r\011\026\000\202\006\153\000\198\006\153\011\030\017\154\006\153\001~\001^\025n\000\206\011\"\006\153\001\142\000\190\000.\011&\025r\020\250\026\183\026\187\006\153\006\153\003\173\026\191\000~\006\153\006\153\006\201\000\202\016J\006\153\021\006\006\153\006\153\000\n\006\153\006\153\006\153\000\206\021\n\001\214\006\153\006\153\006\153\000\198\016N\006\153\006\153\006\153\023\206\021n\bR\006\153\006\153\006\153\006\153\006\153\006\153\t\021\000\138\0045\006\153\006\153\000\n\t\233\003\193\011\194\022^\006\017\006\017\020\142\000\202\011\198\006\153\006\153\006I\t\162\006\153\006\153\006\153\006\153\000\206\006\153\006N\006\153\016\238\021\022\006\153\003\193\006\201\006\153\006\153\028\178\027\178\006\129\023\186\021\026\005\241\023\210\001\026\001\222\027\162\026\215\026\219\027\170\006\153\000\n\026\223\b\253\006\153\006\153\006\153\006\153\004\133\028\190\006\153\001\238\006\153\019~\0045\019\166\006\153\006\153\006\153\bb\019\230\0045\006\153\006\153\000\190\006\153\002\141\006\153\006\153\004\165\006\153\006\153\006\153\006\185\006\185\006\185\006\185\006\185\006\185\006\185\006\185\006\185\006\185\006\185\006\185\006\185\006\185\003^\006\185\006\185\006\185\006\185\006\185\006\185\006\185\006\185\006\185\006\185\r9\006\185\tz\015*\006\185\014\174\tM\014\194\t\134\n\001\006\185\006\185\t=\006\185\028\218\022v\022~\006\185\012n\006\185\006\185\025\018\006\185\r9\000\202\006\185\019\134\014\014\019\174\005\241\006\185\006\185\006\185\019\242\000\206\006\185\006\185\006\185\006\185\r9\018\014\006\185\006\185\006\185\006\185\027\186\006\185\006\185\014\222\005\241\006\185\006\185\006\185\006\185\t\222\006\185\027\170\022\134\002\173\000\n\006\185\025\018\006\185\004\n\006\185\006\185\006\185\006\185\021\138\006\185\0152\006\185\006\185\006\185\b\221\rI\006\185\006\185\006\185\015.\004*\006\185\006\185\006\185\006\185\006\185\006\185\006\185\n\021\022:\015F\0069\006\185\006)\b\205\011\230\r1\0042\0061\rq\014\178\b\209\014\198\006\185\006\185\006\185\015\218\006\185\006\185\006\185\006\185\006\185\006\185\014\246\006\185\011~\000\n\006\185\012\006\018\142\006\185\006\185\022v\022~\r9\006\185\006\185\r9\023\182\015R\006a\004\154\006\185\002m\012\"\006\185\014\165\014\165\011~\006\185\006\185\014\165\006\185\014\226\012n\006\185\0166\006\185\004\162\004\186\n\021\006\185\016j\014\014\011~\017\"\017V\004\194\006\185\017j\006\185\022j\006\185\006\185\024&\006\185\006\185\006\185\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\020v\000v\025Z\000\182\011\"\000\186\001\146\001\150\000z\011&\025^\027z\020z\n\r\017\134\011*\018\238\026\"\005\138\020\"\006&\t1\011:\020~\001\154\020\130\014\250\006i\001\242\020\134\012B\011B\027~\012F\0062\020\138\012J\016\146\n\001\027\130\016\178\000~\023\230\012^\020\150\ry\t\253\012n\020\154\rA\015\218\ra\002\002\006^\020\158\025\146\014\014\011~\006n\016:\011~\014\"\012\162\025\190\025\202\016n\014&\017\202\017&\017Z\020\162\002&\017n\002*\004\181\n\r\001\162\015\210\014.\000\190\n1\n1\012\186\0022\0142\n1\ri\012\190\006\238\002:\020*\006v\006\150\012\194\012\198\011V\011Z\012\202\0146\006\162\006\170\020\166\006\186\014:\020\170\006\206\006y\023\014\027\138\017\138\000\198\t\154\026.\023\170\006\254\012\206\t!\020\174\014>\014B\012\210\014F\020\178\000\n\020\182\014Z\020\186\020\190\004\145\020\194\026N\014f\012\218\007\026\002\157\015\218\020\198\000\202\007j\020\202\027\150\027\146\007v\025\222\028\154\028\174\015\"\000\206\024\026\007\166\015&\015r\004\181\011^\020\206\006!\012\222\007\174\015v\020\210\020\214\027\154\012\230\004\181\004\181\n1\n1\b>\004\181\015~\n1\012\234\000\n\006\193\006\193\bz\012\242\002~\006\193\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\b\138\000v\025Z\000\182\011\"\000\186\001\146\001\150\000z\011&\025^\b\146\000\n\029\003\b\158\011*\b\170\002\233\b\182\b\210\004\198\002\233\011:\b\222\001\154\b\230\b\238\b\254\001\242\005\241\012B\011B\t\n\012F\t\022\t&\012J\t2\tF\tV\t^\000~\tb\012^\t\158\t\166\t\253\t\182\001\238\t\190\t\194\t\202\002\002\t\242\000\190\012n\t\246\t\254\n\014\n\030\nF\014\"\012\162\025\190\014\014\nj\014&\018\018\nv\n\147\0176\002&\n\178\002*\004\197\n\250\001\162\015\210\014.\011.\0116\011>\012\186\0022\0142\000\198\017:\012\190\006\238\002:\011F\011N\011R\012\194\012\198\011V\011Z\012\202\0146\011z\011\142\011\154\015\214\014:\011\162\011\166\011\174\011\194\011\190\011\206\011\214\011\218\000\202\011\198\006\254\012\206\011\238\011\246\014>\014B\012\210\014F\000\206\000\n\005\241\014Z\012\014\012\022\004\145\012*\027\254\014f\012\218\0122\012>\012V\012j\012v\012~\012\134\012\142\012\170\012\178\015\218\005\241\r\026\015\"\000\n\005\241\r&\015&\015r\r^\011^\r\142\014\006\012\222\014J\015v\014R\014b\014j\012\230\014\138\004\197\014\150\014\158\014\162\014\170\015~\014\186\012\234\014\206\006\209\006\209\000\190\012\242\002~\006\209\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\014\234\000v\025Z\000\182\011\"\000\186\001\146\001\150\000z\011&\025^\015\002\015\014\000\198\026>\011*\015\022\015\030\015n\006\177\015z\015\130\011:\015\142\001\154\006\177\006\177\015\146\001\242\015\154\012B\011B\015\158\012F\015\166\015\174\012J\028\022\015\182\015\190\000\202\000~\015\230\012^\016*\0162\t\253\006\169\000\190\016B\000\206\016R\002\002\006\169\006\169\012n\016Z\016^\016f\016v\016~\012\158\012\162\006\177\014\014\006\169\014&\016\134\016\138\016\154\016\162\002&\016\186\002*\004\225\000\n\001\162\014*\014.\000\198\011\150\016\194\012\186\0022\0142\016\254\017\006\012\190\006\238\002:\017\022\006\169\017\030\012\194\012\198\011V\011Z\012\202\0146\017.\017>\011\194\014\173\014:\017F\017J\000\202\011\198\017R\017b\017v\017\146\017\178\002\233\006\254\012\206\000\206\002\233\014>\014B\012\210\014F\017\250\000\n\018\006\014Z\018z\018\134\004\145\018\166\018\210\014f\012\218\018\222\018\230\018\250\019\018\019\030\019.\019F\019V\000\n\019b\015\218\019\147\019\187\015\"\019\211\019\255\020\023\015&\015r\004\225\011^\0207\020O\012\222\020g\015v\020r\020\146\020\254\012\230\004\225\004\225\021\014\021?\021\150\004\225\015~\000\190\012\234\000\190\n9\n9\021\171\012\242\002~\n9\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\021\211\000v\021\223\000\182\011\"\000\186\001\146\001\150\000z\011&\000\198\014\146\021\239\021\247\015*\011*\022\018\022\027\022#\022+\004y\022F\011:\022W\001\154\022z\022\130\022\146\001\242\022\175\012B\011B\011\194\012F\022\191\000\202\012J\000\202\011\198\022\199\027f\000~\b9\012^\022\218\000\206\t\253\000\206\022\227\022\235\022\243\022\254\002\002\023#\023/\012n\b9\023B\023K\023S\023[\012\158\012\162\023~\014\014\023\135\014&\023\143\023\194\023\242\000\n\002&\000\n\002*\0242\024S\001\162\014*\014.\024[\024g\024w\012\186\0022\0142\024\127\024\139\012\190\006\238\002:\015.\024\150\024\166\012\194\012\198\011V\011Z\012\202\0146\024\179\024\187\024\194\003\165\014:\024\207\024\219\024\227\024\239\024\251\025\022\025\158\025\198\002q\b9\006\254\012\206\027\214\025\214\014>\014B\012\210\014F\026\n\000\n\026\018\014Z\027\234\026B\026j\026n\004y\014f\012\218\028B\026v\027\238\004y\004y\026\163\027j\003\165\027v\027\134\015\218\027\142\027\203\015\"\027\211\004y\004y\015&\015r\027\218\011^\027\231\027\242\012\222\028\002\015v\0287\028F\028S\012\230\028w\028\147\028\162\b9\028\170\028\182\015~\028\194\012\234\028\207\028\214\004y\028\222\012\242\002~\b9\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\028\231\000v\n\001\000\182\011\"\000\186\001\146\001\150\000z\011&\028\238\012n\028\247\029\011\000\000\011*\000\000\000\000\000\000\003\165\014\014\000\000\011:\000\000\001\154\003\165\003\165\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\003\165\000\000\000\000\000\000\000~\000\000\012^\000\000\000\000\t\253\000\000\000\000\000\000\000\000\000\000\002\002\000\000\003\165\012n\000\000\000\000\014\165\000\000\000\000\012\158\012\162\003\165\014\014\027\170\014&\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\014*\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\011V\011Z\012\202\0146\015\218\000\000\000\000\014\173\014:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\000\000\014\165\014\165\014f\012\218\000\000\014\165\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\218\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\000\015~\000\000\012\234\000\000\014\173\014\173\000\000\012\242\002~\014\173\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\025Z\000\182\011\"\000\186\001\146\001\150\000z\011&\025^\000\000\000\000\000\000\000\000\011*\000\000\000\000\000\000\000\000\000\000\000\000\011:\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\000\000\000\000\000\000\000\000\000~\000\000\012^\000\000\000\000\t\253\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\"\012\162\000\000\000\000\000\000\014&\026\238\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\015\210\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\003\177\014:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\004\145\000\000\000\000\014f\012\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\027\162\000\000\000\000\000\000\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\000\015~\000\000\012\234\000\000\n\029\n\029\000\000\012\242\002~\n\029\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\003\173\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\000\000\011*\000\000\000\000\000\000\003\177\000\000\000\000\011:\000\000\001\154\003\177\003\177\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\003\177\000\000\000\000\000\000\000~\000\000\012^\000\000\000\000\t\253\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\"\012\162\003\177\000\000\027\170\014&\015\238\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\015\210\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\014\137\014:\000\000\000\000\000\000\000\000\000\000\000\000\003\173\000\000\000\000\000\000\006\254\012\206\003\173\003\173\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\003\173\027r\000\000\014f\012\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\003\173\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\000\015~\000\000\012\234\000\000\014\137\014\137\000\000\012\242\002~\014\137\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\000\000\011*\000\000\000\000\000\000\000\000\000\000\000\000\011:\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\000\000\000\000\000\000\000\000\000~\000\000\012^\000\000\000\000\t\253\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\"\012\162\000\000\000\000\000\000\014&\025\162\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\015\210\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\000\000\014:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\000\000\000\000\000\000\014f\012\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\000\015~\000\000\012\234\000\000\014\213\014\213\000\000\012\242\002~\014\213\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\000\000\011*\000\000\000\000\000\000\000\000\000\000\000\000\011:\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\000\000\000\000\000\000\000\000\000~\000\000\012^\000\000\000\000\t\253\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\"\012\162\000\000\000\000\000\000\014&\025\162\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\015\210\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\000\000\014:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\000\000\000\000\000\000\014f\012\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\000\015~\000\000\012\234\000\000\014\209\014\209\000\000\012\242\002~\014\209\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\000\000\011*\000\000\000\000\000\000\000\000\000\000\000\000\011:\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\011\026\000\000\000\000\000\000\000~\011\030\012^\000\000\000\000\t\253\025n\000\000\011\"\000\000\000\000\002\002\000\000\011&\025r\000\000\000\000\000\000\000\000\000\000\014\"\012\162\000\000\000\000\000\000\014&\018F\000\000\000\000\000\000\002&\000\000\002*\000\000\000\190\001\162\015\210\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\016J\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\000\000\014:\000\000\000\000\000\198\016N\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\011\194\000\000\000\000\014f\012\218\000\202\011\198\b1\000\000\000\000\000\000\n\001\000\000\000\000\000\000\000\206\000\000\000\000\015\"\000\000\012n\b1\015&\015r\000\000\011^\000\000\000\000\012\222\014\014\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\n\015~\000\000\012\234\000\000\004\165\000\000\000\000\012\242\002~\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\b1\011*\000\000\000\000\000\000\000\000\000\000\000\000\011:\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\011\026\000\000\000\000\000\000\000~\011\030\012^\015\218\000\000\t\253\025n\000\000\011\"\000\000\000\000\002\002\000\000\011&\025r\000\000\000\000\000\000\000\000\000\000\019\218\012\162\000\000\000\000\000\000\014&\b1\000\000\000\000\000\000\002&\000\000\002*\000\000\000\190\001\162\000\000\014.\b1\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\016J\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\000\000\014:\000\000\000\000\000\198\016N\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\011\194\000\000\000\000\014f\012\218\000\202\011\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\n\015~\000\000\012\234\000\000\004\165\000\000\000\000\012\242\002~\000R\000V\000Z\000\146\000\000\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\rQ\rQ\000\000\000\000\000\000\000\000\000\190\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\007\229\007\229\001\242\000\000\012B\007\229\016J\001\246\000\000\000\000\001\250\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\t\245\000\198\016N\000\000\000\000\000\000\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\004R\002\026\002\022\000\000\002\030\000\000\000\000\000\000\000\000\011\194\000\000\002&\000\000\002*\000\202\011\198\001\162\005z\000\000\000\000\005\130\000\000\002.\0022\000\206\000\000\000\000\0026\001\"\002:\rQ\000\000\000\000\002>\002B\011V\014n\002F\002J\000\000\000\000\000\000\000\000\005\146\005\154\000\000\000\000\000\000\000\000\000\n\rQ\000\000\000\000\000\000\000\190\002N\000\000\000\000\005\162\000\000\002R\rQ\002E\000\n\005\170\005\178\000\000\rQ\rQ\000\000\0176\000\000\002Z\000\000\005\186\000\000\000\000\005\194\000\000\005\202\000\000\000\000\000\000\002^\000\000\000\198\017:\000\000\000\000\000\000\006I\000\000\000\022\011^\000\000\000\000\002b\000\000\004R\rQ\000\000\000\000\002n\000\000\rQ\rQ\005\210\011\194\000\000\000\000\000\000\002\134\000\202\011\198\000\000\000\000\002v\002~\000R\000V\000Z\000\146\000\206\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\005\218\000\n\000\000\002E\000\000\000\000\000\000\005\226\000\000\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\000\000\000\000\012F\000\000\002E\012J\000\000\000\000\002E\002E\000~\000\000\018\198\000\000\000\000\t\253\000\000\000\000\000\000\005\234\005\242\002\002\000\000\000\000\000\000\006I\000\000\000\000\000\000\000\000\018\214\012\162\000\000\000\000\001\t\000\000\000\000\001\t\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\000\000\000\000\000\000\000\000\000\000\012\186\0022\000\000\000\000\000\000\012\190\001\"\002:\000\000\002\242\003\026\012\194\012\198\011V\014n\012\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\000\001\t\000\000\001\t\001\t\006\254\012\206\000\000\000\000\000\000\000\000\012\210\000\000\003\"\000\n\000\000\003\002\000\000\003\018\000\000\000\000\r\185\000\000\012\218\000\000\000\000\r\185\000\000\000j\r\185\000r\r\185\000\000\r\185\000\000\000\178\000\000\000\000\r\185\r\185\000\000\r\185\000\000\000\000\011^\003*\000\000\012\222\000\000\018\218\000\000\000\000\r\185\012\230\r\185\000\000\000\000\000\000\r\185\r\185\018\226\000\000\012\234\000\000\r\185\000\000\000\000\012\242\002~\000\000\r\185\r\185\000\000\r\185\000\000\r\185\000\000\r\185\000\000\000\000\000\000\000\000\000\000\r\185\000\000\0032\000\000\000\000\001\t\000\000\r\185\r\185\003\n\000\000\r\185\000\000\000\000\000\000\000\000\r\185\r\185\000\000\007\198\r\185\000\000\r\185\001\t\000\000\000\000\000\000\001\t\001\t\r\185\000\000\000\000\000\000\000\000\r\185\r\185\000\000\000\000\001\t\003:\000\000\000\000\000\000\000\000\r\185\007\206\007\214\r\185\r\185\000\000\r\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\185\007\222\000\000\000\000\r\185\000\000\000\000\007\230\007\238\r\185\r\185\r\185\000\000\r\185\r\185\r\185\r\185\007\246\000\000\000\000\007\254\000\000\b\006\r\185\000\000\r\165\r\185\000\000\000\000\000\000\r\165\000\000\000\000\r\165\000b\r\165\000\000\r\165\000\000\000\000\000\000\r\185\r\165\r\165\000\000\r\165\r\185\r\185\r\185\b\014\000\000\r\185\r\185\000\000\000\000\r\185\r\165\000\000\r\165\000\000\r\185\r\185\r\165\r\165\000\000\r\185\000\000\000\000\r\165\000\000\000\000\000\000\000\000\000\000\r\165\r\165\000\000\r\165\000\000\r\165\000\000\r\165\000\000\000\000\000\000\000\000\000\000\r\165\000\000\b\022\000\000\000\000\000\000\000\000\r\165\r\165\b\030\000\000\r\165\000\000\000\000\000\000\000\000\r\165\r\165\000\000\000\205\r\165\000\000\r\165\005]\000\000\000\000\000\000\000\000\000\000\r\165\005]\000\000\000\000\000\000\r\165\r\165\000\000\000\000\b&\b.\000\000\000\000\000\000\000\000\r\165\002\242\003\026\r\165\r\165\000\000\r\165\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\165\002\250\000\000\000\000\r\165\000\000\000\000\000\205\000\205\r\165\r\165\r\165\000\000\r\165\r\165\r\165\r\165\003\"\000\000\000\000\003\002\000\000\003\018\r\165\000\000\r\193\r\165\000\000\000\000\000\000\r\193\000\000\000\000\r\193\000n\r\193\000\000\r\193\000\000\000\000\000\000\r\165\r\193\r\193\000\000\r\193\r\165\r\165\r\165\003*\000\000\r\165\r\165\000\000\000\000\r\165\r\193\000\000\r\193\000\000\r\165\r\165\r\193\r\193\000\000\r\165\000\000\000\000\r\193\000\000\000\000\000\000\000\000\000\000\r\193\r\193\000\000\r\193\000\000\r\193\000\000\r\193\000\000\000\000\000\000\000\000\000\000\r\193\000\000\0032\000\000\000\000\000\000\000\000\r\193\r\193\003\n\000\000\r\193\000\000\000\000\000\000\000\000\r\193\r\193\000\000\000\181\r\193\000\000\r\193\000\205\000\000\000\000\000\000\000\000\000\000\r\193\000\205\000\000\000\000\000\000\r\193\r\193\000\000\000\000\000\205\003:\000\000\000\000\000\000\000\000\r\193\000\181\000\181\r\193\r\193\000\000\r\193\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\193\002\250\000\000\000\000\r\193\000\000\000\000\000\181\000\181\r\193\r\193\r\193\000\000\r\193\r\193\r\193\r\193\000\181\000\000\000\000\003\002\000\000\003\018\r\193\000\000\b\137\r\193\000\000\000\000\000\000\b\137\000\000\000\000\b\137\000\000\b\137\000\000\b\137\000\000\000\000\000\000\r\193\b\137\b\137\000\000\b\137\r\193\r\193\r\193\000\181\000\000\r\193\r\193\000\000\000\000\r\193\b\137\000\000\b\137\000\000\r\193\r\193\b\137\b\137\000\000\r\193\000\000\000\000\b\137\000\000\000\000\000\000\000\000\000\000\b\137\b\137\000\000\b\137\000\000\b\137\000\000\b\137\000\000\000\000\000\000\000\000\000\000\b\137\000\000\000\181\000\000\000\000\000\000\000\000\b\137\b\137\003\n\000\000\b\137\001\134\000\000\000\000\000\000\b\137\b\137\000\000\000\177\b\137\000\000\b\137\000\181\000\000\000\000\000\000\000\000\000\000\b\137\000\181\000\000\000\000\000\000\b\137\b\137\000\000\000\000\000\181\000\181\000\000\000\000\000\000\000\000\b\137\000\177\000\177\b\137\b\137\000\000\b\137\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\137\002\250\000\000\000\000\b\137\000\000\000\000\000\177\000\177\b\137\b\137\b\137\000\000\b\137\b\137\b\137\b\137\000\177\000\000\000\000\003\002\000\000\003\018\b\137\000\000\r\177\b\137\000\000\000\000\000\000\r\177\000\000\000\000\r\177\000\000\r\177\000\000\r\177\000\000\000\000\000\000\b\137\r\177\r\177\000\000\r\177\b\137\b\137\b\137\000\177\000\000\b\137\b\137\000\000\000\000\b\137\r\177\000\000\r\177\000\000\b\137\b\137\r\177\r\177\000\000\b\137\000\000\000\000\r\177\000\000\000\000\000\000\000\000\000\000\r\177\r\177\000\000\r\177\000\000\r\177\000\000\r\177\000\000\000\000\000\000\000\000\000\000\r\177\000\000\000\177\000\000\000\000\000\000\000\000\r\177\r\177\003\n\000\000\r\177\001\166\000\000\000\000\000\000\r\177\r\177\000\000\000\169\r\177\000\000\r\177\000\177\000\000\000\000\000\000\000\000\000\000\r\177\000\177\000\000\000\000\000\000\r\177\r\177\000\000\000\000\000\177\000\177\000\000\000\000\000\000\000\000\r\177\000\169\000\169\r\177\r\177\000\000\r\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\177\000\169\000\000\000\000\r\177\000\000\000\000\000\169\000\169\r\177\r\177\r\177\000\000\r\177\r\177\r\177\r\177\000\169\000\000\000\000\003\002\000\000\000\169\r\177\000\000\b\149\r\177\000\000\000\000\000\000\b\149\000\000\000\000\b\149\000\000\b\149\000\000\b\149\000\000\000\000\000\000\r\177\b\149\b\149\000\000\b\149\r\177\r\177\r\177\000\169\000\000\r\177\r\177\000\000\000\000\r\177\b\149\000\000\b\149\000\000\r\177\r\177\b\149\b\149\000\000\r\177\000\000\000\000\b\149\000\000\000\000\000\000\000\000\000\000\b\149\b\149\000\000\b\149\000\000\b\149\000\000\b\149\000\000\000\000\000\000\000\000\000\000\b\149\000\000\000\169\000\000\000\000\000\000\000\000\b\149\b\149\003\n\000\000\b\149\n>\000\000\000\000\000\000\b\149\b\149\000\000\000\000\b\149\000\000\b\149\000\169\000\000\000\000\000\000\000\000\000\000\b\149\000\169\000\000\000\000\000\000\b\149\b\149\000\000\000\000\000\169\000\169\000\000\000\000\000\000\000\000\b\149\000\000\000\000\b\149\b\149\000\000\b\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\149\000\000\000\000\000\000\b\149\000\000\000\000\000\000\000\000\b\149\b\149\b\149\000\000\b\149\b\149\b\149\b\149\000\000\000\000\000\000\000\000\000\000\000\000\b\149\000\000\000\000\b\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\149\000\000\000\000\000\000\000\000\b\149\b\149\b\149\000\000\000\000\b\149\b\149\000\000\000\000\b\149\000\000\000\000\000\000\000\000\b\149\b\149\000\000\000\000\000\000\b\149\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\002\n\000\000\000\000\002\014\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\162\004\146\000\000\002\030\000\000\000\000\005*\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\001\241\000\000\000\000\001\241\000\000\004\206\0022\000\000\000\000\000\000\004\210\001\"\002:\000\000\000\000\005.\004\214\004\218\000\000\000\000\004\222\002J\000\000\000\000\000\000\000\000\001\241\001\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\226\000\000\000\000\001\241\000\000\004\230\000\000\001\241\000\n\001\241\001\241\000\000\000\000\000\000\000\000\000\000\000\000\004\238\000\000\001\241\000\000\000\000\001\241\000\000\001\241\000\000\000\000\000\000\0052\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\242\000\000\000\000\000\000\000\000\000\000\004\250\000\000\000\000\004\t\001\241\000\000\000\000\004\001\000\000\004\254\000\000\004\001\000\000\000\000\005\006\002~\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\004\001\000\000\000\000\000\000\000\000\001\241\005B\000\000\001\241\000\000\000\000\000\000\001\241\000\000\000\000\001\154\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\002\n\000\000\001\241\002\014\004\001\000\000\001\241\001\241\000~\000\000\000\000\000\000\000\000\005J\000\000\004\001\000\000\001\241\001\241\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\162\004\146\000\000\002\030\000\000\000\000\005*\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\000\000\004\001\004\001\000\000\000\000\004\206\0022\000\000\000\000\000\000\004\210\001\"\002:\000\000\000\000\005.\004\214\004\218\000\000\003J\004\222\002J\004\001\004\001\000\000\004\001\000\000\000\000\000\000\000\000\000\000\004\001\004\001\000\000\000\000\015!\004\001\000\000\004\226\000\000\000\000\000\000\000\000\004\230\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\238\000\000\000\000\000\000\000\000\000\000\015!\015!\000\000\000\000\000\000\0052\000\000\000\000\007Z\000\000\000\000\000\000\000\000\000\000\000\000\015!\000\000\000\000\004\242\000\000\000\000\015!\015!\000\000\004\250\007b\000\000\b\181\007n\000\000\000\000\015!\000\000\004\254\015!\000\000\015!\000\000\005\006\002~\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\015!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\001\242\007z\000\190\000\000\000\000\002\n\000\000\000\000\002\014\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015!\000\000\000\000\002\002\000\000\007~\002\006\015!\000\000\000\000\000\000\000\000\002\162\004\146\000\000\002\030\007\134\000\000\005*\000\000\000\000\015!\002&\000\000\002*\000\000\000\000\001\162\015!\000\000\000\000\000\000\000\000\004\206\0022\000\000\015!\015!\004\210\001\"\002:\000\000\000\000\005.\004\214\004\218\000\000\000\000\004\222\002J\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\241\000\000\000\000\000\241\000\000\000\000\000\000\000\000\004\226\000\000\000\000\000\000\000\000\004\230\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\238\000\241\000\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0052\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\000\000\241\000\000\000\241\000\241\004\242\000\000\000\000\000\000\000\000\000\000\004\250\000\000\000\241\002a\000\000\003\002\000\000\003\018\000\000\004\254\000\000\000\000\000\000\000\000\005\006\002~\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\241\000\186\001\146\001\150\000z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\002\n\000\000\000\000\002\014\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\241\000\000\000\000\000\241\000\000\000\000\000\000\003\n\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\162\004\146\000\000\002\030\000\241\000\000\005:\000\000\000\241\000\241\002&\000\000\002*\000\000\000\000\001\162\000\000\000\000\000\000\000\241\000\241\004\206\0022\000\000\000\000\000\000\004\210\001\"\002:\000\000\000\000\005.\004\214\004\218\000\000\000\000\004\222\002J\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\226\000\000\000\000\000\000\000\000\004\230\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000R\000V\000Z\000\146\004\238\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000\000\000\000\004\242\000\000\000\000\000\000\000\000\000\000\004\250\000\000\000\000\b\197\001\154\000\000\000\000\000\000\001\242\004\254\000\190\000\000\000\000\001\246\005\006\002~\001\250\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\026\002\022\000\000\002\030\000\000\000\000\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\000\000\000\000\000\000\000\000\000\000\002.\0022\000\000\000\000\000\000\0026\001\"\002:\000\000\000\000\000\000\002>\002B\000\000\000\000\002F\002J\000\000\000V\004^\000\146\000\000\000\150\000\000\000\154\000\158\004b\000^\000\000\000\170\000\174\000\000\000v\002N\000\182\000\000\000\186\001\146\002R\000z\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002Z\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\000\000\000\000\002^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000~\000\000\002b\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\134\000\000\000\000\000\000\000\000\002v\002~\001\149\001\149\001\149\001\149\000\000\001\149\005\233\001\149\001\149\001\149\001\149\001\162\001\149\001\149\000\000\001\149\000\000\001\149\005\233\001\149\001\149\001\149\001\149\000\000\000\000\000\000\000\000\020Z\000\000\005\233\000\000\005\233\000\000\000\000\000\000\005\233\005\233\001\149\001\149\001\149\000\000\005\233\000\000\020^\000\000\000\000\000\000\005\233\000\000\001\149\005\233\000\000\000\000\000\000\005\233\001\149\000\000\000\000\001\149\000\000\005\233\000\000\001\149\000\000\000\000\020j\000\000\000\000\001\149\000\000\000\000\005\233\000\000\000\000\000\000\001\149\005\233\011\006\000\000\000\000\001\149\000\000\005\233\000\000\000\000\000\000\000\000\000\000\000\000\001\149\001\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\233\000\000\000\000\005\233\000\000\000\000\005\233\000\000\001\149\000\000\000\000\001\149\000\000\000\000\001\149\000\000\000\000\000\000\000\000\005\233\000\000\000\000\000\000\000\000\005\233\005\233\005\233\001\149\005\233\005\233\000\000\005\233\001\149\000\000\001\149\000\000\000\000\001\149\005\233\020n\000\000\005\233\000\000\000\000\001\149\000\000\001\149\000\000\000\000\001\149\000\000\000\000\000\000\000\000\000\000\000\000\005\233\000\000\000\000\000\000\000\000\005\233\005\233\000\000\001\149\001\149\000\000\000\000\000\000\001\149\001\149\000\000\000\000\000\000\000R\000V\004^\000\146\000\000\000\150\021B\000\154\000\158\004b\000^\000\000\000\170\000\174\020v\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\020z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\001\154\020\130\000\000\000\000\000\000\020\134\000\000\000\000\000\000\000\000\000\000\020\138\000\000\000\000\000\000\000\000\000\000\024\146\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\n\166\000\000\000\000\000\000\000\000\022.\000\000\000\000\000\000\020\162\023\154\000\000\000\000\011*\000\000\001\162\000\000\000\000\000\000\000\000\011:\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\011B\000\000\012F\000\000\000\000\012J\000\000\000\000\n\210\000\000\000\000\020\166\012^\000\000\020\170\t\253\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\020\174\000\000\000\000\014V\012\162\020\178\000\n\020\182\014&\020\186\020\190\000\000\020\194\002&\000\000\002*\000\000\000\000\000\000\020\198\014.\000\000\020\202\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\020\206\000\000\012\202\0146\000\000\020\210\020\214\000\000\014:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\000\000\000\000\000\000\014f\012\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\011*\000\000\000\000\000\000\012\222\000\000\015v\011:\000\000\000\000\012\230\000\000\000\000\001\242\000\000\000\190\011B\015~\012F\012\234\000\000\012J\011\026\000\000\012\242\002~\000\000\011\030\012^\000\000\000\000\t\253\025n\000\000\011\"\000\000\000\000\002\002\000\000\011&\025r\000\000\000\000\000\000\000\000\000\000\012\182\012\162\000\000\000\000\000\000\014&\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\190\000\000\000\000\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\016J\000\000\012\194\012\198\000\000\000\000\012\202\0146\000\000\000\000\000\000\000\000\014:\000\000\000\000\000\198\016N\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\011\194\000\000\000\000\014f\012\218\000\202\011\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\000\000\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\n\015~\000\000\012\234\000\000\004\165\000\000\000\000\012\242\002~\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\ni\ni\001\242\000\000\000\190\ni\000\000\012F\000\000\000\000\012J\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\019\218\012\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\015\197\000\000\000\000\015\197\000\000\012\186\0022\000\000\000\000\000\000\012\190\001\"\002:\000\000\000\000\000\000\012\194\012\198\000\000\012\149\012\202\000\000\000\000\000\000\000\000\000\000\015\197\015\197\000\000\000\000\000\000\015\197\000\000\000\000\015\197\015\197\000\000\006\254\012\206\000\000\000\000\015\197\000\000\012\210\015\197\015\197\000\n\015\197\015\197\000\000\012\149\015\197\000\000\015\197\015\197\012\218\000\000\015\197\000\000\000\000\015\197\000\000\015\197\015\197\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\149\000\000\012\222\000\000\000\000\000\000\000\000\000\000\012\230\000\000\012\149\000\000\015\197\000\000\015\197\000\000\000\000\012\234\000\000\000\000\000\000\000\000\012\242\002~\000\000\015\197\000\000\000\000\000\000\000\000\000\000\000\000\015\197\000\000\000\000\012\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\197\015\197\000\000\015\197\015\197\015\197\000\000\015\197\000\000\000\000\000\000\000\000\000\000\000\000\005\t\000\000\015\197\005\t\000\000\000\000\005\t\015\197\000\000\005\t\015\197\000\000\015\197\000\000\000\000\000\000\000\000\000\000\015\197\015\197\015\197\000\000\015\197\015\197\015\197\012\145\005\t\005\t\000\000\000\000\000\000\000\000\005\t\005\t\005\t\005\t\000\000\005\t\000\000\000\000\005\t\005\t\000\000\000\000\000\000\000\000\000\000\005\t\005\t\000\000\005\t\005\t\000\000\005\t\005\t\000\000\012\145\005\t\000\000\005\t\005\t\000\000\005\t\005\t\000\000\000\000\005\t\000\000\005\t\005\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\145\000\000\000\000\000\000\000\000\000\000\005\t\000\000\000\000\000\000\012\145\000\000\005\t\000\000\005\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\t\005\t\000\000\000\000\000\000\000\000\000\000\005\t\000\000\000\000\012\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\t\005\t\000\000\000\000\007\137\005\t\005\t\005\t\000\000\005\t\007\137\005\t\000\000\005\t\000\000\000\000\005\t\000\000\000\000\000\000\000\000\005\t\005\t\000\000\005\t\000\000\000\000\005\t\005\t\000\000\005\t\000\000\005\t\000\000\000\000\000\000\005\t\005\t\005\t\005\t\005\t\000\000\005\t\005\t\005\t\012\001\012\001\012\001\012\001\000\000\012\001\000\000\012\001\012\001\012\001\012\001\000\000\012\001\012\001\000\000\012\001\000\000\012\001\000\000\012\001\012\001\012\001\012\001\000\000\000\000\015u\000\000\000\000\015u\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\001\012\001\012\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\001\000\000\015u\015u\000\000\000\000\012\001\015u\000\000\021R\002\150\015u\000\000\021Z\000\000\000\000\000\000\015u\000\000\012\001\015u\015u\000\000\015u\015u\000\000\012\001\002\158\000\000\015u\002\178\012\001\000\000\015u\000\000\000\000\015u\000\000\015u\015u\012\001\012\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\001\000\000\015u\012\001\015u\000\000\012\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015u\000\000\000\000\000\000\012\001\000\000\000\000\004\014\000\000\012\001\000\000\012\001\000\000\000\000\012\001\000\000\000\000\000\000\000\000\000\000\000\000\012\001\000\000\012\001\000\000\000\000\012\001\015u\015u\000\000\015u\015u\004\018\000\000\015u\000\000\000\000\000\000\000\000\000\000\000\000\012\001\012\001\004\026\000\000\000\000\021\174\012\001\015u\000\000\000\000\015u\015u\015u\015u\015u\000\000\000\000\000\000\015u\015u\015u\000\000\015u\015u\015u\015\005\000\000\000\000\015\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\005\015\005\000\000\000\000\000\000\015\005\000\000\000\000\002\150\015\005\000\000\000\000\000\000\000\000\000\000\015\005\000\000\000\000\015\005\015\005\000\000\015\005\015\005\000\000\000\000\002\158\000\000\015\005\002\178\000\000\000\000\015\005\000\000\000\000\015\005\000\000\015\005\015\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\005\000\000\015\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\005\011\241\011\241\011\241\011\241\000\000\011\241\004\014\011\241\011\241\011\241\011\241\000\000\011\241\011\241\000\000\011\241\000\000\011\241\000\000\011\241\011\241\011\241\011\241\000\000\000\000\000\000\015\005\015\005\000\000\015\005\015\005\004\018\000\000\015\005\000\000\000\000\000\000\011\241\011\241\011\241\000\000\000\000\004\026\000\000\000\000\000\000\000\000\015\005\000\000\011\241\015\005\015\005\015\005\015\005\015\005\011\241\000\000\000\000\015\005\015\005\015\005\000\000\015\005\015\005\015\005\000V\004^\000\146\011\241\000\150\000\000\000\154\000\158\004b\000^\011\241\000\170\000\174\000\000\000v\011\241\000\182\000\000\000\186\001\146\000\000\000z\000\000\000\000\011\241\011\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\000\000\000\000\001\170\000\000\000\000\000\000\011\241\000\000\000\000\011\241\000\000\000\000\011\241\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\241\000\000\000\000\000\000\000\000\011\241\000\000\011\241\000\000\000\000\011\241\000\000\000\000\000\000\000\000\000\000\000\000\011\241\000\000\011\241\000\000\000\000\011\241\001\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\241\011\241\000\000\000\000\000\000\021V\011\241\011\245\011\245\011\245\011\245\000\000\011\245\000\000\011\245\011\245\011\245\011\245\000\000\011\245\011\245\000\000\011\245\000\000\011\245\000\000\011\245\011\245\011\245\011\245\000\000\000\000\005\017\000\n\000\000\005\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\245\011\245\011\245\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\245\000\000\005\017\005\017\000\000\000\000\011\245\005\017\000\000\021\178\005\017\005\017\000\000\000\000\000\000\000\000\000\000\005\017\000\000\011\245\005\017\005\017\000\000\005\017\005\017\000\000\011\245\005\017\000\000\005\017\005\017\011\245\000\000\005\017\000\000\000\000\005\017\000\000\005\017\005\017\011\245\011\245\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\245\000\000\005\017\011\245\005\017\000\000\011\245\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\017\000\000\000\000\000\000\011\245\000\000\000\000\005\017\000\000\011\245\000\000\011\245\000\000\000\000\011\245\000\000\000\000\000\000\000\000\000\000\000\000\011\245\000\000\011\245\000\000\000\000\011\245\005\017\005\017\000\000\005\017\007\149\005\017\000\000\005\017\000\000\000\000\000\000\000\000\000\000\000\000\011\245\011\245\005\017\000\000\000\000\005\r\011\245\005\017\005\r\000\000\005\017\000\000\005\017\000\000\005\017\000\000\000\000\000\000\005\017\005\017\005\017\000\000\005\017\005\017\005\017\000\000\000\000\000\000\000\000\000\000\000\000\005\r\005\r\000\000\000\000\000\000\005\r\000\000\000\000\005\r\005\r\000\000\000\000\000\000\0159\000\000\005\r\000\000\000\000\005\r\005\r\000\000\005\r\005\r\000\000\000\000\005\r\000\000\005\r\005\r\000\000\000\000\005\r\000\000\000\000\005\r\000\000\005\r\005\r\000\000\0159\0159\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0159\000\000\000\000\000\000\000\000\000\000\0159\0159\000\000\005\r\000\000\005\r\000\000\000\000\004\198\000\000\0159\000\000\000\000\0159\000\000\0159\005\r\000R\000V\004^\000\146\000\000\000\150\005\r\000\154\000\158\004b\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\0159\005\r\005\r\000\000\005\r\007\141\005\r\000\000\005\r\000\000\000\000\000\000\021\186\001\154\021\214\000\000\000\000\005\r\000\000\000\000\000\000\000\000\005\r\000\000\021\226\005\r\000\000\005\r\000\000\005\r\000~\000\000\000\000\005\r\005\r\005\r\000\000\005\r\005\r\005\r\0159\000\000\000\000\021\250\000\000\000\000\000\000\0159\000\000\000\000\n\166\000\000\000\000\000\000\000\000\022.\000\000\000\000\000\000\000\000\000\000\0159\000\000\000\000\022N\001\162\000\000\000\000\0159\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0159\0159\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\004\170\n\210\000\000\004\174\022Z\000\000\000\000\022\178\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\002\022\202\000\000\004\202\000\000\000\000\022\246\000\000\t\229\006\142\006\154\023&\006\178\006\190\006\214\006\218\000\000\000\000\0232\002&\023^\002*\000\000\024^\000\000\000\000\000\000\000\000\000\000\000\000\006\222\0022\000\000\006\226\006\230\006\234\006\238\002:\024j\024\130\000\000\006\242\006\246\000\000\024\142\006\250\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\000\000\011\026\000\000\000\000\007\006\000\000\011\030\000\n\000\000\000\000\000\000\025n\000\000\011\"\000\000\000\000\007\014\000\000\011&\025r\000\000\000\000\000\000\000\000\000\000\006\t\000\000\007\018\000\000\007\"\001\242\000\000\000\190\000\000\000\000\004\170\000\000\000\000\004\174\000\190\007*\000\000\000\000\000\000\000\000\000\000\0072\000\000\000\000\000\000\000\000\000\000\004\025\000\000\002\002\0076\000\000\004\202\000\000\000\000\007>\002~\000\000\006\142\006\154\000\000\006\178\006\190\006\214\006\218\000\198\011\150\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\222\0022\000\000\006\226\006\230\006\234\006\238\002:\011\194\000\000\000\000\006\242\006\246\000\202\011\198\006\250\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\000\000\000\000\000\000\000\000\007\006\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\007\014\000\000\000\000\004\165\000\000\000\000\000\000\000\000\000\000\006\t\000\000\007\018\000\000\007\"\001\242\000\000\000\190\000\000\000\000\004\170\000\000\000\000\004\174\000\000\007*\000\000\000\000\000\000\000\000\000\000\0072\000\000\000\000\000\000\000\000\000\000\t\t\000\000\002\002\0076\000\000\004\202\000\000\000\000\007>\002~\000\000\006\142\006\154\000\000\006\178\006\190\006\214\006\218\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\222\0022\000\000\006\226\006\230\006\234\006\238\002:\000\000\000\000\000\000\006\242\006\246\000\000\000\000\006\250\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\000\000\000\000\000\000\000\000\007\006\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\t\000\000\007\018\000\000\007\"\001\242\000\000\000\190\000\000\000\000\004\170\000\000\000\000\004\174\000\000\007*\000\000\000\000\000\000\000\000\000\000\0072\000\000\000\000\000\000\000\000\000\000\002\145\000\000\002\002\0076\000\000\004\202\000\000\000\000\007>\002~\000\000\006\142\006\154\000\000\006\178\006\190\006\214\bV\000\000\003\146\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\222\0022\000\000\006\226\006\230\006\234\006\238\002:\000\000\000\000\000\000\006\242\006\246\002\242\003\026\006\250\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\000\006\254\007\002\000\213\003\154\000\000\000\000\007\006\000\000\000\000\000\n\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\007\014\000\000\015\141\000\000\000\000\015\141\000\000\000\000\000\000\006\t\000\000\000\000\000\000\007\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007*\000\000\003*\000\000\015\141\015\141\0072\000\000\000\000\015\141\000\000\000\000\t\025\015\141\000\000\0076\000\000\000\000\000\000\015\141\007>\002~\015\141\015\141\000\000\015\141\015\141\000\000\000\000\000\000\000\000\015\141\000\000\004\198\000\000\015\141\000\000\000\000\015\141\000\000\015\141\015\141\0032\000\000\000\000\000\000\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\213\000\000\000\000\000\000\015\141\000\000\015\141\000\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\162\003:\015\141\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\025Z\000\182\011\"\000\186\001\146\001\150\000z\011&\025^\000\000\015\141\015\141\000\000\015\141\015\141\000\000\000\000\015\141\000\000\000\000\000\000\000\000\001\154\015\029\000\000\000\000\015\029\000\000\001\170\000\000\000\000\015\141\000\000\000\000\015\141\015\141\015\141\015\141\015\141\000~\000\000\000\000\015\141\015\141\015\141\000\000\015\141\015\141\015\141\015\029\015\029\000\000\000\000\000\000\015\029\000\000\000\000\000\000\015\029\001\158\000\000\000\000\000\000\000\000\015\029\000\000\000\000\015\029\015\029\000\000\015\029\015\029\000\000\000\000\001\162\000\000\015\029\000\000\004\198\000\000\015\029\000\000\000\000\015\029\000\000\015\029\015\029\000\000\000\000\000\000\000\000\000\000\000\000\011V\011Z\000\000\n\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\029\000\000\015\029\000\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\000\000\000\000\015\029\004\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\001\011^\015\029\015\029\000\000\015\029\015\029\000\000\000\000\015\029\000\000\006\001\000\000\000\000\000\000\015Y\006\001\000\000\015Y\000\000\000\000\000\000\000\000\015\029\000\000\000\000\015\029\015\029\015\029\015\029\015\029\000\000\000\000\000\000\015\029\015\029\015\029\000\000\015\029\015\029\015\029\015Y\015Y\000\000\000\000\000\000\015Y\000\000\000\000\r\n\015Y\000\000\000\000\000\000\000\000\000\000\015Y\000\000\000\000\015Y\015Y\000\000\015Y\015Y\000\000\000\000\r\018\000\000\015Y\r\030\000\000\000\000\015Y\000\000\000\000\015Y\000\000\015Y\015Y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\225\000\000\000\000\001\225\000\000\000\000\000\000\000\000\000\000\015Y\000\000\015Y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015Y\000\000\000\000\000\000\001\225\001\225\000\000\r*\000\000\001\225\000\000\000\000\000\000\001\225\000\000\000\000\000\000\000\000\000\000\001\225\000\000\000\000\001\225\001\225\000\000\001\225\001\225\015Y\015Y\000\000\015Y\001\225\r.\000\000\015Y\001\225\000\000\000\000\001\225\000\000\001\225\001\225\000\000\r6\001\225\000\000\000\000\000\000\000\000\000\000\000\000\015Y\000\000\015Y\000\000\000\000\000\000\000\000\000\000\015Y\015Y\015Y\000\000\015Y\015Y\015Y\000\000\001\225\001\225\001\225\000\000\000\000\001\225\000\000\000\000\000\000\001\225\000\000\000\000\000\000\001\225\000\000\001\225\000\000\000\000\001\225\001\225\000\000\001\225\001\225\000\000\000\000\000\000\000\000\001\225\000\000\000\000\000\000\001\225\000\000\000\000\001\225\000\000\001\225\001\225\000\000\000\000\001\225\002\186\000\000\001\225\001\225\000\000\000\000\001\225\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\225\000\000\001\225\001\225\001\225\001\225\001\225\000\000\000\000\000\000\000\000\003\254\001\225\001\225\000\000\001\225\001\225\001\225\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\225\002\194\000\000\001\225\001\225\000\000\000\000\001\225\000\000\000\000\000\000\000\000\000\000\001i\000\000\000\000\001i\000\000\000\000\000\000\000\000\001\225\000\000\000\000\001\225\001\225\001\225\001\225\000\000\000\000\000\000\000\000\003\242\001\225\001\225\000\000\001\225\001\225\001\225\001i\001i\000\000\000\000\000\000\001i\000\000\000\000\000\000\001i\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001i\001i\000\000\001i\001i\000\000\000\000\000\000\000\000\001i\000\000\000\000\000\000\001i\000\000\000\000\003\002\000\000\003\018\001i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001i\000\000\001i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001i\003\249\003\249\003\249\003\249\000\000\003\249\000\000\003\249\003\249\003\249\003\249\000\000\003\249\003\249\000\000\003\249\000\000\003\249\000\000\003\249\003\249\003\249\003\249\000\000\000\000\000\000\001i\000\000\000\000\001i\001i\000\000\001\210\003\n\000\000\000\000\000\000\000\000\003\249\001]\000\000\000\000\001]\000\000\003\249\000\000\000\000\001i\000\000\000\000\001i\001i\001i\001i\001i\003\249\000\000\000\000\000\000\001i\001i\000\000\001i\001i\001i\001]\001]\000\000\000\000\000\000\001]\000\000\000\000\000\000\001]\003\249\000\000\000\000\000\000\000\000\001]\003\249\000\000\001]\001]\000\000\001]\001]\000\000\000\000\003\249\000\000\001]\000\000\000\000\000\000\001]\000\000\000\000\003\002\000\000\001]\001]\000\000\003\249\003\249\000\000\000\000\000\000\000\000\000\000\000\000\003\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001]\000\000\001]\000\000\000\000\000\000\000\000\000\000\000\000\003\249\000\000\000\000\000\000\001]\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\001]\000\000\000\000\001]\001]\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\001a\003\249\000\000\001a\000\000\001\170\000\000\000\000\001]\000\000\000\000\001]\001]\001]\001]\001]\000~\000\000\000\000\000\000\001]\001]\000\000\001]\001]\001]\001a\001a\000\000\000\000\000\000\001a\000\000\000\000\000\000\001a\001\174\000\000\000\000\000\000\000\000\001a\001\202\000\000\001a\001a\000\000\001a\001a\000\000\000\000\001\162\000\000\001a\000\000\000\000\000\000\001a\000\000\000\000\003\002\000\000\001a\001a\000\000\001\178\001\182\000\000\000\000\000\000\000\000\000\000\000\000\001\186\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001a\000\000\001a\000\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\000\000\000\000\001a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001a\000\000\000\000\001a\001a\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\001e\014E\000\000\001e\000\000\000\000\000\000\000\000\001a\000\000\000\000\001a\001a\001a\001a\001a\000\000\000\000\000\000\000\000\001a\001a\000\000\001a\001a\001a\001e\001e\000\000\000\000\000\000\001e\000\000\000\000\000\000\001e\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001e\001e\000\000\001e\001e\000\000\000\000\000\000\000\000\001e\000\000\000\000\000\000\001e\000\000\000\000\003\002\000\000\003\018\001e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001e\000\000\001e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001e\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\001e\000\000\000\000\001e\001e\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\001u\000\000\000\000\001u\000\000\001\170\000\000\000\000\001e\000\000\000\000\001e\001e\001e\001e\001e\000~\000\000\000\000\000\000\001e\001e\000\000\001e\001e\001e\002\242\003\026\000\000\000\000\000\000\001u\000\000\000\000\000\000\001u\001\174\000\000\000\000\000\000\000\000\002\250\001\202\000\000\001u\001u\000\000\001u\001u\000\000\000\000\001\162\000\000\001u\000\000\000\000\000\000\001u\000\000\000\000\003\002\000\000\003\018\001u\000\000\001\178\001\182\000\000\000\000\000\000\000\000\000\000\000\000\001\186\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\001u\000\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\000\000\000\000\001u\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001u\000\000\000\000\001u\001u\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\001m\002\197\000\000\001m\000\000\000\000\000\000\000\000\001u\000\000\000\000\001u\001u\001u\001u\001u\000\000\000\000\000\000\000\000\001u\001u\000\000\001u\001u\001u\002\242\003\026\000\000\000\000\000\000\001m\000\000\000\000\000\000\001m\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001m\001m\000\000\001m\001m\000\000\000\000\000\000\000\000\001m\000\000\000\000\000\000\001m\000\000\000\000\003\002\000\000\003\018\001m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001m\000\000\001m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001m\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\001m\000\000\000\000\001m\001m\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\001q\000\000\000\000\001q\000\000\001\170\000\000\000\000\001m\000\000\000\000\001m\001m\001m\001m\001m\000~\000\000\000\000\000\000\001m\001m\000\000\001m\001m\001m\002\242\003\026\000\000\000\000\000\000\001q\000\000\000\000\000\000\001q\001\174\000\000\000\000\000\000\000\000\002\250\001\202\000\000\001q\001q\000\000\001q\001q\000\000\000\000\001\162\000\000\001q\000\000\000\000\000\000\001q\000\000\000\000\003\002\000\000\003\018\001q\000\000\001\178\001\182\000\000\000\000\000\000\000\000\000\000\000\000\001\186\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\001q\000\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\000\000\000\000\001q\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\001q\000\000\000\000\001q\001q\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\001y\002\189\000\000\001y\000\000\000\000\000\000\000\000\001q\000\000\000\000\001q\001q\001q\001q\001q\000~\000\000\000\000\000\000\001q\001q\000\000\001q\001q\001q\002\242\003\026\000\000\000\000\000\000\001y\000\000\000\000\000\000\001y\001\158\000\000\000\000\000\000\000\000\002\250\tf\000\000\001y\001y\000\000\001y\001y\000\000\000\000\001\162\000\000\001y\000\000\tj\tn\003\"\000\000\000\000\003\002\000\000\003\018\001y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\001y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\tv\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001y\001y\000\000\000\000\003\n\000\000\000\000\000\000\004)\000\000\001\129\000\000\000\000\001\129\000\000\000\000\000\000\000\000\001y\000\000\000\000\001y\001y\001y\001y\001y\000\000\000\000\000\000\000\000\001y\001y\000\000\001y\001y\001y\002\242\003\026\000\000\000\000\000\000\001\129\000\000\000\000\000\000\001\129\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001\129\001\129\000\000\001\129\001\129\000\000\000\000\000\000\000\000\001\129\000\000\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\001\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\129\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\0032\000\000\000\000\001\129\001\129\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\003\146\000\000\000\000\001}\000\000\000\000\000\000\000\000\001\129\000\000\000\000\001\129\001\129\001\129\001\129\001\129\000~\000\000\000\000\000\000\001\129\001\129\000\000\001\129\003:\001\129\002\242\003\026\000\000\000\000\000\000\001}\000\000\000\000\000\000\001}\001\158\000\000\000\000\000\000\000\000\002\250\tf\000\000\001}\001}\000\000\001}\001}\000\000\000\000\001\162\000\000\001}\000\000\tj\tn\003\"\000\000\000\000\003\002\000\000\003\018\001}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\001}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\tv\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001}\001}\000\000\000\000\003\n\000\000\000\000\000\000\tA\000\000\003\146\000\000\000\000\001\133\000\000\000\000\000\000\000\000\001}\000\000\000\000\001}\001}\001}\001}\001}\000\000\000\000\000\000\000\000\001}\001}\000\000\001}\003:\001}\002\242\003\026\000\000\000\000\000\000\001\133\000\000\000\000\000\000\001\133\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001\133\001\133\000\000\001\133\003\154\000\237\000\000\000\000\000\237\001\133\000\000\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\237\000\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\002\250\001\133\000\000\000\000\000\237\000\000\000\237\000\237\000\000\000\000\000\000\000\000\001\133\000\000\000\000\000\000\000\237\000\000\000\000\003\002\002\213\003\018\000\000\000\000\000^\002\213\000\000\000f\000\000\000v\002\213\000\000\002\213\000\000\000\000\000\000\000z\002\213\002\213\0032\000\000\000\000\001\133\001\133\000\000\000\000\003\n\000\000\000\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\213\000\000\001\133\000\000\000\000\001\133\001\133\001\133\001\133\001\133\000\000\000~\002\213\000\000\001\133\001\133\002\213\001\133\003:\001\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\237\002\213\002\213\000\237\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\000\000\002\213\000\000\000\138\000\000\000\000\000\000\000\000\000\237\000\000\002\213\000\000\000\237\000\237\000\000\002\213\002\213\000\000\000\000\000\000\000\000\000\000\000\000\000\237\000\237\002\213\000\000\002\209\000\000\002\213\000\000\000^\002\209\000\000\000f\000\000\000v\002\209\000\000\002\209\002\213\000\000\000\000\000z\002\209\002\209\000\000\000\000\000\000\000\000\002\213\000\000\000\000\000\000\000\000\002\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\209\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000~\002\209\000\000\000\000\000\000\002\209\000\000\000\000\000\000\000\000\000\000\000\000\002\213\000\000\000\000\002\213\002\213\000\000\000\000\002\213\002\209\002\209\000\000\002\230\002\213\002\213\003B\000\000\000\000\002\213\000\000\000\000\000\000\002\209\000\000\000\138\000\000\000\000\000\000\000\000\000\000\000\000\002\209\000\000\000\000\000\000\000\000\002\209\002\209\003r\003z\003\146\000\000\000\000\002=\000\000\000\000\002\209\002=\000\000\000\000\002\209\000\000\000\000\003\130\000\000\000\000\002=\002=\000\193\003\138\003\170\002\209\000\000\000\000\000\000\002=\002\242\003\026\000\000\003\178\000\000\002\209\003\186\000\000\003\194\002=\002\209\000\000\000\000\000\000\000\000\002\250\000\000\000\000\002\242\003\026\000\000\000\201\000\201\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\"\000\000\002\250\003\002\003\202\003\018\002=\000\000\000\193\000\193\000\000\000\000\002\209\000\000\000\000\002\209\002\209\002=\000\193\002\209\000\000\003\002\000\000\003\018\002\209\002\209\000\000\000\000\000\000\002\209\000\000\000\000\003*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\210\000\000\000\000\002=\002=\000\000\003*\003\218\000\000\000\000\000\000\000\000\000\000\000\145\000\000\000\000\000\145\000\000\000\000\000\000\000\000\002=\000\000\000\000\002=\002=\002=\002=\0032\000\000\000\000\000\000\000\000\002=\002=\003\n\003\226\003\234\002=\002\242\003\026\000\000\000\000\000\000\000\145\000\000\000\193\000\000\000\145\000\201\000\000\000\000\000\000\003\n\002\250\000\000\000\201\000\145\000\145\000\000\000\145\000\145\000\000\000\000\000\201\003:\000\145\000\193\000\000\000\000\003\"\000\000\000\000\003\002\000\193\003\018\000\145\000\000\000\000\000\000\000\000\000y\000\193\000\193\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\145\000\000\000\000\000y\000y\000\000\000\000\000\000\000y\000\000\000\000\000\145\000y\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000y\000y\000\000\000y\000y\000\000\000\000\000\000\000\000\000y\000\000\000\000\000\000\000y\000\000\000\000\003\002\0032\003\018\000y\000\145\000\145\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\145\000\000\000\000\000\145\000\145\000\145\000\145\000y\000\000\000y\000\000\000\000\000\145\000\145\000\000\000\145\003:\000\145\000\000\000\000\000y\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000y\000\000\000\000\000y\000y\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\000u\000\000\000\000\000u\000\000\000\000\000\000\000\000\000y\000\000\000\000\000y\000y\000y\000y\000\000\000~\000\000\000\000\000\000\000y\000y\000\000\000y\000y\000y\000u\000u\000\000\000\000\000\000\000u\000\000\000\000\000\000\000u\001\158\000\000\000\000\000\000\000\000\002\250\tf\000\000\000u\000u\000\000\000u\000u\000\000\000\000\001\162\000\000\000u\000\000\tj\tn\000u\000\000\000\000\003\002\000\000\003\018\000u\000\000\000\000\000\000\000\000\000m\000\000\000\000\000m\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000u\000\000\000u\000\000\000\000\000m\000m\000\000\000\000\000\000\000m\000\000\000\000\000u\000m\000\000\000\000\000\000\000\000\000\000\000m\000\000\000\000\000m\000m\000\000\000m\000m\000\000\tv\000\000\000\000\000m\000\000\000\000\000\000\000m\000\000\000\000\003\002\000u\000m\000m\000u\000u\000\000\000\000\003\n\000\000\000\000\000\000\002\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000u\000\000\000\000\000u\000u\000u\000u\000m\000\000\000m\000\000\000\000\000u\000u\000\000\000u\000u\000u\000\000\000\000\000m\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000m\000\000\000\000\000m\000m\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\003\146\000\000\000\000\000\153\000\000\000\000\000\000\000\000\000m\000\000\000\000\000m\000m\000m\000m\000\000\000~\000\000\000\000\000\000\000m\000m\000\000\000m\000m\000m\002\242\003\026\000\000\000\000\000\000\000\153\000\000\000\000\000\000\000\153\001\158\000\000\000\000\000\000\000\000\002\250\026\022\000\000\000\153\000\153\000\000\000\153\003\154\000\000\000\000\001\162\000\000\000\153\000\000\026\026\tn\003\"\000\000\000\000\003\002\000\000\003\018\000\153\000\000\000\000\000\000\000\000\003\146\000\000\000\000\000\141\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\153\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\141\000\000\000\000\000\153\000\141\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\141\000\141\000\000\000\141\000\141\000\000\026\030\000\000\000\000\000\141\000\000\000\000\000\000\003\"\000\000\000\000\003\002\0032\003\018\000\141\000\153\000\153\000\000\000\000\003\n\000\000\000\000\000\000\004!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\153\000\000\000\000\000\153\000\153\000\153\000\153\003*\000\000\000\141\000\000\000\000\000\153\000\153\000\000\003\162\003:\000\153\000\000\000\000\000\141\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\0032\000\000\000\000\000\141\000\141\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\000\133\000\000\000\000\000\133\000\000\000\000\000\000\000\000\000\141\000\000\000\000\000\141\000\141\000\141\000\141\000\000\000~\000\000\000\000\000\000\000\141\000\141\000\000\000\141\003:\000\141\002\242\003\026\000\000\000\000\000\000\000\133\000\000\000\000\000\000\000\133\001\158\000\000\000\000\000\000\000\000\002\250\026\022\000\000\000\133\000\133\000\000\000\133\000\133\000\000\000\000\001\162\000\000\000\133\000\000\026\026\tn\000\133\000\000\000\000\003\002\000\000\003\018\000\133\000\000\000\000\000\000\000\000\000q\000\000\000\000\000q\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\133\000\000\000\000\000q\000q\000\000\000\000\000\000\000q\000\000\000\000\000\133\000q\000\000\000\000\000\000\000\000\000\000\000q\000\000\000\000\000q\000q\000\000\000q\000q\000\000\026\030\000\000\000\000\000q\000\000\000\000\000\000\000q\000\000\000\000\003\002\000\133\000q\000q\000\133\000\133\000\000\000\000\003\n\000\000\000\000\000\000\t%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\000\000\000\000\000\133\000\133\000\133\000\133\000q\000\000\000q\000\000\000\000\000\133\000\133\000\000\000\133\000\133\000\133\000\000\000\000\000q\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000q\000\000\000\000\000q\000q\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\000}\000\000\000\000\000}\000\000\000\000\000\000\000\000\000q\000\000\000\000\000q\000q\000q\000q\000\000\000~\000\000\000\000\000\000\000q\000q\000\000\000q\000q\000q\002\242\003\026\000\000\000\000\000\000\000}\000\000\000\000\000\000\000}\001\158\000\000\000\000\000\000\000\000\002\250\026\022\000\000\000}\000}\000\000\000}\000}\000\000\000\000\001\162\000\000\000}\000\000\026\026\tn\000}\000\000\000\000\003\002\000\000\003\018\000}\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\129\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000}\000\000\000}\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\129\000\000\000\000\000}\000\129\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\129\000\129\000\000\000\129\000\129\000\000\026\030\000\000\000\000\000\129\000\000\000\000\000\000\000\129\000\000\000\000\003\002\000}\003\018\000\129\000}\000}\000\000\000\000\003\n\000\000\000\000\000\000\002\161\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000}\000\000\000\000\000}\000}\000}\000}\003*\000\000\000\129\000\000\000\000\000}\000}\000\000\000}\000}\000}\000\000\000\000\000\129\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000\129\000\000\000\000\000\129\000\129\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\003\146\000\000\000\000\000\149\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\129\000\129\000\129\000\129\000\000\000~\000\000\000\000\000\000\000\129\000\129\000\000\000\129\000\129\000\129\002\242\003\026\000\000\000\000\000\000\000\149\000\000\000\000\000\000\000\149\001\158\000\000\000\000\000\000\000\000\002\250\t~\000\000\000\149\000\149\000\000\000\149\003\154\000\000\000\000\001\162\000\000\000\149\000\000\tj\tn\003\"\000\000\000\000\003\002\000\000\003\018\000\149\000\000\000\000\000\000\000\000\000\137\000\000\000\000\000\137\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\149\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\137\000\000\000\000\000\149\000\137\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\137\000\137\000\000\000\137\000\137\000\000\000\000\000\000\000\000\000\137\000\000\000\000\000\000\003\"\000\000\000\000\003\002\0032\003\018\000\137\000\149\000\149\000\000\000\000\003\n\000\000\000\000\000\000\tQ\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\149\000\000\000\000\000\149\000\149\000\149\000\149\003*\000\000\000\137\000\000\000\000\000\149\000\149\000\000\000\149\003:\000\149\000\000\000\000\000\137\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\181\0032\000\000\000\000\000\137\000\137\000\000\000\000\003\n\000\000\000\000\r\181\000\000\r\181\012\005\012\005\000\000\r\181\000\000\000\000\012\005\000\000\000\137\r\181\000\173\000\137\000\137\000\137\000\137\r\181\000\000\000\000\r\181\000\000\000\137\000\137\r\181\000\137\000\137\000\137\000\000\000\000\r\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\173\000\173\000\000\r\181\000\000\000\000\012\005\000\000\r\181\r\181\000\000\000\000\000\000\000\000\000\000\000\173\000\000\000\000\000\000\000\000\000\000\000\173\000\173\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\173\000\000\000\000\003\002\000\000\000\173\012\005\000\000\r\181\000\000\000\000\r\181\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\250\r\181\000\000\000\000\000\000\000\000\r\181\r\181\r\181\000\173\r\181\r\181\000\000\r\181\000\000\000\000\002\002\000\000\000\000\002\006\r\181\000\000\000\000\r\181\000\000\002\018\002\022\000\000\002\030\000\000\007\030\000\000\000\000\000\000\000\000\002&\000\000\002*\r\181\000\000\000\000\000\000\000\000\r\181\r\181\012\005\002.\0022\000\000\000\173\br\0026\001\"\002:\000\000\000\000\003\n\002>\002B\000\000\000\000\002F\002J\000\000\000\000\000\000\000\000\000\000\015q\000\000\000\173\015q\000\000\000\000\000\000\000\000\000\000\000\173\000\000\002N\000\000\000\000\000\000\000\000\002R\000\173\000\173\000\n\000\000\000\000\000\000\000\000\000\000\000\000\015q\015q\002Z\000\000\000\000\015q\000\000\000\000\000\000\015q\000\000\000\000\000\000\002^\t\245\015q\000\000\000\000\015q\015q\000\000\015q\015q\000\000\000\000\000\000\002b\015q\000\000\004\198\000\000\015q\002n\000\000\015q\t\245\015q\015q\000\000\000\000\000\000\002\134\000\000\000\000\000\000\000\000\002v\002~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015q\000\000\015q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015q\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\250\000\000\000\000\000\000\000\000\000\000\000\000\015q\015q\000\000\015q\000\000\000\000\000\000\015q\000\000\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\018\002\022\000\000\002\030\000\000\004\198\015q\000\000\015q\000\000\002&\000\000\002*\000\000\015q\015q\015q\000\000\015q\015q\015q\002.\0022\000\000\000\000\000\000\0026\001\"\002:\000\000\000\000\000\000\002>\002B\000\000\000\000\002F\002J\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\250\000\000\000\000\002N\000\000\000\000\000\000\000\000\002R\000\000\012b\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\002\022\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002b\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\t\245\000\000\002>\002B\002\134\000\000\002F\002J\000\000\002v\002~\000\000\000\000\001\249\000\000\000\000\001\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002N\000\000\000\000\000\000\000\000\002R\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\001\249\001\249\002Z\000\000\000\000\001\249\000\000\000\000\000\000\001\249\000\000\000\000\000\000\002^\000\000\001\249\000\000\000\000\001\249\001\249\000\000\001\249\001\249\000\000\000\000\000\000\002b\001\249\000\000\000\000\000\000\001\249\002n\000\000\001\249\000\000\001\249\001\249\000\000\000\000\000\000\002\134\000\000\000\000\000\000\000\000\002v\002~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\249\000\000\001\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\250\000\000\000\000\000\000\000\000\000\000\001\249\rJ\000\000\001\249\t\245\000\000\000\000\001\249\000\000\000\000\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\018\002\022\000\000\002\030\000\000\001\249\000\000\001\249\000\000\000\000\002&\000\000\002*\rR\001\249\001\249\000\000\001\249\001\249\001\249\000\000\002.\0022\000\000\000\000\000\000\0026\001\"\002:\000\000\000\000\000\000\002>\002B\000\000\000\000\002F\002J\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\250\000\000\000\000\002N\000\000\000\000\000\000\000\000\002R\000\000\018\202\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\002\022\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002b\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\000\000\000\000\002>\002B\002\134\000\000\002F\002J\000\000\002v\002~\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\002N\000\000\000\000\000\000\000\000\002R\000\000\000\000\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\t\030\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002b\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\000\000\000\000\002>\002B\002\134\000\000\002F\002J\000\000\002v\002~\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\002N\000\000\000\000\000\000\000\000\002f\000\000\000\000\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\t\014\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002j\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\000\000\000\000\002>\002B\002r\000\000\002F\002J\000\000\002v\002~\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\002N\000\000\000\000\000\000\000\000\002f\000\000\000\000\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\b\246\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002j\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\000\000\000\000\002>\002B\002r\000\000\002F\002J\000\000\002v\002~\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\002N\000\000\000\000\000\000\000\000\002f\000\000\000\000\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\002V\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002j\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\000\000\000\000\002>\002B\002r\000\000\002F\002J\000\000\002v\002~\000\000\000R\000\000\000\000\000\000\000\000\000\000\007\241\020v\000\000\000\000\000\000\007\241\002N\000\000\000\000\000\000\007\241\002f\007\241\020z\000\n\001\150\000\000\007\241\007\241\000\000\022\250\000\000\000\000\002Z\020~\000\000\020\130\000\000\000\000\000\000\020\134\000\000\000\000\000\000\002^\000\000\020\138\000\000\007\241\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\000\002j\000\000\020\154\007\241\000\000\000\000\002n\007\241\020\158\000\000\000\000\000\000\000\000\000\000\000\000\002r\000\000\000\000\000\000\022\002\002v\002~\007\241\007\241\020\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\241\000\000\000\000\007\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\241\000\000\000\000\000\000\000\000\007\241\007\241\000\000\000\000\012-\000\000\020\166\000\000\000\000\020\170\007\241\000\000\000\000\000\000\007\241\000\000\000\000\000\000\000\000\000\000\022\006\000\000\020\174\000\000\000\000\007\241\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\007\241\000\000\000\000\000\000\000\000\007\241\020\198\000\000\000\000\020\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\020\206\002\n\000\000\000\000\002\014\020\210\020\214\012-\000\000\000\000\000\000\000\000\000\000\000\000\007\241\000\000\000\000\007\241\007\241\000\000\002\002\007\241\000\000\002\006\000\000\000\000\007\241\007\241\000\000\002\"\004\146\007\241\002\030\000\000\004\166\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\206\0022\000\000\000\000\000\000\004\210\001\"\002:\000\185\000\000\000\000\004\214\004\218\000\000\000\000\004\222\002J\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\000\000\000\000\000\000\000\000\004\226\002\242\003\026\000\000\000\000\004\230\000\000\000\000\000\n\002\002\000\000\000\000\002\006\000\000\000\000\000\000\002\250\004\238\002\018\004\178\000\000\002\030\000\185\000\185\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\185\000\000\000\000\003\002\000\000\003\018\000\000\002.\0022\004\242\000\000\000\000\0026\001\"\002:\004\250\000\000\000\000\002>\002B\000\000\000\000\002F\002J\004\254\000\000\000\000\000\000\000\000\005\006\002~\000\000\000\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002N\000\000\000\000\000\000\000\000\002f\000\000\000\000\000\n\000\000\000\000\006j\000\000\000\000\000\000\000\000\000\000\002Z\000\000\000\000\000\000\003\225\000\000\003\225\000\000\000\000\003\225\000\000\002^\003\225\000\000\000\000\000\185\000\000\000\000\000\000\000\000\000\000\000\000\003\n\000\000\002j\000\000\000\000\000\000\003\225\000\000\002n\003\225\000\000\000\000\000\000\000\000\000\185\003\225\003\225\002r\003\225\000\000\000\000\000\185\002v\002~\000\000\003\225\000\000\003\225\000\000\000\185\000\185\000\000\000\000\000\000\000\000\000\000\003\225\003\225\000\000\000\000\000\000\003\225\003\225\003\225\000\000\000\000\000\000\003\225\003\225\000\000\000\000\003\225\003\225\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\000\000\000\000\000\000\000\000\003\225\000\000\000\000\000\000\000\000\003\225\000\000\000\000\003\225\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\003\225\002\018\012N\000\000\002\030\000\000\000\000\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002.\0022\003\225\000\000\000\000\0026\001\"\002:\003\225\000\000\000\000\002>\002B\000\000\000\000\002F\002J\003\225\000\000\000\000\000\000\000\000\003\225\003\225\000\000\000\000\000\000\000\000\020v\000\000\000\000\000\000\000\000\002N\000\000\000\000\000\000\000\000\002f\000\000\020z\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002Z\020~\000\000\020\130\012Y\012Y\000\000\020\134\000\000\000\000\000\000\002^\000\000\020\138\000\000\000\000\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\189\002j\000\000\020\154\000\000\000\000\000\000\002n\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\002r\000\000\000\000\000\000\020v\002v\002~\012Y\000\000\020\162\002\242\003\026\000\000\000\000\000\000\000\000\020z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\250\000\000\020~\000\000\020\130\000\000\000\189\000\189\020\134\000\000\000\000\012-\000\000\012Y\020\138\020\166\000\189\000\000\020\170\003\002\020\142\003\018\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\000\000\020\174\000\000\020\158\000\000\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\023v\022\138\000\000\012-\003*\020\162\020\198\000\000\000\000\020\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\206\000\000\000\000\000\000\000\000\020\210\020\214\012Y\000\000\000\000\012-\000\000\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\000\189\000\000\000\000\000\000\000\000\000\000\000\000\003\n\020\174\000\000\000\000\000\000\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\000\189\r~\000\000\000\000\r\134\000\000\020\198\000\189\000\000\020\202\000\000\000\000\000\000\000\000\000\000\000\189\000\189\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\206\000\000\000\000\r\150\r\158\020\210\020\214\012-\002M\000\000\000\000\000\000\002M\000\000\000\000\000\000\000\000\000\000\r\166\000\000\000\000\002M\002M\000\000\r\174\r\182\000\000\000\000\000\000\001E\002M\000\000\001E\000\000\r\190\000\000\000\000\r\198\000\000\r\206\002M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\001E\000\000\000\000\000\000\001E\000\000\r\214\000\000\002M\000\000\002\250\000\000\000\000\001E\001E\000\000\001E\001E\000\000\002M\000\000\000\000\001E\000\000\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001E\000\000\000\000\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\r\222\000\170\000\174\002M\000v\000\000\000\182\r\230\000\186\001\146\001\150\000z\003*\000\000\001E\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002M\001E\002M\001\154\000\000\000\000\000\000\000\000\000\000\002M\002M\000\000\r\238\r\246\002M\000\000\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001E\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\158\001-\000\000\000\000\001-\000\000\026&\000\000\000\000\000\000\000\000\000\000\001E\000\000\001E\001\162\000\000\000\000\000\000\026\026\tn\001E\001E\000\000\001E\003:\001E\001-\001-\000\000\000\000\000\000\001-\000\000\000\000\000\000\001-\tr\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001-\001-\000\000\001-\001-\000\000\000\000\000\000\001)\001-\000\000\001)\000\000\001-\000\000\000\000\003\002\000\000\003\018\001-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001)\001)\000\000\000\000\000\000\001)\000\000\000\000\000\000\001)\000\000\001-\000\000\001-\000\000\002\250\000\000\000\000\001)\001)\000\000\001)\001)\000\000\001-\t5\000\000\001)\000\000\000\000\000\000\001)\000\000\000\000\003\002\000\000\003\018\001)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001-\000\000\000\000\001-\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001)\000\000\001)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001-\001)\001-\000\000\000\000\000\000\000\000\000\000\000\000\001-\001-\000\000\001-\001-\001-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001)\000\000\000\000\001)\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\001!\000\000\000\000\001!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001)\000\000\001)\000\000\000\000\000\000\000\000\000\000\000\000\001)\001)\000\000\001)\001)\001)\001!\001!\000\000\000\000\000\000\001!\000\000\000\000\000\000\001!\000\000\000\000\000\000\000\000\000\000\001!\000\000\000\000\001!\001!\000\000\001!\001!\000\000\000\000\000\000\003\146\001!\000\000\001M\000\000\001!\000\000\000\000\003\002\000\000\001!\001!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\001M\000\000\000\000\000\000\001M\000\000\001!\000\000\001!\000\000\002\250\000\000\000\000\001M\001M\000\000\001M\003\154\000\000\001!\000\000\000\000\001M\000\000\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001!\000\000\000\000\001!\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\003*\000\000\001M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001!\001M\001!\000\000\000\000\000\000\000\000\000\000\000\000\001!\001!\000\000\001!\001!\001!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001M\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\003\146\000\000\000\000\001A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001M\000\000\001M\000\000\000\000\000\000\000\000\000\000\000\000\001M\001M\000\000\003\162\003:\001M\002\242\003\026\000\000\000\000\000\000\001A\000\000\000\000\000\000\001A\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001A\001A\000\000\001A\001A\000\000\000\000\000\000\0019\001A\000\000\0019\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\0019\000\000\000\000\000\000\0019\000\000\003*\000\000\001A\000\000\002\250\000\000\000\000\0019\0019\000\000\0019\0019\000\000\001A\000\000\000\000\0019\000\000\000\000\000\000\0019\000\000\000\000\003\002\000\000\003\018\0019\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001A\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\003*\000\000\0019\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001A\0019\001A\000\000\000\000\000\000\000\000\000\000\000\000\001A\001A\000\000\001A\003:\001A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0019\000\000\000\000\0019\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\001%\000\000\000\000\001%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0019\000\000\0019\000\000\000\000\000\000\000\000\000\000\000\000\0019\0019\000\000\0019\0019\0019\001%\001%\000\000\000\000\000\000\001%\000\000\000\000\000\000\001%\000\000\000\000\000\000\000\000\000\000\001%\000\000\000\000\001%\001%\000\000\001%\001%\000\000\000\000\000\000\0011\001%\000\000\0011\000\000\001%\000\000\000\000\003\002\000\000\001%\001%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\0011\000\000\000\000\000\000\0011\000\000\001%\000\000\001%\000\000\002\250\000\000\000\000\0011\0011\000\000\0011\0011\000\000\001%\000\000\000\000\0011\000\000\000\000\000\000\0011\000\000\000\000\003\002\000\000\003\018\0011\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001%\000\000\000\000\001%\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\0011\000\000\0011\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001%\0011\001%\000\000\000\000\000\000\000\000\000\000\000\000\001%\001%\000\000\001%\001%\001%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0011\000\000\000\000\0011\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\0015\000\000\000\000\0015\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0011\000\000\0011\000\000\000\000\000\000\000\000\000\000\000\000\0011\0011\000\000\0011\0011\0011\002\242\003\026\000\000\000\000\000\000\0015\000\000\000\000\000\000\0015\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\0015\0015\000\000\0015\0015\000\000\000\000\000\000\003\146\0015\000\000\001I\000\000\0015\000\000\000\000\003\002\000\000\003\018\0015\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\003\146\000\000\000\000\001I\000\000\000\000\000\000\001I\000\000\003*\000\000\0015\000\000\002\250\000\000\000\000\001I\001I\000\000\001I\003\154\000\000\0015\000\000\000\000\001I\002\242\003\026\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001I\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\000\000\000\000\000\000\209\003\154\0015\000\000\000\000\0015\000\000\000\000\000\000\003\n\003\"\000\000\000\000\003\002\003*\003\018\001I\000\197\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0015\001I\0015\000\000\000\000\000\000\000\000\000\000\000\000\0015\0015\000\000\0015\0015\0015\000\000\003*\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001I\002\250\000\000\000\000\003\n\000\000\000\000\000\197\000\197\000\000\001=\000\000\000\000\001=\000\000\000\000\000\000\003\"\000\000\000\000\003\002\001I\003\018\001I\000\000\0032\000\000\000\000\000\000\000\000\001I\001I\003\n\001I\003:\001I\002\242\003\026\000\000\000\000\000\000\001=\000\000\000\000\000\000\001=\000\209\000\000\000\000\003*\000\000\002\250\000\000\000\209\001=\001=\000\000\001=\001=\000\000\000\000\000\209\003:\001=\000\000\000\000\000\000\003\"\000\000\023b\003\002\023j\003\018\001=\000\000\000\000\000\000\000\000\000\000\000\000\023r\000\000\000\000\000\000\000\000\023\146\000\000\000\000\000\000\0032\000\000\000\000\020z\000\000\000\000\000\000\003\n\000\000\000\000\003*\000\000\001=\000\000\020~\000\000\020\130\000\000\000\000\000\000\020\134\000\197\000\000\001=\000\000\000\000\020\138\000\000\000\197\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\197\000\197\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\0032\000\000\000\000\001=\000\000\000\000\000\000\003\n\000\000\000\000\000\000\020\162\023\154\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001=\000\000\001=\000\000\000\000\000\000\000\000\000\000\000\000\001=\001=\000\000\001=\001=\001=\000\000\000\000\000\000\020\166\006A\000\000\020\170\000\000\000\000\006A\000\000\000\000\000\000\000\000\006A\000\000\006A\000\000\000\000\020\174\000\000\006A\006A\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\006A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006A\000\000\020\206\000\000\006A\000\000\000\000\020\210\020\214\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015=\006A\006A\015=\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004j\000\000\000\000\006A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006A\000\000\000\000\015=\015=\006A\006A\000\000\000\000\000\000\000\000\005\030\000\000\000\000\000\000\006A\000\000\000\000\015=\006A\000\000\000\000\015=\000\000\015=\015=\000\000\000\000\005&\000\000\006A\006*\000\000\000\000\015=\000\000\000\000\015=\000\000\015=\006A\000\000\000\000\000\000\000\000\006A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\004\170\015=\000\000\004\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006A\000\000\000\000\006A\006A\000\000\002\002\006A\0066\000\000\000\000\000\000\006A\006A\000\000\006\142\006\154\006A\000\000\000\000\006\174\000\000\000\000\000\000\000\000\002&\000\000\002*\015=\015=\000\000\015=\000\000\006:\000\000\015=\006\222\0022\000\000\000\000\000\000\006\234\001\"\002:\006B\000\000\000\000\006\242\006\246\015=\000\000\006\250\000\000\015=\015=\000\000\000\000\000\000\000\000\000\000\015=\000\000\000\000\000\000\015=\015=\000\000\000\000\006\254\007\002\000\000\000\000\000\000\000\000\007\006\000\000\000\000\000\n\000\000\001\242\000\000\000\190\000\000\000\000\012F\000\000\007\014\012J\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\007*\000\000\012\182\012\162\000\000\000\000\0072\r\254\000\000\000\000\000\000\000\000\002&\000\000\002*\0076\000\000\000\000\000\000\000\000\007>\002~\000\000\012\186\0022\000\000\000\000\000\000\012\190\001\"\002:\000\000\000\000\000\000\012\194\012\198\000\000\020v\012\202\000\000\000\000\000\000\000\000\000\000\000\000\020v\000\000\000\000\000\000\020z\000\000\000\000\000\000\000\000\000\000\006\254\012\206\020z\000\000\000\000\020~\012\210\020\130\000\000\000\n\000\000\020\134\000\000\020~\000\000\020\130\000\000\020\138\012\218\020\134\000\000\000\000\000\000\020\142\000\000\020\138\020\150\000\000\000\000\000\000\020\154\020\142\000\000\000\000\020\150\000\000\020\158\000\000\020\154\000\000\000\000\000\000\012\222\000\000\020\158\000\000\000\000\022\210\012\230\000\000\000\000\000\000\020\162\000\000\000\000\023:\000\000\012\234\000\000\000\000\020\162\000\000\012\242\002~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012-\000\000\020\166\000\000\000\000\020\170\000\000\000\000\012-\000\000\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\020\174\000\000\000\000\000\000\000\000\020\178\000\n\020\182\020\174\020\186\020\190\000\000\020\194\020\178\000\n\020\182\000\000\020\186\020\190\020\198\020\194\000\000\020\202\000\000\t\237\000\000\000\000\020\198\000\000\000\000\020\202\000\000\000\000\000\000\000\000\000\000\t\237\020\206\000\000\000\000\000\000\000\000\020\210\020\214\012-\020\206\000\000\t\237\000\000\t\237\020\210\020\214\012-\t\237\000\000\000\000\000\000\000\000\000\000\t\237\000\000\000\000\000\000\b\169\000\000\t\237\000\000\000\000\t\237\000\000\000\000\000\000\t\237\021^\000\000\b\169\000\000\000\000\t\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\169\000\000\b\169\000\000\000\000\000\000\b\169\000\000\t\237\000\000\000\000\000\000\b\169\000\000\000\000\000\000\000\000\000\000\b\169\000\000\000\000\b\169\000\000\000\000\000\000\b\169\000\000\000\000\000\000\000\000\000\000\b\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\237\000\000\000\000\t\237\000\000\000\000\000\000\000\000\b\169\023\154\000\000\000\000\000\000\000\000\000\000\000\000\t\237\000\000\000\000\000\000\000\000\t\237\t\237\t\237\000\000\t\237\t\237\000\000\t\237\000\000\000\000\000\000\000\000\000\000\000\000\t\237\000\000\000\000\t\237\b\169\000\000\000\000\b\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\237\000\000\b\169\000\000\000\000\t\237\t\237\b\169\b\169\b\169\000\000\b\169\b\169\006\225\b\169\000\000\000\000\000\000\000\000\000\000\000\000\b\169\000\000\000\000\b\169\006\225\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\225\000\000\006\225\b\169\000\000\000\000\006\225\000\000\b\169\b\169\000\000\000\000\006\225\000\000\000\000\000\000\021\230\000\000\006\225\000\000\000\000\006\225\000\000\000\000\000\000\006\225\000\000\000\000\020z\000\000\000\000\006\225\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\024\162\000\000\000\000\020\134\000\000\006\225\000\000\000\000\000\000\020\138\000\000\000\000\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\225\000\000\000\000\006\225\000\000\000\000\000\000\000\000\020\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\225\000\000\000\000\000\000\000\000\006\225\006\225\006\225\000\000\006\225\006\225\000\000\006\225\000\000\000\000\000\000\000\000\000\000\000\000\006\225\000\000\000\000\006\225\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\225\000\000\020\174\000\000\000\000\006\225\006\225\020\178\000\n\020\182\000\000\020\186\020\190\021\254\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\020\206\000\000\000\000\020\134\000\000\020\210\020\214\000\000\000\000\020\138\000\000\000\000\000\000\020v\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\020z\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\000\000\000\000\000\000\020\134\000\000\020\162\000\000\000\000\000\000\020\138\000\000\000\000\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\022\182\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\174\000\000\000\000\000\000\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\206\000\000\020\174\000\000\000\000\020\210\020\214\020\178\000\n\020\182\000\000\020\186\020\190\022\206\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\020\206\000\000\000\000\020\134\000\000\020\210\020\214\000\000\000\000\020\138\000\000\000\000\000\000\0236\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\020z\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\000\000\000\000\000\000\020\134\000\000\020\162\000\000\000\000\000\000\020\138\000\000\000\000\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\020\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\174\000\000\000\000\000\000\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\206\000\000\020\174\000\000\000\000\020\210\020\214\020\178\000\n\020\182\000\000\020\186\020\190\020v\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\020\206\000\000\000\000\020\134\000\000\020\210\020\214\000\000\000\000\020\138\000\000\000\000\000\000\020v\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\020z\000\000\000\000\020\158\000\000\000\000\000\000\015U\000\000\000\000\015U\020~\000\000\020\130\000\000\000\000\000\000\020\134\000\000\024n\000\000\000\000\000\000\020\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\150\015U\015U\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\015U\000\000\020\166\000\000\015U\020\170\015U\015U\000\000\000\000\020\162\000\000\000\000\000\000\004\198\000\000\015U\000\000\020\174\015U\000\000\015U\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020\166\000\000\000\000\020\170\000\000\000\000\000\000\015U\000\000\000\000\000\000\000\000\000\000\000\000\020\206\000\000\020\174\000\000\000\000\020\210\020\214\020\178\024\154\020\182\000\000\020\186\020\190\000\000\020\194\000\229\000\000\000\000\000\229\000\000\000\000\020\198\000\000\000\000\020\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015U\015U\000\000\015U\000\000\000\000\020\206\015U\000\229\000\229\000\000\020\210\020\214\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015U\000\000\000\229\000\000\015U\015U\000\229\003\146\000\229\000\229\001\017\015U\000\000\000\000\000\000\015U\015U\000\000\000\229\000\000\000\000\003\002\000\000\000\229\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\229\000\000\001\017\000\000\001\017\003\154\000\000\003\146\000\000\000\000\001\005\000\000\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\229\000\000\000\000\000\229\000\000\000\000\003*\003\n\002\250\000\000\000\000\000\000\001\005\000\253\001\005\001\005\000\253\000\000\000\000\000\000\000\000\000\229\000\000\000\000\003\"\000\229\000\229\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\229\000\229\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001\017\000\000\000\000\000\000\003\n\002\250\000\000\003*\000\000\000\253\000\000\000\253\000\253\000\000\000\233\000\000\000\000\000\233\001\017\000\000\000\000\000\253\001\017\001\017\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\003\162\003:\000\000\000\000\000\000\000\000\000\000\000\233\000\233\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001\005\000\000\000\000\003*\003\n\000\233\000\000\000\000\000\000\000\233\000\245\000\233\000\233\000\245\000\000\000\000\000\000\000\000\001\005\000\000\000\000\000\233\001\005\001\005\003\002\000\000\000\233\000\000\000\000\000\000\000\000\000\000\000\000\001\005\003:\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\253\000\000\000\000\000\253\000\000\000\000\000\000\003\n\002\250\000\000\000\233\000\000\000\245\000\000\000\245\000\245\000\000\000\249\000\000\000\000\000\249\000\253\000\000\000\000\000\245\000\253\000\253\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\253\000\253\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\233\000\000\000\000\000\233\000\000\000\000\000\245\003\n\002\250\000\000\000\000\000\000\000\249\003\146\000\249\000\249\001\r\000\000\000\000\000\000\000\000\000\233\000\000\000\000\000\249\000\233\000\233\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\233\000\233\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\245\000\000\000\000\000\245\000\000\000\000\000\000\003\n\002\250\000\000\003*\000\000\001\r\000\000\001\r\003\154\000\000\001\001\000\000\000\000\001\001\000\245\000\000\000\000\003\"\000\245\000\245\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\245\000\245\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\249\000\000\000\000\000\249\000\000\000\000\003*\003\n\002\250\000\000\000\000\000\000\001\001\000\000\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\249\000\000\000\000\003\"\000\249\000\249\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\249\000\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001\r\000\000\000\000\000\000\003\n\000\000\000\000\003*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\r\000\000\000\000\000\000\001\r\001\r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\r\003:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001\001\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\000\000\000\000\000\000\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\001\001"))
+ ((16, "\002\130\000\185\000\000\000\000\022\134\000\185\000\000\000\000\000\026\000\000\000\000\000\000\000\213\000\000\000\000\000\000\002\130\000\000\000\005:*\000\000\000\000I\182\026P\000\000\025,\027t\000\000\000\000\000\000\000\000\000\213\0002\000\000\000\000\000\000\000\000\000\000\000\000\000\000J\142\000\000\000\000\025,\000\000\000\000\000\006\000\000\000\017\000\017\000\000\000\000\000\000\000\000\000\r\000\000\000\000\000\144\000\017\000\000\000\144\000\000\000\000\000\017\000\162\001\244\000\017\001\242\000\000\003\000\000R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\223\000\017\000\000\000I\002\220\000\017\000\000\000\005\001f\000\000\000\000\000\000\002\016\000\000\028\152\000\017\002\028\000\000\000\000\000\000\000\000:*\029\188?\184\000\000?\184\000\000\000\000\000\000\000\017\000\000?\184\000\000>\156\003\028?\184\003P\000\000\000\000\000\017\007fW\234\000\000\000\000[0[\200\000\000^\200\000\000\\`Vn%\254%\254^\200Vn\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\\\248%\254\000\000\000\000\\\248\\\248\\\248\000\000\\\248\000\006\000\000\000\000Vn\\\248\000\000\000\000/\026\000\017\000\000 b%\254Vn\000\0000jVn<\002Vn<\128Vn\000\000\000\000\000\000\000\000\000\000\000\000\000\000J\248Vn\000\000L\020Vn=\156Vn>\184Vn\000\000Vn\000\000Vn?\212Vn@\240VnB\012VnC(VnDDVnE`Vn!`Vn\000\000\000\000\000\000\003dVn\000\000\000\000\000\000\000\000VnL\156VnM\184VnN@VnO\\VnF|VnG\152VnH\180VnO\228VnQ\000Vn\000\000VnQ\136VnR\164VnS,Vn\000\000VnTHVnT\208Vn\000\000\000\000Vn\000\000\003\202\000\000\000\000\000\017\000\000\000\000\000\000\000\000\003\242\000\000\004\020\000\000\000\020Vn\000\000\000\020\000\000\000\000\000\194:*\000\000&\224\0032\0032m\164]\226\000\000m\164\000\000\000\000m\164\000\000\000\194\000\000\000\000%\254\004V\000\000\004x^\2005p\000\000_X%\254\004z\000\000\004\1384>5p^\200\000\000\000\000\000\000\000\000\000\000\000\000\\\248\000\000\000\000\\\248\000\000\000\000\\\248\000\000\000\006\000\000^\200\000\000\000\000n\006\000\017\000\000 b b\000\000\000\227$\226 b \230Vn\000\000Vn\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\023\028Vn\024\132Vn\005\nVn\000\000Vn$\"VnI\022Vnw\154Vnw\246VnxZVnx\182Vn\000\000Vny\026VnyvVny\218Vn\000\000Vnz6Vnz\154\000\175!\226\000\000\000\000\001X#b\000\000\000\000\000\000\000\000\004\228\000\000Vn\004\252\000\000\000\000\000\017\000\000\000\000\000\000\002\184^\200\000\000\000\000\006\000\000\000\000[`0\005\242Vn\005\240\000\000\000\000^\200\000[\000\000\000\000Vn\005v\000\000%\254\005\130\000\000\005\132n\1385p^\200\005\134\000\000Vn\000|Vn\005\138\000\000\000\0005p5p\000\000\000\000\000\000\000\0002\200\000\000\000\000\000\000\000\000\000\000\\\248\000\000\000\000\000\164\006\136Vn5p\000\017\000\000\\\248\000\000\000\000\\\248\000\000\000\006\000\0003\240n\138\000\000\000\000\"\172\000\017\000\000 b\005\208\000\000Vn\005\212\000\000\000\000\000\017\000\000\000\000\000\000\000\000\000\000-\140\000\000\000\000\006\0165p\006&5p\000\000\000\003\000\000\000\000\025\168Vn\026\204Vn\027\240Vn\029\020Vn\0308Vn8\168VnK0VnKTVn\000\000VnV\000Vn_fVna\224Vn\000\000VnkBVnk\194\000\000\006\004\000\000\001(6\\\000\000\002x845p\000\000\003\n7H\000\000\000\000\000\000\000\000\006\152\000\000\000\000\000\000\0068\000\000\006N\000\000\000\000\006T\000\000\000\000\006X\000\000\000\000\006b\000\000\000\000\000\000\000\000\000\000\000\000\006d\007,\000\000\006j\000\000\006r\000\000\006rW\234\000\000%\254\006tv\188\000\000\007X\000\000%\254\006\1309*\000\000%\254\006\132:F\000\000\006\132\000\000\000\000\007f\000\000\007x\000\000\000\000\001f\007H\000\017\006\142\007`EDED\000\000\000\000\000\000\003\\T,ED\003hG|\000\000\000\000\000\000\006h\007R\002\162\007fED\000\000\000\000\006\156\000\000\006\160\007pED\006\164\000\000\001N\000\000\000\000\003\196M\156\000\000\000\000\000\000\006\168\007\156\000\000\007\158\000\0001\234\000\017\007\160\000\000\000\000\000\000\006\174\000\000?\184\000\000D(A\240\000\000\000\000\030\224?\184\006\176\000\000\000\000\001\140?\184\000\000\001\140\000\000\000\000\006\194\000\000\002\162\006\192\000\000\001V:*\000\000:*\000\000\006\174\000\000\001V\000\000\019\1524\240:*\000\000\006\208\000\000\002\000:*\000\000\000\000\002\000\000\000\000\000\000\000\000\026\000\000\000\000\001<\000\026\000\000\000\000\000\000\007\194\000\000&\224'n'n\000\000\000\000'n\000\000\000\000\000\000\000\000\000\000\007\170Vn\006\222)X\007^\000\000\007\192Vn\006\244\007\188:*\000\000\000\000\000\000:*\000\017\000\000\000\017Vn\007\242\000\000\000\017\000\000\000\017\007\244\000\000\t.\007\196\000\017\007\014\007\222ED\007\018\001\154\000\000Vn\b\004\000\000\000\000\000\000\007\230ED\007\026\b\n\000\000\003\186\004>Vn\b\020\000\000\b\022\000\0001\234\000\017\004lVn\b(\000\000\b*\000\000\000\017\004\140Vn\b.\000\000\b6\000\000\0013\007t\t\n,n\000\000`\192%\254\007LW(\000\000X\130\000\000\b<\000\000\003\002\b\018Vn\007\208\000\000\b\022Vn\007\212\000\000\001p\000\000\t\n\t\n%\254\007X\000\000\007ZoLoL\000\000\000\000\000\000\000\000\000\000\000\000\\\248\000\000\000\000\\\248\000\000\000\000\\\248\000\000\000\006\000\000oL\000\000\000\000;b\000\017\000\000 b\007`\000\000Vn\007d\000\000\000\000\000\017\000\000\000\000\000\000\000\000\000\000Y<Vn\000\000Vn\000\000\007p\000\000\000\020\000\000\000\000\000\000\000\000\000\000c\014VncvVn\007\156Vn\000\000Vnd\146Vnd\250Vnf\022Vnf~Vng\154Vnh\002Vn\000\000Vni\030Vni\134Vnj\162Vn\000\000Vnk\nVnl&5p\007n\000\000\000\000\003\002\000\000\003\002\000\000\019\152\t\n\t\n\000\000\000\000\000\000\000\003\000\000\000\000\000\000\bFVn\007|)X*j\000\017\bl\000\000\bN\022\152\000\000:*\000\017\001\166\000\000Vn\br\000\000\n&\bD\000\017\007\138\bZED\007\142\004H\000\000Vn\b\128\000\000\004L\000\000Vn\b\132\000\0001\234\000\017\004\158\000\000Vn\b\174\000\000\000\017\005 \000\000Vn\b\196\000\000-\152\b\198Z\000\b\206Vn\007\226)X)X\001\022\001\022\003\228\001\226\001\022\000\000\000\000\004\012\004\026\000\000\004Z\n\"\000\000\000\000\000\000\000\000\000\000\007\228\000\000\000\000\b\214\000\000\b\216\000\000\000\000\t\026\b\196Vn\007\250\b\238\000\000\b\242\000\000\b0\000\000\b\218 b\b\014)X\000\000\000\000\000\000\007\136\000\000\000\000\003\002\000\000\b\146\000\000\015\018\0012\000\000\015\018\000\000\000\000-\152\000\000\011\182\000\000\000\000\012\014\000\000\015\018\000\000\b\230 b\b\026\005b\000\000Vn\t\016\000\000\0032\000\000\b\226\000\017\b0\t\000ED\b4\005n\000\000Vn\t$\000\000\t\006ED\bF\t6\000\000\0056Vn\t8\000\000\t:\000\0001\234\000\017\005<Vn\t>\000\000\tP\000\000\000\000\000\000\012\014\000\000\000\000\001:\000\000\t\n\000\000\0032\000\000\000\000Z\000\tXVn\bl)X\000\000\000\000\tB b\bx\005t\000\000Vn\tt\000\000\007\184\000\000\tD\000\017\b\144\t`ED\b\152\005v\000\000Vn\t\136\000\000\005|\000\000Vn\t\138\000\0001\234\000\017\005\198\000\000Vn\t\140\000\000\002\200*j\000\000\002\200\000\000\000\000\b\162\000\000\000\020\001\128)X\000\000\006\006\0007\006\006\000\000\0007\000\000\t\n\000\000\t\n\000\000\000\000\000\000\b\174\000\000\000\000\b\186\000\000\004V\007\136\0007\006\006\000\000\000\000\000\000\0007\000\000\t\n\000\000\004V\000\000\000\000\022|\020R\019\152\000\000\020R\000\000\n\140\019\152\000\000\000\000\n\140\000\000\000\000\b\186\000\000\000\000\b\192\000\000\004\244\t\n\000\000\004\244\000\000\000\000\t@\000\000\001:\000\000\t\n\000\000\000\000\000\000\024\024Z\152\000\000\t\178\000\000\024\024\t\184\000\000\t\186\000\000\005\146\024\024\000\000\t\188\000\000\000\000\005\146\000\000\000\000\b\210\000\000\023@\tP\000\000\000\000\000\000\tR\000\000\000\165\000\178\000\000\019\152\t\176\000\000\000\000Vn\t\002\t\n\000\000\b\214\000\000\0013\000\000:*\000\000\000\000\003\236\019\152\000\000\019\152\000\000\b\198\000\000\003\236\000\000Vn\003\240Vn\000\000Vn\000\000\b\200\000\000\003\240\000\000Vn\003\240\b\204\000\000\021\024+\234\000\000\003\250\021\024\000\000\000\000\021\024\000\000\b\206\000\000\003\250\000\000Vn\003\240\b\208\000\000:*\005\216:*\000\000:*\000\000\b\218\000\000\005\216\000\000Vn\003\240\b\220\000\000\000\000'~\000\000\000\185\t~\000\000\000\000\tT]\212\000\000\000\000\000\000\000\000\000\000\000\000\t(\006\006\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\004]\212\000\000\001\b\003P\t*\000\185\000\000\000\000\t2\000\185\000\000\000\000\000\000\000\000\001\024\003P\000\000\000\000\000\000\000\000\t\144\000\000\000\000\000\000\000\000/\0261j\000\000q&\000\000]\212\000\000\002v]\212\000\000\002\196\001\218\001\218\000\000\003\224\001\218\000\000\t\b\000\000\000\000\000\000\000\000\t\162\000\0002\200\000\0004\240]\212\000\000\000\029]\212\000\000\t\198\000\000]\212\t\202\000\000r\194]\212\t\222\000\000\t\224\000\000s\194]\212]\212\t\138\000\185\000\000\000\000\000\000\t`]\212\t\234\000\000\t\236\000\000\t\240\000\000:*\000\000\004\n:*\000\000\tj'n\000\000]\212\t\248\000\000\002\220]\212\000\000\004\154]\212\000\000\004\132\n~\000\000\n\128\000\000b\030]\212\tv\000\000\000\000\000\000\000\000\000\000\000\000\n\n\000\000t\016a\156\n\020\000\000\n\030\000\000u\016p\012]\212\t\158]\212\n(\000\000\n*\000\000\n,\000\000a\156\t\212\000\185\000\000\000\000\005\154a\156\000\000\004\132\000\000\n2\000\000]\212\n8\000\000u^p\028]\212\t\178]\212\n<\000\000\n>\000\000\nD\000\000l\200'n\000\000'n\000\000b\030]\212\t\192]\212\nL\000\000\nN\000\000'n\000\000qt\000\000\000\000\005\166]\212\000\000\001\128\003\142\001\218\t\198\000\000\000\000\0032\0032\000\000\000\000\000\000\000\000\005\024\0032\000\000\t\208\000\000\000\000\000\000\000\000\000\000\000\000\000\000]\212\000\000\005\236]\212\000\000\005Z\001f\000\185\t\210\000\000\000\000\000\000\000\000\000\000\000\000\000\000\nd\000\000\nf\000\000]\212\nh\000\000v^a\156\np\000\000\nr\000\000]\212\n|\000\000(\226\n\"v\172U\206rt\n\004\000\000]\212\n\142\000\000\n\144\000\000\nd(\226]\212\n\152\000\000]\212\n\154\000\000\n\156\000\000]\212\n\158\000\000\000\185\n\n\000\000\000\000'~\000\000\000\000\0044\011\004\000\000\000\000\001C\000\000\000\000\000\000Vn\000\000\000\000\000\000\004\132\000\000\000J\000\000\000\000\000\000\006\006:*:*:*\000\000\003`\003`\003`\003`\000\000\000\000\000\000\000\000\000\000\000\000\003\002\019\152\n\250\016\148\0012\000\000\000\000\004P\000\000\012\014\000\0005p\n&\000\000\003\002\019\152\n4\018\022\000\000\003\002\016\148\000\000\000\000\000\000:*6j\000\000\000\000\000\000\n\132\0032\011\014O@O@\000\000\004\230d,O@\005\164P\228\000\000\000\000\b\170\n\254\000\017\000\000\005\200R\136\000\000\000\000\000\000\000\000\000\000\nD\011\020\t\n\nP\000\000\000\000\004P\000\000\012\014\000\000\021r\000\027\000\000\000\000\011\004\000\000\000\000\0044\000\000\002\030\000\000\000\000\000\000Vn\000\000\004\132\000\000\002\198\000\000\000\000\000\000\007\136\000\000\r\144\005L\r\144\000\000\t\n\r\144\000\000\005\246\000\000\t\n\000\000\t\n\000\000\t\n\000\000\019\242\000\000\000\000\000\000\000\000\000\000\t\n\000\000\005\246\000\000\t\n\000\000*\196\000\000\000\000\n\140\n\134\000\185\002$\0110\005\202\000\000\005\202\011Z\000\000\011\\\000\000\006\204\000\000\005\202\002\196\005\202\0110\005\202\000\000\000\000\003\170\000\000\0144\002$\nV\000\000\n`\000\000\n\160\000\185\002$\nf\000\000\n\140\011t\000\000\014\234\bd\011\136\000\225\011\136\000\000\000\000\b,\000\185\000\000\001D\000\000\000\000\000p\000\000\np\000\000\000\000\000\000\n\174\000\185\002$\nv\000\000\000\000\n\140\014\234\bd\b,\001D\000p\nx\000\000\014\234\bd\b,\001D\000p\nz\000\000\006\170\002\012\n\152\000\185\n\146\006\220\003\230\n\190\000\185\000\000\n\194\000\185\000\000\011 \000\000\n\168\004\140\n\196\006\220\011\\\000\000\n\220\006\220\011b\000\000\000\000\006\220\000\000\011d\000\000"), (16, "\r\217\r\217\r\217\r\217\r\217\r\217\r\217\r\217\r\217\r\217\r\217\r\217\r\217\r\217\012:\r\217\r\217\r\217\r\217\r\217\r\217\r\217\r\217\r\217\r\217\019N\006\145\025/\0253\r\217\005\249\001\194\0257\r%\n\005\r-\r\217\000\190\r\217\r%\r%\026\163\r\217\012n\r\217\r\217\000\n\r\217\000\190\026\167\r\217\r%\014\014\r=\000\130\r\217\r\217\r\217\001\170\026\170\r\217\000&\004\217\0056\028\018\001N\r\217\b\197\000\198\r\217\r\217\n\005\b\237\001\198\000\254\r\217\r\217\r%\r\217\006\190\r\217\000*\0007\000;\000\194\r\217\000\190\r\217\r\217\005\254\r\217\r\217\r\217\b\181\0196\000\202\r\217\r\217\r\217\004:\r]\r\217\r\217\r\217\n\218\000\206\001\"\r\217\r\217\r\217\r\217\r\217\r\217\006f\001\006\007\022\r\217\r\217\000N\n\158\019\158\019\198\019\214\020\n\020\026\020B\n\222\r\217\r\217\r\217\000\n\015\218\r\217\r\217\r\217\r\217\006\145\r\217\012\150\r\217\001Z\000\n\r\217\001\030\001\"\r\217\r\217\b\253\011r\001&\001\002\000\n\004\217\001*\001.\006\t\r\217\r\217\007\149\007\"\r\217\000\234\021\198\000\134\r\217\r\217\r\217\r\217\011~\r]\r\217\0012\r\217\000\222\001j\b\241\r\217\r\217\r\217\000\n\r\217\002}\r\217\r\217\000\190\r\217\004R\r\217\r\217\006Y\r\217\r\217\r\217\r\229\r\229\r\229\r\229\r\229\r\229\r\229\r\229\r\229\r\229\r\229\r\229\r\229\r\229\028:\r\229\r\229\r\229\r\229\r\229\r\229\r\229\r\229\r\229\r\229\n\005\r\149\006\198\015*\r\229\012n\000\190\025W\025[\012n\n~\r\229\025_\r\229\014\014\012\150\018\186\r\229\014\014\r\229\r\229\023\194\r\229\018\190\000\202\r\229\006\210\005\129\012\137\001\238\r\229\r\229\r\229\006Q\000\206\r\229\r\157\000\198\tR\003\233\003\241\r\229\0246\000\254\r\229\r\229\003\233\003\241\011\178\012\154\r\229\r\229\014\169\r\229\014~\r\229\014\169\023\214\006I\000\n\r\229\019\"\r\229\r\229\000\202\r\229\r\229\r\229\000\190\nR\020\246\r\229\r\229\r\229\000\206\020\142\r\229\r\229\r\229\015.\028\170\n\134\r\229\r\229\r\229\r\229\r\229\r\229\n\t\028.\012\137\r\229\r\229\015\218\021&\004]\0282\015\218\r\157\000\n\021~\004\017\r\229\r\229\r\229\0156\bF\r\229\r\229\r\229\r\229\018\186\r\229\t\t\r\229\001\n\n\230\r\229\018\190\001\002\r\229\r\229\018\194\014\169\014\169\005\241\000\202\n\186\014\169\005\241\006\014\017\190\r\229\004]\002]\r\229\000\206\000\006\000\"\r\229\r\229\r\229\r\229\011\182\002\129\r\229\006\025\r\229\001\018\014\130\n\t\r\229\r\229\r\229\r\133\r\229\019\"\r\229\r\229\006\137\r\229\000\n\r\229\r\229\000\190\r\229\r\229\r\229\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\000\n\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\006\153\000\190\000\n\000\198\tR\006\153\012r\012\130\012\146\003\193\000^\b\229\006\153\000f\006\153\000v\004R\027\174\006\153\r\141\006\153\006\153\000z\006\153\020\234\006q\006\153\021z\027~\011\026\000\202\006\153\000\198\006\153\011\030\017\154\006\153\001~\001^\025z\000\206\011\"\006\153\001\142\000\190\000.\011&\025~\020\250\026\195\026\199\006\153\006\153\003\173\026\203\000~\006\153\006\153\006\205\000\202\016J\006\153\021\006\006\153\006\153\000\n\006\153\006\153\006\153\000\206\021\n\001\214\006\153\006\153\006\153\000\198\016N\006\153\006\153\006\153\023\218\021n\bR\006\153\006\153\006\153\006\153\006\153\006\153\t\025\000\138\0045\006\153\006\153\000\n\t\237\003\193\011\194\022j\006\017\006\017\020\142\000\202\011\198\006\153\006\153\006I\t\162\006\153\006\153\006\153\006\153\000\206\006\153\006N\006\153\016\238\021\022\006\153\003\193\006\205\006\153\006\153\028\190\027\190\006\129\023\198\021\026\005\241\023\222\001\026\001\222\027\174\026\227\026\231\027\182\006\153\000\n\026\235\t\001\006\153\006\153\006\153\006\153\004\133\028\202\006\153\001\238\006\153\019~\0045\019\166\006\153\006\153\006\153\bb\019\230\0045\006\153\006\153\000\190\006\153\002\141\006\153\006\153\004\165\006\153\006\153\006\153\006\189\006\189\006\189\006\189\006\189\006\189\006\189\006\189\006\189\006\189\006\189\006\189\006\189\006\189\003^\006\189\006\189\006\189\006\189\006\189\006\189\006\189\006\189\006\189\006\189\r=\006\189\tz\015*\006\189\014\174\tQ\014\194\t\134\n\005\006\189\006\189\tA\006\189\028\230\022\130\022\138\006\189\012n\006\189\006\189\025\030\006\189\r=\000\202\006\189\019\134\014\014\019\174\005\241\006\189\006\189\006\189\019\242\000\206\006\189\006\189\006\189\006\189\r=\018\014\006\189\006\189\006\189\006\189\027\198\006\189\006\189\014\222\005\241\006\189\006\189\006\189\006\189\t\222\006\189\027\182\022\146\002\173\000\n\006\189\025\030\006\189\004\n\006\189\006\189\006\189\006\189\021\138\006\189\0152\006\189\006\189\006\189\b\225\rM\006\189\006\189\006\189\015.\004*\006\189\006\189\006\189\006\189\006\189\006\189\006\189\n\025\022F\015F\0069\006\189\006)\b\209\011\230\r5\0042\0061\ru\014\178\b\213\014\198\006\189\006\189\006\189\015\218\006\189\006\189\006\189\006\189\006\189\006\189\014\246\006\189\011~\000\n\006\189\012\006\018\142\006\189\006\189\022\130\022\138\r=\006\189\006\189\r=\023\194\015R\006a\004\154\006\189\002m\012\"\006\189\014\169\014\169\011~\006\189\006\189\014\169\006\189\014\226\012n\006\189\0166\006\189\004\162\004\186\n\025\006\189\016j\014\014\011~\017\"\017V\004\194\006\189\017j\006\189\022v\006\189\006\189\0242\006\189\006\189\006\189\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\020v\000v\025f\000\182\011\"\000\186\001\146\001\150\000z\011&\025j\027\134\020z\n\017\017\134\011*\018\238\026.\005\138\020\"\006&\t5\011:\020~\001\154\020\130\014\250\006i\001\242\020\134\012B\011B\027\138\012F\0062\020\138\012J\016\146\n\005\027\142\016\178\000~\023\242\012^\020\150\r}\n\001\012n\020\154\rE\015\218\re\002\002\006^\020\158\025\158\014\014\011~\006n\016:\011~\014\"\012\162\025\202\025\214\016n\014&\017\202\017&\017Z\020\162\002&\017n\002*\004\181\n\017\001\162\015\210\014.\000\190\n5\n5\012\186\0022\0142\n5\rm\012\190\006\238\002:\020*\006v\006\150\012\194\012\198\011V\011Z\012\202\0146\006\162\006\170\020\166\006\186\014:\020\170\006\206\006y\023\026\027\150\017\138\000\198\t\154\026:\023\182\006\254\012\206\t%\020\174\014>\014B\012\210\014F\020\178\000\n\020\182\014Z\020\186\020\190\004\145\020\194\026Z\014f\012\218\007\026\002\157\015\218\020\198\000\202\007j\020\202\027\162\027\158\007v\025\234\028\166\028\186\015\"\000\206\024&\007\166\015&\015r\004\181\011^\020\206\006!\012\222\007\174\015v\020\210\020\214\027\166\012\230\004\181\004\181\n5\n5\b>\004\181\015~\n5\012\234\000\n\006\197\006\197\bz\012\242\002~\006\197\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\b\138\000v\025f\000\182\011\"\000\186\001\146\001\150\000z\011&\025j\b\146\000\n\029\015\b\158\011*\b\170\002\233\b\182\b\210\004\198\002\233\011:\b\222\001\154\b\230\b\238\b\254\001\242\005\241\012B\011B\t\n\012F\t\022\t&\012J\t2\tF\tV\t^\000~\tb\012^\t\158\t\166\n\001\t\182\001\238\t\190\t\194\t\202\002\002\t\242\000\190\012n\t\246\t\254\n\014\n\030\nF\014\"\012\162\025\202\014\014\nj\014&\018\018\nv\n\147\0176\002&\n\178\002*\004\197\n\250\001\162\015\210\014.\011.\0116\011>\012\186\0022\0142\000\198\017:\012\190\006\238\002:\011F\011N\011R\012\194\012\198\011V\011Z\012\202\0146\011z\011\142\011\154\015\214\014:\011\162\011\166\011\174\011\194\011\190\011\206\011\214\011\218\000\202\011\198\006\254\012\206\011\238\011\246\014>\014B\012\210\014F\000\206\000\n\005\241\014Z\012\014\012\022\004\145\012*\028\n\014f\012\218\0122\012>\012V\012j\012v\012~\012\134\012\142\012\170\012\178\015\218\005\241\r\026\015\"\000\n\005\241\r&\015&\015r\r^\011^\r\142\014\006\012\222\014J\015v\014R\014b\014j\012\230\014\138\004\197\014\150\014\158\014\162\014\170\015~\014\186\012\234\014\206\006\213\006\213\000\190\012\242\002~\006\213\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\014\234\000v\025f\000\182\011\"\000\186\001\146\001\150\000z\011&\025j\015\002\015\014\000\198\026J\011*\015\022\015\030\015n\006\181\015z\015\130\011:\015\142\001\154\006\181\006\181\015\146\001\242\015\154\012B\011B\015\158\012F\015\166\015\174\012J\028\"\015\182\015\190\000\202\000~\015\230\012^\016*\0162\n\001\006\173\000\190\016B\000\206\016R\002\002\006\173\006\173\012n\016Z\016^\016f\016v\016~\012\158\012\162\006\181\014\014\006\173\014&\016\134\016\138\016\154\016\162\002&\016\186\002*\004\225\000\n\001\162\014*\014.\000\198\011\150\016\194\012\186\0022\0142\016\254\017\006\012\190\006\238\002:\017\022\006\173\017\030\012\194\012\198\011V\011Z\012\202\0146\017.\017>\011\194\014\177\014:\017F\017J\000\202\011\198\017R\017b\017v\017\146\017\178\002\233\006\254\012\206\000\206\002\233\014>\014B\012\210\014F\017\250\000\n\018\006\014Z\018z\018\134\004\145\018\166\018\210\014f\012\218\018\222\018\230\018\250\019\018\019\030\019.\019F\019V\000\n\019b\015\218\019\147\019\187\015\"\019\211\019\255\020\023\015&\015r\004\225\011^\0207\020O\012\222\020g\015v\020r\020\146\020\254\012\230\004\225\004\225\021\014\021?\021\150\004\225\015~\000\190\012\234\000\190\n=\n=\021\171\012\242\002~\n=\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\021\211\000v\021\223\000\182\011\"\000\186\001\146\001\150\000z\011&\000\198\014\146\021\239\021\247\015*\011*\022\n\022\030\022'\022/\004y\0227\011:\022R\001\154\022c\022\134\022\142\001\242\022\158\012B\011B\011\194\012F\022\187\000\202\012J\000\202\011\198\022\203\027r\000~\b=\012^\022\211\000\206\n\001\000\206\022\230\022\239\022\247\022\255\002\002\023\n\023/\012n\b=\023;\023N\023W\023_\012\158\012\162\023g\014\014\023\138\014&\023\147\023\155\023\206\000\n\002&\000\n\002*\023\254\024>\001\162\014*\014.\024_\024g\024s\012\186\0022\0142\024\131\024\139\012\190\006\238\002:\015.\024\151\024\162\012\194\012\198\011V\011Z\012\202\0146\024\178\024\191\024\199\003\165\014:\024\206\024\219\024\231\024\239\024\251\025\007\025\"\025\170\002q\b=\006\254\012\206\027\226\025\210\014>\014B\012\210\014F\025\226\000\n\026\022\014Z\027\246\026\030\026N\026v\004y\014f\012\218\028N\026z\027\250\004y\004y\026\130\026\175\003\165\027v\027\130\015\218\027\146\027\154\015\"\027\215\004y\004y\015&\015r\027\223\011^\027\230\027\243\012\222\027\254\015v\028\014\028C\028R\012\230\028_\028\131\028\159\b=\028\174\028\182\015~\028\194\012\234\028\206\028\219\004y\028\226\012\242\002~\b=\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\028\234\000v\n\005\000\182\011\"\000\186\001\146\001\150\000z\011&\028\243\012n\028\250\029\003\029\023\011*\000\000\000\000\000\000\003\165\014\014\000\000\011:\000\000\001\154\003\165\003\165\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\003\165\000\000\000\000\000\000\000~\000\000\012^\000\000\000\000\n\001\000\000\000\000\000\000\000\000\000\000\002\002\000\000\003\165\012n\000\000\000\000\014\169\000\000\000\000\012\158\012\162\003\165\014\014\027\182\014&\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\014*\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\011V\011Z\012\202\0146\015\218\000\000\000\000\014\177\014:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\000\000\014\169\014\169\014f\012\218\000\000\014\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\218\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\000\015~\000\000\012\234\000\000\014\177\014\177\000\000\012\242\002~\014\177\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\025f\000\182\011\"\000\186\001\146\001\150\000z\011&\025j\000\000\000\000\000\000\000\000\011*\000\000\000\000\000\000\000\000\000\000\000\000\011:\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\000\000\000\000\000\000\000\000\000~\000\000\012^\000\000\000\000\n\001\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\"\012\162\000\000\000\000\000\000\014&\026\250\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\015\210\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\003\177\014:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\004\145\000\000\000\000\014f\012\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\027\174\000\000\000\000\000\000\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\000\015~\000\000\012\234\000\000\n!\n!\000\000\012\242\002~\n!\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\003\173\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\000\000\011*\000\000\000\000\000\000\003\177\000\000\000\000\011:\000\000\001\154\003\177\003\177\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\003\177\000\000\000\000\000\000\000~\000\000\012^\000\000\000\000\n\001\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\"\012\162\003\177\000\000\027\182\014&\015\238\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\015\210\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\014\141\014:\000\000\000\000\000\000\000\000\000\000\000\000\003\173\000\000\000\000\000\000\006\254\012\206\003\173\003\173\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\003\173\027~\000\000\014f\012\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\003\173\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\000\015~\000\000\012\234\000\000\014\141\014\141\000\000\012\242\002~\014\141\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\000\000\011*\000\000\000\000\000\000\000\000\000\000\000\000\011:\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\000\000\000\000\000\000\000\000\000~\000\000\012^\000\000\000\000\n\001\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\"\012\162\000\000\000\000\000\000\014&\025\174\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\015\210\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\000\000\014:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\000\000\000\000\000\000\014f\012\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\000\015~\000\000\012\234\000\000\014\217\014\217\000\000\012\242\002~\014\217\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\000\000\011*\000\000\000\000\000\000\000\000\000\000\000\000\011:\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\000\000\000\000\000\000\000\000\000~\000\000\012^\000\000\000\000\n\001\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\"\012\162\000\000\000\000\000\000\014&\025\174\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\015\210\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\000\000\014:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\000\000\000\000\000\000\014f\012\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\000\015~\000\000\012\234\000\000\014\213\014\213\000\000\012\242\002~\014\213\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\000\000\011*\000\000\000\000\000\000\000\000\000\000\000\000\011:\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\011\026\000\000\000\000\000\000\000~\011\030\012^\000\000\000\000\n\001\025z\000\000\011\"\000\000\000\000\002\002\000\000\011&\025~\000\000\000\000\000\000\000\000\000\000\014\"\012\162\000\000\000\000\000\000\014&\018F\000\000\000\000\000\000\002&\000\000\002*\000\000\000\190\001\162\015\210\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\016J\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\000\000\014:\000\000\000\000\000\198\016N\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\011\194\000\000\000\000\014f\012\218\000\202\011\198\b5\000\000\000\000\000\000\n\005\000\000\000\000\000\000\000\206\000\000\000\000\015\"\000\000\012n\b5\015&\015r\000\000\011^\000\000\000\000\012\222\014\014\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\n\015~\000\000\012\234\000\000\004\165\000\000\000\000\012\242\002~\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\b5\011*\000\000\000\000\000\000\000\000\000\000\000\000\011:\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\011B\000\000\012F\000\000\000\000\012J\011\026\000\000\000\000\000\000\000~\011\030\012^\015\218\000\000\n\001\025z\000\000\011\"\000\000\000\000\002\002\000\000\011&\025~\000\000\000\000\000\000\000\000\000\000\019\218\012\162\000\000\000\000\000\000\014&\b5\000\000\000\000\000\000\002&\000\000\002*\000\000\000\190\001\162\000\000\014.\b5\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\016J\000\000\012\194\012\198\011V\011Z\012\202\0146\000\000\000\000\000\000\000\000\014:\000\000\000\000\000\198\016N\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\011\194\000\000\000\000\014f\012\218\000\202\011\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\011^\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\n\015~\000\000\012\234\000\000\004\165\000\000\000\000\012\242\002~\000R\000V\000Z\000\146\000\000\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\rU\rU\000\000\000\000\000\000\000\000\000\190\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\007\233\007\233\001\242\000\000\012B\007\233\016J\001\246\000\000\000\000\001\250\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\t\249\000\198\016N\000\000\000\000\000\000\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\004R\002\026\002\022\000\000\002\030\000\000\000\000\000\000\000\000\011\194\000\000\002&\000\000\002*\000\202\011\198\001\162\005z\000\000\000\000\005\130\000\000\002.\0022\000\206\000\000\000\000\0026\001\"\002:\rU\000\000\000\000\002>\002B\011V\014n\002F\002J\000\000\000\000\000\000\000\000\005\146\005\154\000\000\000\000\000\000\000\000\000\n\rU\000\000\000\000\000\000\000\190\002N\000\000\000\000\005\162\000\000\002R\rU\002E\000\n\005\170\005\178\000\000\rU\rU\000\000\0176\000\000\002Z\000\000\005\186\000\000\000\000\005\194\000\000\005\202\000\000\000\000\000\000\002^\000\000\000\198\017:\000\000\000\000\000\000\006I\000\000\000\022\011^\000\000\000\000\002b\000\000\004R\rU\000\000\000\000\002n\000\000\rU\rU\005\210\011\194\000\000\000\000\000\000\002\134\000\202\011\198\000\000\000\000\002v\002~\000R\000V\000Z\000\146\000\206\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\000\000\000\182\011\"\000\186\001\146\001\150\000z\011&\000\000\000\000\000\000\000\000\005\218\000\n\000\000\002E\000\000\000\000\000\000\005\226\000\000\000\000\001\154\000\000\000\000\000\000\001\242\000\000\012B\000\000\000\000\012F\000\000\002E\012J\000\000\000\000\002E\002E\000~\000\000\018\198\000\000\000\000\n\001\000\000\000\000\000\000\005\234\005\242\002\002\000\000\000\000\000\000\006I\000\000\000\000\000\000\000\000\018\214\012\162\000\000\000\000\001\t\000\000\000\000\001\t\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\000\000\000\000\000\000\000\000\000\000\012\186\0022\000\000\000\000\000\000\012\190\001\"\002:\000\000\002\242\003\026\012\194\012\198\011V\014n\012\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\000\001\t\000\000\001\t\001\t\006\254\012\206\000\000\000\000\000\000\000\000\012\210\000\000\003\"\000\n\000\000\003\002\000\000\003\018\000\000\000\000\r\189\000\000\012\218\000\000\000\000\r\189\000\000\000j\r\189\000r\r\189\000\000\r\189\000\000\000\178\000\000\000\000\r\189\r\189\000\000\r\189\000\000\000\000\011^\003*\000\000\012\222\000\000\018\218\000\000\000\000\r\189\012\230\r\189\000\000\000\000\000\000\r\189\r\189\018\226\000\000\012\234\000\000\r\189\000\000\000\000\012\242\002~\000\000\r\189\r\189\000\000\r\189\000\000\r\189\000\000\r\189\000\000\000\000\000\000\000\000\000\000\r\189\000\000\0032\000\000\000\000\001\t\000\000\r\189\r\189\003\n\000\000\r\189\000\000\000\000\000\000\000\000\r\189\r\189\000\000\007\198\r\189\000\000\r\189\001\t\000\000\000\000\000\000\001\t\001\t\r\189\000\000\000\000\000\000\000\000\r\189\r\189\000\000\000\000\001\t\003:\000\000\000\000\000\000\000\000\r\189\007\206\007\214\r\189\r\189\000\000\r\189\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\189\007\222\000\000\000\000\r\189\000\000\000\000\007\230\007\238\r\189\r\189\r\189\000\000\r\189\r\189\r\189\r\189\007\246\000\000\000\000\007\254\000\000\b\006\r\189\000\000\r\169\r\189\000\000\000\000\000\000\r\169\000\000\000\000\r\169\000b\r\169\000\000\r\169\000\000\000\000\000\000\r\189\r\169\r\169\000\000\r\169\r\189\r\189\r\189\b\014\000\000\r\189\r\189\000\000\000\000\r\189\r\169\000\000\r\169\000\000\r\189\r\189\r\169\r\169\000\000\r\189\000\000\000\000\r\169\000\000\000\000\000\000\000\000\000\000\r\169\r\169\000\000\r\169\000\000\r\169\000\000\r\169\000\000\000\000\000\000\000\000\000\000\r\169\000\000\b\022\000\000\000\000\000\000\000\000\r\169\r\169\b\030\000\000\r\169\000\000\000\000\000\000\000\000\r\169\r\169\000\000\000\205\r\169\000\000\r\169\005]\000\000\000\000\000\000\000\000\000\000\r\169\005]\000\000\000\000\000\000\r\169\r\169\000\000\000\000\b&\b.\000\000\000\000\000\000\000\000\r\169\002\242\003\026\r\169\r\169\000\000\r\169\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\169\002\250\000\000\000\000\r\169\000\000\000\000\000\205\000\205\r\169\r\169\r\169\000\000\r\169\r\169\r\169\r\169\003\"\000\000\000\000\003\002\000\000\003\018\r\169\000\000\r\197\r\169\000\000\000\000\000\000\r\197\000\000\000\000\r\197\000n\r\197\000\000\r\197\000\000\000\000\000\000\r\169\r\197\r\197\000\000\r\197\r\169\r\169\r\169\003*\000\000\r\169\r\169\000\000\000\000\r\169\r\197\000\000\r\197\000\000\r\169\r\169\r\197\r\197\000\000\r\169\000\000\000\000\r\197\000\000\000\000\000\000\000\000\000\000\r\197\r\197\000\000\r\197\000\000\r\197\000\000\r\197\000\000\000\000\000\000\000\000\000\000\r\197\000\000\0032\000\000\000\000\000\000\000\000\r\197\r\197\003\n\000\000\r\197\000\000\000\000\000\000\000\000\r\197\r\197\000\000\000\181\r\197\000\000\r\197\000\205\000\000\000\000\000\000\000\000\000\000\r\197\000\205\000\000\000\000\000\000\r\197\r\197\000\000\000\000\000\205\003:\000\000\000\000\000\000\000\000\r\197\000\181\000\181\r\197\r\197\000\000\r\197\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\197\002\250\000\000\000\000\r\197\000\000\000\000\000\181\000\181\r\197\r\197\r\197\000\000\r\197\r\197\r\197\r\197\000\181\000\000\000\000\003\002\000\000\003\018\r\197\000\000\b\141\r\197\000\000\000\000\000\000\b\141\000\000\000\000\b\141\000\000\b\141\000\000\b\141\000\000\000\000\000\000\r\197\b\141\b\141\000\000\b\141\r\197\r\197\r\197\000\181\000\000\r\197\r\197\000\000\000\000\r\197\b\141\000\000\b\141\000\000\r\197\r\197\b\141\b\141\000\000\r\197\000\000\000\000\b\141\000\000\000\000\000\000\000\000\000\000\b\141\b\141\000\000\b\141\000\000\b\141\000\000\b\141\000\000\000\000\000\000\000\000\000\000\b\141\000\000\000\181\000\000\000\000\000\000\000\000\b\141\b\141\003\n\000\000\b\141\001\134\000\000\000\000\000\000\b\141\b\141\000\000\000\177\b\141\000\000\b\141\000\181\000\000\000\000\000\000\000\000\000\000\b\141\000\181\000\000\000\000\000\000\b\141\b\141\000\000\000\000\000\181\000\181\000\000\000\000\000\000\000\000\b\141\000\177\000\177\b\141\b\141\000\000\b\141\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\141\002\250\000\000\000\000\b\141\000\000\000\000\000\177\000\177\b\141\b\141\b\141\000\000\b\141\b\141\b\141\b\141\000\177\000\000\000\000\003\002\000\000\003\018\b\141\000\000\r\181\b\141\000\000\000\000\000\000\r\181\000\000\000\000\r\181\000\000\r\181\000\000\r\181\000\000\000\000\000\000\b\141\r\181\r\181\000\000\r\181\b\141\b\141\b\141\000\177\000\000\b\141\b\141\000\000\000\000\b\141\r\181\000\000\r\181\000\000\b\141\b\141\r\181\r\181\000\000\b\141\000\000\000\000\r\181\000\000\000\000\000\000\000\000\000\000\r\181\r\181\000\000\r\181\000\000\r\181\000\000\r\181\000\000\000\000\000\000\000\000\000\000\r\181\000\000\000\177\000\000\000\000\000\000\000\000\r\181\r\181\003\n\000\000\r\181\001\166\000\000\000\000\000\000\r\181\r\181\000\000\000\169\r\181\000\000\r\181\000\177\000\000\000\000\000\000\000\000\000\000\r\181\000\177\000\000\000\000\000\000\r\181\r\181\000\000\000\000\000\177\000\177\000\000\000\000\000\000\000\000\r\181\000\169\000\169\r\181\r\181\000\000\r\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\181\000\169\000\000\000\000\r\181\000\000\000\000\000\169\000\169\r\181\r\181\r\181\000\000\r\181\r\181\r\181\r\181\000\169\000\000\000\000\003\002\000\000\000\169\r\181\000\000\b\153\r\181\000\000\000\000\000\000\b\153\000\000\000\000\b\153\000\000\b\153\000\000\b\153\000\000\000\000\000\000\r\181\b\153\b\153\000\000\b\153\r\181\r\181\r\181\000\169\000\000\r\181\r\181\000\000\000\000\r\181\b\153\000\000\b\153\000\000\r\181\r\181\b\153\b\153\000\000\r\181\000\000\000\000\b\153\000\000\000\000\000\000\000\000\000\000\b\153\b\153\000\000\b\153\000\000\b\153\000\000\b\153\000\000\000\000\000\000\000\000\000\000\b\153\000\000\000\169\000\000\000\000\000\000\000\000\b\153\b\153\003\n\000\000\b\153\n>\000\000\000\000\000\000\b\153\b\153\000\000\000\000\b\153\000\000\b\153\000\169\000\000\000\000\000\000\000\000\000\000\b\153\000\169\000\000\000\000\000\000\b\153\b\153\000\000\000\000\000\169\000\169\000\000\000\000\000\000\000\000\b\153\000\000\000\000\b\153\b\153\000\000\b\153\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\153\000\000\000\000\000\000\b\153\000\000\000\000\000\000\000\000\b\153\b\153\b\153\000\000\b\153\b\153\b\153\b\153\000\000\000\000\000\000\000\000\000\000\000\000\b\153\000\000\000\000\b\153\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\153\000\000\000\000\000\000\000\000\b\153\b\153\b\153\000\000\000\000\b\153\b\153\000\000\000\000\b\153\000\000\000\000\000\000\000\000\b\153\b\153\000\000\000\000\000\000\b\153\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\002\n\000\000\000\000\002\014\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\162\004\146\000\000\002\030\000\000\000\000\005*\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\001\241\000\000\000\000\001\241\000\000\004\206\0022\000\000\000\000\000\000\004\210\001\"\002:\000\000\000\000\005.\004\214\004\218\000\000\000\000\004\222\002J\000\000\000\000\000\000\000\000\001\241\001\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\226\000\000\000\000\001\241\000\000\004\230\000\000\001\241\000\n\001\241\001\241\000\000\000\000\000\000\000\000\000\000\000\000\004\238\000\000\001\241\000\000\000\000\001\241\000\000\001\241\000\000\000\000\000\000\0052\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\242\000\000\000\000\000\000\000\000\000\000\004\250\000\000\000\000\004\t\001\241\000\000\000\000\004\001\000\000\004\254\000\000\004\001\000\000\000\000\005\006\002~\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\004\001\000\000\000\000\000\000\000\000\001\241\005B\000\000\001\241\000\000\000\000\000\000\001\241\000\000\000\000\001\154\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\002\n\000\000\001\241\002\014\004\001\000\000\001\241\001\241\000~\000\000\000\000\000\000\000\000\005J\000\000\004\001\000\000\001\241\001\241\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\162\004\146\000\000\002\030\000\000\000\000\005*\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\000\000\004\001\004\001\000\000\000\000\004\206\0022\000\000\000\000\000\000\004\210\001\"\002:\000\000\000\000\005.\004\214\004\218\000\000\003J\004\222\002J\004\001\004\001\000\000\004\001\000\000\000\000\000\000\000\000\000\000\004\001\004\001\000\000\000\000\015%\004\001\000\000\004\226\000\000\000\000\000\000\000\000\004\230\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\238\000\000\000\000\000\000\000\000\000\000\015%\015%\000\000\000\000\000\000\0052\000\000\000\000\007Z\000\000\000\000\000\000\000\000\000\000\000\000\015%\000\000\000\000\004\242\000\000\000\000\015%\015%\000\000\004\250\007b\000\000\b\185\007n\000\000\000\000\015%\000\000\004\254\015%\000\000\015%\000\000\005\006\002~\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\015%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\001\242\007z\000\190\000\000\000\000\002\n\000\000\000\000\002\014\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015%\000\000\000\000\002\002\000\000\007~\002\006\015%\000\000\000\000\000\000\000\000\002\162\004\146\000\000\002\030\007\134\000\000\005*\000\000\000\000\015%\002&\000\000\002*\000\000\000\000\001\162\015%\000\000\000\000\000\000\000\000\004\206\0022\000\000\015%\015%\004\210\001\"\002:\000\000\000\000\005.\004\214\004\218\000\000\000\000\004\222\002J\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\241\000\000\000\000\000\241\000\000\000\000\000\000\000\000\004\226\000\000\000\000\000\000\000\000\004\230\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\238\000\241\000\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0052\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\000\000\241\000\000\000\241\000\241\004\242\000\000\000\000\000\000\000\000\000\000\004\250\000\000\000\241\002a\000\000\003\002\000\000\003\018\000\000\004\254\000\000\000\000\000\000\000\000\005\006\002~\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\241\000\186\001\146\001\150\000z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\002\n\000\000\000\000\002\014\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\241\000\000\000\000\000\241\000\000\000\000\000\000\003\n\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\162\004\146\000\000\002\030\000\241\000\000\005:\000\000\000\241\000\241\002&\000\000\002*\000\000\000\000\001\162\000\000\000\000\000\000\000\241\000\241\004\206\0022\000\000\000\000\000\000\004\210\001\"\002:\000\000\000\000\005.\004\214\004\218\000\000\000\000\004\222\002J\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\226\000\000\000\000\000\000\000\000\004\230\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000R\000V\000Z\000\146\004\238\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000\000\000\000\004\242\000\000\000\000\000\000\000\000\000\000\004\250\000\000\000\000\b\201\001\154\000\000\000\000\000\000\001\242\004\254\000\190\000\000\000\000\001\246\005\006\002~\001\250\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\026\002\022\000\000\002\030\000\000\000\000\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\000\000\000\000\000\000\000\000\000\000\002.\0022\000\000\000\000\000\000\0026\001\"\002:\000\000\000\000\000\000\002>\002B\000\000\000\000\002F\002J\000\000\000V\004^\000\146\000\000\000\150\000\000\000\154\000\158\004b\000^\000\000\000\170\000\174\000\000\000v\002N\000\182\000\000\000\186\001\146\002R\000z\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002Z\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\000\000\000\000\002^\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000~\000\000\002b\000\000\000\000\000\000\000\000\000\000\002n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\134\000\000\000\000\000\000\000\000\002v\002~\001\149\001\149\001\149\001\149\000\000\001\149\005\233\001\149\001\149\001\149\001\149\001\162\001\149\001\149\000\000\001\149\000\000\001\149\005\233\001\149\001\149\001\149\001\149\000\000\000\000\000\000\000\000\020Z\000\000\005\233\000\000\005\233\000\000\000\000\000\000\005\233\005\233\001\149\001\149\001\149\000\000\005\233\000\000\020^\000\000\000\000\000\000\005\233\000\000\001\149\005\233\000\000\000\000\000\000\005\233\001\149\000\000\000\000\001\149\000\000\005\233\000\000\001\149\000\000\000\000\020j\000\000\000\000\001\149\000\000\000\000\005\233\000\000\000\000\000\000\001\149\005\233\011\006\000\000\000\000\001\149\000\000\005\233\000\000\000\000\000\000\000\000\000\000\000\000\001\149\001\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\233\000\000\000\000\005\233\000\000\000\000\005\233\000\000\001\149\000\000\000\000\001\149\000\000\000\000\001\149\000\000\000\000\000\000\000\000\005\233\000\000\000\000\000\000\000\000\005\233\005\233\005\233\001\149\005\233\005\233\000\000\005\233\001\149\000\000\001\149\000\000\000\000\001\149\005\233\020n\000\000\005\233\000\000\000\000\001\149\000\000\001\149\000\000\000\000\001\149\000\000\000\000\000\000\000\000\000\000\000\000\005\233\000\000\000\000\000\000\000\000\005\233\005\233\000\000\001\149\001\149\000\000\000\000\000\000\001\149\001\149\000\000\000\000\000\000\000R\000V\004^\000\146\000\000\000\150\021B\000\154\000\158\004b\000^\000\000\000\170\000\174\020v\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\020z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\001\154\020\130\000\000\000\000\000\000\020\134\000\000\000\000\000\000\000\000\000\000\020\138\000\000\000\000\000\000\000\000\000\000\024\158\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\n\166\000\000\000\000\000\000\000\000\022:\000\000\000\000\000\000\020\162\023\166\000\000\000\000\011*\000\000\001\162\000\000\000\000\000\000\000\000\011:\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\011B\000\000\012F\000\000\000\000\012J\000\000\000\000\n\210\000\000\000\000\020\166\012^\000\000\020\170\n\001\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\020\174\000\000\000\000\014V\012\162\020\178\000\n\020\182\014&\020\186\020\190\000\000\020\194\002&\000\000\002*\000\000\000\000\000\000\020\198\014.\000\000\020\202\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\000\000\000\000\012\194\012\198\020\206\000\000\012\202\0146\000\000\020\210\020\214\000\000\014:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\000\000\000\000\000\000\014f\012\218\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\011*\000\000\000\000\000\000\012\222\000\000\015v\011:\000\000\000\000\012\230\000\000\000\000\001\242\000\000\000\190\011B\015~\012F\012\234\000\000\012J\011\026\000\000\012\242\002~\000\000\011\030\012^\000\000\000\000\n\001\025z\000\000\011\"\000\000\000\000\002\002\000\000\011&\025~\000\000\000\000\000\000\000\000\000\000\012\182\012\162\000\000\000\000\000\000\014&\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\190\000\000\000\000\014.\000\000\000\000\000\000\012\186\0022\0142\000\000\000\000\012\190\006\238\002:\000\000\016J\000\000\012\194\012\198\000\000\000\000\012\202\0146\000\000\000\000\000\000\000\000\014:\000\000\000\000\000\198\016N\000\000\000\000\000\000\000\000\000\000\000\000\006\254\012\206\000\000\000\000\014>\014B\012\210\014F\000\000\000\n\000\000\014Z\000\000\000\000\011\194\000\000\000\000\014f\012\218\000\202\011\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\015\"\000\000\000\000\000\000\015&\015r\000\000\000\000\000\000\000\000\012\222\000\000\015v\000\000\000\000\000\000\012\230\000\000\000\000\000\000\000\000\000\000\000\n\015~\000\000\012\234\000\000\004\165\000\000\000\000\012\242\002~\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\nm\nm\001\242\000\000\000\190\nm\000\000\012F\000\000\000\000\012J\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\019\218\012\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\001\162\015\201\000\000\000\000\015\201\000\000\012\186\0022\000\000\000\000\000\000\012\190\001\"\002:\000\000\000\000\000\000\012\194\012\198\000\000\012\153\012\202\000\000\000\000\000\000\000\000\000\000\015\201\015\201\000\000\000\000\000\000\015\201\000\000\000\000\015\201\015\201\000\000\006\254\012\206\000\000\000\000\015\201\000\000\012\210\015\201\015\201\000\n\015\201\015\201\000\000\012\153\015\201\000\000\015\201\015\201\012\218\000\000\015\201\000\000\000\000\015\201\000\000\015\201\015\201\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\153\000\000\012\222\000\000\000\000\000\000\000\000\000\000\012\230\000\000\012\153\000\000\015\201\000\000\015\201\000\000\000\000\012\234\000\000\000\000\000\000\000\000\012\242\002~\000\000\015\201\000\000\000\000\000\000\000\000\000\000\000\000\015\201\000\000\000\000\012\153\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\201\015\201\000\000\015\201\015\201\015\201\000\000\015\201\000\000\000\000\000\000\000\000\000\000\000\000\005\t\000\000\015\201\005\t\000\000\000\000\005\t\015\201\000\000\005\t\015\201\000\000\015\201\000\000\000\000\000\000\000\000\000\000\015\201\015\201\015\201\000\000\015\201\015\201\015\201\012\149\005\t\005\t\000\000\000\000\000\000\000\000\005\t\005\t\005\t\005\t\000\000\005\t\000\000\000\000\005\t\005\t\000\000\000\000\000\000\000\000\000\000\005\t\005\t\000\000\005\t\005\t\000\000\005\t\005\t\000\000\012\149\005\t\000\000\005\t\005\t\000\000\005\t\005\t\000\000\000\000\005\t\000\000\005\t\005\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\149\000\000\000\000\000\000\000\000\000\000\005\t\000\000\000\000\000\000\012\149\000\000\005\t\000\000\005\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\t\005\t\000\000\000\000\000\000\000\000\000\000\005\t\000\000\000\000\012\149\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\t\005\t\000\000\000\000\007\141\005\t\005\t\005\t\000\000\005\t\007\141\005\t\000\000\005\t\000\000\000\000\005\t\000\000\000\000\000\000\000\000\005\t\005\t\000\000\005\t\000\000\000\000\005\t\005\t\000\000\005\t\000\000\005\t\000\000\000\000\000\000\005\t\005\t\005\t\005\t\005\t\000\000\005\t\005\t\005\t\012\005\012\005\012\005\012\005\000\000\012\005\000\000\012\005\012\005\012\005\012\005\000\000\012\005\012\005\000\000\012\005\000\000\012\005\000\000\012\005\012\005\012\005\012\005\000\000\000\000\015y\000\000\000\000\015y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\005\012\005\012\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\005\000\000\015y\015y\000\000\000\000\012\005\015y\000\000\021R\002\150\015y\000\000\021Z\000\000\000\000\000\000\015y\000\000\012\005\015y\015y\000\000\015y\015y\000\000\012\005\002\158\000\000\015y\002\178\012\005\000\000\015y\000\000\000\000\015y\000\000\015y\015y\012\005\012\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\012\005\000\000\015y\012\005\015y\000\000\012\005\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015y\000\000\000\000\000\000\012\005\000\000\000\000\004\014\000\000\012\005\000\000\012\005\000\000\000\000\012\005\000\000\000\000\000\000\000\000\000\000\000\000\012\005\000\000\012\005\000\000\000\000\012\005\015y\015y\000\000\015y\015y\004\018\000\000\015y\000\000\000\000\000\000\000\000\000\000\000\000\012\005\012\005\004\026\000\000\000\000\021\174\012\005\015y\000\000\000\000\015y\015y\015y\015y\015y\000\000\000\000\000\000\015y\015y\015y\000\000\015y\015y\015y\015\t\000\000\000\000\015\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\t\015\t\000\000\000\000\000\000\015\t\000\000\000\000\002\150\015\t\000\000\000\000\000\000\000\000\000\000\015\t\000\000\000\000\015\t\015\t\000\000\015\t\015\t\000\000\000\000\002\158\000\000\015\t\002\178\000\000\000\000\015\t\000\000\000\000\015\t\000\000\015\t\015\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\t\000\000\015\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015\t\011\245\011\245\011\245\011\245\000\000\011\245\004\014\011\245\011\245\011\245\011\245\000\000\011\245\011\245\000\000\011\245\000\000\011\245\000\000\011\245\011\245\011\245\011\245\000\000\000\000\000\000\015\t\015\t\000\000\015\t\015\t\004\018\000\000\015\t\000\000\000\000\000\000\011\245\011\245\011\245\000\000\000\000\004\026\000\000\000\000\000\000\000\000\015\t\000\000\011\245\015\t\015\t\015\t\015\t\015\t\011\245\000\000\000\000\015\t\015\t\015\t\000\000\015\t\015\t\015\t\000V\004^\000\146\011\245\000\150\000\000\000\154\000\158\004b\000^\011\245\000\170\000\174\000\000\000v\011\245\000\182\000\000\000\186\001\146\000\000\000z\000\000\000\000\011\245\011\245\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\154\000\000\000\000\000\000\000\000\000\000\001\170\000\000\000\000\000\000\011\245\000\000\000\000\011\245\000\000\000\000\011\245\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\245\000\000\000\000\000\000\000\000\011\245\000\000\011\245\000\000\000\000\011\245\000\000\000\000\000\000\000\000\000\000\000\000\011\245\000\000\011\245\000\000\000\000\011\245\001\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\245\011\245\000\000\000\000\000\000\021V\011\245\011\249\011\249\011\249\011\249\000\000\011\249\000\000\011\249\011\249\011\249\011\249\000\000\011\249\011\249\000\000\011\249\000\000\011\249\000\000\011\249\011\249\011\249\011\249\000\000\000\000\005\017\000\n\000\000\005\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\249\011\249\011\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\249\000\000\005\017\005\017\000\000\000\000\011\249\005\017\000\000\021\178\005\017\005\017\000\000\000\000\000\000\000\000\000\000\005\017\000\000\011\249\005\017\005\017\000\000\005\017\005\017\000\000\011\249\005\017\000\000\005\017\005\017\011\249\000\000\005\017\000\000\000\000\005\017\000\000\005\017\005\017\011\249\011\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\249\000\000\005\017\011\249\005\017\000\000\011\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\017\000\000\000\000\000\000\011\249\000\000\000\000\005\017\000\000\011\249\000\000\011\249\000\000\000\000\011\249\000\000\000\000\000\000\000\000\000\000\000\000\011\249\000\000\011\249\000\000\000\000\011\249\005\017\005\017\000\000\005\017\007\153\005\017\000\000\005\017\000\000\000\000\000\000\000\000\000\000\000\000\011\249\011\249\005\017\000\000\000\000\005\r\011\249\005\017\005\r\000\000\005\017\000\000\005\017\000\000\005\017\000\000\000\000\000\000\005\017\005\017\005\017\000\000\005\017\005\017\005\017\000\000\000\000\000\000\000\000\000\000\000\000\005\r\005\r\000\000\000\000\000\000\005\r\000\000\000\000\005\r\005\r\000\000\000\000\000\000\015=\000\000\005\r\000\000\000\000\005\r\005\r\000\000\005\r\005\r\000\000\000\000\005\r\000\000\005\r\005\r\000\000\000\000\005\r\000\000\000\000\005\r\000\000\005\r\005\r\000\000\015=\015=\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015=\000\000\000\000\000\000\000\000\000\000\015=\015=\000\000\005\r\000\000\005\r\000\000\000\000\004\198\000\000\015=\000\000\000\000\015=\000\000\015=\005\r\000R\000V\004^\000\146\000\000\000\150\005\r\000\154\000\158\004b\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\015=\005\r\005\r\000\000\005\r\007\145\005\r\000\000\005\r\000\000\000\000\000\000\021\186\001\154\021\214\000\000\000\000\005\r\000\000\000\000\000\000\000\000\005\r\000\000\021\226\005\r\000\000\005\r\000\000\005\r\000~\000\000\000\000\005\r\005\r\005\r\000\000\005\r\005\r\005\r\015=\000\000\000\000\021\250\000\000\000\000\000\000\015=\000\000\000\000\n\166\000\000\000\000\000\000\000\000\022:\000\000\000\000\000\000\000\000\000\000\015=\000\000\000\000\022Z\001\162\000\000\000\000\015=\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015=\015=\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\004\170\n\210\000\000\004\174\022f\000\000\000\000\022\190\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\002\022\214\000\000\004\202\000\000\000\000\023\002\000\000\t\233\006\142\006\154\0232\006\178\006\190\006\214\006\218\000\000\000\000\023>\002&\023j\002*\000\000\024j\000\000\000\000\000\000\000\000\000\000\000\000\006\222\0022\000\000\006\226\006\230\006\234\006\238\002:\024v\024\142\000\000\006\242\006\246\000\000\024\154\006\250\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\000\000\011\026\000\000\000\000\007\006\000\000\011\030\000\n\000\000\000\000\000\000\025z\000\000\011\"\000\000\000\000\007\014\000\000\011&\025~\000\000\000\000\000\000\000\000\000\000\006\t\000\000\007\018\000\000\007\"\001\242\000\000\000\190\000\000\000\000\004\170\000\000\000\000\004\174\000\190\007*\000\000\000\000\000\000\000\000\000\000\0072\000\000\000\000\000\000\000\000\000\000\004\025\000\000\002\002\0076\000\000\004\202\000\000\000\000\007>\002~\000\000\006\142\006\154\000\000\006\178\006\190\006\214\006\218\000\198\011\150\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\222\0022\000\000\006\226\006\230\006\234\006\238\002:\011\194\000\000\000\000\006\242\006\246\000\202\011\198\006\250\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\000\000\000\000\000\000\000\000\007\006\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\007\014\000\000\000\000\004\165\000\000\000\000\000\000\000\000\000\000\006\t\000\000\007\018\000\000\007\"\001\242\000\000\000\190\000\000\000\000\004\170\000\000\000\000\004\174\000\000\007*\000\000\000\000\000\000\000\000\000\000\0072\000\000\000\000\000\000\000\000\000\000\t\r\000\000\002\002\0076\000\000\004\202\000\000\000\000\007>\002~\000\000\006\142\006\154\000\000\006\178\006\190\006\214\006\218\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\222\0022\000\000\006\226\006\230\006\234\006\238\002:\000\000\000\000\000\000\006\242\006\246\000\000\000\000\006\250\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\254\007\002\000\000\000\000\000\000\000\000\007\006\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\014\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\t\000\000\007\018\000\000\007\"\001\242\000\000\000\190\000\000\000\000\004\170\000\000\000\000\004\174\000\000\007*\000\000\000\000\000\000\000\000\000\000\0072\000\000\000\000\000\000\000\000\000\000\002\145\000\000\002\002\0076\000\000\004\202\000\000\000\000\007>\002~\000\000\006\142\006\154\000\000\006\178\006\190\006\214\bV\000\000\003\146\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\222\0022\000\000\006\226\006\230\006\234\006\238\002:\000\000\000\000\000\000\006\242\006\246\002\242\003\026\006\250\000\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\000\006\254\007\002\000\213\003\154\000\000\000\000\007\006\000\000\000\000\000\n\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\007\014\000\000\015\145\000\000\000\000\015\145\000\000\000\000\000\000\006\t\000\000\000\000\000\000\007\"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007*\000\000\003*\000\000\015\145\015\145\0072\000\000\000\000\015\145\000\000\000\000\t\029\015\145\000\000\0076\000\000\000\000\000\000\015\145\007>\002~\015\145\015\145\000\000\015\145\015\145\000\000\000\000\000\000\000\000\015\145\000\000\004\198\000\000\015\145\000\000\000\000\015\145\000\000\015\145\015\145\0032\000\000\000\000\000\000\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\213\000\000\000\000\000\000\015\145\000\000\015\145\000\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\162\003:\015\145\000R\000V\000Z\000\146\n\162\000\150\011\026\000\154\000\158\000\162\000^\011\030\000\170\000\174\000\000\000v\025f\000\182\011\"\000\186\001\146\001\150\000z\011&\025j\000\000\015\145\015\145\000\000\015\145\015\145\000\000\000\000\015\145\000\000\000\000\000\000\000\000\001\154\015!\000\000\000\000\015!\000\000\001\170\000\000\000\000\015\145\000\000\000\000\015\145\015\145\015\145\015\145\015\145\000~\000\000\000\000\015\145\015\145\015\145\000\000\015\145\015\145\015\145\015!\015!\000\000\000\000\000\000\015!\000\000\000\000\000\000\015!\001\158\000\000\000\000\000\000\000\000\015!\000\000\000\000\015!\015!\000\000\015!\015!\000\000\000\000\001\162\000\000\015!\000\000\004\198\000\000\015!\000\000\000\000\015!\000\000\015!\015!\000\000\000\000\000\000\000\000\000\000\000\000\011V\011Z\000\000\n\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015!\000\000\015!\000\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\000\000\000\000\015!\004\145\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\001\011^\015!\015!\000\000\015!\015!\000\000\000\000\015!\000\000\006\001\000\000\000\000\000\000\015]\006\001\000\000\015]\000\000\000\000\000\000\000\000\015!\000\000\000\000\015!\015!\015!\015!\015!\000\000\000\000\000\000\015!\015!\015!\000\000\015!\015!\015!\015]\015]\000\000\000\000\000\000\015]\000\000\000\000\r\n\015]\000\000\000\000\000\000\000\000\000\000\015]\000\000\000\000\015]\015]\000\000\015]\015]\000\000\000\000\r\018\000\000\015]\r\030\000\000\000\000\015]\000\000\000\000\015]\000\000\015]\015]\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\225\000\000\000\000\001\225\000\000\000\000\000\000\000\000\000\000\015]\000\000\015]\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015]\000\000\000\000\000\000\001\225\001\225\000\000\r*\000\000\001\225\000\000\000\000\000\000\001\225\000\000\000\000\000\000\000\000\000\000\001\225\000\000\000\000\001\225\001\225\000\000\001\225\001\225\015]\015]\000\000\015]\001\225\r.\000\000\015]\001\225\000\000\000\000\001\225\000\000\001\225\001\225\000\000\r6\001\225\000\000\000\000\000\000\000\000\000\000\000\000\015]\000\000\015]\000\000\000\000\000\000\000\000\000\000\015]\015]\015]\000\000\015]\015]\015]\000\000\001\225\001\225\001\225\000\000\000\000\001\225\000\000\000\000\000\000\001\225\000\000\000\000\000\000\001\225\000\000\001\225\000\000\000\000\001\225\001\225\000\000\001\225\001\225\000\000\000\000\000\000\000\000\001\225\000\000\000\000\000\000\001\225\000\000\000\000\001\225\000\000\001\225\001\225\000\000\000\000\001\225\002\186\000\000\001\225\001\225\000\000\000\000\001\225\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\225\000\000\001\225\001\225\001\225\001\225\001\225\000\000\000\000\000\000\000\000\003\254\001\225\001\225\000\000\001\225\001\225\001\225\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\225\002\194\000\000\001\225\001\225\000\000\000\000\001\225\000\000\000\000\000\000\000\000\000\000\001i\000\000\000\000\001i\000\000\000\000\000\000\000\000\001\225\000\000\000\000\001\225\001\225\001\225\001\225\000\000\000\000\000\000\000\000\003\242\001\225\001\225\000\000\001\225\001\225\001\225\001i\001i\000\000\000\000\000\000\001i\000\000\000\000\000\000\001i\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001i\001i\000\000\001i\001i\000\000\000\000\000\000\000\000\001i\000\000\000\000\000\000\001i\000\000\000\000\003\002\000\000\003\018\001i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001i\000\000\001i\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001i\003\249\003\249\003\249\003\249\000\000\003\249\000\000\003\249\003\249\003\249\003\249\000\000\003\249\003\249\000\000\003\249\000\000\003\249\000\000\003\249\003\249\003\249\003\249\000\000\000\000\000\000\001i\000\000\000\000\001i\001i\000\000\001\210\003\n\000\000\000\000\000\000\000\000\003\249\001]\000\000\000\000\001]\000\000\003\249\000\000\000\000\001i\000\000\000\000\001i\001i\001i\001i\001i\003\249\000\000\000\000\000\000\001i\001i\000\000\001i\001i\001i\001]\001]\000\000\000\000\000\000\001]\000\000\000\000\000\000\001]\003\249\000\000\000\000\000\000\000\000\001]\003\249\000\000\001]\001]\000\000\001]\001]\000\000\000\000\003\249\000\000\001]\000\000\000\000\000\000\001]\000\000\000\000\003\002\000\000\001]\001]\000\000\003\249\003\249\000\000\000\000\000\000\000\000\000\000\000\000\003\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001]\000\000\001]\000\000\000\000\000\000\000\000\000\000\000\000\003\249\000\000\000\000\000\000\001]\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\001]\000\000\000\000\001]\001]\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\001a\003\249\000\000\001a\000\000\001\170\000\000\000\000\001]\000\000\000\000\001]\001]\001]\001]\001]\000~\000\000\000\000\000\000\001]\001]\000\000\001]\001]\001]\001a\001a\000\000\000\000\000\000\001a\000\000\000\000\000\000\001a\001\174\000\000\000\000\000\000\000\000\001a\001\202\000\000\001a\001a\000\000\001a\001a\000\000\000\000\001\162\000\000\001a\000\000\000\000\000\000\001a\000\000\000\000\003\002\000\000\001a\001a\000\000\001\178\001\182\000\000\000\000\000\000\000\000\000\000\000\000\001\186\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001a\000\000\001a\000\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\000\000\000\000\001a\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001a\000\000\000\000\001a\001a\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\001e\014I\000\000\001e\000\000\000\000\000\000\000\000\001a\000\000\000\000\001a\001a\001a\001a\001a\000\000\000\000\000\000\000\000\001a\001a\000\000\001a\001a\001a\001e\001e\000\000\000\000\000\000\001e\000\000\000\000\000\000\001e\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001e\001e\000\000\001e\001e\000\000\000\000\000\000\000\000\001e\000\000\000\000\000\000\001e\000\000\000\000\003\002\000\000\003\018\001e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001e\000\000\001e\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001e\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\001e\000\000\000\000\001e\001e\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\001u\000\000\000\000\001u\000\000\001\170\000\000\000\000\001e\000\000\000\000\001e\001e\001e\001e\001e\000~\000\000\000\000\000\000\001e\001e\000\000\001e\001e\001e\002\242\003\026\000\000\000\000\000\000\001u\000\000\000\000\000\000\001u\001\174\000\000\000\000\000\000\000\000\002\250\001\202\000\000\001u\001u\000\000\001u\001u\000\000\000\000\001\162\000\000\001u\000\000\000\000\000\000\001u\000\000\000\000\003\002\000\000\003\018\001u\000\000\001\178\001\182\000\000\000\000\000\000\000\000\000\000\000\000\001\186\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\001u\000\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\000\000\000\000\001u\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\206\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001u\000\000\000\000\001u\001u\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\001m\002\197\000\000\001m\000\000\000\000\000\000\000\000\001u\000\000\000\000\001u\001u\001u\001u\001u\000\000\000\000\000\000\000\000\001u\001u\000\000\001u\001u\001u\002\242\003\026\000\000\000\000\000\000\001m\000\000\000\000\000\000\001m\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001m\001m\000\000\001m\001m\000\000\000\000\000\000\000\000\001m\000\000\000\000\000\000\001m\000\000\000\000\003\002\000\000\003\018\001m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001m\000\000\001m\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001m\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\001m\000\000\000\000\001m\001m\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\001q\000\000\000\000\001q\000\000\001\170\000\000\000\000\001m\000\000\000\000\001m\001m\001m\001m\001m\000~\000\000\000\000\000\000\001m\001m\000\000\001m\001m\001m\002\242\003\026\000\000\000\000\000\000\001q\000\000\000\000\000\000\001q\001\174\000\000\000\000\000\000\000\000\002\250\001\202\000\000\001q\001q\000\000\001q\001q\000\000\000\000\001\162\000\000\001q\000\000\000\000\000\000\001q\000\000\000\000\003\002\000\000\003\018\001q\000\000\001\178\001\182\000\000\000\000\000\000\000\000\000\000\000\000\001\186\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\001q\000\000\000\000\000\000\000\000\000\000\000\000\000\n\000\000\000\000\000\000\001q\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\001q\000\000\000\000\001q\001q\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\001y\002\189\000\000\001y\000\000\000\000\000\000\000\000\001q\000\000\000\000\001q\001q\001q\001q\001q\000~\000\000\000\000\000\000\001q\001q\000\000\001q\001q\001q\002\242\003\026\000\000\000\000\000\000\001y\000\000\000\000\000\000\001y\001\158\000\000\000\000\000\000\000\000\002\250\tf\000\000\001y\001y\000\000\001y\001y\000\000\000\000\001\162\000\000\001y\000\000\tj\tn\003\"\000\000\000\000\003\002\000\000\003\018\001y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\001y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\tv\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001y\001y\000\000\000\000\003\n\000\000\000\000\000\000\004)\000\000\001\129\000\000\000\000\001\129\000\000\000\000\000\000\000\000\001y\000\000\000\000\001y\001y\001y\001y\001y\000\000\000\000\000\000\000\000\001y\001y\000\000\001y\001y\001y\002\242\003\026\000\000\000\000\000\000\001\129\000\000\000\000\000\000\001\129\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001\129\001\129\000\000\001\129\001\129\000\000\000\000\000\000\000\000\001\129\000\000\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\001\129\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\129\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\0032\000\000\000\000\001\129\001\129\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\003\146\000\000\000\000\001}\000\000\000\000\000\000\000\000\001\129\000\000\000\000\001\129\001\129\001\129\001\129\001\129\000~\000\000\000\000\000\000\001\129\001\129\000\000\001\129\003:\001\129\002\242\003\026\000\000\000\000\000\000\001}\000\000\000\000\000\000\001}\001\158\000\000\000\000\000\000\000\000\002\250\tf\000\000\001}\001}\000\000\001}\001}\000\000\000\000\001\162\000\000\001}\000\000\tj\tn\003\"\000\000\000\000\003\002\000\000\003\018\001}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\001}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001}\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\tv\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001}\001}\000\000\000\000\003\n\000\000\000\000\000\000\tE\000\000\003\146\000\000\000\000\001\133\000\000\000\000\000\000\000\000\001}\000\000\000\000\001}\001}\001}\001}\001}\000\000\000\000\000\000\000\000\001}\001}\000\000\001}\003:\001}\002\242\003\026\000\000\000\000\000\000\001\133\000\000\000\000\000\000\001\133\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001\133\001\133\000\000\001\133\003\154\000\237\000\000\000\000\000\237\001\133\000\000\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\237\000\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\002\250\001\133\000\000\000\000\000\237\000\000\000\237\000\237\000\000\000\000\000\000\000\000\001\133\000\000\000\000\000\000\000\237\000\000\000\000\003\002\002\213\003\018\000\000\000\000\000^\002\213\000\000\000f\000\000\000v\002\213\000\000\002\213\000\000\000\000\000\000\000z\002\213\002\213\0032\000\000\000\000\001\133\001\133\000\000\000\000\003\n\000\000\000\237\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\213\000\000\001\133\000\000\000\000\001\133\001\133\001\133\001\133\001\133\000\000\000~\002\213\000\000\001\133\001\133\002\213\001\133\003:\001\133\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\237\002\213\002\213\000\237\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\000\000\002\213\000\000\000\138\000\000\000\000\000\000\000\000\000\237\000\000\002\213\000\000\000\237\000\237\000\000\002\213\002\213\000\000\000\000\000\000\000\000\000\000\000\000\000\237\000\237\002\213\000\000\002\209\000\000\002\213\000\000\000^\002\209\000\000\000f\000\000\000v\002\209\000\000\002\209\002\213\000\000\000\000\000z\002\209\002\209\000\000\000\000\000\000\000\000\002\213\000\000\000\000\000\000\000\000\002\213\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\209\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000~\002\209\000\000\000\000\000\000\002\209\000\000\000\000\000\000\000\000\000\000\000\000\002\213\000\000\000\000\002\213\002\213\000\000\000\000\002\213\002\209\002\209\000\000\002\230\002\213\002\213\003B\000\000\000\000\002\213\000\000\000\000\000\000\002\209\000\000\000\138\000\000\000\000\000\000\000\000\000\000\000\000\002\209\000\000\000\000\000\000\000\000\002\209\002\209\003r\003z\003\146\000\000\000\000\002=\000\000\000\000\002\209\002=\000\000\000\000\002\209\000\000\000\000\003\130\000\000\000\000\002=\002=\000\193\003\138\003\170\002\209\000\000\000\000\000\000\002=\002\242\003\026\000\000\003\178\000\000\002\209\003\186\000\000\003\194\002=\002\209\000\000\000\000\000\000\000\000\002\250\000\000\000\000\002\242\003\026\000\000\000\201\000\201\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\"\000\000\002\250\003\002\003\202\003\018\002=\000\000\000\193\000\193\000\000\000\000\002\209\000\000\000\000\002\209\002\209\002=\000\193\002\209\000\000\003\002\000\000\003\018\002\209\002\209\000\000\000\000\000\000\002\209\000\000\000\000\003*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\210\000\000\000\000\002=\002=\000\000\003*\003\218\000\000\000\000\000\000\000\000\000\000\000\145\000\000\000\000\000\145\000\000\000\000\000\000\000\000\002=\000\000\000\000\002=\002=\002=\002=\0032\000\000\000\000\000\000\000\000\002=\002=\003\n\003\226\003\234\002=\002\242\003\026\000\000\000\000\000\000\000\145\000\000\000\193\000\000\000\145\000\201\000\000\000\000\000\000\003\n\002\250\000\000\000\201\000\145\000\145\000\000\000\145\000\145\000\000\000\000\000\201\003:\000\145\000\193\000\000\000\000\003\"\000\000\000\000\003\002\000\193\003\018\000\145\000\000\000\000\000\000\000\000\000y\000\193\000\193\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\145\000\000\000\000\000y\000y\000\000\000\000\000\000\000y\000\000\000\000\000\145\000y\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000y\000y\000\000\000y\000y\000\000\000\000\000\000\000\000\000y\000\000\000\000\000\000\000y\000\000\000\000\003\002\0032\003\018\000y\000\145\000\145\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\145\000\000\000\000\000\145\000\145\000\145\000\145\000y\000\000\000y\000\000\000\000\000\145\000\145\000\000\000\145\003:\000\145\000\000\000\000\000y\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000y\000\000\000\000\000y\000y\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\000u\000\000\000\000\000u\000\000\000\000\000\000\000\000\000y\000\000\000\000\000y\000y\000y\000y\000\000\000~\000\000\000\000\000\000\000y\000y\000\000\000y\000y\000y\000u\000u\000\000\000\000\000\000\000u\000\000\000\000\000\000\000u\001\158\000\000\000\000\000\000\000\000\002\250\tf\000\000\000u\000u\000\000\000u\000u\000\000\000\000\001\162\000\000\000u\000\000\tj\tn\000u\000\000\000\000\003\002\000\000\003\018\000u\000\000\000\000\000\000\000\000\000m\000\000\000\000\000m\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000u\000\000\000u\000\000\000\000\000m\000m\000\000\000\000\000\000\000m\000\000\000\000\000u\000m\000\000\000\000\000\000\000\000\000\000\000m\000\000\000\000\000m\000m\000\000\000m\000m\000\000\tv\000\000\000\000\000m\000\000\000\000\000\000\000m\000\000\000\000\003\002\000u\000m\000m\000u\000u\000\000\000\000\003\n\000\000\000\000\000\000\002\177\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000u\000\000\000\000\000u\000u\000u\000u\000m\000\000\000m\000\000\000\000\000u\000u\000\000\000u\000u\000u\000\000\000\000\000m\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000m\000\000\000\000\000m\000m\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\003\146\000\000\000\000\000\153\000\000\000\000\000\000\000\000\000m\000\000\000\000\000m\000m\000m\000m\000\000\000~\000\000\000\000\000\000\000m\000m\000\000\000m\000m\000m\002\242\003\026\000\000\000\000\000\000\000\153\000\000\000\000\000\000\000\153\001\158\000\000\000\000\000\000\000\000\002\250\026\"\000\000\000\153\000\153\000\000\000\153\003\154\000\000\000\000\001\162\000\000\000\153\000\000\026&\tn\003\"\000\000\000\000\003\002\000\000\003\018\000\153\000\000\000\000\000\000\000\000\003\146\000\000\000\000\000\141\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\153\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\141\000\000\000\000\000\153\000\141\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\141\000\141\000\000\000\141\000\141\000\000\026*\000\000\000\000\000\141\000\000\000\000\000\000\003\"\000\000\000\000\003\002\0032\003\018\000\141\000\153\000\153\000\000\000\000\003\n\000\000\000\000\000\000\004!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\153\000\000\000\000\000\153\000\153\000\153\000\153\003*\000\000\000\141\000\000\000\000\000\153\000\153\000\000\003\162\003:\000\153\000\000\000\000\000\141\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\0032\000\000\000\000\000\141\000\141\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\000\133\000\000\000\000\000\133\000\000\000\000\000\000\000\000\000\141\000\000\000\000\000\141\000\141\000\141\000\141\000\000\000~\000\000\000\000\000\000\000\141\000\141\000\000\000\141\003:\000\141\002\242\003\026\000\000\000\000\000\000\000\133\000\000\000\000\000\000\000\133\001\158\000\000\000\000\000\000\000\000\002\250\026\"\000\000\000\133\000\133\000\000\000\133\000\133\000\000\000\000\001\162\000\000\000\133\000\000\026&\tn\000\133\000\000\000\000\003\002\000\000\003\018\000\133\000\000\000\000\000\000\000\000\000q\000\000\000\000\000q\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\133\000\000\000\000\000q\000q\000\000\000\000\000\000\000q\000\000\000\000\000\133\000q\000\000\000\000\000\000\000\000\000\000\000q\000\000\000\000\000q\000q\000\000\000q\000q\000\000\026*\000\000\000\000\000q\000\000\000\000\000\000\000q\000\000\000\000\003\002\000\133\000q\000q\000\133\000\133\000\000\000\000\003\n\000\000\000\000\000\000\t)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\133\000\000\000\000\000\133\000\133\000\133\000\133\000q\000\000\000q\000\000\000\000\000\133\000\133\000\000\000\133\000\133\000\133\000\000\000\000\000q\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000q\000\000\000\000\000q\000q\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\000}\000\000\000\000\000}\000\000\000\000\000\000\000\000\000q\000\000\000\000\000q\000q\000q\000q\000\000\000~\000\000\000\000\000\000\000q\000q\000\000\000q\000q\000q\002\242\003\026\000\000\000\000\000\000\000}\000\000\000\000\000\000\000}\001\158\000\000\000\000\000\000\000\000\002\250\026\"\000\000\000}\000}\000\000\000}\000}\000\000\000\000\001\162\000\000\000}\000\000\026&\tn\000}\000\000\000\000\003\002\000\000\003\018\000}\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\129\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000}\000\000\000}\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\129\000\000\000\000\000}\000\129\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\129\000\129\000\000\000\129\000\129\000\000\026*\000\000\000\000\000\129\000\000\000\000\000\000\000\129\000\000\000\000\003\002\000}\003\018\000\129\000}\000}\000\000\000\000\003\n\000\000\000\000\000\000\002\161\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000}\000\000\000\000\000}\000}\000}\000}\003*\000\000\000\129\000\000\000\000\000}\000}\000\000\000}\000}\000}\000\000\000\000\000\129\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\000\000\000\170\000\174\000\000\000v\000\000\000\182\000\000\000\186\001\146\001\150\000z\000\000\000\000\000\000\000\129\000\000\000\000\000\129\000\129\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\154\003\146\000\000\000\000\000\149\000\000\000\000\000\000\000\000\000\129\000\000\000\000\000\129\000\129\000\129\000\129\000\000\000~\000\000\000\000\000\000\000\129\000\129\000\000\000\129\000\129\000\129\002\242\003\026\000\000\000\000\000\000\000\149\000\000\000\000\000\000\000\149\001\158\000\000\000\000\000\000\000\000\002\250\t~\000\000\000\149\000\149\000\000\000\149\003\154\000\000\000\000\001\162\000\000\000\149\000\000\tj\tn\003\"\000\000\000\000\003\002\000\000\003\018\000\149\000\000\000\000\000\000\000\000\000\137\000\000\000\000\000\137\000\000\tr\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003*\000\000\000\149\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\137\000\000\000\000\000\149\000\137\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\137\000\137\000\000\000\137\000\137\000\000\000\000\000\000\000\000\000\137\000\000\000\000\000\000\003\"\000\000\000\000\003\002\0032\003\018\000\137\000\149\000\149\000\000\000\000\003\n\000\000\000\000\000\000\tU\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\149\000\000\000\000\000\149\000\149\000\149\000\149\003*\000\000\000\137\000\000\000\000\000\149\000\149\000\000\000\149\003:\000\149\000\000\000\000\000\137\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\r\185\0032\000\000\000\000\000\137\000\137\000\000\000\000\003\n\000\000\000\000\r\185\000\000\r\185\012\t\012\t\000\000\r\185\000\000\000\000\012\t\000\000\000\137\r\185\000\173\000\137\000\137\000\137\000\137\r\185\000\000\000\000\r\185\000\000\000\137\000\137\r\185\000\137\000\137\000\137\000\000\000\000\r\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\173\000\173\000\000\r\185\000\000\000\000\012\t\000\000\r\185\r\185\000\000\000\000\000\000\000\000\000\000\000\173\000\000\000\000\000\000\000\000\000\000\000\173\000\173\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\173\000\000\000\000\003\002\000\000\000\173\012\t\000\000\r\185\000\000\000\000\r\185\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\250\r\185\000\000\000\000\000\000\000\000\r\185\r\185\r\185\000\173\r\185\r\185\000\000\r\185\000\000\000\000\002\002\000\000\000\000\002\006\r\185\000\000\000\000\r\185\000\000\002\018\002\022\000\000\002\030\000\000\007\030\000\000\000\000\000\000\000\000\002&\000\000\002*\r\185\000\000\000\000\000\000\000\000\r\185\r\185\012\t\002.\0022\000\000\000\173\br\0026\001\"\002:\000\000\000\000\003\n\002>\002B\000\000\000\000\002F\002J\000\000\000\000\000\000\000\000\000\000\015u\000\000\000\173\015u\000\000\000\000\000\000\000\000\000\000\000\173\000\000\002N\000\000\000\000\000\000\000\000\002R\000\173\000\173\000\n\000\000\000\000\000\000\000\000\000\000\000\000\015u\015u\002Z\000\000\000\000\015u\000\000\000\000\000\000\015u\000\000\000\000\000\000\002^\t\249\015u\000\000\000\000\015u\015u\000\000\015u\015u\000\000\000\000\000\000\002b\015u\000\000\004\198\000\000\015u\002n\000\000\015u\t\249\015u\015u\000\000\000\000\000\000\002\134\000\000\000\000\000\000\000\000\002v\002~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015u\000\000\015u\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015u\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\250\000\000\000\000\000\000\000\000\000\000\000\000\015u\015u\000\000\015u\000\000\000\000\000\000\015u\000\000\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\018\002\022\000\000\002\030\000\000\004\198\015u\000\000\015u\000\000\002&\000\000\002*\000\000\015u\015u\015u\000\000\015u\015u\015u\002.\0022\000\000\000\000\000\000\0026\001\"\002:\000\000\000\000\000\000\002>\002B\000\000\000\000\002F\002J\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\250\000\000\000\000\002N\000\000\000\000\000\000\000\000\002R\000\000\012b\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\002\022\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002b\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\t\249\000\000\002>\002B\002\134\000\000\002F\002J\000\000\002v\002~\000\000\000\000\001\249\000\000\000\000\001\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002N\000\000\000\000\000\000\000\000\002R\000\000\000\000\000\n\000\000\000\000\000\000\000\000\000\000\000\000\001\249\001\249\002Z\000\000\000\000\001\249\000\000\000\000\000\000\001\249\000\000\000\000\000\000\002^\000\000\001\249\000\000\000\000\001\249\001\249\000\000\001\249\001\249\000\000\000\000\000\000\002b\001\249\000\000\000\000\000\000\001\249\002n\000\000\001\249\000\000\001\249\001\249\000\000\000\000\000\000\002\134\000\000\000\000\000\000\000\000\002v\002~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\249\000\000\001\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\250\000\000\000\000\000\000\000\000\000\000\001\249\rJ\000\000\001\249\t\249\000\000\000\000\001\249\000\000\000\000\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\000\000\002\018\002\022\000\000\002\030\000\000\001\249\000\000\001\249\000\000\000\000\002&\000\000\002*\rR\001\249\001\249\000\000\001\249\001\249\001\249\000\000\002.\0022\000\000\000\000\000\000\0026\001\"\002:\000\000\000\000\000\000\002>\002B\000\000\000\000\002F\002J\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\250\000\000\000\000\002N\000\000\000\000\000\000\000\000\002R\000\000\018\202\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\002\022\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002b\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\000\000\000\000\002>\002B\002\134\000\000\002F\002J\000\000\002v\002~\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\002N\000\000\000\000\000\000\000\000\002R\000\000\000\000\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\t\030\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002b\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\000\000\000\000\002>\002B\002\134\000\000\002F\002J\000\000\002v\002~\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\002N\000\000\000\000\000\000\000\000\002f\000\000\000\000\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\t\014\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002j\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\000\000\000\000\002>\002B\002r\000\000\002F\002J\000\000\002v\002~\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\002N\000\000\000\000\000\000\000\000\002f\000\000\000\000\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\b\246\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002j\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\000\000\000\000\002>\002B\002r\000\000\002F\002J\000\000\002v\002~\000\000\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\002N\000\000\000\000\000\000\000\000\002f\000\000\000\000\000\n\000\000\000\000\000\000\000\000\002\002\000\000\000\000\002\006\002Z\000\000\000\000\000\000\000\000\002\018\002V\000\000\002\030\000\000\000\000\002^\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\002j\000\000\002.\0022\000\000\000\000\002n\0026\001\"\002:\000\000\000\000\000\000\002>\002B\002r\000\000\002F\002J\000\000\002v\002~\000\000\000R\000\000\000\000\000\000\000\000\000\000\007\245\020v\000\000\000\000\000\000\007\245\002N\000\000\000\000\000\000\007\245\002f\007\245\020z\000\n\001\150\000\000\007\245\007\245\000\000\022\006\000\000\000\000\002Z\020~\000\000\020\130\000\000\000\000\000\000\020\134\000\000\000\000\000\000\002^\000\000\020\138\000\000\007\245\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\000\002j\000\000\020\154\007\245\000\000\000\000\002n\007\245\020\158\000\000\000\000\000\000\000\000\000\000\000\000\002r\000\000\000\000\000\000\022\002\002v\002~\007\245\007\245\020\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\245\000\000\000\000\007\245\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\007\245\000\000\000\000\000\000\000\000\007\245\007\245\000\000\000\000\0121\000\000\020\166\000\000\000\000\020\170\007\245\000\000\000\000\000\000\007\245\000\000\000\000\000\000\000\000\000\000\022\018\000\000\020\174\000\000\000\000\007\245\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\007\245\000\000\000\000\000\000\000\000\007\245\020\198\000\000\000\000\020\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\020\206\002\n\000\000\000\000\002\014\020\210\020\214\0121\000\000\000\000\000\000\000\000\000\000\000\000\007\245\000\000\000\000\007\245\007\245\000\000\002\002\007\245\000\000\002\006\000\000\000\000\007\245\007\245\000\000\002\"\004\146\007\245\002\030\000\000\004\166\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\206\0022\000\000\000\000\000\000\004\210\001\"\002:\000\185\000\000\000\000\004\214\004\218\000\000\000\000\004\222\002J\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\000\000\000\000\000\000\000\000\004\226\002\242\003\026\000\000\000\000\004\230\000\000\000\000\000\n\002\002\000\000\000\000\002\006\000\000\000\000\000\000\002\250\004\238\002\018\004\178\000\000\002\030\000\185\000\185\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\185\000\000\000\000\003\002\000\000\003\018\000\000\002.\0022\004\242\000\000\000\000\0026\001\"\002:\004\250\000\000\000\000\002>\002B\000\000\000\000\002F\002J\004\254\000\000\000\000\000\000\000\000\005\006\002~\000\000\000\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002N\000\000\000\000\000\000\000\000\002f\000\000\000\000\000\n\000\000\000\000\006j\000\000\000\000\000\000\000\000\000\000\002Z\000\000\000\000\000\000\003\225\000\000\003\225\000\000\000\000\003\225\000\000\002^\003\225\000\000\000\000\000\185\000\000\000\000\000\000\000\000\000\000\000\000\003\n\000\000\002j\000\000\000\000\000\000\003\225\000\000\002n\003\225\000\000\000\000\000\000\000\000\000\185\003\225\003\225\002r\003\225\000\000\000\000\000\185\002v\002~\000\000\003\225\000\000\003\225\000\000\000\185\000\185\000\000\000\000\000\000\000\000\000\000\003\225\003\225\000\000\000\000\000\000\003\225\003\225\003\225\000\000\000\000\000\000\003\225\003\225\000\000\000\000\003\225\003\225\000\000\001\242\000\000\000\190\000\000\000\000\001\246\000\000\000\000\001\254\000\000\000\000\000\000\000\000\000\000\000\000\003\225\000\000\000\000\000\000\000\000\003\225\000\000\000\000\003\225\002\002\000\000\000\000\002\006\000\000\000\000\000\000\000\000\003\225\002\018\012N\000\000\002\030\000\000\000\000\000\000\000\000\000\000\000\000\002&\000\000\002*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002.\0022\003\225\000\000\000\000\0026\001\"\002:\003\225\000\000\000\000\002>\002B\000\000\000\000\002F\002J\003\225\000\000\000\000\000\000\000\000\003\225\003\225\000\000\000\000\000\000\000\000\020v\000\000\000\000\000\000\000\000\002N\000\000\000\000\000\000\000\000\002f\000\000\020z\000\n\000\000\000\000\000\000\000\000\000\000\023\006\000\000\000\000\002Z\020~\000\000\020\130\012]\012]\000\000\020\134\000\000\000\000\000\000\002^\000\000\020\138\000\000\000\000\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\189\002j\000\000\020\154\000\000\000\000\000\000\002n\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\002r\000\000\000\000\000\000\020v\002v\002~\012]\000\000\020\162\002\242\003\026\000\000\000\000\000\000\000\000\020z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\250\000\000\020~\000\000\020\130\000\000\000\189\000\189\020\134\000\000\000\000\0121\000\000\012]\020\138\020\166\000\189\000\000\020\170\003\002\020\142\003\018\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\000\000\020\174\000\000\020\158\000\000\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\023\130\022\150\000\000\0121\003*\020\162\020\198\000\000\000\000\020\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\206\000\000\000\000\000\000\000\000\020\210\020\214\012]\000\000\000\000\0121\000\000\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\000\189\000\000\000\000\000\000\000\000\000\000\000\000\003\n\020\174\000\000\000\000\000\000\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\000\189\r~\000\000\000\000\r\134\000\000\020\198\000\189\000\000\020\202\000\000\000\000\000\000\000\000\000\000\000\189\000\189\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\206\000\000\000\000\r\150\r\158\020\210\020\214\0121\002M\000\000\000\000\000\000\002M\000\000\000\000\000\000\000\000\000\000\r\166\000\000\000\000\002M\002M\000\000\r\174\r\182\000\000\000\000\000\000\001E\002M\000\000\001E\000\000\r\190\000\000\000\000\r\198\000\000\r\206\002M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\001E\000\000\000\000\000\000\001E\000\000\r\214\000\000\002M\000\000\002\250\000\000\000\000\001E\001E\000\000\001E\001E\000\000\002M\000\000\000\000\001E\000\000\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001E\000\000\000\000\000R\000V\000Z\000\146\000\000\000\150\000\000\000\154\000\158\000\162\000^\r\222\000\170\000\174\002M\000v\000\000\000\182\r\230\000\186\001\146\001\150\000z\003*\000\000\001E\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002M\001E\002M\001\154\000\000\000\000\000\000\000\000\000\000\002M\002M\000\000\r\238\r\246\002M\000\000\000\000\000\000\000\000\000\000\000~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001E\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001\158\001-\000\000\000\000\001-\000\000\0262\000\000\000\000\000\000\000\000\000\000\001E\000\000\001E\001\162\000\000\000\000\000\000\026&\tn\001E\001E\000\000\001E\003:\001E\001-\001-\000\000\000\000\000\000\001-\000\000\000\000\000\000\001-\tr\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001-\001-\000\000\001-\001-\000\000\000\000\000\000\001)\001-\000\000\001)\000\000\001-\000\000\000\000\003\002\000\000\003\018\001-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001)\001)\000\000\000\000\000\000\001)\000\000\000\000\000\000\001)\000\000\001-\000\000\001-\000\000\002\250\000\000\000\000\001)\001)\000\000\001)\001)\000\000\001-\t9\000\000\001)\000\000\000\000\000\000\001)\000\000\000\000\003\002\000\000\003\018\001)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001-\000\000\000\000\001-\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\001)\000\000\001)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001-\001)\001-\000\000\000\000\000\000\000\000\000\000\000\000\001-\001-\000\000\001-\001-\001-\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001)\000\000\000\000\001)\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\001!\000\000\000\000\001!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001)\000\000\001)\000\000\000\000\000\000\000\000\000\000\000\000\001)\001)\000\000\001)\001)\001)\001!\001!\000\000\000\000\000\000\001!\000\000\000\000\000\000\001!\000\000\000\000\000\000\000\000\000\000\001!\000\000\000\000\001!\001!\000\000\001!\001!\000\000\000\000\000\000\003\146\001!\000\000\001M\000\000\001!\000\000\000\000\003\002\000\000\001!\001!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\001M\000\000\000\000\000\000\001M\000\000\001!\000\000\001!\000\000\002\250\000\000\000\000\001M\001M\000\000\001M\003\154\000\000\001!\000\000\000\000\001M\000\000\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001!\000\000\000\000\001!\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\003*\000\000\001M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001!\001M\001!\000\000\000\000\000\000\000\000\000\000\000\000\001!\001!\000\000\001!\001!\001!\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001M\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\003\146\000\000\000\000\001A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001M\000\000\001M\000\000\000\000\000\000\000\000\000\000\000\000\001M\001M\000\000\003\162\003:\001M\002\242\003\026\000\000\000\000\000\000\001A\000\000\000\000\000\000\001A\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\001A\001A\000\000\001A\001A\000\000\000\000\000\000\0019\001A\000\000\0019\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\0019\000\000\000\000\000\000\0019\000\000\003*\000\000\001A\000\000\002\250\000\000\000\000\0019\0019\000\000\0019\0019\000\000\001A\000\000\000\000\0019\000\000\000\000\000\000\0019\000\000\000\000\003\002\000\000\003\018\0019\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001A\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\003*\000\000\0019\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001A\0019\001A\000\000\000\000\000\000\000\000\000\000\000\000\001A\001A\000\000\001A\003:\001A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0019\000\000\000\000\0019\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\001%\000\000\000\000\001%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0019\000\000\0019\000\000\000\000\000\000\000\000\000\000\000\000\0019\0019\000\000\0019\0019\0019\001%\001%\000\000\000\000\000\000\001%\000\000\000\000\000\000\001%\000\000\000\000\000\000\000\000\000\000\001%\000\000\000\000\001%\001%\000\000\001%\001%\000\000\000\000\000\000\0011\001%\000\000\0011\000\000\001%\000\000\000\000\003\002\000\000\001%\001%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\0011\000\000\000\000\000\000\0011\000\000\001%\000\000\001%\000\000\002\250\000\000\000\000\0011\0011\000\000\0011\0011\000\000\001%\000\000\000\000\0011\000\000\000\000\000\000\0011\000\000\000\000\003\002\000\000\003\018\0011\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001%\000\000\000\000\001%\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\0011\000\000\0011\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001%\0011\001%\000\000\000\000\000\000\000\000\000\000\000\000\001%\001%\000\000\001%\001%\001%\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0011\000\000\000\000\0011\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\0015\000\000\000\000\0015\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0011\000\000\0011\000\000\000\000\000\000\000\000\000\000\000\000\0011\0011\000\000\0011\0011\0011\002\242\003\026\000\000\000\000\000\000\0015\000\000\000\000\000\000\0015\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\0015\0015\000\000\0015\0015\000\000\000\000\000\000\003\146\0015\000\000\001I\000\000\0015\000\000\000\000\003\002\000\000\003\018\0015\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\003\146\000\000\000\000\001I\000\000\000\000\000\000\001I\000\000\003*\000\000\0015\000\000\002\250\000\000\000\000\001I\001I\000\000\001I\003\154\000\000\0015\000\000\000\000\001I\002\242\003\026\000\000\003\"\000\000\000\000\003\002\000\000\003\018\001I\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\000\000\000\000\000\000\000\000\209\003\154\0015\000\000\000\000\0015\000\000\000\000\000\000\003\n\003\"\000\000\000\000\003\002\003*\003\018\001I\000\197\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0015\001I\0015\000\000\000\000\000\000\000\000\000\000\000\000\0015\0015\000\000\0015\0015\0015\000\000\003*\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001I\002\250\000\000\000\000\003\n\000\000\000\000\000\197\000\197\000\000\001=\000\000\000\000\001=\000\000\000\000\000\000\003\"\000\000\000\000\003\002\001I\003\018\001I\000\000\0032\000\000\000\000\000\000\000\000\001I\001I\003\n\001I\003:\001I\002\242\003\026\000\000\000\000\000\000\001=\000\000\000\000\000\000\001=\000\209\000\000\000\000\003*\000\000\002\250\000\000\000\209\001=\001=\000\000\001=\001=\000\000\000\000\000\209\003:\001=\000\000\000\000\000\000\003\"\000\000\023n\003\002\023v\003\018\001=\000\000\000\000\000\000\000\000\000\000\000\000\023~\000\000\000\000\000\000\000\000\023\158\000\000\000\000\000\000\0032\000\000\000\000\020z\000\000\000\000\000\000\003\n\000\000\000\000\003*\000\000\001=\000\000\020~\000\000\020\130\000\000\000\000\000\000\020\134\000\197\000\000\001=\000\000\000\000\020\138\000\000\000\197\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\197\000\197\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\0032\000\000\000\000\001=\000\000\000\000\000\000\003\n\000\000\000\000\000\000\020\162\023\166\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001=\000\000\001=\000\000\000\000\000\000\000\000\000\000\000\000\001=\001=\000\000\001=\001=\001=\000\000\000\000\000\000\020\166\006A\000\000\020\170\000\000\000\000\006A\000\000\000\000\000\000\000\000\006A\000\000\006A\000\000\000\000\020\174\000\000\006A\006A\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\006A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006A\000\000\020\206\000\000\006A\000\000\000\000\020\210\020\214\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015A\006A\006A\015A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004j\000\000\000\000\006A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006A\000\000\000\000\015A\015A\006A\006A\000\000\000\000\000\000\000\000\005\030\000\000\000\000\000\000\006A\000\000\000\000\015A\006A\000\000\000\000\015A\000\000\015A\015A\000\000\000\000\005&\000\000\006A\006*\000\000\000\000\015A\000\000\000\000\015A\000\000\015A\006A\000\000\000\000\000\000\000\000\006A\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\242\000\000\000\190\000\000\000\000\004\170\015A\000\000\004\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006A\000\000\000\000\006A\006A\000\000\002\002\006A\0066\000\000\000\000\000\000\006A\006A\000\000\006\142\006\154\006A\000\000\000\000\006\174\000\000\000\000\000\000\000\000\002&\000\000\002*\015A\015A\000\000\015A\000\000\006:\000\000\015A\006\222\0022\000\000\000\000\000\000\006\234\001\"\002:\006B\000\000\000\000\006\242\006\246\015A\000\000\006\250\000\000\015A\015A\000\000\000\000\000\000\000\000\000\000\015A\000\000\000\000\000\000\015A\015A\000\000\000\000\006\254\007\002\000\000\000\000\000\000\000\000\007\006\000\000\000\000\000\n\000\000\001\242\000\000\000\190\000\000\000\000\012F\000\000\007\014\012J\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\002\000\000\000\000\000\000\000\000\000\000\000\000\007*\000\000\012\182\012\162\000\000\000\000\0072\r\254\000\000\000\000\000\000\000\000\002&\000\000\002*\0076\000\000\000\000\000\000\000\000\007>\002~\000\000\012\186\0022\000\000\000\000\000\000\012\190\001\"\002:\000\000\000\000\000\000\012\194\012\198\000\000\020v\012\202\000\000\000\000\000\000\000\000\000\000\000\000\020v\000\000\000\000\000\000\020z\000\000\000\000\000\000\000\000\000\000\006\254\012\206\020z\000\000\000\000\020~\012\210\020\130\000\000\000\n\000\000\020\134\000\000\020~\000\000\020\130\000\000\020\138\012\218\020\134\000\000\000\000\000\000\020\142\000\000\020\138\020\150\000\000\000\000\000\000\020\154\020\142\000\000\000\000\020\150\000\000\020\158\000\000\020\154\000\000\000\000\000\000\012\222\000\000\020\158\000\000\000\000\022\222\012\230\000\000\000\000\000\000\020\162\000\000\000\000\023F\000\000\012\234\000\000\000\000\020\162\000\000\012\242\002~\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0121\000\000\020\166\000\000\000\000\020\170\000\000\000\000\0121\000\000\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\020\174\000\000\000\000\000\000\000\000\020\178\000\n\020\182\020\174\020\186\020\190\000\000\020\194\020\178\000\n\020\182\000\000\020\186\020\190\020\198\020\194\000\000\020\202\000\000\t\241\000\000\000\000\020\198\000\000\000\000\020\202\000\000\000\000\000\000\000\000\000\000\t\241\020\206\000\000\000\000\000\000\000\000\020\210\020\214\0121\020\206\000\000\t\241\000\000\t\241\020\210\020\214\0121\t\241\000\000\000\000\000\000\000\000\000\000\t\241\000\000\000\000\000\000\b\173\000\000\t\241\000\000\000\000\t\241\000\000\000\000\000\000\t\241\021^\000\000\b\173\000\000\000\000\t\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\b\173\000\000\b\173\000\000\000\000\000\000\b\173\000\000\t\241\000\000\000\000\000\000\b\173\000\000\000\000\000\000\000\000\000\000\b\173\000\000\000\000\b\173\000\000\000\000\000\000\b\173\000\000\000\000\000\000\000\000\000\000\b\173\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\241\000\000\000\000\t\241\000\000\000\000\000\000\000\000\b\173\023\166\000\000\000\000\000\000\000\000\000\000\000\000\t\241\000\000\000\000\000\000\000\000\t\241\t\241\t\241\000\000\t\241\t\241\000\000\t\241\000\000\000\000\000\000\000\000\000\000\000\000\t\241\000\000\000\000\t\241\b\173\000\000\000\000\b\173\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\241\000\000\b\173\000\000\000\000\t\241\t\241\b\173\b\173\b\173\000\000\b\173\b\173\006\229\b\173\000\000\000\000\000\000\000\000\000\000\000\000\b\173\000\000\000\000\b\173\006\229\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\229\000\000\006\229\b\173\000\000\000\000\006\229\000\000\b\173\b\173\000\000\000\000\006\229\000\000\000\000\000\000\021\230\000\000\006\229\000\000\000\000\006\229\000\000\000\000\000\000\006\229\000\000\000\000\020z\000\000\000\000\006\229\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\024\174\000\000\000\000\020\134\000\000\006\229\000\000\000\000\000\000\020\138\000\000\000\000\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\229\000\000\000\000\006\229\000\000\000\000\000\000\000\000\020\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\229\000\000\000\000\000\000\000\000\006\229\006\229\006\229\000\000\006\229\006\229\000\000\006\229\000\000\000\000\000\000\000\000\000\000\000\000\006\229\000\000\000\000\006\229\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\006\229\000\000\020\174\000\000\000\000\006\229\006\229\020\178\000\n\020\182\000\000\020\186\020\190\021\254\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\020\206\000\000\000\000\020\134\000\000\020\210\020\214\000\000\000\000\020\138\000\000\000\000\000\000\020v\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\020z\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\000\000\000\000\000\000\020\134\000\000\020\162\000\000\000\000\000\000\020\138\000\000\000\000\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\022\194\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\174\000\000\000\000\000\000\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\206\000\000\020\174\000\000\000\000\020\210\020\214\020\178\000\n\020\182\000\000\020\186\020\190\022\218\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\020\206\000\000\000\000\020\134\000\000\020\210\020\214\000\000\000\000\020\138\000\000\000\000\000\000\023B\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\020z\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\000\000\000\000\000\000\020\134\000\000\020\162\000\000\000\000\000\000\020\138\000\000\000\000\000\000\000\000\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\020\162\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\174\000\000\000\000\000\000\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020\166\000\000\000\000\020\170\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\206\000\000\020\174\000\000\000\000\020\210\020\214\020\178\000\n\020\182\000\000\020\186\020\190\020v\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020z\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020~\000\000\020\130\020\206\000\000\000\000\020\134\000\000\020\210\020\214\000\000\000\000\020\138\000\000\000\000\000\000\020v\000\000\020\142\000\000\000\000\020\150\000\000\000\000\000\000\020\154\000\000\000\000\020z\000\000\000\000\020\158\000\000\000\000\000\000\015Y\000\000\000\000\015Y\020~\000\000\020\130\000\000\000\000\000\000\020\134\000\000\024z\000\000\000\000\000\000\020\138\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\020\150\015Y\015Y\000\000\020\154\000\000\000\000\000\000\000\000\000\000\020\158\000\000\000\000\000\000\000\000\000\000\015Y\000\000\020\166\000\000\015Y\020\170\015Y\015Y\000\000\000\000\020\162\000\000\000\000\000\000\004\198\000\000\015Y\000\000\020\174\015Y\000\000\015Y\000\000\020\178\000\n\020\182\000\000\020\186\020\190\000\000\020\194\000\000\000\000\000\000\000\000\000\000\000\000\020\198\000\000\000\000\020\202\020\166\000\000\000\000\020\170\000\000\000\000\000\000\015Y\000\000\000\000\000\000\000\000\000\000\000\000\020\206\000\000\020\174\000\000\000\000\020\210\020\214\020\178\024\166\020\182\000\000\020\186\020\190\000\000\020\194\000\229\000\000\000\000\000\229\000\000\000\000\020\198\000\000\000\000\020\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015Y\015Y\000\000\015Y\000\000\000\000\020\206\015Y\000\229\000\229\000\000\020\210\020\214\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\015Y\000\000\000\229\000\000\015Y\015Y\000\229\003\146\000\229\000\229\001\017\015Y\000\000\000\000\000\000\015Y\015Y\000\000\000\229\000\000\000\000\003\002\000\000\000\229\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\250\000\000\000\229\000\000\001\017\000\000\001\017\003\154\000\000\003\146\000\000\000\000\001\005\000\000\000\000\000\000\003\"\000\000\000\000\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\229\000\000\000\000\000\229\000\000\000\000\003*\003\n\002\250\000\000\000\000\000\000\001\005\000\253\001\005\001\005\000\253\000\000\000\000\000\000\000\000\000\229\000\000\000\000\003\"\000\229\000\229\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\229\000\229\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001\017\000\000\000\000\000\000\003\n\002\250\000\000\003*\000\000\000\253\000\000\000\253\000\253\000\000\000\233\000\000\000\000\000\233\001\017\000\000\000\000\000\253\001\017\001\017\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\003\162\003:\000\000\000\000\000\000\000\000\000\000\000\233\000\233\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001\005\000\000\000\000\003*\003\n\000\233\000\000\000\000\000\000\000\233\000\245\000\233\000\233\000\245\000\000\000\000\000\000\000\000\001\005\000\000\000\000\000\233\001\005\001\005\003\002\000\000\000\233\000\000\000\000\000\000\000\000\000\000\000\000\001\005\003:\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\253\000\000\000\000\000\253\000\000\000\000\000\000\003\n\002\250\000\000\000\233\000\000\000\245\000\000\000\245\000\245\000\000\000\249\000\000\000\000\000\249\000\253\000\000\000\000\000\245\000\253\000\253\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\253\000\253\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\233\000\000\000\000\000\233\000\000\000\000\000\245\003\n\002\250\000\000\000\000\000\000\000\249\003\146\000\249\000\249\001\r\000\000\000\000\000\000\000\000\000\233\000\000\000\000\000\249\000\233\000\233\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\233\000\233\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\245\000\000\000\000\000\245\000\000\000\000\000\000\003\n\002\250\000\000\003*\000\000\001\r\000\000\001\r\003\154\000\000\001\001\000\000\000\000\001\001\000\245\000\000\000\000\003\"\000\245\000\245\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\245\000\245\000\000\000\000\000\000\000\000\000\000\002\242\003\026\000\000\000\000\000\000\000\000\000\000\000\249\000\000\000\000\000\249\000\000\000\000\003*\003\n\002\250\000\000\000\000\000\000\001\001\000\000\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\249\000\000\000\000\003\"\000\249\000\249\003\002\000\000\003\018\000\000\000\000\000\000\000\000\000\000\000\000\000\249\000\249\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001\r\000\000\000\000\000\000\003\n\000\000\000\000\003*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\r\000\000\000\000\000\000\001\r\001\r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\r\003:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0032\000\000\000\000\001\001\000\000\000\000\000\000\003\n\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\000\000\000\000\000\000\001\001\001\001\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\001\001\001"))
let lhs =
- (16, "\000\012\000\011\000\n\000\t\000\b\000\007\000\006\000\005\000\004\000\003\000\002\000\001\000\000\0018\0018\0018\0017\0017\0017\0017\0016\0016\0016\0016\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0011\0011\0011\0011\0011\0011\0011\0011\0011\0011\0011\0011\0011\0011\0010\0010\0010\0010\001/\001.\001.\001.\001-\001-\001-\001,\001,\001,\001+\001+\001+\001*\001)\001(\001'\001'\001&\001&\001%\001%\001$\001$\001#\001#\001\"\001!\001 \001\031\001\030\001\029\001\028\001\027\001\026\001\025\001\024\001\023\001\022\001\021\001\020\001\019\001\019\001\018\001\018\001\017\001\017\001\016\001\016\001\015\001\015\001\015\001\015\001\014\001\014\001\014\001\014\001\r\001\r\001\r\001\r\001\012\001\012\001\012\001\012\001\011\001\011\001\011\001\011\001\n\001\n\001\n\001\n\001\t\001\t\001\t\001\b\001\b\001\b\001\b\001\b\001\007\001\006\001\005\001\005\001\005\001\005\001\005\001\004\001\004\001\003\001\002\001\001\001\001\001\001\001\001\001\000\001\000\001\000\001\000\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\254\000\253\000\253\000\252\000\252\000\252\000\252\000\252\000\252\000\252\000\252\000\251\000\251\000\250\000\250\000\250\000\249\000\248\000\247\000\247\000\246\000\246\000\245\000\244\000\243\000\243\000\242\000\242\000\241\000\241\000\240\000\240\000\239\000\238\000\237\000\237\000\236\000\236\000\235\000\235\000\234\000\234\000\233\000\233\000\232\000\231\000\231\000\230\000\230\000\230\000\230\000\230\000\230\000\229\000\229\000\229\000\228\000\227\000\226\000\226\000\226\000\226\000\225\000\225\000\224\000\223\000\223\000\223\000\222\000\222\000\222\000\222\000\222\000\221\000\221\000\221\000\221\000\220\000\220\000\220\000\220\000\219\000\219\000\219\000\219\000\218\000\217\000\217\000\216\000\216\000\216\000\215\000\214\000\214\000\214\000\213\000\212\000\212\000\211\000\211\000\211\000\210\000\210\000\210\000\209\000\209\000\209\000\209\000\208\000\208\000\207\000\207\000\207\000\207\000\207\000\207\000\206\000\206\000\206\000\205\000\205\000\205\000\205\000\205\000\205\000\205\000\204\000\203\000\202\000\202\000\201\000\201\000\200\000\200\000\199\000\199\000\198\000\198\000\197\000\197\000\196\000\196\000\196\000\196\000\196\000\196\000\196\000\196\000\195\000\194\000\193\000\193\000\192\000\192\000\191\000\191\000\190\000\190\000\189\000\189\000\188\000\188\000\187\000\187\000\186\000\186\000\185\000\185\000\184\000\184\000\183\000\183\000\182\000\182\000\181\000\181\000\180\000\180\000\179\000\179\000\178\000\178\000\177\000\177\000\176\000\176\000\175\000\175\000\174\000\174\000\173\000\173\000\172\000\172\000\171\000\171\000\170\000\170\000\169\000\169\000\168\000\168\000\167\000\167\000\166\000\166\000\165\000\165\000\164\000\164\000\163\000\163\000\162\000\162\000\161\000\161\000\160\000\160\000\160\000\159\000\159\000\158\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\156\000\156\000\156\000\156\000\155\000\154\000\153\000\152\000\151\000\150\000\149\000\148\000\147\000\146\000\145\000\144\000\143\000\143\000\143\000\142\000\142\000\142\000\141\000\141\000\141\000\141\000\140\000\140\000\139\000\138\000\137\000\136\000\135\000\134\000\133\000\132\000\131\000\130\000\130\000\129\000\129\000\129\000\128\000\128\000\127\000\127\000\127\000~\000~\000~\000}\000}\000|\000{\000{\000{\000z\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000x\000x\000w\000w\000w\000w\000w\000w\000w\000v\000v\000v\000v\000v\000v\000v\000u\000u\000u\000u\000u\000u\000u\000t\000t\000t\000t\000t\000t\000t\000s\000s\000s\000s\000s\000s\000s\000r\000r\000r\000r\000r\000r\000r\000q\000q\000p\000p\000o\000o\000n\000n\000m\000m\000l\000l\000k\000k\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000i\000i\000h\000h\000g\000g\000f\000f\000e\000e\000d\000d\000c\000c\000b\000b\000b\000b\000b\000a\000a\000`\000`\000`\000`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r")
+ (16, "\000\012\000\011\000\n\000\t\000\b\000\007\000\006\000\005\000\004\000\003\000\002\000\001\000\000\0018\0018\0018\0017\0017\0017\0017\0016\0016\0016\0016\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0015\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0014\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0013\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0012\0011\0011\0011\0011\0011\0011\0011\0011\0011\0011\0011\0011\0011\0011\0010\0010\0010\0010\001/\001.\001.\001.\001-\001-\001-\001,\001,\001,\001+\001+\001+\001*\001)\001(\001'\001'\001&\001&\001%\001%\001$\001$\001#\001#\001\"\001!\001 \001\031\001\030\001\029\001\028\001\027\001\026\001\025\001\024\001\023\001\022\001\021\001\020\001\019\001\019\001\018\001\018\001\017\001\017\001\016\001\016\001\015\001\015\001\015\001\015\001\014\001\014\001\014\001\014\001\r\001\r\001\r\001\r\001\012\001\012\001\012\001\012\001\011\001\011\001\011\001\011\001\n\001\n\001\n\001\n\001\t\001\t\001\t\001\b\001\b\001\b\001\b\001\b\001\007\001\006\001\005\001\005\001\005\001\005\001\005\001\004\001\004\001\003\001\002\001\001\001\001\001\001\001\001\001\000\001\000\001\000\001\000\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\255\000\254\000\253\000\253\000\252\000\252\000\252\000\252\000\252\000\252\000\252\000\252\000\251\000\251\000\250\000\250\000\250\000\249\000\248\000\247\000\247\000\246\000\246\000\245\000\244\000\243\000\243\000\242\000\242\000\241\000\241\000\240\000\240\000\239\000\238\000\237\000\237\000\236\000\236\000\235\000\235\000\234\000\234\000\233\000\233\000\232\000\231\000\231\000\230\000\230\000\230\000\230\000\230\000\230\000\229\000\229\000\229\000\228\000\227\000\226\000\226\000\226\000\226\000\225\000\225\000\224\000\223\000\223\000\223\000\222\000\222\000\222\000\222\000\222\000\221\000\221\000\221\000\221\000\220\000\220\000\220\000\220\000\219\000\219\000\219\000\219\000\218\000\217\000\217\000\216\000\216\000\216\000\215\000\214\000\214\000\214\000\213\000\212\000\212\000\211\000\211\000\211\000\210\000\210\000\210\000\209\000\209\000\209\000\209\000\208\000\208\000\207\000\207\000\207\000\207\000\207\000\207\000\206\000\206\000\206\000\205\000\205\000\205\000\205\000\205\000\205\000\205\000\204\000\203\000\202\000\202\000\201\000\201\000\200\000\200\000\199\000\199\000\198\000\198\000\197\000\197\000\196\000\196\000\196\000\196\000\196\000\196\000\196\000\196\000\195\000\194\000\193\000\193\000\192\000\192\000\191\000\191\000\190\000\190\000\189\000\189\000\188\000\188\000\187\000\187\000\186\000\186\000\185\000\185\000\184\000\184\000\183\000\183\000\182\000\182\000\181\000\181\000\180\000\180\000\179\000\179\000\178\000\178\000\177\000\177\000\176\000\176\000\175\000\175\000\174\000\174\000\173\000\173\000\172\000\172\000\171\000\171\000\170\000\170\000\169\000\169\000\168\000\168\000\168\000\167\000\167\000\166\000\166\000\165\000\165\000\164\000\164\000\163\000\163\000\162\000\162\000\161\000\161\000\160\000\160\000\160\000\159\000\159\000\158\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\157\000\156\000\156\000\156\000\156\000\155\000\154\000\153\000\152\000\151\000\150\000\149\000\148\000\147\000\146\000\145\000\144\000\143\000\143\000\143\000\142\000\142\000\142\000\141\000\141\000\141\000\141\000\140\000\140\000\139\000\138\000\137\000\136\000\135\000\134\000\133\000\132\000\131\000\130\000\130\000\129\000\129\000\129\000\128\000\128\000\127\000\127\000\127\000~\000~\000~\000}\000}\000|\000{\000{\000{\000z\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000y\000x\000x\000w\000w\000w\000w\000w\000w\000w\000v\000v\000v\000v\000v\000v\000v\000u\000u\000u\000u\000u\000u\000u\000t\000t\000t\000t\000t\000t\000t\000s\000s\000s\000s\000s\000s\000s\000r\000r\000r\000r\000r\000r\000r\000q\000q\000p\000p\000o\000o\000n\000n\000m\000m\000l\000l\000k\000k\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000j\000i\000i\000h\000h\000g\000g\000f\000f\000e\000e\000d\000d\000c\000c\000b\000b\000b\000b\000b\000a\000a\000`\000`\000`\000`\000_\000^\000]\000]\000]\000\\\000\\\000\\\000[\000[\000[\000[\000[\000[\000Z\000Z\000Z\000Z\000Z\000Z\000Z\000Z\000Y\000Y\000Y\000Y\000Y\000Y\000Y\000Y\000X\000X\000X\000X\000X\000X\000X\000X\000W\000W\000W\000W\000W\000W\000W\000W\000V\000V\000U\000U\000T\000T\000T\000T\000T\000T\000T\000T\000T\000T\000T\000T\000T\000T\000S\000S\000S\000S\000S\000S\000S\000S\000S\000S\000S\000S\000S\000S\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000R\000Q\000Q\000Q\000Q\000Q\000Q\000Q\000Q\000Q\000Q\000Q\000Q\000Q\000Q\000P\000P\000P\000P\000P\000O\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000N\000M\000M\000M\000L\000K\000J\000I\000I\000H\000H\000G\000F\000F\000E\000E\000E\000D\000D\000C\000C\000B\000A\000A\000A\000A\000A\000A\000A\000@\000@\000@\000@\000@\000@\000@\000?\000?\000?\000?\000?\000>\000>\000=\000=\000=\000=\000=\000<\000<\000;\000;\000:\000:\0009\0009\0008\0008\0007\0007\0006\0006\0005\0005\0004\0004\0003\0003\0002\0002\0001\0001\0000\0000\000/\000/\000.\000.\000-\000-\000,\000,\000,\000,\000,\000,\000,\000,\000,\000,\000+\000+\000*\000*\000*\000*\000*\000*\000*\000*\000*\000*\000*\000*\000*\000*\000*\000*\000*\000*\000*\000)\000)\000)\000(\000(\000(\000(\000'\000'\000&\000%\000%\000%\000$\000$\000$\000$\000$\000$\000$\000$\000#\000#\000\"\000\"\000!\000 \000\031\000\031\000\031\000\031\000\030\000\030\000\030\000\029\000\029\000\028\000\028\000\028\000\027\000\027\000\027\000\026\000\026\000\026\000\026\000\026\000\026\000\026\000\025\000\025\000\024\000\024\000\024\000\024\000\023\000\023\000\023\000\022\000\022\000\022\000\022\000\022\000\022\000\022\000\021\000\021\000\021\000\021\000\021\000\021\000\021\000\020\000\020\000\020\000\020\000\020\000\020\000\020\000\019\000\019\000\019\000\019\000\019\000\019\000\019\000\018\000\018\000\018\000\018\000\018\000\018\000\018\000\017\000\017\000\017\000\017\000\017\000\016\000\016\000\015\000\014\000\014\000\014\000\014\000\014\000\r")
let goto =
- ((16, "\002\128\0020\000\000\000\000\000\000\000M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001q\000\000\001G\006H\000\000\000\000\000\r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\003v\000\000\005\172\003\254\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\015\000l\000\000\000\255\000\000\000\000\003\\\000\000\000\000\005*\000\000\000\000\000\000\000R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003x\000\000\000\000\001\246\019X\000\000\000\000\020\178\000\000\000\000\000\000\000\000\000\000\000\000\014\212\000\000\000\000\000\000\000\000\000\000\005\202\000\000\000\018\000\000\000\142\000\000\000\000\000\000\005\206\000\000\b\228\000\000\000\000\000\000\b\172\000\000\000\000\000\000\016\212\001O,\152\000\000\000\000\027\246\028\"\000\000\000N\000\000\030t1H6J1H\016\"1\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\1607 \000\000\000\000!\030)\0180\134\000\0002R\003~\000\000\000\000*\0185\228\000\000\000\000\000\000\001\022\000\000\000\1302\004+\b\000\000\000\000Ml\000\000\004>\000\000\006:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\170\000\000\000\000\006\160\000\000\018*\000\000\023\160\000\000\024\172\000\000!\028\000\000\"\164\000\000#\154\000\000%\"\000\000&\012\000\000&\170\000\0004z\000\000\017\196\000\000\000\000\000\000\000\000\t\130\000\000\000\000\000\000\000\000'\160\000\000(\138\000\000.\186\000\0004\168\000\0007x\000\0008:\000\000;F\000\000DJ\000\000H\224\000\000J\152\000\000L\234\000\000S\022\000\000U\168\000\000V&\000\000VV\000\000V\144\000\000\0070\000\000\000\000\b&\000\000\000\000\000\000\000\000\002\146\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000gM\210\000\000\000+\000\000\000\000\000d\t\176\000\000\000b\000\r\000 \000\166\001{\000\000\001$\000\000\000\000\001\146\000\000\001\156\000\000\000\00074\000\000\000\000\000\000\000,\nz\000\000;&7\236\000\000\000\000\000\000\000\000\011p\018\014\000\000\000\000\000\000\000\000\000\000\000\000;\128\000\000\000\000<\n\000\000\000\000=\178\000\000\004\026\000\000\b(\000\000\000\000\000\000\003@\000\0002\2428&\000\000\000\0008j9\018\000\000\t\028\000\000\n\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000V\168\000\0004\188\000\000Uz\000\000V\188\000\000V\234\000\000W\156\000\000W\198\000\000W\254\000\000X\002\000\000X\030\000\000X\146\000\000X\192\000\000X\226\000\000Y\018\000\000Y0\000\000Y>\000\000\000\000:\006\000\000\000\000\000\000:J\000\000\000\000\000\000\000\000\000\000\000\000N$\000\000\000\000\000\000\b\236\000\000\000\000\000\000\000\000#\232\000\000\000\000\000\000\000\000\001G\000\000\000\000N>\000\000\000\000\000\000\020,\000\197\000\000\000\000A\238\000\000\000\000:\234\000\000\000\000\000\000\000\026\012f+\022\000\000\000\000On\000\000O\152\000\000\000\000\000\000\r\\B<\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=\216\000\000\000\000\000\000\000\000BZ\014R\016\182\000\000?\244\000\000\000\000I\018\000\000\006V\000\000\000\000\024|\000\000\000\000\000\000\018\248\000\0003x\000\000\000\000O\154\000\000\000\000\000\000\021\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\028 \000\000\030\158\000\000\000}\000\000\000\000\000\000Yz\000\000Y\174\000\000Y\242\000\000ZZ\000\000Z|\000\000Z\148\000\000Z\198\000\000[ \000\000[0\000\000[j\000\000[\136\000\000[\210\000\000[\234\000\000\\v\000\000\000\000\000\000\000\000\000\000C2\000\000\000\000\003\146D\012\000\000\000\000D4\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001\\\000\000;\156\000\000\000\000\000\000\000\000\000\000<2\000\000\000\000\000\000<\200\000\000\000\000\000\000\000\000\000\000\000\000\001\015\000\000\000\000\000\000\000\000\014H\000\000\021@\000\000\000\000\0022\005\238\000\000\000\000\000\000\000\000\020N\014\252\000\000\016\232\000\000\000\000\000\000\021\174\000\000\023\"\000\000&B\000\000\000\000\000\000\000\000\000\000\000\000(\192\000\000\000\000\000\183\000\000\000\000\000\000\0226\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000b\022&\000\000\000\000\000\000\000\000\000\000\000\000\000\254\000\000\016\018\r\140\000\000\000\000\000\000\017:\000\000\000\000\000\000\002v\rT\000\000\002\184\000\000\000\000\000\000\000\000\014H\000\000\000\000\000D\nr\000\000\n\166\000\000\000\000\000\000\000\246\000\000\017\228\000\158\0007\000\000\000\000\000\000\002\208\000\222\000\000\000\000\003`\000\000\000\000\000\000\005H\000\000\000\000\000\000\000\252\000\000\000\000\000\000\000\000\000\000\003 \000\203\000w\000\000\000\000\000k\000\000\000\000\000\000\000\000\000\000\000\000O\186\000\000>\158\000\000\000\000\000\000P.\000\000\000\000\003b\000\000\000\000\000\000\003j\020*\000\000\000\000Db\000\000\000\000\004L\000\000\000\000\000\000\000\000\016p\000\000\023\204\000\000\000\000->\000\000\000\000\000\000D\180\000\000\000\000\000\000\000\000\000\0009\248\000\000\000\000\000\000\001O\000\000E\014\000\000\000\000\000\000\000\000\002\178\020\218\000\000E(\000\000\000\000\000\000\000\000\022\214\000\000E\218\000\000\000\000\000\000\000\000\003\168\000\000\n4\000\000\000\000J\190<\242\000\000\000\000\000\000PR\000\000\000\000\000\000\000\012\000\000P\226\000\000\000\000\000\000Q\004\000\000\000\000\000\230\000\000!\206\000\027=\136\000\000\000\000\000\000\021(\021~\000\000\000\000\000\000\000\000\000\000\000\000Kv\000\000\000\000O$\000\000\000\000O\220\000\000\006\130\000\000\0224\000\000\000\000\000\000\024\164\000\0003\146\000\000\000\000Q\154\000\000\000\000\000\000\025D\000\000\000\000\000\000\000\000\000\000\000\000\011\b\000\000\025\162\000\000\000\000\000\000\004\128\000\000\000\000\000\000\000\000\000\000\000\000\\\146\000\000E\242\000\000U\142\000\000]\000\000\000]\030\000\000]>\000\000]\192\000\000]\230\000\000]\234\000\000^(\000\000^T\000\000^~\000\000^\212\000\000^\246\000\000_\018\000\000_\022\000\000,\196\000\000\000\000\000\000\001F\000\000\004\252\000\000\018\218\003N\011*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R*\000\000>\228\0044\027N\000\000\000\000\000\00000\000\000\003\128\024\134\000\000\000\000F\198\000\000\000\000\000h\000\000\025T\000\000\000\000EF\000\000\000\000\000\000G\002\000\000\000\000\000\000\000\000Gh\000\000\000\000\012\b\026\174\000\000\000\000G\204\000\000\000\000\027@\000\000\000\000G\224\000\000\000\000\000\000\000\000H.\000\000IB\000\000?f?\214\001N\0062\000\000\006\158\007\210\000\000\000\000\000\000\014\202\000\000\000\000\0200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R>\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0004\024\000\000@\020\000\000\000\000\000\000\019l\000\000\000\000\007\020\000\000\000\000\000\000\"`\002\152\000\000#V\000\000\000\000\000\000\000\000\004h\000\000\000\000\020b\000\000$L\000\000\000\0004\158\000\000\000\000\000\000Iv\000\000\000\000\0180\000\000\000\000\029\230\000\000\000\000Z\238\000\000\000\000\000\000I\196\000\000\000\000\000\000]N\000\000\000\000\000\000\000\000J*\000\000\000\000\000\000\000\000\r\178\022\222\000\000JT\000\000\000\000\000\000\000\000\000\000\000\000\021X\000\000\000\000\004\150\000\000\021\234\000\000\0180\000\000\000\000J|\000\000K\016\000\000@\250\000\000\000\000\000\0005\146\000\000\000\000\000\000KZ\000\000\000\000\012\222\000\000\000\000\030\030\000\000\000\000]\228\000\000\000\000\000\000K\240\000\000\000\000\000\000\000\000LV\000\000\000\000\015\234\030@\000\000\000\000M\018\000\000\000\000\004\166A\208\000\000\004\186\000\000\000\000\000\000\000\000\004\128\000\000A8\000\000$\222\000I%\212\000\000\001L\000\000\022\224\000\000\023\214\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\020&\202\002\006'\\\000\000\000\000\000\000\003.\000\000\024h\000\000\005&\000\000\000\000\018\208\001$(R\000\000\002\226\000\000\025^)H\000\000\000\000\026T\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\140\012 \000\000\005\164\000\000\000\000\000\000\000\000\005\238\000\000\026\230\000\000\000\000\000\000/\166RZ\000\000\000\000\000\000/:\000\000\000\000\000\000\000\000\005\1881\014\000\000\000\000\000\000\000\000\005\192\000\000\000\000\000\000\000\000\016R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\"\000\000\027\220\000\000\000\000\000\000R\240\000\000\r\022\000\000\000\000\000\000\0050\000\000\005\178\000\000\000\000\002\212\028\210\000\000\029d\000\000\000\000\000\000\003\156\000\000Sr\004\250S\134\000\000S\162\000\000\000\000\000\000\005h\000\000T2\005\190\000\000\000\000,X=z\000\000\005\204-\232\000\000\000\000.z\000\000\000\000\000\000\006\006\000\000TF\006\018\000\000\000\000\b\208\006\030\014p\000\000\0272\000\000\000\000\000\000\0068\000\000T\200\006\156\000\000\000\000\000\000\002H\000\000\002\192\000\000\000\000\000\000\000\000\000\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\022\000\000\000\000\007\186\000\000\000\160\000\000\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\007\188\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\026\000\000\000\000\001\150\000\000\t\196\000\000\000\000\000D\000\000\002\188\001R\002x\000\000\000\000\000\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0034\004\254\000\000\000\000\b\166\000\000\000\000\000\000\012\002\000\000\000\000\012\248\rR\000\000\000\000\000\000\000\000\r\238\015>\002\186\000\000\000\000\000\000\018\156\000\000\000\000\000\000\000\000\000\000\000\000\000E\000\000\000\000\007\202\000\000\000\000\001\194\000\000\019\002\000\000\000\000\000\000\b\020\000\000\000\000\019\200\000\000\000c\000\000\000\000\000\000\000\000\000\129\019`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\022\200\021V\000\000\000\000\000\000\000\000\024\162\024\250\b\206\000\000\026\022\000\000\000\000\000\000\000\000\000\000\000\000\018\178\000\000\002\176\000\000\000\000\000\000\n\012\000\000\000<\000\000\000\000\000\000\023\212\000\000\000\000\0266\027\002\n\186\000\000\027x\000\000\000\000\000\000\000\000\000\000\000\000\002\170\002b\000\000\002\128\000\000\028r\011\002\000\000\028\202\000\000\000\000\000\000\000\000\002\202\000\000\003\170\000\000\000\000\000\000\001f\000\000\001f\003`\003\246\000\000\000\000\000\000\001l\014\176\000\000\000\000\000\000\000\000\000\000\002\236\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\016\000\000\000\000\000\005\000\000\014\248\004:\004\164\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\142\000\000\000\000\024\244\029$\000\000\000\000\000\000\000\000\029\128\000\000\000\0006\132\000\000\005\130\000\000\000\000\000\000\000\000\014\250\000\000\000\000\000\000\000\000\000\000\001|\024\204\000\000\000\000\026~\000\000\000\000\000\000\000\000\r\012\000\000\000\000\003\144\000\000\000\000\000\000\000\191\000\000\000\000\000\215\000\000\000\000\000\000\000\000\000\000\000\000\000\000M.\000\000\000\000\000\000\001\011\000\000\000\000\000\000\000\000\000\000\001\026\012\152\017\b\017\132\000\000\006\184\007\014\007\022\007d\000\000\000\000\000\000\000\000\000\000\000\000\007$\030Z\000\000)\218\007~\000\000\000\000\007\224\000\000\031P\000\000B\022\000\000\000\000\007(\031\226\000\000*\208\000\000\007f+\198\000\000\000\000\000\000\002\148\025\130\000\000\000\000\000\000\000\000\016\222\000\000\021\206!$\000\000\000\000\027\200\"\026\000\000\"L\000\000\000\000\021\174\000\000\023\"\000\000\000\000$\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\012\000\000\000\000\000\000\b\002\000\000 \216\000\000\026t\004\\\000\000\000\000\000\000\000\000\000\000\0044\000\000\000\000\000\000\000\000\000\000M\134\000\000\004\014\000\000\000\000\000\000\000\000\000\000\002*\000\000\015\002\0022\015\248\000\000\004p\016\238\000\000\004\178\000\000\005f\000\000\006\\\000\000\007R\000\000\026t\000\000\000\000\000\000\000\000\000\000\bH\000\000\004\186\000\000\t>\000\000\026t\005\018\000\000\001\194\000\000\005\018\006\236\000\000\003\230\000\000\004\020\000\000\000\000\000\000\000\000\000\000\000\000\004L\000\000\004h\000\000\004\132\000\000\000\000\000\000\000\000\000\000\004\228\000\000\000\000\000\000\000\000\000\000\006v\005.\000\000\000\000\005d\000\000\000\000\005l\005\128\007:\000\000\007H\000\000\000\000\003\136\006R\000\000\005\252\000\000\000\000\0068\000\000\000\000\000\000\000\000\000\000\000\000\007J\006D\000\000\000\000\000\000\006\178\006\138\005\158\006@\006\184\006\240\000\000\000\000\006\160\006P\006\162\006\212\007\018\000\000\000\000\007\176\b\012\000\000\b$\000\000\bb\000\000\000\000\bB\000\000\000\000\bF\000\000\000\000\000\000\000\000\bP\000\000\b\132\000\000\000\000\000\000\b\144\000\000\000\000\000\000\b\150\000\000\000\000\000\000"), (16, "\001\210\000p\000\018\000=\003?\004t\003R\001\159\000p\006Q\000y\000=\006R\005\166\005L\005M\000\007\000y\005\167\005\168\003\133\003\134\000p\002N\005\141\000\017\000N\002\217\004r\0042\001\211\000y\006V\005\021\001\212\000N\006G\006H\000$\001D\0059\000\005\001E\000?\000p\002\133\002\134\002\157\002\137\006\b\005\169\000>\000N\000y\000N\002P\001D\003\007\006L\001P\000*\005\170\006B\006C\005:\0005\004\001\0005\003A\005=\005L\005M\001\162\006\006\003B\006\t\005L\005M\000N\000z\001\160\005]\001D\001\028\000p\001P\001\017\001\t\002S\003\233\002\196\006O\000O\000y\001\t\005N\001\213\005\167\005\168\002u\000p\000O\001\214\002\182\001F\005[\000p\002\148\001\t\000y\001G\005^\005L\005M\000p\000y\001\017\006O\000O\002\130\000O\001F\002\172\000y\001\147\001\239\001\019\001G\002S\005\199\001\t\0006\002\195\0006\002\174\005d\002O\004\161\002\198\003W\005\170\000z\001\012\003\235\000O\001\160\000p\001F\001V\002\185\002S\005N\0005\001G\001\210\000y\001\018\005N\003?\005A\003R\001\150\000p\002\133\002\138\001V\002\137\006{\002O\005E\001\t\000y\002\187\006|\004\202\004\208\000p\003\133\003\134\003\237\0005\006}\004|\004\000\001\135\000y\001\t\004\147\001\238\001\"\003O\001V\001\t\005N\003\242\005\246\002\188\000z\000\179\004\002\001\t\003P\004\163\004\128\004\207\002S\002S\004t\0009\005T\0009\003\007\002O\005\255\006(\004n\001\227\002\154\0006\002\164\004\001\005n\003A\001\029\000\179\000p\001\012\001\228\003B\001$\005\142\005\236\001\t\000\179\000y\002\166\001W\002\177\001\023\005b\003\244\006\005\0043\003\233\004z\001\023\0006\004\n\001\t\002\139\000\179\004\145\000P\001W\005\145\005\234\005\237\005L\005M\004*\003[\005\248\001\t\001\031\0005\006\006\002B\006\t\005L\005M\005O\000Q\002\176\002T\004\157\002\243\000\179\001 \003\\\001W\006\000\002\129\006\127\003]\001 \003\217\001\029\003^\001\153\007\022\001\210\006\001\006\002\003_\003?\0009\003R\003\235\001 \002\248\004\134\000<\001\136\002-\007\023\006\128\002&\005Y\002\167\006\186\0062\001\t\000p\001Z\002,\003\176\000p\006}\006\187\004\000\001 \000y\006\189\003\208\002\166\000y\001\030\001X\005g\001Y\0006\001[\003\136\003\237\000\004\002\156\001\163\001\023\005N\001Z\001]\001\029\0005\002\129\003O\001\"\001^\003\007\003\242\005N\0065\002\192\000\179\004\002\006\129\003P\004\001\001[\003A\000\005\001\026\003\253\001\\\006\130\003B\000p\001]\002\139\006\206\006\160\006Y\005a\001^\003\254\000y\002\177\001 \001\127\006\204\003\233\000p\001!\001 \001\023\004w\001#\000\167\005\246\002a\000y\002\197\002T\005\254\005\233\003\244\002k\004\005\006\162\001\t\002\129\002\218\004\n\001\t\003\218\004\203\006\164\000\004\0009\0006\002S\004\147\002d\003\209\004*\003[\003\000\005\147\005\234\005\237\005L\005M\003\219\001 \005\193\002S\004\205\005\131\005L\005M\0005\005\251\000\005\003\\\003\235\006(\000p\001\210\003]\001 \006\207\003?\003^\003R\0005\000y\000p\002\151\003_\004\134\005R\007\031\001\t\001 \005\248\000y\004\205\000N\0005\000p\005h\000N\006\003\002\192\002\217\004r\0042\001\t\000y\000p\003\237\001\210\0068\000p\002\217\001\211\005b\004\136\000y\001\212\002\151\003O\000y\000Z\000p\003\242\0009\002\153\005S\000\179\004\002\006\208\003P\000y\003\007\002\178\0006\005\218\004\150\000F\006\130\005N\002\197\004\001\003\007\003A\006\210\000\r\002\218\005N\0006\003B\005\220\002S\005i\002l\0060\002S\005\132\003\158\002\152\000]\001\t\000O\0006\0005\003\233\000O\002S\000\016\000\017\003\244\001\t\004\005\006\212\002\180\006>\001\230\004\n\000N\002|\001\213\006\214\002e\004\228\001\t\002f\001\214\000R\005\230\004*\003[\001\210\006Z\001\023\001\t\003?\000N\003R\001\t\004\230\000\170\000U\005a\0005\000\b\000\176\002\178\006\004\003\\\001\t\006:\006\005\0009\003]\004\129\003W\001\006\003^\001\012\003\235\004f\001\210\001\232\003_\005\249\003?\0009\003R\001 \005\232\0006\005\242\001 \004\004\006~\006\006\005T\006\t\005L\005M\0009\005e\002\255\000p\000O\003\254\002\179\002\225\006}\006\192\0042\006\180\000y\001\233\006\181\003\237\0048\001\230\007\b\003A\006\014\003\014\000O\006\022\004\139\003B\003O\000\164\003\254\0006\003\242\006\172\006\173\000\172\000\179\004\002\005\025\003P\003\007\004\131\003\233\001 \006\189\004\231\001\235\004\002\006\189\004\001\000\004\003A\006@\004n\003\133\003\134\000a\003B\001\026\004\216\000\159\004\230\001\227\000S\002\024\001I\006\203\0007\005b\0009\000\179\000\178\003\233\001\228\000V\000\005\0005\000S\003\244\000F\0043\005N\004z\006\170\002\192\004\n\006\185\004l\000V\004\145\004\220\001\t\003W\000F\005p\004\n\003\235\004*\003[\004\018\006\195\002\185\007\015\002\229\006\211\006\177\001\210\004*\0009\001\238\003?\002\255\003R\002\193\003\164\001\017\003\\\006\216\005q\005L\005M\003]\003\181\002\197\002\189\003^\003\235\002\027\000p\004i\006\220\003_\003\237\006}\006\192\0042\001 \000y\001C\004i\000N\0005\0006\003O\000\170\006O\001 \003\242\002\188\000\171\001 \000\179\001\240\006\240\003P\003Z\000\179\002S\0005\000\180\000:\001 \003\237\003\007\006O\004\218\000p\001\241\004n\004k\002\143\002\217\004\001\003O\003A\000y\006\238\003\242\000p\004j\003B\000\179\004\002\006\198\003P\0057\0058\000y\004\142\006\197\004\172\000\181\006\130\003\244\005\240\003\233\000p\004\142\003\243\000{\005N\003\007\003\254\006\020\006\232\000y\000O\0006\0005\003\135\002S\000\164\000N\003[\001\t\002\226\000\170\000\172\006\234\0009\000\182\000\176\004\238\003\244\0006\0043\000N\006\200\004\144\001\210\004\n\003\\\006\236\003?\006\202\003R\003]\004\143\004\240\000\183\003^\000p\004*\003[\000\255\000^\003_\004\166\000N\003\235\000y\000p\001\t\000\178\000\185\004\219\006}\006\192\0042\004\166\000y\003\\\0005\000N\001\t\007\007\003]\000\170\002a\004\193\003^\004\193\000\171\007\005\0006\002{\003_\004\241\000O\006\242\006\012\001 \001\t\000\164\0009\003\237\003\007\004\168\007\026\000\172\000\005\002d\000O\004\240\000D\004\001\003O\003A\001\012\004\167\003\242\0009\006^\003B\000\179\004\002\006\198\003P\006\248\004\195\000F\004\194\006\199\003\216\000O\006\130\006\249\006\254\003\233\004\221\004\244\003\243\003\133\003\134\005t\000\178\004\255\001\t\0006\000O\003\133\003\134\003\133\003\134\000\164\000N\004\240\001\t\000\179\000\170\000\172\000\180\005\001\004\002\000\176\006^\003\244\006\255\0043\006^\006\200\003\208\001\210\004\n\002\190\005\002\003?\006\202\003R\000S\000_\004\218\005\005\003\133\003\134\004*\003[\006\241\007\027\005\r\000V\005\001\003\235\000\181\000p\000F\000\178\007!\004\240\006}\006\192\0042\005\016\000y\003\\\005\015\004\220\007\004\006^\003]\006j\004\n\002\147\003^\007\003\004\018\007\016\007\011\005\015\003_\007\r\000O\003\254\004*\001 \003\208\000\164\001\020\003\237\003\007\000\179\007\016\000\172\000\180\007\019\001\023\0005\007\"\004\001\003O\003A\000\187\002e\003\242\001\209\002f\003B\000\179\004\002\006\198\003P\005\019\000\188\001\023\000p\006\201\005H\005K\006\130\006m\003\209\003\233\001 \000y\003\243\000\181\003>\004\240\000\178\007?\007\015\003\254\005I\005I\001 \007\020\006\161\005\144\000N\000N\001\t\000\179\000\170\001D\000\180\007@\001E\000\176\003\254\003\244\002\159\0043\001 \006\200\000\182\001\210\004\n\003\248\001\023\003?\006\202\003R\0006\006b\007\024\006f\005\153\006t\004*\003[\007\025\007\028\007\029\000\183\003\212\003\235\000\181\000p\000\184\007\015\007\016\007 \006}\006\192\0042\007#\000y\003\\\000\185\007$\005\154\0075\003]\005\157\005L\005M\003^\001 \006y\003\215\001\t\003\207\003_\007*\000O\000O\006a\001 \001F\000\164\006`\003\237\003\007\000\179\001G\000\172\000\180\0073\007/\006\244\0072\004\001\003O\003A\000\187\007;\003\242\000p\000w\003B\000\179\004\002\006\198\003P\0079\000\190\000y\0005\006\209\003\208\007=\006\130\005s\007B\003\233\000p\000\000\003\243\000\181\006_\002\217\000\178\001V\000\000\000y\000p\002\133\002\134\002\135\002\137\000\000\000N\000z\001\t\000y\000\170\005q\005L\005M\000\000\000\176\002S\003\244\000\000\0043\005N\006\200\000\182\001\210\004\n\003\007\000\000\003?\006\202\003R\000\000\005\131\005L\005M\002S\000z\004*\003[\005<\000\000\000\000\000\183\000\000\003\235\002S\000p\000\254\000\000\0006\000\000\006}\006\192\0042\000\000\000y\003\\\000\185\000N\001\t\000\000\003]\000\170\005:\000\000\003^\000\000\000\174\005=\005L\005M\003_\000\000\000O\003\209\000\000\001 \001\t\000\164\000\000\003\237\003\007\000\179\000\179\000\172\000\180\001W\001\t\000\000\005\142\004\001\003O\003A\000\000\005N\003\242\000\000\001\023\003B\000\179\004\002\006\198\003P\000p\000\000\000\000\000\000\006\213\000\000\000\000\006\130\000\000\000y\003\233\005N\000\000\003\243\000\181\000\000\000\000\000\178\000\000\000\000\005\182\000O\005Z\0009\000\000\000\000\000\164\000N\000\000\001\t\000\000\000\170\000\172\001 \000\000\000\000\000\176\000\000\003\244\005\171\0043\000\000\006\200\000\182\001\210\004\n\005[\005N\003?\006\202\003R\000\000\005^\005L\005M\000\000\000\000\004*\003[\000\000\005\197\001\146\000\183\000\000\003\235\004\002\000p\001\001\000\178\000\000\000\000\002\217\004r\0042\000\000\000y\003\\\000\185\000\000\001\210\000\000\003]\000\000\001\211\005\195\003^\001\t\001\212\005\198\005L\005M\003_\000\000\000O\000\000\000\000\001 \000p\000\164\002T\003\237\003\007\000\179\002\139\000\172\000\180\000y\002\129\005\b\000\000\004\001\003O\003A\004\n\001\144\003\242\000\000\004\018\003B\000\179\004\002\006\198\003P\000p\000\000\004*\000\000\002T\000\000\000\000\006\130\000\000\000y\003\233\005N\002\129\003\243\000\181\000\000\000\000\000\178\000\000\000\000\000\000\000\000\001\230\001 \000\000\000\000\001\213\000N\000\000\001\t\000\179\000\170\001\214\000\180\000\000\000\000\000\176\000\000\003\244\000\000\0043\001 \006\200\000\182\001\210\004\n\000\000\005N\003?\006\202\003R\001 \005\131\005L\005M\000\000\000\000\004*\003[\001\231\001\t\000\000\000\183\000\217\003\235\000\181\000p\001R\001\232\000\000\000\000\002\217\004r\0042\000\000\000y\003\\\000\185\000\000\001\210\000\000\003]\000\000\001\211\000\000\003^\001\t\001\212\005\131\005L\005M\003_\000\000\000O\000\212\000\000\001 \000\000\000\164\001\233\003\237\003\007\000\179\000\000\000\172\000\180\001\022\000\000\000\000\000\000\004\001\003O\003A\000\183\001\023\003\242\000\000\000\218\003B\000\179\004\002\000\214\003P\004\211\004\128\000\000\000\000\000\000\000\185\005j\001\235\000\000\006\005\003\233\005N\000\000\003\243\000\181\000\000\000\000\000\178\000\000\000\000\005\208\000\000\001\230\001\227\002*\002\017\001\213\000\000\000\000\001\t\001 \000\179\001\214\006\006\001\228\006\t\005L\005M\003\244\000\000\0043\000\000\004z\000\182\001\210\004\n\000\000\005N\003?\004\018\003R\000\000\000\000\000\000\000p\002\028\005\223\004*\003[\001\231\000\000\002\020\000\183\000y\003\235\000\000\000p\001T\001\232\005p\001\238\002\217\004r\0042\000\000\000y\003\\\000\185\000\000\001\210\002\161\003]\000\000\001\211\000\000\003^\000\000\001\212\001\023\003\182\000\000\003_\000\000\005q\005L\005M\001 \000\000\002S\001\233\003\237\003\007\000\179\000\000\000\000\000\180\002\163\000\000\000\000\000\000\004\001\003O\003A\001\240\001\023\003\242\000\000\005N\003B\000\179\004\002\000\000\003P\004~\004\128\000\000\000p\001 \001\241\000\000\001\235\006Y\000\000\003\233\000\000\000y\003\243\000\181\000\000\0005\001\t\000\000\000\000\000\000\000\000\001\230\001\227\002'\002\017\001\213\000\000\000\000\001\t\001 \000\179\001\214\000\000\001\228\000\000\000\000\000\000\003\244\000\000\0043\000\000\004z\000\182\001\210\004\n\000\000\000\000\003?\004\018\003R\000\000\005N\000\000\000\000\002\028\000\000\004*\003[\001\231\000\000\002\020\000\183\000\000\003\235\000\000\000p\003T\001\232\005p\001\238\002\217\004r\0042\000\000\000y\003\\\000\185\005\233\001\210\000\000\003]\0006\001\211\000\000\003^\000\000\001\212\000\000\001\t\000\000\003_\000\000\005q\005L\005M\001 \000p\002\150\001\233\003\237\003\007\005\234\005\237\005L\005M\000y\000\000\000\000\000\000\004\001\003O\003A\001\240\005p\003\242\006\025\000\000\003B\000\179\004\002\000\000\003P\004\165\004\128\000p\002\133\002\141\001\241\002\137\001\235\000\000\000z\003\233\000y\000\000\003\243\000\000\005q\005L\005M\002S\000\000\000\000\000p\001\230\001\227\002$\002\017\001\213\000\000\000\000\001\t\000y\000\179\001\214\000\000\001\228\000\000\0009\000z\003\244\000\000\0043\000\000\004z\000\000\001\210\004\n\002S\000\000\003?\004\018\003R\000\000\005N\005w\000\000\002\028\004+\004*\003[\001\231\001\t\002\020\005N\000\000\003\235\002S\000p\006d\001\232\005p\001\238\002\217\004r\0042\0005\000y\003\\\000\000\000\000\001\210\000\000\003]\000\000\001\211\001\026\003^\000\000\001\212\001\t\000\000\000\000\003_\000\000\005q\005L\005M\001 \005N\000\000\001\233\003\237\003\007\000\000\004\031\000\000\000\000\000\000\001\t\000\000\006[\004\001\003O\003A\001\240\000\000\003\242\000p\001\023\003B\000\179\004\002\002\217\003P\004\215\004\128\000y\005\246\002\248\001\241\000\000\001\235\000\000\000\000\003\233\000\000\000\000\003\243\000\000\000\000\0005\0006\000\000\000\000\004Z\0005\001\230\001\227\002\"\002\017\001\213\000\000\003\007\001\t\000\000\000\179\001\214\001 \001\228\000\000\000\000\002S\003\244\000\000\0043\000\000\004z\000\000\001\210\004\n\005\247\000\000\003?\004\018\003R\000\000\005N\005}\000\000\002\028\000\000\004*\003[\001\231\006\015\002\020\006;\000p\003\235\000\000\000p\000\000\001\232\005\248\001\238\006}\000y\004\000\000\000\000y\003\\\001\"\006\005\001\t\002T\003]\0006\000\000\002\139\003^\000\000\0006\002\129\000\000\000\000\003_\000\000\006\016\0009\006\017\001 \000\000\005{\001\233\003\237\003\007\006\006\000\000\006\t\005L\005M\000\000\002T\000\000\004\001\003O\003A\001\240\005p\003\242\002\129\001$\003B\000\179\004\002\003\211\003P\006\157\004\128\000^\006\018\001 \001\241\006\205\001\235\000\000\000\000\003\233\000\000\002a\003\243\006\019\005q\005L\005M\000\000\002v\000\000\000\000\000\000\001\227\002\015\002\017\001\t\000\000\000\000\001\t\000\000\000\179\001 \000\000\001\228\002d\003\208\000\000\003\244\000\000\0043\0009\004z\000\000\001\210\004\n\000\000\004\002\003?\004\018\003R\001\026\000\000\005\138\000\000\002\028\000\000\004*\003[\000p\000\000\002\020\000{\005N\003\235\000N\000p\000\000\000y\001D\001\238\006}\001P\004\000\000\000\000y\003\\\005\249\002\127\000p\002\133\003]\000\000\002\140\000\000\003^\000\000\000\000\000y\0005\005\n\003_\000\000\000\000\004`\004\n\001 \005N\000\000\004\018\003\237\003\007\000\000\002S\0005\000\000\000\000\004*\000\000\000\000\004\001\003O\003A\001\240\000z\003\242\000S\000c\003B\000\179\004\002\006\191\003P\002S\000\000\003\209\000\000\000V\001\241\006\190\006\130\000O\000F\003\233\001F\000\000\006\194\001\147\000\000\0005\001G\000\000\000\000\000\000\000\000\001\t\001 \000\000\002\219\000\000\000\000\000\000\001\t\005\252\0005\0006\000\000\000\000\000\000\0005\000\000\003\244\000\000\004\005\006\196\001\t\002e\001\210\004\n\002f\0006\003?\006\202\003R\001\150\000\000\000\000\001\023\001V\000\000\004*\003[\000\000\000\000\000\000\006,\000p\003\235\000\000\000p\000\000\000\000\000\000\000\000\006}\000y\004\000\000\000\000y\003\\\000\000\000\000\000p\000\000\003]\0006\000\000\006Y\003^\000\000\000\000\000y\000\000\000\000\003_\001\"\001 \000\000\000\000\001 \0006\005\136\000\000\003\237\003\007\0006\000\000\000p\002\133\002\134\002\145\002\137\0009\004\001\003O\003A\000y\000\000\003\242\000\000\000\000\003B\000\179\004\002\006\191\003P\000\000\0009\000\000\000\000\000\000\000\000\006\193\006\130\000\000\001$\003\233\000\000\002a\006\194\000\000\000\000\000z\000\179\000p\002c\001W\000\000\000\000\006Y\000\000\002S\001\t\000y\000N\001\t\000\000\000\000\000\170\0027\000\000\002d\0009\000\174\003\244\000\000\004\005\006\196\001\t\000\000\001\210\004\n\000\000\000\000\003?\006\202\003R\0009\000\000\004\031\000\000\001\153\0009\004*\003[\000\000\000\000\000\000\002T\002\142\003\235\000N\000p\001\t\002\243\001D\002\129\002\217\001P\004\000\000\000\000y\003\\\002\248\000\000\000N\001Z\003]\0005\000\170\000\000\003^\000\000\000\000\000\171\001\026\000\000\003_\002\248\004Z\000O\000\000\001 \000\000\001[\000\164\003\237\003\007\000\000\001\163\001\t\000\172\000\000\001]\002\249\001 \004\001\003O\003A\001^\000\000\003\242\000\000\000\000\003B\000\179\004\002\006\191\003P\006\132\000\000\000\000\002\219\001\202\000\000\000\000\006\130\000O\002\253\003\233\001F\000\000\006\194\001\147\000\000\000\000\001G\000\178\000{\006c\000\000\000O\000\000\006\159\0006\000\000\000\164\000\000\001\t\000\000\000\000\004\223\000\172\000\000\002Q\000\000\004\160\003\244\0005\004\005\006\196\000\000\002e\001\210\004\n\002f\000\000\003?\006\202\003R\001\150\000\000\005p\001\023\001V\000\000\004*\003[\0005\005\194\000\000\006[\002\139\003\235\000\000\000p\000\000\000\000\000\178\001\023\002\217\000\000\004\000\000\000\000y\003\\\005q\005L\005M\000\000\003]\006Z\002\219\005\195\003^\000\000\002T\005\198\005L\005M\003_\000\000\001 \000\000\002\129\001 \000\000\000\000\000\000\003\237\003\007\0009\000\179\005p\0006\000\180\0005\000\000\001 \004\001\003O\003A\000\000\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\006[\0006\000\000\000\000\005q\005L\005M\003\249\001\023\003\233\001 \000\000\004\149\000\000\000\181\000p\000\179\000\000\000\000\001W\002\217\003\251\004\000\000\000\000y\000\000\000\000\005p\001\t\000\000\000\179\004\158\001\151\000\180\000\000\005N\004\160\003\244\000\000\004\005\004\151\001\"\000\000\000\212\004\n\004\031\005N\001 \004\018\0006\003\007\005q\005L\005M\001\153\000\000\004*\003[\0009\004\001\000\000\003A\000\183\003\235\000\000\000\181\000\213\003B\000\000\002\248\000\214\000\000\000\000\000\000\000\000\003\\\005\156\000\185\0009\001Z\003]\001$\003\233\000\000\003^\004$\005N\000Y\0005\000N\003_\0005\000\000\001D\000\000\001 \001P\001[\000\000\003\237\005\154\001\t\001\163\005\157\005L\005M\001]\000\000\000\000\004(\003O\000\000\001^\000\187\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\000\000\000\192\004\031\0009\000\000\000p\000\000\000\000\004\007\002\219\005N\000\000\004\149\003\235\000y\000p\000\000\000\000\000\000\000\000\002\217\004\b\0042\000\000\000y\000\000\002\248\000\000\000\000\000\000\000\000\0006\000O\0005\0006\001F\005\134\003\244\001\147\004\005\004\151\001G\004$\005\200\004\n\000\000\001\216\000\000\004\018\003\237\003\007\000\000\000\000\0005\000\000\000\000\004*\003[\000\000\004\001\003O\003A\005N\000\000\003\242\000\000\004(\003B\000\179\004\002\000\000\003P\000\000\003\214\000\000\003\\\000\000\002w\000S\001V\003]\000\000\003\233\000\000\003^\0047\0005\005\149\000\000\000V\003_\001\t\000N\000\000\000F\001 \003?\002\219\003@\0006\002d\001\t\000\000\000\000\0005\000\000\000\000\000\000\0009\000\000\003\244\003\208\004\005\0049\000\000\000\000\001\210\004\n\000\000\0006\003?\004;\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\0045\000\000\000\000\005\164\000N\003\235\000\\\000p\003?\000\000\003R\000\000\002\217\004\b\0042\000\000\000y\003\\\000\000\000\000\000\000\0006\003]\000\000\005p\000\000\003^\000O\0005\003A\000\000\000\000\003_\000\179\000\000\003B\001W\001 \000\000\0006\000\000\003\237\003\007\000\000\000\000\0009\000\000\000\000\005q\005L\005M\004\001\003O\003A\000\000\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\0009\000p\000\000\000{\003\209\000O\001\161\003A\004:\003\233\000y\000\000\003\243\003B\000\000\000p\000\000\000\000\000\000\002\220\002\217\004\b\0042\0005\000y\000\000\000\000\000\000\001\t\0006\000N\001Z\000\000\0009\003?\002e\003@\003\244\002f\0043\002z\0044\000\000\002\227\004\n\000\000\001\023\000\000\004\018\001[\003\007\0009\000\000\000p\001\163\000S\004*\003[\001]\004\001\000\000\003A\000y\003\235\001^\005N\000V\003B\000\000\000\000\000\000\000F\000\000\000\000\006\139\003\\\000\000\000\000\003W\000\000\003]\006\152\003\233\000\000\003^\001 \003O\001\t\000\000\0006\003_\000{\000\000\000\000\000\179\001 \000O\003P\003A\003\237\000\000\001\t\000\000\000\000\003B\000\000\0009\003\001\000\000\000\000\003O\0005\000\000\000\000\003\242\0005\001\210\000\000\000\179\004\002\003?\003P\003R\000\000\001\225\002a\000\000\000\000\000\000\003O\000\000\003\005\002y\000\000\000\000\003\243\003\235\000\179\000p\001\t\003P\005\153\000{\002\217\004r\0042\000\000\000y\002d\0005\000\000\000\000\000\000\000\000\003Y\002\219\000\000\000\000\002W\002\219\003\244\000\000\0043\000\000\0044\005\154\0009\004\n\005\157\005L\005M\004\018\003\237\003\007\003\131\000\000\000\000\0006\000\000\004*\003[\0006\004\001\003O\003A\000\000\000\000\003\242\000\000\005\175\003B\000\179\004\002\000\000\003P\000\000\000\000\002t\003\\\003[\006\153\000\000\000\000\003]\000\000\003\233\000\000\003^\003\243\000\000\000\000\000\000\000N\003_\000\000\0006\000\170\003\\\001 \000\000\003O\000\171\003]\000\000\001\t\006\154\003^\006\142\000\179\000\000\006\143\003P\003_\003\244\0005\0043\000\000\0044\001\023\001\210\004\n\000\000\000\000\003?\004\018\003R\000\000\000\000\000\000\000\000\005N\000\000\004*\003[\0009\000\000\000\000\000{\0009\003\235\000\000\000p\000\000\000\000\000\000\000\000\002\217\004r\0042\000\000\000y\003\\\000\000\002\131\000\000\005\153\003]\001 \000O\002e\003^\000\000\002f\000\164\000\000\000\000\003_\000\000\000\000\000\172\001\023\001 \0009\000\000\000\000\003\237\003\007\000\000\000\000\005\154\0006\000\000\005\157\005L\005M\004\001\003O\003A\003Q\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\004y\000\000\000\000\000N\000\000\000\000\000\178\001\211\0005\003\233\001 \001\212\003\243\000\000\000\000\000p\000\000\000\000\000\000\000\000\002\217\004r\0042\0005\000y\000\000\000{\000N\001\t\000\000\000{\000\170\000\000\000\000\000\000\000\000\000\171\003\244\000\000\0043\000\000\004z\003\b\000\000\004\n\000\000\004,\000\000\004\018\000\000\003\007\000\000\005\177\000\000\000\000\000\000\004*\003[\0009\004\001\000\000\003A\005p\003\235\002o\005N\003\012\003B\000\000\000O\0040\000\000\000\000\001\213\0006\003\\\000\000\000\000\000\000\001\214\003]\006\005\003\233\000\000\003^\000\000\005q\005L\005M\0006\003_\000\179\000\000\000O\000\180\001 \000\000\000\000\000\164\003\237\005\153\001\t\000\000\0005\000\172\006\006\005p\006\t\005L\005M\003O\0005\000\000\000\000\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\004{\005\154\000\000\000\181\005\157\005L\005M\005q\005L\005M\000\000\0005\003\243\003\235\000\000\000p\000\000\000\178\000\000\000\000\002\217\004\152\0042\000\000\000y\000\000\000{\000N\0009\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\176\003\244\006^\0043\000\000\004z\002\232\0009\004\n\005N\0006\000\000\004\018\003\237\003\007\000\187\000\000\000\000\0006\002\219\004*\003[\000\000\004\001\003O\003A\000\194\005\203\003\242\000\000\005N\003B\000\179\004\002\001\227\003P\000\000\004\141\000\000\003\\\000\000\0006\000\179\000\000\003]\001\228\003\233\000\000\003^\003\243\005N\000\000\000\000\005N\003_\000\000\000\000\000O\000\000\001 \000\000\000\000\000\164\000\000\000\000\001\t\000\179\000\000\000\172\000\180\000\000\004\154\000\000\000\000\003\244\000\000\0043\000\000\004z\000\000\001\210\004\n\000\000\000{\003?\004\018\003R\0009\000\000\005p\000\000\000\000\000\000\004*\003[\0009\0005\000\000\003D\003\159\003\235\000\181\000p\000\000\000\178\005p\000\000\002\217\004\152\0042\000\000\000y\003\\\005q\005L\005M\000\000\003]\0009\000\000\000\000\003^\000\000\006^\001\229\0005\000\000\003_\000\000\005q\005L\005M\001 \005\188\000\000\000\000\003\237\003\007\000\000\006\005\002\219\000\000\000\000\000\000\000\000\000\000\004\001\003O\003A\000\187\000\000\003\242\0063\001\210\003B\000\179\004\002\003?\003P\003R\000\196\000\000\0006\006\006\000\000\006\t\005L\005M\004\174\003\233\000\000\006\031\003\243\000\000\000\000\000p\000\000\005\186\003M\000\000\002\217\004\b\0042\006b\000y\002\243\000{\000\000\001\t\000\179\000\000\0006\000\180\000\000\004\156\005N\000\000\003\244\0005\0043\000\000\004\155\003\167\000\000\004\n\0005\000\000\005p\004\018\002\248\003\007\005N\000\000\000p\000\000\000\000\004*\003[\002\217\004\001\000\000\003A\000y\003\235\000\181\002\249\000\000\003B\000\000\000\000\000\000\005q\005L\005M\000\000\003\\\000\000\000\000\000\000\0009\003]\000\000\003\233\000\000\003^\000\000\000\000\005N\003\007\002\253\003_\000\000\000\000\000\182\000\000\001 \000\000\002S\000\000\003\237\000\000\001\t\000\000\000\000\0006\000\000\005p\000\000\0009\000\000\003O\0006\000\183\000\000\003\242\000\000\001\210\003V\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\000\000\000\185\000p\000N\005q\005L\005M\000\161\002K\003\243\003\235\000y\000p\001\t\000\000\000\000\000\000\002\217\006b\004\000\004\031\000y\000\000\000\000\001\210\000N\000\000\005N\001\211\000\161\002G\000\000\001\212\005\184\003\244\000\000\0043\000\000\004\155\000\000\000\000\004\n\000\000\000\000\002\248\004\018\003\237\003\007\000\000\005\214\000\000\000\000\000\000\004*\003[\0009\004\001\003O\003A\000\000\004$\003\242\0009\000\000\003B\000\179\004\002\000\000\003P\000O\000\000\000\000\003\\\000{\000\164\006\147\000\000\003]\000\000\003\233\000\165\003^\003\243\0066\004(\000\000\005N\003_\001\t\003\183\001\230\000O\001 \000\000\001\213\000\000\000\164\000\000\001\t\000\000\001\214\004\209\000\165\000\000\004\002\005p\004\160\003\244\000\000\0043\000\000\0044\000\000\001\210\004\n\000\000\000\178\003?\004\018\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\005q\005L\005M\000\000\003\235\000\000\000p\001\232\000\000\000\178\000\000\002\217\000\000\004\000\000\000\000y\003\\\000{\005\012\000\000\005p\003]\005\212\004\n\003\152\003^\000\000\004\018\000\000\000\000\000\000\003_\000\000\003\189\000\000\004*\001 \000\000\001\233\000\000\003\237\003\007\000\000\000\000\005q\005L\005M\000\000\000\000\000\000\004\001\003O\003A\000\000\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\000\005p\000\000\000\000\000\000\001\235\000\000\000\000\000\179\003\233\001 \000\180\004\149\000\000\000\000\000p\000\000\005\210\005N\000\000\002\217\001\227\004\000\002\014\000y\005q\005L\005M\001\t\000\179\000\179\004\225\001\228\000\180\000\000\006\142\004\160\003\244\006\143\004\005\004\151\006\150\000\000\000\181\004\n\000\000\001\023\005p\004\018\000\000\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\0005\004\001\000\000\003A\005N\003\235\000\000\000\181\000\000\003B\001\238\000\000\000\000\005q\005L\005M\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\001 \0005\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\003\237\000\000\001\t\000\000\0005\004\227\000\000\000\000\005N\000\000\004\160\003O\001\240\000\000\000\000\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\000\000\0006\000\000\001\241\000\000\000\000\000N\000\000\000\000\000\000\000\161\002A\004\149\003\235\000\000\000p\000\000\000\000\000\000\005\227\002\217\000\000\004\000\000\000\000y\000\000\000\000\001\210\000N\0006\005N\001\211\000\161\0026\000\000\001\212\000\000\003\244\000\000\004\005\004\151\000\000\000\000\000\000\004\n\000\000\0006\000\000\004\018\003\237\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000\000\005\225\003\242\000\000\000\000\003B\000\179\004\002\000\000\003P\000O\000\000\000\000\003\\\000\000\000\164\0009\000\000\003]\000\000\003\233\000\165\003^\004\149\000\000\000\000\000\000\000\000\003_\000\000\000\000\001\230\000O\001 \000\000\001\213\000\000\000\164\000\000\001\t\000\000\001\214\006g\000\165\0009\000\000\006\029\004\160\003\244\000\000\004\005\004\151\000\000\000\000\001\210\004\n\000\000\000\178\003?\004\018\003R\0009\000\000\000\000\000\000\000\000\000\000\004*\003[\006o\000\000\000\000\000\000\000\000\003\235\000\000\000p\001\232\000\000\000\178\000\000\002\217\004\b\0042\000\000\000y\003\\\000\000\000\000\000\000\000\000\003]\006\"\000\000\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000{\001\233\000\000\003\237\003\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\001\003O\003A\004\022\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\000\000{\000\000\000\000\000\000\001\235\000\000\000\000\000\179\003\233\000\000\000\180\004\149\000\000\000\000\000p\000\000\004Q\000{\000\000\002\217\001\227\004\000\001\237\000y\000\000\000\000\000\000\001\t\000\179\000\179\000\000\001\228\000\180\004a\000\000\000\000\003\244\000\000\004\005\004\151\000\000\000\000\000\181\004\n\000\000\000\000\000\000\004\018\000\000\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\000\000\003A\000\000\003\235\000\000\000\181\000\000\003B\001\238\000\000\000\000\000\000\000\000\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\003\237\000\000\001\t\000\000\000\000\006u\000\000\000\000\000\000\000\000\004\160\003O\001\240\000\000\000\000\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\001\241\000\000\000\000\000\000\000\000\006\163\000\000\000\000\000\000\003\243\003\235\000\000\000p\000\000\000\000\000\000\000\000\002\217\004\b\0042\000\000\000y\000\000\000\000\000N\000N\000\000\000\000\000\170\000\161\0023\000\000\000\000\000\171\003\244\000\000\0043\000\000\0044\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\003\007\000\000\000\000\000p\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000y\000\000\003\242\000\000\000\000\003B\000\179\004\002\000\000\003P\000\000\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\004\149\000\000\000\000\000\000\000\000\003_\000\000\000\000\000O\000O\001 \000\000\000\000\000\164\000\164\000\000\001\t\000\000\000\000\000\172\000\165\000\000\000\000\000\000\000\000\003\244\000\000\004\005\004\151\000\000\000\000\001\210\004\n\000\000\004\169\003?\004\018\003R\000\000\000\000\000\000\006\139\000\000\000\000\004*\003[\000\000\000\000\006\151\000\000\000\000\003\235\000\000\000p\001\t\000\178\000\178\000\000\002\217\000\000\0042\000\000\000y\003\\\000\000\000\000\000\000\000\000\003]\000\000\000\000\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\003\237\003\007\000\000\000\000\000p\000\000\000\000\000\000\000\000\000\000\004\001\003O\003A\000y\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\000\000\000\000\000p\000\000\000\000\000\000\003\233\000\000\0046\003\243\000\000\000y\000p\000\000\000\000\000\000\000\000\002\217\000\000\004\000\000\000\000y\000\000\000\000\000N\001\t\000\179\000\179\000\170\000\180\000\180\000\000\000\000\000\171\003\244\000\000\0043\000\000\0044\000\000\000\000\004\n\000\000\000\000\000\000\004\018\000\000\003\007\000\000\000\000\006\139\000\000\000\000\004*\003[\000\000\004\001\006\146\003A\000\000\003\235\000\181\000\181\001\t\003B\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\\\000\000\000\000\006\139\000\000\003]\000\000\003\233\006\142\003^\006\141\006\143\000\000\000\000\000\000\003_\001\t\000\000\000O\001\023\001 \000\000\000\000\000\164\003\237\000\000\001\t\000\000\000\000\000\172\000\000\000\000\000\000\000\000\000\000\003O\000\000\000\187\000\000\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\000\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \003\255\004\171\003\235\000\000\000p\000\000\000\178\000\000\000\000\002\217\000\000\004\000\000\000\000y\000\000\000\000\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\171\003\244\000\000\0043\000\000\004\173\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000\000\000\000\003\242\000\000\000N\003B\000\179\004\002\001D\003P\000\000\001P\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\006\142\003^\004\003\006\143\000\000\000\000\000\000\003_\000\000\000\000\000O\001\023\001 \000\000\000\000\000\164\000\000\000\000\001\t\000\179\000\000\000\172\000\180\000\000\000\000\006\142\000\000\003\244\006\143\004\005\004\006\000\000\000\000\001\210\004\n\000\000\001\023\003?\004\018\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\000O\001 \004\t\001F\003\235\000\181\000p\000\000\000\178\001G\000\000\002\217\000\000\004\000\000\000\000y\003\\\000\000\000\000\000\000\000\000\003]\000\000\000\000\000\000\003^\001 \000\000\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\003\237\003\007\000\000\000\000\000\000\000\000\000\000\001V\000\000\000\000\004\001\003O\003A\000\187\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\200\000\000\000\000\000\000\000\000\000p\000\000\000\000\000\000\003\233\000\000\000\000\004\003\000\000\000y\000p\000\000\000\000\000\000\000\000\002\217\000\000\004\000\000\000\000y\000\000\000\000\000N\001\t\000\179\000\000\000\170\000\180\000\000\000\000\000\000\000\171\003\244\000\000\004\005\004\006\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\000\000\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\000\000\003A\000\000\003\235\000\181\000\000\000\000\003B\000\179\000\000\000\000\001W\000\000\000\000\000\000\003\\\000\000\000\000\006\139\000\000\003]\000\000\003\233\000\000\003^\006\149\000\000\000\000\000\000\000\000\003_\001\t\000\000\000O\000\000\001 \000\000\000\000\000\164\003\237\000\000\001\t\000\000\000\000\000\172\000\000\000\000\000\000\000\000\000\000\003O\000\000\000\187\000\000\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\000\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001Z\000\000\000\000\000\000\004\003\003\235\000\000\000p\000\000\000\178\000\000\000\000\002\217\000N\004\000\000\000\000y\000\170\001[\000\000\000\000\000\000\000\171\001\149\000\000\000\000\000\000\001]\000\000\003\244\000\000\004\005\004\006\001^\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000\000\000\000\003\242\000\000\000\000\003B\000\179\004\002\000p\003P\000\000\000\000\000\000\003\\\000\000\004}\000\000\000y\003]\000\000\003\233\000\000\003^\004v\000\000\000O\000\000\000\000\003_\000\000\000\164\000\000\000\000\001 \000\000\000\000\000\172\000\000\000N\001\t\000\179\000\000\000\170\000\180\000\000\000\000\006\142\000\171\003\244\006\143\004\005\004x\000\000\000\000\001\210\004\n\000\000\001\023\003?\004\018\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\000\000\000\000\000\178\000\000\003\235\000\181\000p\000\000\000\000\000\000\002a\002\217\000\000\004\000\000\000\000y\003\\\002k\000\000\000\000\000\000\003]\000\000\000\000\001\t\003^\001 \000\000\000\000\000\000\000\000\003_\000\000\002d\000O\000\000\001 \000\000\000\000\000\164\003\237\003\007\000\000\000\000\000\000\000\172\000\000\000\000\000\000\000\000\004\001\003O\003A\000\187\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\204\000\000\000\000\000\000\004u\000\000\000\000\000\000\000\000\003\233\000\000\000\000\004v\000\000\000\000\000p\000\000\000\178\000\000\000\000\002\217\000\000\004\000\000\179\000y\000\000\000\180\000N\001\t\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\171\003\244\000\000\004\005\004x\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\000\000\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\181\004\001\000\000\003A\000\000\003\235\000\000\000\000\000\000\003B\000\000\000\000\000\000\000\000\002l\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\000\000\000O\000\000\001 \000\000\002m\000\164\003\237\002e\001\t\000\179\002f\000\172\000\180\000\187\000\000\000\000\000\000\003O\001\023\000\000\000\000\003\242\000\000\001\210\000\206\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\004\137\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\138\003\235\000\181\000p\000\000\000\178\000\000\000\000\002\217\000N\004\000\000\000\000y\000\170\000\000\001 \000\000\000\000\000\171\000\000\000\000\000\000\000\000\000\000\000\000\003\244\000\000\004\005\004\140\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000\187\000\000\003\242\000\000\000\000\003B\000\179\004\002\000p\003P\000\000\000\208\000\000\003\\\000\000\004\135\000\000\000y\003]\000\000\003\233\000\000\003^\004v\000\000\000O\000\000\000N\003_\000\000\000\164\000\161\0022\001 \000\000\000\000\000\172\000\000\000\000\001\t\000\179\000\000\000\000\000\180\000\000\000\000\000\000\004\148\003\244\000\000\004\005\004x\000\000\000\000\001\210\004\n\000\000\000\000\003?\004\018\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\000\000\000\000\000\178\000\000\003\235\000\181\000p\000\000\000\000\000\000\002a\002\217\000\000\004\000\000\000\000y\003\\\002k\000\000\000\000\000\000\003]\000\000\000O\001\t\003^\000\000\000\000\000\164\000\000\000\000\003_\000\000\002d\000\165\000\000\001 \000\000\000\000\000\000\003\237\003\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\001\003O\003A\000\187\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\222\000\000\000\000\000\000\000\000\000\000\000\178\000\000\000\000\003\233\006k\000\000\004\149\000\000\000\000\000p\000\000\000\000\000\000\000\000\002\217\000N\004\000\000\179\000y\000\170\000\180\000\000\001\t\000\000\000\171\000\000\000\000\000\000\000\000\000\000\004\153\003\244\000\000\004\005\004\151\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\000\000\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\181\004\001\000\000\003A\000\000\003\235\000\000\000\000\000\000\003B\000\000\000\000\000\000\000\000\002l\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\000\000\000\000\000O\000\000\000\000\003_\000\179\000\164\000\000\000\180\001 \000\000\002r\000\172\003\237\002e\001\t\000\000\002f\000\000\000\000\000\187\000\000\000\000\000\000\003O\001\023\000\000\000\000\003\242\000\000\001\210\000\224\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\006w\000\178\004\149\003\235\000\000\000p\000\000\000\000\000\000\000\000\002\217\000N\004\000\000\000\000y\000\170\000\000\001 \000N\000\000\000\171\000\000\001D\000\000\000\000\001P\000\000\003\244\000\000\004\005\004\151\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000\000\000\000\003\242\000\000\000\000\003B\000\179\004\002\000\000\003P\000\000\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\006l\000\000\000O\000\000\000\000\003_\000\000\000\164\000\000\000O\001 \000\179\001F\000\172\000\180\001\147\001\t\000\000\001G\000\000\000\000\000\000\000\000\000\000\000\000\003\244\000\000\004\005\006n\000\000\000\000\001\210\004\n\000\000\000\000\003?\004\018\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\000\181\000\000\006z\000\178\000\000\003\235\001\150\000p\000\000\000\000\001V\000\000\002\217\000\000\004\000\000\000\000y\003\\\000\000\000\000\000\000\000\000\003]\000\000\000\000\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\003\237\003\007\000\000\000\000\000\000\000\000\000\000\002/\000\000\000\000\004\001\003O\003A\000\000\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\233\000\000\000\000\006l\000\000\000\000\000p\000\000\000\000\000\000\000\000\002\217\000\000\004\248\000\179\000y\000N\000\180\000\000\001\t\000\170\000\179\000\000\000\000\001W\000\174\000\000\000\000\003\244\000\000\004\005\006n\000\000\000\000\000\000\004\n\000\000\001\174\001\210\004\018\000\000\003\007\001\211\000\000\000\000\000\000\001\212\004*\003[\000\181\004\001\000\000\003A\000\000\003\235\000\000\000\000\000\000\003B\001\153\000\000\000\000\000\000\000\000\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000O\000\000\001Z\000\000\001 \000\164\000\000\000\210\003\237\000\000\001\t\000\172\000\000\000\000\000\000\001\b\000\000\000\000\000\000\003O\001[\000\000\001\230\003\242\002L\001\163\001\213\000\179\004\002\001]\003P\000\000\001\214\000\000\000\000\001^\000\000\000\000\000\000\000p\000\000\000\000\000\000\000\000\006l\003\235\000\000\000\178\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\231\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\232\003\244\000\000\004\005\006n\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\004\249\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\000\000\003O\000\000\000\000\000\000\003\242\000\000\000\000\001\233\000\179\004\002\001\210\003P\000\000\000\000\003?\003\\\003R\000\000\000\000\002a\003]\000\000\000\000\000\000\003^\003\243\002k\000\000\000\000\000\000\003_\000\000\000p\001\t\000\000\001 \000\000\002\217\001\235\004\248\000\179\000y\002d\000\180\000\000\000\000\000\000\000\000\000\000\000\000\003\244\000\000\004\252\000\000\001\227\003\129\002\017\004\n\000\000\000\000\000\000\004\018\000\179\000\000\000\000\001\228\000\000\003\007\000\219\004*\003[\000\000\000\000\000\000\000\000\000\181\004\001\000\000\003A\000\000\000\000\000\000\000\000\001\210\003B\000\000\002\028\003?\003\\\003R\000\000\000\000\002\020\003]\000\000\000\000\000\000\003^\000\000\003\233\000\000\001\238\000\000\003_\000\212\000p\000\000\000\000\001 \000\000\002\217\000\000\004\248\000\000\000y\000N\000\000\000\000\001\t\000\170\000\000\000\000\000\000\000\183\000\171\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\000\000\185\000\000\003\007\000\000\000\000\000\000\001\240\002l\000\000\000\000\000\000\004\001\000\000\003A\000\000\003\235\000\000\000\000\000\000\003B\000\000\001\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\235\000\000\003\233\002e\000\000\000\000\002f\000\000\000\000\000N\000\000\000O\000\000\003?\001\023\003R\000\164\000\000\000\000\003\237\004\251\001\t\000\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003O\000p\000\000\000\000\003\242\000\000\003\157\000\000\000\179\004\002\000y\003P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\000\003\243\003\235\000\000\000\178\000\000\000\000\004\187\000\000\000N\000\000\000\000\003\188\003?\000\000\003R\000\000\000\000\000\000\000\000\000\000\003\194\000\000\003A\000\000\000\000\003\244\000\000\004\252\003B\000\000\000p\000\000\004\n\000\000\000\000\003\157\004\018\003\237\004\254\000y\000\000\000\000\000\000\004\190\004*\003[\000\000\004\192\003O\000\000\000\000\000\000\003\242\000\000\000\000\000\000\000\179\004\002\000\000\003P\004\199\000\000\001\t\003\\\000\000\003\188\000\000\000\000\003]\000\000\000\000\000\000\003^\003\243\003\194\000\000\003A\000N\003_\000\000\000\000\000\170\003B\001 \000\000\000\000\000\174\000\000\000\179\004\196\000\000\000\180\000\000\003W\000\000\000\000\001\012\004\190\003\244\000p\004\252\004\192\000\000\000\000\003\157\004\n\000\000\000\000\000y\004\018\000\000\000\000\000\000\000\000\000\000\000\000\001\t\004*\003[\000\000\000N\000\000\000\000\000\181\000\161\0021\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\188\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\194\003O\003^\000\000\000\000\000\164\000\000\000\210\003_\000\179\004D\000\172\003P\001 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\195\000\000\004n\004>\000\187\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\226\000\000\000\000\001\t\000O\000\000\000N\000\000\000\178\000\164\003?\000\000\003R\000\000\000\000\000\165\003O\000\000\000\000\004E\000\000\000\000\000\000\004\198\000\179\004D\000\000\003P\000p\000\000\000\000\004_\003[\003\157\000\000\000N\000\000\000y\000\000\000\170\000\000\003\243\000\000\000\000\000\174\000N\000\000\000\000\000\000\000\170\003\\\000\178\000\000\000\000\000\171\003]\000\000\000p\004\189\003^\000\000\000\000\000\000\003\188\000\000\003_\000y\000\000\000\000\000\000\001 \000\000\003\194\004E\003A\000\000\000\000\004M\000\000\000N\003B\000\000\000\000\000\170\000\000\004_\003[\000\000\000\174\000\000\000\000\000\000\000\000\000\179\004D\004\190\000\180\000\000\000\000\004\192\000\000\000O\000\000\000\000\003\\\000\000\000\164\000\000\000\210\003]\000\000\000O\000\172\003^\001\t\000\000\000\164\000\000\000\000\003_\000\000\000\219\000\172\000\000\001 \000\000\000\000\000\000\000\181\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\179\000\000\000\174\000\180\000\000\000\000\004E\001\t\000\000\000O\004M\000\000\000\178\000\000\000\164\000p\000\210\000\000\004_\000\000\000\172\000\212\000\178\000\000\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000N\000\000\000\000\000\181\000\161\0020\000\000\0029\000\183\001\012\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\000\000\185\000\178\001 \000\000\000O\003O\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000\179\004D\000\172\003P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\n\000\000\003\243\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000O\000\000\000\180\001\t\000\000\000\164\000\000\000\000\000\178\000\179\000\000\000\165\000\180\000\000\000N\000\000\000\000\000\000\001D\004E\000\000\001P\000\000\004M\000\000\000\000\000\000\001\014\000\000\000\000\000\000\004_\003[\000\000\000\181\001\n\000p\001\012\000\000\000\000\000\000\000\000\000\000\000\179\000\181\000y\000\180\000\178\000\000\000\000\003\\\000\000\001\020\000\000\000\000\003]\000\000\000\000\000\000\003^\001\023\000\000\000\000\000\212\000\000\003_\000\000\000\000\000\000\000\000\001 \001\014\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000O\000N\000\183\001F\000\000\001D\000\220\000\000\001P\001G\000\214\000\000\002=\000\179\000N\000\000\000\180\000\185\001D\001 \000\000\001P\000\000\000p\000\000\000\000\000\000\000\212\000\000\000\000\000\000\000\000\000y\000\000\000\000\000\000\000p\000\000\000\000\000\000\001\135\001\014\001\t\000\000\000\000\000y\000\183\001V\000\181\000\000\000\220\000\000\000\179\000\000\000\214\000\180\000\000\000\000\000\000\000\000\000\000\000\185\000\000\000\000\000\000\000\000\001\020\000O\000\000\000\000\001F\000\000\000\000\000\000\001\023\000\000\001G\000\212\000\000\000\000\000O\000N\000\000\001F\000\000\001D\000\000\000\181\001P\001G\000\000\000\000\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\000\000\220\000\000\000\000\000p\000\214\000\000\000\000\001\135\000\000\001\t\000\000\000\185\000y\001 \001V\000\000\000\000\000\000\000\000\000\000\001\135\000\000\001\t\000\000\000\000\000\000\000\000\001V\000\000\000\000\000N\000\000\000\179\000\000\000\170\001W\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000O\000N\000\000\001F\000\000\001D\000N\000\000\001P\001G\000\170\001\136\001\137\000\000\000\000\000\171\000N\000\000\000\000\000\000\000\170\000\000\000\000\000p\000\000\000\174\000\000\000\000\000\000\000\000\000\000\000\000\000y\000\000\000\000\000\000\001X\000\000\001Y\000\000\001\135\000\000\001\t\000\000\000\000\000\000\001\023\001V\001Z\000O\000\000\000\000\000\179\000\000\000\164\001W\000\210\000\000\000\000\000\000\000\172\000\000\000\000\000\000\000\000\000\179\001[\000O\001W\000\000\001F\001\\\000O\000\215\000\000\001]\001G\000\164\001\136\001\218\000\000\001^\000O\000\172\000\000\001 \001\127\000\164\000\000\000\210\000\000\001\136\003F\000\172\000\000\000\000\000\178\000\000\000\000\000\000\000\000\000\000\000\000\001X\000\000\001Y\001b\001\135\000\000\001\t\000\000\000\000\000\000\001\023\001V\001Z\001X\000\000\001Y\000\178\000\000\000\000\000\000\000N\000\000\000\000\001\023\001D\001Z\000\178\001P\000\000\000\179\001[\000\000\001W\000\000\000\000\001\\\000\000\000\000\000\000\001]\000\000\000\000\000p\001[\000\000\001^\000\000\000\000\001\\\001 \001\127\000y\001]\000\000\000\000\001\136\003\239\000\000\001^\000\000\000\000\000N\001 \001\127\000\000\000\161\000\163\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000\000\001X\000\180\001Y\000\000\000\000\000\000\000O\000\000\000\000\001F\001\023\000\000\001Z\000\000\000\000\001G\000\179\000\000\000\000\001W\000\000\000\179\000\000\000\000\000\180\000\000\000\219\000\000\000\000\000\000\001[\000\179\000N\000\181\000\180\001\\\000\170\000\000\000\000\001]\000\000\000\174\001\136\004\012\000\000\001^\001\135\000O\001\t\001 \001\127\000\000\000\164\001V\000p\000\000\000\181\000\000\000\165\000\219\000\000\000\000\000\212\000y\000\000\000\000\000\181\001X\000\000\001Y\000\000\000\000\006(\000\000\000\000\000\000\000\000\001\023\000\000\001Z\000\000\000\183\000\000\000p\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000y\000\000\000\178\000\212\000\185\001[\000O\006\005\000\000\000\000\001\\\000\164\000\187\000\210\001]\000\000\000\000\000\172\000\000\000\000\001^\000\000\000\183\000\228\001 \001\127\000\220\000\000\000\000\000\000\000\214\006\006\000\000\006\t\005L\005M\000\000\000\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000N\001\t\001W\000\000\000\170\000\000\000\178\000\000\000\000\000\174\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000p\000\000\000\000\001\136\004G\000\000\000\000\000\000\001\t\000y\000p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000y\000\000\000\180\000N\000\000\000\000\000\000\000\170\000\000\001X\000\000\001Y\000\171\000\000\000\000\000\000\000\000\000\000\000\000\001\023\000\000\001Z\000\000\000\000\000\000\000O\000\000\005N\006+\000\000\000\164\000\000\000\210\000\000\000\181\000O\000\172\000\000\000\000\001[\000\164\000\000\000\210\000\000\001\\\000\000\000\172\000\000\001]\000\000\000\179\000\000\000\000\000\180\001^\000\000\000\000\000\000\001 \001\127\000\000\000N\000\000\000\000\000\000\000\170\000\000\001\t\000\000\000O\000\174\000\000\000\178\000\000\000\164\000\000\000\000\001\t\001.\000\000\000\172\000\000\000\178\000p\000\000\000\181\000\000\000\000\000\000\000\000\000N\000\000\000y\000\000\001D\000\000\000\000\001P\000\000\000\000\000N\000\000\000\000\002;\000\170\000\000\000\000\000\000\000\000\000\171\000\000\001\023\000p\000\000\000\212\000\000\000\178\000\000\000\000\000\000\000\000\000y\000\000\000\000\000N\000\000\000\000\000O\001D\000\000\000\000\001P\000\164\000\183\000\210\000\000\000\000\000\220\000\172\000\000\002\192\000\214\000\000\000\000\000\000\000\000\000p\000\000\000\185\006.\001 \000\000\000\000\000\000\000\000\000y\000O\000\179\000\000\001F\000\180\000\000\000\000\000\000\000\000\001G\000O\000\179\000\000\001\t\000\180\000\164\000\000\000\000\000\178\000\000\000\000\000\172\000\000\002\197\000\000\000\000\000\000\000\000\000\000\001.\000\000\000\000\000\000\000\000\000O\000\000\000\181\001F\000\000\001&\001\134\000\000\001\t\001G\000\000\000\179\000\181\001V\000\180\000\000\000\000\000\000\000N\000\000\0024\000\000\001D\000\178\000\000\001P\000\000\000\000\001\023\000\000\001(\000\212\000\000\000\000\000\000\000\000\000\000\000\000\001\023\000\000\000p\000\212\001\t\000\000\000\000\000\000\000\181\001V\000\000\000y\000\183\000\000\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\183\000\000\000\000\000\000\000\220\000\185\000\000\001 \000\214\000\179\000\000\000\000\000\180\000\000\000\000\000\185\000\000\001 \000\000\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\000\001F\000\000\000\000\000\000\000\000\000\000\001G\000\187\000\000\000\000\001.\000\179\000\000\000\000\001W\000\000\000\000\000\181\000\230\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0010\000\000\001U\000\000\001\t\000\000\000\000\000\000\001\023\001V\000\179\000\212\000\000\001W\000\000\000\000\000\000\000\000\000N\000\000\000\000\000\181\001D\000\000\000\000\001P\000\000\001X\000\000\001Y\000\183\000\000\000\000\000p\000\220\000\000\000\000\001\023\000\214\001Z\000p\000\000\000y\000\000\000\000\000\185\000\000\001 \000\000\000y\000\000\000\000\000N\000\000\000\000\000\000\001D\001[\000\000\001P\000\000\001X\001\\\001Y\000\000\000\000\001]\000\000\000\000\000\187\001\130\001\023\001^\001Z\000p\000\000\001 \001\127\000\000\000\000\000\232\000\000\000\000\000y\000O\000\000\000\000\001F\000\000\000\000\000\000\001[\000\000\001G\000\179\000\000\001\\\001W\000\000\000\000\001]\000\000\000\000\000\000\000\000\002a\001^\000\000\000\000\000\000\001 \001\131\002k\000\000\000\000\000\000\000\000\000\000\000O\001\t\000\000\001F\000\000\000\000\001\129\000\000\001\t\001G\002d\000\000\000\000\001V\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\001X\000\000\001Y\000\000\000\000\000\000\000\000\000\000\000\000\000p\001\023\000\000\001Z\001\133\000\000\001\t\000\000\000N\000y\000\000\001V\000\161\002)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001[\000\000\000\000\000N\000\000\001\\\000\000\000\170\000\000\001]\000\000\000\000\000\171\000\000\000\000\001^\000\000\000\000\000\000\001 \001\127\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000N\000\000\000\172\000\000\000\161\001;\000\000\000\000\000\000\000\179\000\000\000\000\001W\000\000\000N\000\000\000\000\000\000\000\170\000\000\000\000\000O\000\000\000\174\002l\000\000\000\164\000\000\000\000\000\000\000\000\000\000\000\165\001\t\000\000\000\000\000p\000O\000\178\000\000\000\000\000\000\000\164\000\179\000\000\000y\001W\000\000\000\172\002\245\000\000\000\000\002e\000\000\000\000\002f\000\000\000\000\000\000\000\000\001X\000\000\001Y\001\023\000\000\000\000\000O\000\000\000\178\000N\001\023\000\164\001Z\000\161\001>\000\000\000\000\000\165\000\000\000\000\000O\000\000\000\000\000\000\000\178\000\164\000\000\000\210\000\000\000N\001[\000\172\000\000\000\170\001X\001\\\001Y\000\000\000\174\001]\000\000\000\000\001 \000\000\001\023\001^\001Z\000\000\000\000\001 \001\127\000p\000\000\000\178\000\000\000\000\000\000\000\000\000\000\000\000\000y\000\000\001\t\000\179\001[\000\000\000\180\000\178\000\000\001\\\000\000\000\000\000\000\001]\000\000\000O\000\000\000\000\000\000\001^\000\164\000\000\000\000\001 \001\127\000\000\000\165\000\000\000\000\000\000\000\000\001\168\000\000\000\179\000\000\000O\000\180\000\000\000\181\000\000\000\164\000\000\000\210\000\000\000N\000\000\000\172\000\000\000\170\000\179\000\000\000\000\000\180\000\174\000\000\000\000\001\170\000\000\000\000\000\000\000\000\000\000\000\178\000\000\001\023\000N\000p\000\212\000\181\000\170\000\000\000\000\000\000\000\000\000\174\000y\000\000\001\t\000\179\000\000\000\000\000\180\000\178\000\000\000\181\000\000\000\183\000p\000\000\000\000\000\220\000\000\000\179\000\000\000\214\000\180\000y\000\000\000\000\000\000\000\000\000\185\000\000\001 \000\000\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\000\000\181\000\000\000\164\000\000\000\210\000\000\000\000\001.\000\172\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000O\000\187\000N\000\000\000\000\000\164\003?\000\210\003R\000N\000\000\000\172\000\234\000\170\002?\000\000\000\179\000\000\000\174\000\180\000\000\001\t\001\023\000\000\000p\000\212\000\178\000\000\000\000\000\000\000N\000p\000\000\000y\000\161\001A\000\179\000\000\000\000\000\180\000y\000\000\001\t\000\000\000\183\000\000\000\000\000\178\000\220\000N\000\000\000\181\000\214\000\161\001\195\000\000\000\000\000\000\000\000\000\185\000\000\001 \000\000\000\000\001.\000\000\000\000\000\000\000O\000\000\003A\000\181\000\000\000\000\000\000\000O\003B\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000\000\000\000\000\172\000\000\000\000\002E\000\000\000\000\000\000\000\000\000\000\000\000\000O\001\023\000\000\000\000\000\212\000\164\000\000\000\000\000\000\000\000\000\000\000\165\000\000\000\000\001\t\000\179\000\000\000\000\000\180\000O\000\000\001\t\000\000\000\183\000\164\000\000\000\178\000\220\000\000\000\000\000\165\000\214\000\000\000\000\000\000\000\000\000\179\000\000\000\185\000\180\001 \000\000\000\000\001.\000\000\003W\000\000\000\178\001\012\000\000\000\181\000\000\001\210\000\000\000\000\000\000\003?\000\000\003R\000\000\000\000\000\000\000\000\000\000\001.\000\000\000\178\000\000\002I\000\000\000\000\000\181\000\000\000\000\000\000\000\000\001\023\000\000\000\000\000\212\000\000\003\226\004\222\000\000\000\000\000\000\000\000\001\210\000\000\003\021\000\000\003?\000\000\003R\000\000\000\000\003O\001\023\000\183\000\000\000\212\000\000\000\220\000\000\000\179\000\000\000\214\003P\000\000\000\000\000\000\000\179\000\000\000\185\000\180\001 \003\226\004o\001\230\000\183\003A\003Y\000\000\000\220\000\000\000\000\003B\000\214\000\000\000\000\000\000\000\000\000\179\000\000\000\185\000\180\001 \000\000\000\000\003*\000\000\003\233\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\179\001\210\001\230\000\180\003A\003?\001\020\003R\000\000\000\000\003B\000\000\000\000\003,\001\023\003[\000\181\000\000\000\000\000\000\000\000\001\023\000\000\000\000\000\212\003\233\000\000\000\000\000\000\000\000\003\226\004=\000\000\003\\\000\000\000\181\000\000\000\000\003]\000\000\000\000\000\000\003^\000\183\003\235\000\000\000\000\000\220\003_\000\000\000\000\000\214\000\000\001 \000\000\000\000\000\000\001\210\000\185\000\000\001 \003?\000\000\003R\000\000\000\000\000\000\001\230\000\000\003A\000\000\000\000\000N\000\000\000\000\003B\000\161\001\204\000\000\003\235\003\237\000\000\000\000\000\000\000\000\000\000\003\226\003\227\001\210\000\000\003\233\003O\003?\000\000\003R\003\242\000\000\000\000\000\000\000\179\000\000\000\000\003P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\237\003\243\003\226\003\241\000\000\000\000\000\000\000\000\001\230\000\000\003A\003O\000\000\000\000\000\000\003\242\003B\000\000\000\000\000\179\000\000\000\000\003P\000O\000\000\000\000\003\244\000\000\000\164\003\235\000\000\003\233\000\000\000\000\000\165\000\000\003\243\000\000\000\000\001\230\000\000\003A\000\000\000\000\000\000\000\000\003[\003B\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\244\003\233\000\000\003\\\003\237\000\000\000\000\000\000\003]\000\178\000\000\000\000\003^\000\000\000\000\003O\000\000\000\000\003_\003\242\003[\000\000\000\000\000\179\003\235\000\000\003P\001\210\000\000\000\000\000\000\003?\000\000\003R\000\000\000\000\000\000\000\000\003\\\000\000\003\243\000\000\000\000\003]\000\000\000\000\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\003\235\003\226\004C\001\210\000\000\003\237\000\000\003?\000\000\003R\003\244\000\000\000\000\000\000\000\000\000\000\003O\000\000\000\000\000\000\003\242\000\000\000\000\000\000\000\179\000\000\000\000\003P\000\000\000\000\003[\000\000\003\226\004q\000\000\000\000\003\237\000\000\001\230\000\179\003A\003\243\000\180\000\000\000\000\000\000\003B\003O\003\\\000\000\000\000\003\242\000\000\003]\000\000\000\179\000\000\003^\003P\000\000\000\000\003\233\000\000\003_\000\000\000\000\003\244\000\000\000\000\001\230\000\000\003A\003\243\000\000\000\181\000\000\000\000\003B\000\000\001\210\000\000\000\000\000\000\003?\000\000\003R\003[\000\000\000\000\000\000\000\000\000\000\003\233\000\000\000N\000\000\000\000\003\244\000\170\000\000\000\000\000\000\000\000\000\174\003\\\000\000\000\000\000\000\004h\003]\000\000\000\000\000\000\003^\001\210\003\235\000\000\003[\001\211\003_\000\000\000\000\001\212\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\210\000\000\003\\\000\000\001\211\000\000\000\000\003]\001\212\000\000\000\000\003^\001\230\003\235\003A\000N\000\000\003_\003\237\000\170\003B\000\000\000\000\000\000\000\174\000\000\000\000\000O\000\000\003O\000\000\000\000\000\164\003\242\000\210\003\233\000\000\000\179\000\172\000\000\003P\000\000\000\000\000\000\000\000\000\000\000\000\001\230\000\000\003\237\000\000\001\213\000\000\000\000\003\243\000\000\000\000\001\214\000\000\000\000\003O\000\000\000\000\000\000\003\242\000\000\001\230\000\000\000\179\000\000\001\213\003P\000\000\000\000\000\178\000\000\001\214\000\000\000\000\003\244\000\000\000O\000\000\000\000\001\231\003\243\000\164\000\000\000\210\003\235\000\000\000\000\000\172\001\232\000\000\000\000\000\000\000\000\000\000\003[\000\000\001\165\000\000\002!\000\000\000\000\000\000\000\000\000\000\000\000\003\244\000\000\001\232\000\000\000\000\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\001\210\001\233\003\237\003^\001\211\000\178\000\000\003[\001\212\003_\000\000\000\000\000\000\003O\000\000\000\000\000\000\003\242\000\000\000\000\001\233\000\179\000\000\000\000\003P\003\\\000\000\000\000\000\000\000\000\003]\000\000\001\235\000\000\003^\000\000\000\179\000\000\003\243\000\180\003_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\227\006q\002\017\001\235\000\000\000\000\000\000\000\000\000\179\000\000\000\000\001\228\000\000\000\000\000\000\003\244\001\014\000\000\001\230\001\227\000\000\002\017\001\213\000\181\000\000\000\000\000\000\000\179\001\214\000\000\001\228\000\000\002\028\000\000\000\000\003[\000\000\002\030\002\020\000\000\000\000\000\000\000\179\000\000\000\000\000\180\000\000\001\238\000\000\000\000\000\000\000\000\000\212\003\\\000\000\002\019\000\000\002\020\003]\000\000\000\000\001\210\003^\000\000\001\232\001\211\001\238\000\000\003_\001\212\002 \000\183\000\000\000\000\000\000\000\220\000\000\000\181\000\000\000\214\000\000\001\210\000\000\000\000\000\000\001\211\000\185\000\000\000\000\001\212\001\240\000\000\000N\000\000\000\000\001\233\000\170\000\000\000\000\000\000\000\000\000\171\000\000\000\000\000N\001\241\000\212\000\000\000\170\001\240\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\241\000\183\001\235\001\230\000\000\000\220\000\000\001\213\000\000\000\214\000\000\000\000\000\000\001\214\000\000\000\000\000\185\000\000\001\227\000\000\002\017\000N\000\000\001\230\000\000\000\170\000\179\001\213\000\000\001\228\000\174\000\000\000\000\001\214\000O\000\000\000\000\000\000\000\000\000\164\002\023\000\000\000\000\000\000\000\000\000\172\000O\000\000\000\000\001\232\000\000\000\164\000\000\000\210\000\000\000\000\002\020\000\172\000\000\000\000\002\026\000\000\000\000\000\000\000\000\001\238\000N\000\000\000\000\001\232\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000N\001\233\000\178\000\000\000\170\000\000\000\000\000\000\000O\000\174\000\000\000\000\000\000\000\164\000\178\000\210\000\000\000\000\000\000\000\172\000\000\001\233\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\240\000\000\000\000\001\235\000\000\000\000\000\000\000\000\000p\000\000\000\000\000\000\000\000\000\000\000\000\001\241\000\000\000y\000\000\001\227\000\000\002\017\000\000\001\235\000O\000\000\000\178\000\179\000\000\000\164\001\228\000\210\000\000\000\000\000\000\000\172\000\000\000O\000\000\001\227\000\000\002\017\000\164\000\000\000\210\000\000\000\000\000\179\000\172\000\000\001\228\000\000\000\000\000\000\000\000\000\000\000\000\002\020\000\179\000\000\000N\000\180\000\000\000\000\000\170\002\222\001\238\000\000\000\000\000\174\000\179\000\178\000N\000\180\000\000\000\000\000\170\002\020\000\000\000\000\002a\000\174\000\000\000\000\000\178\000\000\001\238\002k\000\000\000\000\000\000\000\000\000\000\000\181\001\t\000\000\000\000\000\000\002 \000\000\000\000\000\000\000\000\002d\000\000\000\181\002\239\000\000\000\000\001\240\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\241\000\000\000O\000\000\000\000\001\240\000\000\000\164\000\000\000\210\000\212\000\000\000\000\000\172\000O\002 \000\000\000\187\000\000\000\164\001\241\000\210\000\181\000\000\000\000\000\172\000\000\002\251\000\236\000\183\000\000\000\000\000\179\000\220\000\000\000\180\000\000\000\214\003c\000\000\003\003\000\000\000\000\000\000\000\185\000\179\000\000\000\000\000\180\000\178\000\000\000\212\000\000\000\000\000N\000\000\000\000\000\000\000\170\000\000\002 \000\178\000\000\000\174\000\000\000\000\000\000\000\181\000\000\000\000\000\183\000\000\000\000\002 \000\220\000\000\000\000\000\000\000\214\000\000\000\181\000\000\002l\000\000\000N\000\185\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\212\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\170\000\000\000\212\002e\000\000\000\000\002f\000\000\000\183\000\000\000\000\000\000\000\220\000O\001\023\000\000\000\214\000\000\000\164\000\000\000\210\000\183\003\n\000\185\000\172\000\220\000\000\000\179\000N\000\214\000\180\000\000\000\170\000\000\000\000\000\000\000\185\000\174\000\000\000\179\000\000\000\000\000\180\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000\000\001 \000\172\002 \000\000\000\000\000\000\000\000\000\178\000\000\000\181\000\000\000\000\000\000\000\000\000\219\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000N\000\000\000\178\000\212\000\170\000\000\000O\000\000\000\000\000\174\000\000\000\164\000\000\000\210\000\000\000\212\000\000\000\172\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\183\000\000\000\000\000\185\000\220\000N\000\000\000\000\000\214\000\170\000\000\000\000\000\000\000\000\000\174\000\185\000\000\000\000\003\162\000\178\000\000\000\000\000O\000\179\000\000\000\000\000\180\000\164\000\000\000\210\000\000\000\000\000O\000\172\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000\000\000\000\000\172\000\000\000\000\000\000\000\000\003\174\000\000\000\000\002 \000\000\000\179\000\000\000\000\000\180\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\178\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\210\000\178\000\000\002 \000\172\000\000\000\000\000\000\000\000\000\212\000\181\000\000\000\000\000\000\000\000\000\000\000N\003\197\000\000\000\000\000\170\003\179\000\000\000\000\000\000\000\171\000\179\000\000\000\183\000\180\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\212\000\178\000N\000\000\000\185\000\000\000\161\001\207\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002 \000\000\000\000\000\000\000\183\000\000\000\000\000\181\000\220\000\000\000\000\000N\000\214\000\000\000\000\000\170\000\000\003\186\000\000\000\185\000\174\000\000\000\179\000\000\000\000\000\180\000\000\003\192\000O\000\000\000\000\000\000\000\179\000\164\000\000\000\180\000\212\000N\000\000\000\172\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\002 \000\000\000\000\000O\000\000\000\183\000\000\000\181\000\164\000\220\002 \000\000\000\000\000\214\000\165\000\000\000\000\000\181\000\000\000\000\000\185\000\179\000\000\000\000\000\180\000\178\000N\000O\000\000\000\000\000\170\000\000\000\164\000\000\000\210\000\174\000\212\000\000\000\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\000\000\000\000\000\219\000\178\003\199\000\000\000O\000\000\000\183\000\181\000\000\000\164\000\220\000\210\000\000\000\000\000\214\000\172\000\183\000\000\000\000\000\000\000\220\000\185\000\000\000\000\000\214\000\178\000\000\000\000\000N\000\000\000\000\000\185\000\170\000\000\000\000\000\000\000\212\000\174\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000N\000\210\000\178\000\000\000\170\000\172\000\183\000\000\000\000\000\174\000\220\000\000\000\179\000\000\000\214\000\180\000\000\000\000\000\000\000\000\000N\000\185\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000N\000\000\000\000\000\179\000\170\000\000\000\180\000\178\000\000\000\171\000\000\000O\000\000\000\181\000\000\000\000\000\164\000\000\000\210\000N\000\000\000\000\000\172\000\161\003\023\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\181\000\210\000\000\000\000\000\000\000\172\000\000\000\000\000\000\000\000\004\016\000\000\000\000\000\000\000O\000\179\000\000\000\219\000\180\000\164\000\178\000\210\000N\000\187\000\181\000\172\000\170\000\000\000O\000\000\000\000\000\174\000\000\000\164\000\238\000\000\000\000\000\000\004?\000\172\000\000\000\178\000\000\002 \000\000\000\000\000\000\000O\000\000\004\029\000\181\000\000\000\164\000\212\000\179\000\000\000\000\000\180\000\165\000N\000\000\000\178\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\183\000N\000\000\000\178\000\220\000\161\0036\000\212\000\214\000\000\002 \000\000\000\000\000\000\000\000\000\185\000O\000\181\000\000\000\000\000\000\000\164\000\178\000\210\000\000\000\000\000\183\000\172\004&\000\000\000\220\000\000\000\000\000\179\000\214\000\000\000\180\000\000\000\000\000\000\004A\000\185\000\000\000\000\000\000\000\000\000\212\000\000\000\000\004.\000\000\000\000\000\000\000O\000\179\000\000\000\000\000\180\000\164\000\000\000\210\002 \000N\000\178\000\172\000\183\000\170\000O\000\181\000\220\000\000\000\174\000\164\000\214\000\179\000\000\000\000\000\180\000\165\000\000\000\185\000\000\002 \000\000\000\000\000\000\000\000\000\000\000\179\000\181\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\212\000\000\000\000\000\178\000\000\000\219\000\000\000\000\000\000\000\000\000\179\000\000\000\181\000\180\000\000\000\000\000N\000\178\000\000\000\183\000\170\000\212\000\000\000\220\000\000\000\174\000\181\000\214\000\000\000\000\000\000\000O\000\000\000\000\000\185\000\000\000\164\000\000\000\210\000\000\000\183\000\212\000\172\000\000\000\220\000\181\000\000\000\000\000\214\000\000\000\000\000\179\000\000\000\000\000\180\000\185\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\187\000\185\000\000\000\000\000\178\000\219\000\000\000\000\000O\004K\000\000\000\240\000\181\000\164\000\179\000\210\000N\000\180\000\000\000\172\000\170\000\000\000\000\000\000\000\000\000\171\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000N\000\000\000\000\000\000\000\170\000\212\002 \000\000\000\000\000\174\000\000\000\000\000\000\000\181\000N\000\000\000\000\000\000\000\170\000\178\000\000\000\000\000\000\000\174\000\183\000\000\000\000\000\181\000\220\000\000\000\000\000\000\000\214\000\000\006M\000\000\000\000\000\000\000\000\000\185\000\000\000\000\000\212\000\000\000\000\000N\000O\000\000\004X\000\170\000\000\000\164\000\000\000\179\000\174\000\000\000\180\000\172\000N\000\000\000\000\000\183\000\170\000\000\000\000\000\220\000O\000\174\000\000\000\214\000\000\000\164\000\000\000\210\000\000\000\000\000\185\000\172\006\178\000\000\000O\002 \000\000\000\000\000\000\000\164\000\000\000\210\000\181\000\000\000\000\000\172\000\000\000\178\000\000\000\000\000N\000\000\000\000\004]\000\170\000\000\000\000\000\000\000\179\000\174\000\000\000\180\000\000\000\000\000\000\000O\000\000\000\178\000\000\000\000\000\164\000\212\000\210\000\000\000\000\000\000\000\172\000\000\000O\000\000\000\000\000\178\000\000\000\164\000\000\000\210\002 \000\000\000\000\000\172\000\183\000N\000\000\000\181\000\220\000\170\000\000\000\000\000\214\000\000\000\174\000\000\000\000\000\000\000N\000\185\000\000\000\000\000\170\000\000\000\000\000\000\000\178\000\174\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\212\000\210\000\000\000\178\000\000\000\172\000\000\000\000\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\000\000\220\000\000\004d\000\000\000\214\000\000\000\000\000\179\000\000\000\000\000\180\000\185\000O\000\000\000\000\000\000\000\000\000\164\000\178\000\210\000\000\000\179\000\181\000\172\000\180\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000\000\002 \000\172\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\006N\000\000\000\000\000\179\000\000\000\000\000\180\000\181\000\000\000\000\000\178\000\000\000\000\000\000\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\187\000\212\000\178\000\000\000N\000\000\000\000\000\000\000\161\0039\001\002\000\242\000\000\000\000\000\000\000\212\000\000\000\181\000\000\000\000\000\183\000\000\000\000\006N\000\220\000\000\000\000\000\000\000\214\000\000\000\181\000\000\000\000\000\179\000\183\000\185\000\180\000\000\000\220\000\000\000\000\000N\000\214\000\000\000\000\000\170\000\212\000\000\000\000\000\185\000\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\000\000\001\016\000N\000N\000\000\000\183\000\170\000\170\000\181\000\220\000O\000\174\000\174\000\214\000\179\000\164\000\000\000\180\000\183\000N\000\185\000\165\000\220\000\170\000\000\000\000\000\214\000\179\000\174\000\000\000\180\000\000\000\000\000\185\000\000\000\000\000N\000\212\000\000\000\000\000\161\003<\001\140\000\000\000\000\000\000\000\000\000O\000\000\000\181\000\000\000\000\000\164\000\000\000\210\001\157\000\183\000\178\000\172\000\000\000\220\000\000\000\181\000\000\000\214\000\000\000\000\000\000\000O\000O\000\000\000\185\000\000\000\164\000\164\000\210\000\210\000N\000\212\000\172\000\172\000\170\000\000\000\000\000\000\000O\000\174\000\000\000\000\000\000\000\164\000\212\000\210\000\000\000\178\000N\000\172\000\183\000\000\000\170\000\000\000\220\000O\000\000\000\174\000\214\000\000\000\164\000\000\000\000\000\183\000\000\000\185\000\165\000\220\000\178\000\178\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\000\000\185\000\000\000\000\000\000\000\000\000\000\000\000\000\178\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000O\000\000\000\180\000\000\000\000\000\164\000\178\000\210\000\000\000\000\000\000\000\172\000\000\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000N\000\210\000\000\000\000\000\170\000\172\000\000\000\000\000\000\000\174\000\181\000\000\000\179\000\000\000\000\000\180\000\000\000N\000\000\000\000\000\000\000\170\000\000\000\178\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000\179\000\000\000\180\000\180\000\000\000\000\001\177\000\178\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\179\001\221\000\000\000\000\000\000\000O\000\179\000\181\000\181\000\180\000\164\000\000\000\210\000\000\000\000\000\212\000\172\002\205\000\000\000\000\000\000\000\000\000O\000\000\000\181\000\000\000\000\000\164\000\000\000\210\000\000\000N\000\000\000\172\000\183\000\170\000\212\000\212\000\220\000\000\000\174\000\181\000\214\000\000\000\000\000\000\000\000\000\179\000\000\000\185\000\180\000\000\000\178\000\212\000\000\000\183\000\183\000\000\000\000\000\220\000\220\000\000\000\000\000\214\000\214\000\179\000\000\000\000\000\180\000\178\000\185\000\185\000\183\000\000\000\000\002\211\000\220\000\000\000\000\000\000\000\214\000\000\000\181\000\000\000\000\000\000\000\000\000\185\000\000\000\000\000\000\000\000\000\000\003\026\000\000\000\000\000\000\000O\000\000\000\000\000\181\000\000\000\164\000N\000\210\000\000\000\000\000\170\000\172\000\000\000\000\000\212\000\174\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000N\000\000\000\212\000\183\000\170\000\000\000\000\000\220\000\000\000\174\000\179\000\214\000\000\000\180\000\000\000\000\000\000\000\178\000\185\000\000\000\000\000\183\000\000\000\000\000\000\000\220\000\000\000\179\000\000\000\214\000\180\000\000\000\000\000\000\000\000\000\000\000\185\000\000\003\031\000\000\000\000\000\000\000O\000\000\000\000\000\181\000\000\000\164\000\000\000\210\000\000\000\000\000O\000\172\000\000\003#\000\000\000\164\000\000\000\210\000\000\000\000\000\181\000\172\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\210\000\212\000N\000\000\000\172\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000\178\000\000\000\212\000\000\000\183\000N\000\000\000\000\000\220\000\170\000\178\000\000\000\214\000\179\000\171\000\000\000\180\000\000\000\000\000\185\000\000\000\183\000\000\000\000\000\178\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\000\000\185\000\000\000\000\000\000\000\000\003I\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000N\000O\000\000\000\000\000\170\000\000\000\164\000\000\000\210\000\174\000N\000\000\000\172\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000O\000\000\000\000\000\000\000N\000\164\000\212\000\000\000\170\000\000\000\000\000\172\000\000\000\174\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000\183\000\000\000\180\000\178\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\179\000\000\000\185\000\180\003\148\000\000\000\000\000\000\000O\000\178\000\000\000\181\000\000\000\164\003\230\000\210\000\000\000\000\000O\000\172\000\000\000\181\000\000\000\164\000\000\000\210\000\000\000\000\004\180\000\172\000\000\000\000\000O\000\000\000\000\000\181\000\000\000\164\000N\000\210\000\212\000\000\000\170\000\172\000\000\000\000\000\000\000\174\000N\000\000\000\212\000\000\000\170\000\000\000\000\000\178\000\000\000\174\000\000\000\183\000\000\000\000\000\000\000\220\000\212\000\178\000\000\000\214\000\000\000\183\000\000\000\000\000\000\000\220\000\185\000\179\000\000\000\214\000\180\000\178\000\000\000\000\000\000\000\183\000\185\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\179\000\000\000\000\000\180\000\185\000\000\000\000\000\000\000\000\004\213\000O\000\000\000\000\000\000\000\000\000\164\000\181\000\210\000\000\000N\000O\000\172\000\000\000\170\000\000\000\164\000\000\000\210\000\174\000\000\000\000\000\172\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000\178\000\000\000\180\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\178\000\220\000\000\000\179\000\000\000\214\000\180\004\233\000\000\000\000\000\000\000\000\000\185\000\000\000\181\000\000\000\187\004\235\000O\000\000\000\000\000\000\000\000\000\164\000\181\000\210\000\000\000\244\000\000\000\172\000\000\004\237\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000N\000\000\000\212\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000N\000\000\000\212\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\183\000\000\000N\000\178\000\220\000\212\000\170\000\000\000\214\000\000\000\183\000\171\000\000\000\179\000\220\000\185\000\180\000\000\000\214\000\000\000\000\000\000\000\000\000\179\000\183\000\185\000\180\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\000\000\185\000\000\004\243\000\000\000\000\000\000\000O\000\000\000\000\000\181\000\000\000\164\005\004\000\000\000\000\000\000\000O\000\172\000\000\000\181\000\000\000\164\000\000\000\000\000\000\000\000\000N\000\172\000\000\000O\000\170\000\000\000\000\000\000\000\164\000\171\000\000\000\000\000\212\000\000\000\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\000\179\000N\000\000\000\180\000\178\000\170\000\000\000\000\000\183\000\000\000\171\000\000\000\220\000\000\000\178\000\000\000\214\000\000\000\183\000\000\000\000\000\000\000\220\000\185\000\000\000\000\000\214\000\178\005\018\000\000\000N\000\000\000\000\000\185\000\170\000\181\000\000\000\000\000\000\000\171\000\000\000\000\000N\000O\000\000\000\000\000\170\000\000\000\164\000\000\000\000\000\171\000N\000\000\000\172\000\000\000\170\000\000\000\000\000\000\000\000\000\171\000\000\000\000\000\212\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\000\000N\000\000\000\000\000\172\000\170\000\000\000\000\000\000\000\183\000\171\000\000\000\000\000\220\000\000\000\179\000\178\000\214\000\180\000\000\000\000\000\000\000O\000\000\000\185\000\179\000\000\000\164\000\180\000\000\000\000\000\000\000\000\000\172\000O\000\000\000\000\000\000\000\179\000\164\000\178\000\180\000\000\000\000\000O\000\172\000\000\000\000\001d\000\164\000\181\000\000\000\000\000\000\000\000\000\172\000\000\000\000\003e\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\178\000\000\000\000\000\164\000\181\000\000\000\000\000\000\000\000\000\172\000\212\000\000\000\178\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\000N\000\178\000\000\000\000\000\170\000\000\000\000\000\000\000\183\000\171\000\000\000\179\000\218\000\000\000\180\000\000\000\214\000\000\000\183\000\000\000\000\000N\000\218\000\185\000\178\000\170\000\214\000\000\000\000\000\000\000\171\000\187\000\000\000\185\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\246\000\000\000\000\000\000\000\181\000\000\000\000\000N\000\000\000N\000\000\000\170\000\000\000\170\000\000\000\000\000\171\000\000\000\171\000\000\000\000\000\000\000\179\000N\000O\000\180\000\000\000\170\000\181\000\164\000\000\000\000\000\171\000\000\000\179\000\172\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000O\000\000\000\180\000\000\000\000\000\164\000\000\000\187\000\000\000\000\000\000\000\172\000\181\000\000\000\000\000\000\000\000\000\000\000\248\000\000\000\000\000\000\000\179\000\000\000\181\000\180\000\178\000\000\000O\000\000\000O\000\187\000\000\000\164\000\181\000\164\000N\000\000\000\000\000\172\000\170\000\172\000\250\000\000\000O\000\171\000\000\000\178\000\000\000\164\000\000\000\000\000\000\000\000\000\000\000\172\000\000\000\181\000\000\000N\000\187\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\171\000\000\000\000\000\252\000\187\000\000\000\000\000\178\000N\000\178\000\000\000\000\000\170\000\000\000\187\001`\000\000\000\171\000\000\000\000\000\000\000\000\000\000\000\178\000\000\001f\000\000\000\000\000\000\000\000\000\000\000\000\000N\000\000\000O\000\000\000\170\000\187\000\000\000\164\000\000\000\171\000\000\000\179\000\000\000\172\000\180\000N\001h\000\000\000\000\000\170\000\000\000\000\000N\000\000\000\171\000O\000\170\000\000\000\000\000\000\000\164\000\171\000\179\000\000\000\000\000\180\000\172\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\000\000\000\000\181\000\164\000\000\000\178\000\000\000\000\000N\000\172\000\000\000\000\000\170\000\000\000\000\000\000\000\179\000\171\000\179\000\180\000\000\000\180\000O\000\181\000\000\000\000\000\000\000\164\000\178\000\000\000\000\000\000\000\179\000\172\000N\000\180\000\000\000O\000\170\000\000\000\000\000\000\000\164\000\171\000O\000\178\000\000\000\000\000\172\000\164\000\187\000\181\000\000\000\181\000\000\000\172\000\000\000\000\000\000\000\000\000\000\001j\000\000\000\000\000\000\000\000\000\000\000\181\000N\000\178\000\000\000\187\000\170\000\000\000O\000\000\000\000\000\171\000\000\000\164\000\000\000\000\001l\000\000\000\178\000\172\000\000\000\000\000\000\000\000\000\179\000\178\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\187\000O\000\187\000\000\000\000\000\000\000\164\000\000\000\000\000\000\000\000\001n\000\172\001p\000\179\000\000\000\187\000\180\000\000\000\000\000\000\000N\000\178\000\000\000\000\000\170\000\181\001r\000\000\000\000\000\171\000\179\000\000\000\000\000\180\000O\000\000\000\000\000N\000\000\000\164\000\000\000\170\000\000\000\000\000\000\000\172\000\171\000\178\000\181\000N\000\000\000\000\000\000\000\170\000\179\000\000\000\000\000\180\000\171\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\179\000\000\000\000\000\180\000\187\000N\000\000\000\179\000\000\000\170\000\180\000\000\000\178\000\000\000\171\001t\000\000\000O\000\000\000\000\000\181\000\000\000\164\000\000\000\000\000\000\000\000\000\187\000\172\000\000\000\000\000\000\000\000\000\000\000O\000\181\000\000\000\179\001v\000\164\000\180\000\000\000\181\000\000\000\187\000\172\000O\000p\000\000\000\000\000N\000\164\000\000\000\000\000\170\001x\000y\000\172\000N\000\171\000\000\000\000\000\170\000\179\000\178\000\000\000\180\000\171\000\187\000\000\000\000\000O\000\181\000\000\000\000\000\000\000\164\000\000\000\000\001z\000\000\000\178\000\172\000\187\000\000\000\000\000\000\000N\000\000\000\000\000\187\000\170\000\000\000\178\001|\000\000\000\171\000\179\000\181\000\000\000\180\001~\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\171\000\000\000\000\000\000\000\000\000O\000\000\000\178\002a\000\187\000\164\000\000\000\000\000O\000\000\002k\000\172\000\000\000\164\000\000\001\243\000\181\001\t\000\000\000\172\000\000\000\000\000\000\000N\000\000\000\000\002d\000\170\000\000\000\000\000\187\000\000\000\171\000\179\000\000\000N\000\180\000O\000\000\000\170\000\000\001\245\000\164\000\000\000\171\000\000\000\000\000\178\000\172\000\000\000\179\000\000\000O\000\180\000\000\000\178\000\000\000\164\000\000\000\000\000\000\000\000\000\179\000\172\000\187\000\180\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\001\247\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\178\000\181\000\000\000\179\000\000\000O\000\180\000\000\000\000\000\000\000\164\000\000\000\000\000\181\000\000\000\178\000\172\000O\000\000\000\000\000\000\000N\000\164\000\000\000\000\000\170\000\000\000\000\000\172\000\000\000\171\000\000\000\187\000\000\000\000\000N\000\000\000\000\000\181\000\170\000\000\000\000\000\000\001\249\000\171\002l\000\000\000\000\000\179\000\187\000\000\000\180\000\178\000\000\000\000\000\000\000\179\000\000\000\000\000\180\001\251\000\187\000\000\000\000\000\178\000\000\000\000\000\000\000\000\000\000\004\025\000\000\001\253\002e\000\000\000\000\002f\000\000\000\000\000\000\000\000\000\000\000\000\000\181\001\023\000\179\000\187\000O\000\180\000\000\000N\000\181\000\164\000\000\000\170\000\000\000\000\001\255\000\172\000\171\000\179\000O\000\000\000\180\000\000\000N\000\164\000\000\000\000\000\170\000\000\000\000\000\172\000\000\000\171\000\000\000\000\000\000\000\000\000\000\000\181\000N\000\000\001 \000\000\000\170\000\000\000\000\000\000\000\000\000\171\000\187\000\000\000\000\000\178\000\181\000\000\000\179\000\000\000\187\000\180\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\178\000\179\002\003\000p\000\180\000\000\000\000\000\000\000O\000\000\000\000\000\000\000y\000\164\000\000\000\000\000\000\000\000\000\000\000\172\000\187\000\000\000\000\000O\000\181\000\000\000\000\000\000\000\164\000\000\000\000\002\005\000\000\000\000\000\172\000\187\000\181\000\000\000N\000O\000\000\000\000\000\170\000\000\000\164\000\000\002\007\000\171\000\000\000\000\000\172\000\000\000\000\000\000\000\000\000\178\000\000\000N\000\000\000N\000\000\000\170\000\000\000\170\000\000\000\000\000\171\000\000\000\171\000\000\000\178\000\179\000\187\000\000\000\180\002a\000\000\000\000\000p\000\000\000\000\000\000\002k\002\t\000\187\000\179\000\178\000y\000\180\001\t\000N\000\000\000\000\000\000\000\170\002\011\000\000\000\000\002d\000\171\000\000\000\000\000\000\000\000\000O\000\000\000\181\000\000\000\000\000\164\000\000\000\000\000N\000\000\000\000\000\172\000\170\000\000\000\000\000\000\000\181\000\171\000\000\000O\000\000\000O\000\000\000\000\000\164\000\000\000\164\000\000\000\000\000N\000\172\000\000\000\172\000\170\000\000\000\000\000\179\000\000\000\171\000\180\000\000\000\000\000\000\000\000\000\000\000\000\002a\000\178\000\000\000\000\000\187\000\179\000O\002k\000\180\000\000\000\000\000\164\000\000\000\000\001\t\002\r\000\000\000\172\000\187\000\000\000\178\000\179\000\178\002d\000\180\000\181\000N\000\000\000O\003a\000\170\000\000\000\000\000\164\000\000\000\171\000\000\000\000\000\000\000\172\000\181\000\000\000\000\000N\000\000\000\000\000\000\000\170\000\000\000O\000\000\002l\000\171\000\178\000\164\000\000\000\181\000N\000\000\000N\000\172\000\170\000\000\000\170\000\000\000\000\000\171\000\000\000\171\000\000\000\000\000\000\000\000\000\187\000\000\000\178\004!\000\000\000\000\002e\000\000\000\000\002f\000\000\003g\000\000\000\179\000\000\000\187\000\180\001\023\000\000\000O\000\000\000\000\000\000\000\178\000\164\000\000\003i\000\000\000\000\000\000\000\172\000\187\000\179\000\000\000\179\000\180\000O\000\180\000\000\000\000\000\000\000\164\003k\000\000\000\000\000\000\000\000\000\172\000\181\000\000\000O\000\000\000O\002l\000\000\000\164\001 \000\164\000\000\000\000\000\000\000\172\000\000\000\172\000\000\000\179\000\178\000\181\000\180\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004T\000\000\000\000\002e\000\000\000\178\002f\000\000\000\000\000\179\000\000\000\000\000\180\000\000\001\023\000\000\000\000\000\000\000\187\000\178\000\000\000\178\000\181\000\000\000\000\000\000\000\000\000\000\000\000\003m\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\187\000\000\000\187\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\003o\000\000\003q\000\000\000\000\001 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\187\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\003s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000\000\000\187\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003u\000\179\000\000\000\179\000\180\000\181\000\180\000\000\000\000\000\000\000\187\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003w\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\187\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003y\000\000\000\000\000\000\000\000\000\000\000\187\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003{\000\000\000\000\000\187\000\000\000\187\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003}\000\000\003\127"))
+ ((16, "\002\128\0020\000\000\000\000\000\000\000M\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001q\000\000\001G\006H\000\000\000\000\000\r\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000 \000\000\000\000\000\000\000\000\000\000\003v\000\000\005\172\003\254\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\015\000l\000\000\000\255\000\000\000\000\003\\\000\000\000\000\005*\000\000\000\000\000\000\000R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003x\000\000\000\000\001\246\019X\000\000\000\000\020\178\000\000\000\000\000\000\000\000\000\000\000\000\014\212\000\000\000\000\000\000\000\000\000\000\005\202\000\000\000\018\000\000\000\142\000\000\000\000\000\000\005\206\000\000\b\228\000\000\000\000\000\000\b\172\000\000\000\000\000\000\016\212\001O,\152\000\000\000\000\027\246\028\"\000\000\000N\000\000\030t1H6J1H\016\"1\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\030\1607 \000\000\000\000!\030)\0180\134\000\0002R\003~\000\000\000\000*\0185\228\000\000\000\000\000\000\001\022\000\000\000\1302\004+\b\000\000\000\000Ml\000\000\004>\000\000\006:\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\170\000\000\000\000\006\160\000\000\018*\000\000\023\160\000\000\024\172\000\000!\028\000\000\"\164\000\000#\154\000\000%\"\000\000&\012\000\000&\170\000\0004z\000\000\017\196\000\000\000\000\000\000\000\000\t\130\000\000\000\000\000\000\000\000'\160\000\000(\138\000\000.\186\000\0004\168\000\0007x\000\0008:\000\000;F\000\000DJ\000\000H\224\000\000J\152\000\000L\234\000\000S\022\000\000U\168\000\000V&\000\000VV\000\000V\144\000\000\0070\000\000\000\000\b&\000\000\000\000\000\000\000\000\002\146\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000gM\210\000\000\000+\000\000\000\000\000d\t\176\000\000\000b\000\r\000 \000\166\001{\000\000\001$\000\000\000\000\001\146\000\000\001\156\000\000\000\00074\000\000\000\000\000\000\000,\nz\000\000;&7\236\000\000\000\000\000\000\000\000\011p\018\014\000\000\000\000\000\000\000\000\000\000\000\000;\128\000\000\000\000<\n\000\000\000\000=\178\000\000\004\026\000\000\b(\000\000\000\000\000\000\003@\000\0002\2428&\000\000\000\0008j9\018\000\000\t\028\000\000\n\018\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000V\168\000\0004\188\000\000Uz\000\000V\188\000\000V\234\000\000W\156\000\000W\198\000\000W\254\000\000X\002\000\000X\030\000\000X\146\000\000X\192\000\000X\226\000\000Y\018\000\000Y0\000\000Y>\000\000\000\000:\006\000\000\000\000\000\000:J\000\000\000\000\000\000\000\000\000\000\000\000N$\000\000\000\000\000\000\b\236\000\000\000\000\000\000\000\000#\232\000\000\000\000\000\000\000\000\001G\000\000\000\000N>\000\000\000\000\000\000\020,\000\197\000\000\000\000A\238\000\000\000\000:\234\000\000\000\000\000\000\000\026\012f+\022\000\000\000\000On\000\000O\152\000\000\000\000\000\000\r\\B<\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000=\216\000\000\000\000\000\000\000\000BZ\014R\016\182\000\000?\244\000\000\000\000I\018\000\000\006V\000\000\000\000\024|\000\000\000\000\000\000\018\248\000\0003x\000\000\000\000O\154\000\000\000\000\000\000\021\028\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\028 \000\000\030\158\000\000\000}\000\000\000\000\000\000Yz\000\000Y\174\000\000Y\242\000\000ZZ\000\000Z|\000\000Z\148\000\000Z\198\000\000[ \000\000[0\000\000[j\000\000[\136\000\000[\210\000\000[\234\000\000\\v\000\000\000\000\000\000\000\000\000\000C2\000\000\000\000\003\146D\012\000\000\000\000D4\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0001\\\000\000;\156\000\000\000\000\000\000\000\000\000\000<2\000\000\000\000\000\000<\200\000\000\000\000\000\000\000\000\000\000\000\000\001\015\000\000\000\000\000\000\000\000\014H\000\000\021@\000\000\000\000\0022\005\238\000\000\000\000\000\000\000\000\020N\014\252\000\000\016\232\000\000\000\000\000\000\021\174\000\000\023\"\000\000&B\000\000\000\000\000\000\000\000\000\000\000\000(\192\000\000\000\000\000\183\000\000\000\000\000\000\0226\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000b\022&\000\000\000\000\000\000\000\000\000\000\000\000\000\254\000\000\016\018\r\140\000\000\000\000\000\000\017:\000\000\000\000\000\000\002v\rT\000\000\002\184\000\000\000\000\000\000\000\000\014H\000\000\000\000\000D\nr\000\000\n\166\000\000\000\000\000\000\000\246\000\000\017\228\000\158\0007\000\000\000\000\000\000\002\208\000\222\000\000\000\000\003`\000\000\000\000\000\000\005H\000\000\000\000\000\000\000\252\000\000\000\000\000\000\000\000\000\000\003 \000\203\000w\000\000\000\000\000k\000\000\000\000\000\000\000\000\000\000\000\000O\186\000\000>\158\000\000\000\000\000\000P.\000\000\000\000\003b\000\000\000\000\000\000\003j\020*\000\000\000\000Db\000\000\000\000\004L\000\000\000\000\000\000\000\000\016p\000\000\023\204\000\000\000\000->\000\000\000\000\000\000D\180\000\000\000\000\000\000\000\000\000\0009\248\000\000\000\000\000\000\001O\000\000E\014\000\000\000\000\000\000\000\000\002\178\020\218\000\000E(\000\000\000\000\000\000\000\000\022\214\000\000E\218\000\000\000\000\000\000\000\000\003\168\000\000\n4\000\000\000\000J\190<\242\000\000\000\000\000\000PR\000\000\000\000\000\000\000\012\000\000P\226\000\000\000\000\000\000Q\004\000\000\000\000\000\230\000\000!\206\000\027=\136\000\000\000\000\000\000\021(\021~\000\000\000\000\000\000\000\000\000\000\000\000Kv\000\000\000\000O$\000\000\000\000O\220\000\000\006\130\000\000\0224\000\000\000\000\000\000\024\164\000\0003\146\000\000\000\000Q\154\000\000\000\000\000\000\025D\000\000\000\000\000\000\000\000\000\000\000\000\011\b\000\000\025\162\000\000\000\000\000\000\004\128\000\000\000\000\000\000\000\000\000\000\000\000\\\146\000\000E\242\000\000U\142\000\000]\000\000\000]\030\000\000]>\000\000]\192\000\000]\230\000\000]\234\000\000^(\000\000^T\000\000^~\000\000^\212\000\000^\246\000\000_\018\000\000_\022\000\000,\196\000\000\000\000\000\000\001F\000\000\004\252\000\000\018\218\003N\011*\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R*\000\000>\228\0044\027N\000\000\000\000\000\00000\000\000\003\128\024\134\000\000\000\000F\198\000\000\000\000\000h\000\000\025T\000\000\000\000EF\000\000\000\000\000\000G\002\000\000\000\000\000\000\000\000Gh\000\000\000\000\012\b\026\174\000\000\000\000G\204\000\000\000\000\027@\000\000\000\000G\224\000\000\000\000\000\000\000\000H.\000\000IB\000\000?f?\214\001N\0062\000\000\006\158\007\210\000\000\000\000\000\000\014\202\000\000\000\000\0200\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000R>\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0004\024\000\000@\020\000\000\000\000\000\000\019l\000\000\000\000\007\020\000\000\000\000\000\000\"`\002\152\000\000#V\000\000\000\000\000\000\000\000\004h\000\000\000\000\020b\000\000$L\000\000\000\0004\158\000\000\000\000\000\000Iv\000\000\000\000\0180\000\000\000\000\029\230\000\000\000\000Z\238\000\000\000\000\000\000I\196\000\000\000\000\000\000]N\000\000\000\000\000\000\000\000J*\000\000\000\000\000\000\000\000\r\178\022\222\000\000JT\000\000\000\000\000\000\000\000\000\000\000\000\021X\000\000\000\000\004\150\000\000\021\234\000\000\0180\000\000\000\000J|\000\000K\016\000\000@\250\000\000\000\000\000\0005\146\000\000\000\000\000\000KZ\000\000\000\000\012\222\000\000\000\000\030\030\000\000\000\000]\228\000\000\000\000\000\000K\240\000\000\000\000\000\000\000\000LV\000\000\000\000\015\234\030@\000\000\000\000M\018\000\000\000\000\004\166A\208\000\000\004\186\000\000\000\000\000\000\000\000\004\128\000\000A8\000\000$\222\000I%\212\000\000\001L\000\000\022\224\000\000\023\214\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\020&\202\002\006'\\\000\000\000\000\000\000\003.\000\000\024h\000\000\005&\000\000\000\000\018\208\001$(R\000\000\002\226\000\000\025^)H\000\000\000\000\026T\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\140\012 \000\000\005\164\000\000\000\000\000\000\000\000\005\238\000\000\026\230\000\000\000\000\000\000/\166RZ\000\000\000\000\000\000/:\000\000\000\000\000\000\000\000\005\1881\014\000\000\000\000\000\000\000\000\005\192\000\000\000\000\000\000\000\000\016R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\"\000\000\027\220\000\000\000\000\000\000R\240\000\000\r\022\000\000\000\000\000\000\0050\000\000\005\178\000\000\000\000\002\212\028\210\000\000\029d\000\000\000\000\000\000\003\156\000\000Sr\004\250S\134\000\000S\162\000\000\000\000\000\000\005h\000\000T2\005\190\000\000\000\000,X=z\000\000\005\204-\232\000\000\000\000.z\000\000\000\000\000\000\006\006\000\000TF\006\018\000\000\000\000\b\208\006\030\014p\000\000\0272\000\000\000\000\000\000\0068\000\000T\200\006\156\000\000\000\000\000\000\002H\000\000\002\192\000\000\000\000\000\000\000\000\000\017\000\000\000\000\000\000\000\000\000\000\000\000\000\000\005\130\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\t\022\000\000\000\000\007\186\000\000\000\160\000\000\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\007\188\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\026\000\000\000\000\001\150\000\000\t\196\000\000\000\000\000D\000\000\002\188\001R\002x\000\000\000\000\000\160\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0034\004\254\000\000\000\000\b\166\000\000\000\000\000\000\012\002\000\000\000\000\012\248\rR\000\000\000\000\000\000\000\000\r\238\015>\002\186\000\000\002\162\000\000\000\000\000\000\000\000\018\156\000\000\000\000\000\000\000\000\000\000\000\000\000E\000\000\000\000\007\202\000\000\000\000\001\208\000\000\019\002\000\000\000\000\000\000\b\020\000\000\000\000\019\200\000\000\000c\000\000\000\000\000\000\000\000\000\129\019`\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\022\200\021V\000\000\000\000\000\000\000\000\024\162\024\250\b\206\000\000\026\022\000\000\000\000\000\000\000\000\000\000\000\000\018\178\000\000\003B\000\000\000\000\000\000\n\012\000\000\000<\000\000\000\000\000\000\023\212\000\000\000\000\0266\027\002\n\186\000\000\027x\000\000\000\000\000\000\000\000\000\000\000\000\002\170\002\128\000\000\002\202\000\000\028r\011\002\000\000\028\202\000\000\000\000\000\000\000\000\003\028\000\000\003\174\000\000\000\000\000\000\001f\000\000\001f\003\154\003\246\000\000\000\000\000\000\001l\014\176\000\000\000\000\000\000\000\000\000\000\002\236\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\016\000\000\000\000\000\005\000\000\014\248\004\180\004\164\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\011\142\000\000\000\000\024\244\029$\000\000\000\000\000\000\000\000\029\128\000\000\000\0006\132\000\000\005\130\000\000\000\000\000\000\000\000\014\250\000\000\000\000\000\000\000\000\000\000\001|\024\204\000\000\000\000\026~\000\000\000\000\000\000\000\000\r\012\000\000\000\000\003\144\000\000\000\000\000\000\000\191\000\000\000\000\000\215\000\000\000\000\000\000\000\000\000\000\000\000\000\000M.\000\000\000\000\000\000\001\011\000\000\000\000\000\000\000\000\000\000\001\026\012\152\017\b\017\132\000\000\006\184\007\014\007\022\007d\000\000\000\000\000\000\000\000\000\000\000\000\007$\030Z\000\000)\218\007~\000\000\000\000\007\224\000\000\031P\000\000B\022\000\000\000\000\007(\031\226\000\000*\208\000\000\007f+\198\000\000\000\000\000\000\002\148\025\130\000\000\000\000\000\000\000\000\016\222\000\000\021\206!$\000\000\000\000\027\200\"\026\000\000\"L\000\000\000\000\021\174\000\000\023\"\000\000\000\000$\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\014\012\000\000\000\000\000\000\b\002\000\000 \216\000\000\026t\004\160\000\000\000\000\000\000\000\000\000\000\0044\000\000\000\000\000\000\000\000\000\000M\134\000\000\004\014\000\000\000\000\000\000\000\000\000\000\002*\000\000\015\002\0022\015\248\000\000\004p\016\238\000\000\004\178\000\000\005f\000\000\006\\\000\000\007R\000\000\026t\000\000\000\000\000\000\000\000\000\000\bH\000\000\004\186\000\000\t>\000\000\026t\005,\000\000\001\194\000\000\005@\006\236\000\000\004\020\000\000\004L\000\000\000\000\000\000\000\000\000\000\000\000\004h\000\000\004\132\000\000\004\226\000\000\000\000\000\000\000\000\000\000\005\030\000\000\000\000\000\000\000\000\000\000\006\134\0050\000\000\000\000\005\160\000\000\000\000\005\188\005\128\007H\000\000\007N\000\000\000\000\003\136\006R\000\000\006\002\000\000\000\000\006T\000\000\000\000\000\000\000\000\000\000\000\000\007\156\006~\000\000\000\000\000\000\006\190\006\140\005\158\006@\006\186\007\002\000\000\000\000\006\168\006P\006\162\006\220\007\022\000\000\000\000\007\176\b$\000\000\b@\000\000\bd\000\000\000\000\bF\000\000\000\000\bP\000\000\000\000\000\000\000\000\bb\000\000\b\144\000\000\000\000\000\000\b\150\000\000\000\000\000\000\b\156\000\000\000\000\000\000"), (16, "\001\210\000p\000\018\000=\003?\004t\003R\001\159\000p\006T\000y\000=\006U\005\169\005L\005M\000\007\000y\005\170\005\171\003\133\003\134\000p\002N\005\144\000\017\000N\002\217\004r\0042\001\211\000y\006Y\005\021\001\212\000N\006J\006K\000$\001D\0059\000\005\001E\000?\000p\002\133\002\134\002\157\002\137\006\011\005\172\000>\000N\000y\000N\002P\001D\003\007\006O\001P\000*\005\173\006E\006F\005:\0005\004\001\0005\003A\005=\005L\005M\001\162\006\t\003B\006\012\005L\005M\000N\000z\001\160\005]\001D\001\028\000p\001P\001\017\001\t\002S\003\233\002\196\006R\000O\000y\001\t\005N\001\213\005\170\005\171\002u\000p\000O\001\214\002\182\001F\005[\000p\002\148\001\t\000y\001G\005^\005L\005M\000p\000y\001\017\006R\000O\002\130\000O\001F\002\172\000y\001\147\001\239\001\019\001G\002S\005\202\001\t\0006\002\195\0006\002\174\005d\002O\004\161\002\198\003W\005\173\000z\001\012\003\235\000O\001\160\000p\001F\001V\002\185\002S\005N\0005\001G\001\210\000y\001\018\005N\003?\005A\003R\001\150\000p\002\133\002\138\001V\002\137\006~\002O\005E\001\t\000y\002\187\006\127\004\202\004\208\000p\003\133\003\134\003\237\0005\006\128\004|\004\000\001\135\000y\001\t\004\147\001\238\001\"\003O\001V\001\t\005N\003\242\005\249\002\188\000z\000\179\004\002\001\t\003P\004\163\004\128\004\207\002S\002S\004t\0009\005T\0009\003\007\002O\006\002\006+\004n\001\227\002\154\0006\002\164\004\001\005n\003A\001\029\000\179\000p\001\012\001\228\003B\001$\005\145\005\239\001\t\000\179\000y\002\166\001W\002\177\001\023\005b\003\244\006\b\0043\003\233\004z\001\023\0006\004\n\001\t\002\139\000\179\004\145\000P\001W\005\148\005\237\005\240\005L\005M\004*\003[\005\251\001\t\001\031\0005\006\t\002B\006\012\005L\005M\005O\000Q\002\176\002T\004\157\002\243\000\179\001 \003\\\001W\006\003\002\129\006\130\003]\001 \003\217\001\029\003^\001\153\007\025\001\210\006\004\006\005\003_\003?\0009\003R\003\235\001 \002\248\004\134\000<\001\136\002-\007\026\006\131\002&\005Y\002\167\006\189\0065\001\t\000p\001Z\002,\003\176\000p\006\128\006\190\004\000\001 \000y\006\192\003\208\002\166\000y\001\030\001X\005g\001Y\0006\001[\003\136\003\237\000\004\002\156\001\163\001\023\005N\001Z\001]\001\029\0005\002\129\003O\001\"\001^\003\007\003\242\005N\0068\002\192\000\179\004\002\006\132\003P\004\001\001[\003A\000\005\001\026\003\253\001\\\006\133\003B\000p\001]\002\139\006\209\006\163\006\\\005a\001^\003\254\000y\002\177\001 \001\127\006\207\003\233\000p\001!\001 \001\023\004w\001#\000\167\005\249\002a\000y\002\197\002T\006\001\005\236\003\244\002k\004\005\006\165\001\t\002\129\002\218\004\n\001\t\003\218\004\203\006\167\000\004\0009\0006\002S\004\147\002d\003\209\004*\003[\003\000\005\132\005\237\005\240\005L\005M\003\219\001 \005\150\002S\004\205\005\134\005L\005M\0005\005\254\000\005\003\\\003\235\006+\000p\001\210\003]\001 \006\210\003?\003^\003R\0005\000y\000p\002\151\003_\004\134\005R\007\"\001\t\001 \005\251\000y\004\205\000N\0005\000p\005h\000N\006\006\002\192\002\217\004r\0042\001\t\000y\000p\003\237\001\210\006;\000p\002\217\001\211\005b\004\136\000y\001\212\002\151\003O\000y\000Z\000p\003\242\0009\002\153\005S\000\179\004\002\006\211\003P\000y\003\007\002\178\0006\005\196\004\150\000F\006\133\005N\002\197\004\001\003\007\003A\006\213\000\r\002\218\005N\0006\003B\005\221\002S\005i\002l\0063\002S\005\135\003\158\002\152\000]\001\t\000O\0006\0005\003\233\000O\002S\000\016\000\017\003\244\001\t\004\005\006\215\002\180\006A\001\230\004\n\000N\002|\001\213\006\217\002e\004\228\001\t\002f\001\214\000R\005\223\004*\003[\001\210\006]\001\023\001\t\003?\000N\003R\001\t\004\230\000\170\000U\005a\0005\000\b\000\176\002\178\006\007\003\\\001\t\006=\006\b\0009\003]\004\129\003W\001\006\003^\001\012\003\235\004f\001\210\001\232\003_\005\252\003?\0009\003R\001 \005\233\0006\005\235\001 \004\004\006\129\006\t\005T\006\012\005L\005M\0009\005e\002\255\000p\000O\003\254\002\179\002\225\006\128\006\195\0042\006\183\000y\001\233\006\184\003\237\0048\001\230\007\011\003A\005\245\003\014\000O\006\025\004\139\003B\003O\000\164\003\254\0006\003\242\006\175\006\176\000\172\000\179\004\002\005\025\003P\003\007\004\131\003\233\001 \006\192\004\231\001\235\004\002\006\192\004\001\000\004\003A\006C\004n\003\133\003\134\000a\003B\001\026\004\216\000\159\004\230\001\227\000S\002\024\001I\006\206\0007\005b\0009\000\179\000\178\003\233\001\228\000V\000\005\0005\000S\003\244\000F\0043\005N\004z\006\017\002\192\004\n\006\188\004l\000V\004\145\004\220\001\t\003W\000F\005p\004\n\003\235\004*\003[\004\018\006\198\002\185\007\018\002\229\006\214\006\180\001\210\004*\0009\001\238\003?\002\255\003R\002\193\003\164\001\017\003\\\006\173\005q\005L\005M\003]\003\181\002\197\002\189\003^\003\235\002\027\000p\004i\006\219\003_\003\237\006\128\006\195\0042\001 \000y\001C\004i\000N\0005\0006\003O\000\170\006R\001 \003\242\002\188\000\171\001 \000\179\001\240\006\223\003P\003Z\000\179\002S\0005\000\180\000:\001 \003\237\003\007\006R\004\218\000p\001\241\004n\004k\002\143\002\217\004\001\003O\003A\000y\006\243\003\242\000p\004j\003B\000\179\004\002\006\201\003P\0057\0058\000y\004\142\006\200\004\172\000\181\006\133\003\244\005\243\003\233\000p\004\142\003\243\000{\005N\003\007\003\254\006\023\006\241\000y\000O\0006\0005\003\135\002S\000\164\000N\003[\001\t\002\226\000\170\000\172\006\235\0009\000\182\000\176\004\238\003\244\0006\0043\000N\006\203\004\144\001\210\004\n\003\\\006\237\003?\006\205\003R\003]\004\143\004\240\000\183\003^\000p\004*\003[\000\255\000^\003_\004\166\000N\003\235\000y\000p\001\t\000\178\000\185\004\219\006\128\006\195\0042\004\166\000y\003\\\0005\000N\001\t\007\n\003]\000\170\002a\004\193\003^\004\193\000\171\007\b\0006\002{\003_\004\241\000O\006\239\006\015\001 \001\t\000\164\0009\003\237\003\007\004\168\007\029\000\172\000\005\002d\000O\004\240\000D\004\001\003O\003A\001\012\004\167\003\242\0009\006a\003B\000\179\004\002\006\201\003P\006\245\004\195\000F\004\194\006\202\003\216\000O\006\133\006\251\006\252\003\233\004\221\004\244\003\243\003\133\003\134\005t\000\178\004\255\001\t\0006\000O\003\133\003\134\003\133\003\134\000\164\000N\004\240\001\t\000\179\000\170\000\172\000\180\005\001\004\002\000\176\006a\003\244\007\001\0043\006a\006\203\003\208\001\210\004\n\002\190\005\002\003?\006\205\003R\000S\000_\004\218\005\005\003\133\003\134\004*\003[\006\244\007\030\005\r\000V\005\001\003\235\000\181\000p\000F\000\178\007$\004\240\006\128\006\195\0042\005\016\000y\003\\\005\015\004\220\007\002\006a\003]\006m\004\n\002\147\003^\007\007\004\018\007\019\007\006\005\015\003_\007\014\000O\003\254\004*\001 \003\208\000\164\001\020\003\237\003\007\000\179\007\019\000\172\000\180\007\016\001\023\0005\007%\004\001\003O\003A\000\187\002e\003\242\001\209\002f\003B\000\179\004\002\006\201\003P\005\019\000\188\001\023\000p\006\204\005H\005K\006\133\006p\003\209\003\233\001 \000y\003\243\000\181\003>\004\240\000\178\007B\007\018\003\254\005I\005I\001 \007\022\006\164\005\147\000N\000N\001\t\000\179\000\170\001D\000\180\007C\001E\000\176\003\254\003\244\002\159\0043\001 \006\203\000\182\001\210\004\n\003\248\001\023\003?\006\205\003R\0006\006e\007\023\006i\005\156\006w\004*\003[\007\027\007\028\007\031\000\183\003\212\003\235\000\181\000p\000\184\007\018\007\019\007 \006\128\006\195\0042\007#\000y\003\\\000\185\007&\005\157\007'\003]\005\160\005L\005M\003^\001 \006|\003\215\001\t\003\207\003_\0078\000O\000O\006d\001 \001F\000\164\006c\003\237\003\007\000\179\001G\000\172\000\180\007-\0076\006\247\0072\004\001\003O\003A\000\187\0075\003\242\000p\000w\003B\000\179\004\002\006\201\003P\007>\000\190\000y\0005\006\212\003\208\007<\006\133\005s\007@\003\233\000p\007E\003\243\000\181\006b\002\217\000\178\001V\000\000\000y\000p\002\133\002\134\002\135\002\137\000\000\000N\000z\001\t\000y\000\170\005q\005L\005M\000\000\000\176\002S\003\244\000\000\0043\005N\006\203\000\182\001\210\004\n\003\007\000\000\003?\006\205\003R\000\000\005\134\005L\005M\002S\000z\004*\003[\005<\000\000\000\000\000\183\000\000\003\235\002S\000p\000\254\000\000\0006\000\000\006\128\006\195\0042\000\000\000y\003\\\000\185\000N\001\t\000\000\003]\000\170\005:\000\000\003^\000\000\000\174\005=\005L\005M\003_\000\000\000O\003\209\000\000\001 \001\t\000\164\000\000\003\237\003\007\000\179\000\179\000\172\000\180\001W\001\t\000\000\005\145\004\001\003O\003A\000\000\005N\003\242\000\000\001\023\003B\000\179\004\002\006\201\003P\000p\000\000\000\000\000\000\006\216\000\000\000\000\006\133\000\000\000y\003\233\005N\000\000\003\243\000\181\000\000\000\000\000\178\000\000\000\000\005\185\000O\005Z\0009\000\000\000\000\000\164\000N\000\000\001\t\000\000\000\170\000\172\001 \000\000\000\000\000\176\000\000\003\244\005\174\0043\000\000\006\203\000\182\001\210\004\n\005[\005N\003?\006\205\003R\000\000\005^\005L\005M\000\000\000\000\004*\003[\000\000\005\200\001\146\000\183\000\000\003\235\004\002\000p\001\001\000\178\000\000\000\000\002\217\004r\0042\000\000\000y\003\\\000\185\000\000\001\210\000\000\003]\000\000\001\211\005\198\003^\001\t\001\212\005\201\005L\005M\003_\000\000\000O\000\000\000\000\001 \000p\000\164\002T\003\237\003\007\000\179\002\139\000\172\000\180\000y\002\129\005\b\000\000\004\001\003O\003A\004\n\001\144\003\242\000\000\004\018\003B\000\179\004\002\006\201\003P\000p\000\000\004*\000\000\002T\000\000\000\000\006\133\000\000\000y\003\233\005N\002\129\003\243\000\181\000\000\000\000\000\178\000\000\000\000\000\000\000\000\001\230\001 \000\000\000\000\001\213\000N\000\000\001\t\000\179\000\170\001\214\000\180\000\000\000\000\000\176\000\000\003\244\000\000\0043\001 \006\203\000\182\001\210\004\n\000\000\005N\003?\006\205\003R\001 \005\134\005L\005M\000\000\000\000\004*\003[\001\231\001\t\000\000\000\183\000\217\003\235\000\181\000p\001R\001\232\000\000\000\000\002\217\004r\0042\000\000\000y\003\\\000\185\000\000\001\210\000\000\003]\000\000\001\211\000\000\003^\001\t\001\212\005\134\005L\005M\003_\000\000\000O\000\212\000\000\001 \000\000\000\164\001\233\003\237\003\007\000\179\000\000\000\172\000\180\001\022\000\000\000\000\000\000\004\001\003O\003A\000\183\001\023\003\242\000\000\000\218\003B\000\179\004\002\000\214\003P\004\211\004\128\000\000\000\000\000\000\000\185\005j\001\235\000\000\006\b\003\233\005N\000\000\003\243\000\181\000\000\000\000\000\178\000\000\000\000\005\211\000\000\001\230\001\227\002*\002\017\001\213\000\000\000\000\001\t\001 \000\179\001\214\006\t\001\228\006\012\005L\005M\003\244\000\000\0043\000\000\004z\000\182\001\210\004\n\000\000\005N\003?\004\018\003R\000\000\000\000\000\000\000p\002\028\005\226\004*\003[\001\231\000\000\002\020\000\183\000y\003\235\000\000\000p\001T\001\232\005p\001\238\002\217\004r\0042\000\000\000y\003\\\000\185\000\000\001\210\002\161\003]\000\000\001\211\000\000\003^\000\000\001\212\001\023\003\182\000\000\003_\000\000\005q\005L\005M\001 \000\000\002S\001\233\003\237\003\007\000\179\000\000\000\000\000\180\002\163\000\000\000\000\000\000\004\001\003O\003A\001\240\001\023\003\242\000\000\005N\003B\000\179\004\002\000\000\003P\004~\004\128\000\000\000p\001 \001\241\000\000\001\235\006\\\000\000\003\233\000\000\000y\003\243\000\181\000\000\0005\001\t\000\000\000\000\000\000\000\000\001\230\001\227\002'\002\017\001\213\000\000\000\000\001\t\001 \000\179\001\214\000\000\001\228\000\000\000\000\000\000\003\244\000\000\0043\000\000\004z\000\182\001\210\004\n\000\000\000\000\003?\004\018\003R\000\000\005N\000\000\000\000\002\028\000\000\004*\003[\001\231\000\000\002\020\000\183\000\000\003\235\000\000\000p\003T\001\232\005p\001\238\002\217\004r\0042\000\000\000y\003\\\000\185\005\236\001\210\000\000\003]\0006\001\211\000\000\003^\000\000\001\212\000\000\001\t\000\000\003_\000\000\005q\005L\005M\001 \000p\002\150\001\233\003\237\003\007\005\237\005\240\005L\005M\000y\000\000\000\000\000\000\004\001\003O\003A\001\240\005p\003\242\006\028\000\000\003B\000\179\004\002\000\000\003P\004\165\004\128\000p\002\133\002\141\001\241\002\137\001\235\000\000\000z\003\233\000y\000\000\003\243\000\000\005q\005L\005M\002S\000\000\000\000\000p\001\230\001\227\002$\002\017\001\213\000\000\000\000\001\t\000y\000\179\001\214\000\000\001\228\000\000\0009\000z\003\244\000\000\0043\000\000\004z\000\000\001\210\004\n\002S\000\000\003?\004\018\003R\000\000\005N\005w\000\000\002\028\004+\004*\003[\001\231\001\t\002\020\005N\000\000\003\235\002S\000p\006g\001\232\005p\001\238\002\217\004r\0042\0005\000y\003\\\000\000\000\000\001\210\000\000\003]\000\000\001\211\001\026\003^\000\000\001\212\001\t\000\000\000\000\003_\000\000\005q\005L\005M\001 \005N\000\000\001\233\003\237\003\007\000\000\004\031\000\000\000\000\000\000\001\t\000\000\006^\004\001\003O\003A\001\240\000\000\003\242\000p\001\023\003B\000\179\004\002\002\217\003P\004\215\004\128\000y\005\249\002\248\001\241\000\000\001\235\000\000\000\000\003\233\000\000\000\000\003\243\000\000\000\000\0005\0006\000\000\000\000\004Z\0005\001\230\001\227\002\"\002\017\001\213\000\000\003\007\001\t\000\000\000\179\001\214\001 \001\228\000\000\000\000\002S\003\244\000\000\0043\000\000\004z\000\000\001\210\004\n\005\250\000\000\003?\004\018\003R\000\000\005N\005}\000\000\002\028\000\000\004*\003[\001\231\006\018\002\020\006>\000p\003\235\000\000\000p\000\000\001\232\005\251\001\238\006\128\000y\004\000\000\000\000y\003\\\001\"\006\b\001\t\002T\003]\0006\000\000\002\139\003^\000\000\0006\002\129\000\000\000\000\003_\000\000\006\019\0009\006\020\001 \000\000\005{\001\233\003\237\003\007\006\t\000\000\006\012\005L\005M\000\000\002T\000\000\004\001\003O\003A\001\240\005p\003\242\002\129\001$\003B\000\179\004\002\003\211\003P\006\160\004\128\000^\006\021\001 \001\241\006\208\001\235\000\000\000\000\003\233\000\000\002a\003\243\006\022\005q\005L\005M\000\000\002v\000\000\000\000\000\000\001\227\002\015\002\017\001\t\000\000\000\000\001\t\000\000\000\179\001 \000\000\001\228\002d\003\208\000\000\003\244\000\000\0043\0009\004z\000\000\001\210\004\n\000\000\004\002\003?\004\018\003R\001\026\000\000\005\141\000\000\002\028\000\000\004*\003[\000p\000\000\002\020\000{\005N\003\235\000N\000p\000\000\000y\001D\001\238\006\128\001P\004\000\000\000\000y\003\\\005\252\002\127\000p\002\133\003]\000\000\002\140\000\000\003^\000\000\000\000\000y\0005\005\n\003_\000\000\000\000\004`\004\n\001 \005N\000\000\004\018\003\237\003\007\000\000\002S\0005\000\000\000\000\004*\000\000\000\000\004\001\003O\003A\001\240\000z\003\242\000S\000c\003B\000\179\004\002\006\194\003P\002S\000\000\003\209\000\000\000V\001\241\006\193\006\133\000O\000F\003\233\001F\000\000\006\197\001\147\000\000\0005\001G\000\000\000\000\000\000\000\000\001\t\001 \000\000\002\219\000\000\000\000\000\000\001\t\005\255\0005\0006\000\000\000\000\000\000\0005\000\000\003\244\000\000\004\005\006\199\001\t\002e\001\210\004\n\002f\0006\003?\006\205\003R\001\150\000\000\000\000\001\023\001V\000\000\004*\003[\000\000\000\000\000\000\006/\000p\003\235\000\000\000p\000\000\000\000\000\000\000\000\006\128\000y\004\000\000\000\000y\003\\\000\000\000\000\000p\000\000\003]\0006\000\000\006\\\003^\000\000\000\000\000y\000\000\000\000\003_\001\"\001 \000\000\000\000\001 \0006\005\139\000\000\003\237\003\007\0006\000\000\000p\002\133\002\134\002\145\002\137\0009\004\001\003O\003A\000y\000\000\003\242\000\000\000\000\003B\000\179\004\002\006\194\003P\000\000\0009\000\000\000\000\000\000\000\000\006\196\006\133\000\000\001$\003\233\000\000\002a\006\197\000\000\000\000\000z\000\179\000p\002c\001W\000\000\000\000\006\\\000\000\002S\001\t\000y\000N\001\t\000\000\000\000\000\170\0027\000\000\002d\0009\000\174\003\244\000\000\004\005\006\199\001\t\000\000\001\210\004\n\000\000\000\000\003?\006\205\003R\0009\000\000\004\031\000\000\001\153\0009\004*\003[\000\000\000\000\000\000\002T\002\142\003\235\000N\000p\001\t\002\243\001D\002\129\002\217\001P\004\000\000\000\000y\003\\\002\248\000\000\000N\001Z\003]\0005\000\170\000\000\003^\000\000\000\000\000\171\001\026\000\000\003_\002\248\004Z\000O\000\000\001 \000\000\001[\000\164\003\237\003\007\000\000\001\163\001\t\000\172\000\000\001]\002\249\001 \004\001\003O\003A\001^\000\000\003\242\000\000\000\000\003B\000\179\004\002\006\194\003P\006\135\000\000\000\000\002\219\001\202\000\000\000\000\006\133\000O\002\253\003\233\001F\000\000\006\197\001\147\000\000\000\000\001G\000\178\000{\006f\000\000\000O\000\000\006\162\0006\000\000\000\164\000\000\001\t\000\000\000\000\004\223\000\172\000\000\002Q\000\000\004\160\003\244\0005\004\005\006\199\000\000\002e\001\210\004\n\002f\000\000\003?\006\205\003R\001\150\000\000\005p\001\023\001V\000\000\004*\003[\0005\005\197\000\000\006^\002\139\003\235\000\000\000p\000\000\000\000\000\178\001\023\002\217\000\000\004\000\000\000\000y\003\\\005q\005L\005M\000\000\003]\006]\002\219\005\198\003^\000\000\002T\005\201\005L\005M\003_\000\000\001 \000\000\002\129\001 \000\000\000\000\000\000\003\237\003\007\0009\000\179\005p\0006\000\180\0005\000\000\001 \004\001\003O\003A\000\000\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\006^\0006\000\000\000\000\005q\005L\005M\003\249\001\023\003\233\001 \000\000\004\149\000\000\000\181\000p\000\179\000\000\000\000\001W\002\217\003\251\004\000\000\000\000y\000\000\000\000\005p\001\t\000\000\000\179\004\158\001\151\000\180\000\000\005N\004\160\003\244\000\000\004\005\004\151\001\"\000\000\000\212\004\n\004\031\005N\001 \004\018\0006\003\007\005q\005L\005M\001\153\000\000\004*\003[\0009\004\001\000\000\003A\000\183\003\235\000\000\000\181\000\213\003B\000\000\002\248\000\214\000\000\000\000\000\000\000\000\003\\\005\159\000\185\0009\001Z\003]\001$\003\233\000\000\003^\004$\005N\000Y\0005\000N\003_\0005\000\000\001D\000\000\001 \001P\001[\000\000\003\237\005\157\001\t\001\163\005\160\005L\005M\001]\000\000\000\000\004(\003O\000\000\001^\000\187\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\000\000\000\192\004\031\0009\000\000\000p\000\000\000\000\004\007\002\219\005N\000\000\004\149\003\235\000y\000p\000\000\000\000\000\000\000\000\002\217\004\b\0042\000\000\000y\000\000\002\248\000\000\000\000\000\000\000\000\0006\000O\0005\0006\001F\005\137\003\244\001\147\004\005\004\151\001G\004$\005\203\004\n\000\000\001\216\000\000\004\018\003\237\003\007\000\000\000\000\0005\000\000\000\000\004*\003[\000\000\004\001\003O\003A\005N\000\000\003\242\000\000\004(\003B\000\179\004\002\000\000\003P\000\000\003\214\000\000\003\\\000\000\002w\000S\001V\003]\000\000\003\233\000\000\003^\0047\0005\005\152\000\000\000V\003_\001\t\000N\000\000\000F\001 \003?\002\219\003@\0006\002d\001\t\000\000\000\000\0005\000\000\000\000\000\000\0009\000\000\003\244\003\208\004\005\0049\000\000\000\000\001\210\004\n\000\000\0006\003?\004;\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\0045\000\000\000\000\005\167\000N\003\235\000\\\000p\003?\000\000\003R\000\000\002\217\004\b\0042\000\000\000y\003\\\000\000\000\000\000\000\0006\003]\000\000\005p\000\000\003^\000O\0005\003A\000\000\000\000\003_\000\179\000\000\003B\001W\001 \000\000\0006\000\000\003\237\003\007\000\000\000\000\0009\000\000\000\000\005q\005L\005M\004\001\003O\003A\000\000\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\0009\000p\000\000\000{\003\209\000O\001\161\003A\004:\003\233\000y\000\000\003\243\003B\000\000\000p\000\000\000\000\000\000\002\220\002\217\004\b\0042\0005\000y\000\000\000\000\000\000\001\t\0006\000N\001Z\000\000\0009\003?\002e\003@\003\244\002f\0043\002z\0044\000\000\002\227\004\n\000\000\001\023\000\000\004\018\001[\003\007\0009\000\000\000p\001\163\000S\004*\003[\001]\004\001\000\000\003A\000y\003\235\001^\005N\000V\003B\000\000\000\000\000\000\000F\000\000\000\000\006\142\003\\\000\000\000\000\003W\000\000\003]\006\155\003\233\000\000\003^\001 \003O\001\t\000\000\0006\003_\000{\000\000\000\000\000\179\001 \000O\003P\003A\003\237\000\000\001\t\000\000\000\000\003B\000\000\0009\003\001\000\000\000\000\003O\0005\000\000\000\000\003\242\0005\001\210\000\000\000\179\004\002\003?\003P\003R\000\000\001\225\002a\000\000\000\000\000\000\003O\000\000\003\005\002y\000\000\000\000\003\243\003\235\000\179\000p\001\t\003P\005\156\000{\002\217\004r\0042\000\000\000y\002d\0005\000\000\000\000\000\000\000\000\003Y\002\219\000\000\000\000\002W\002\219\003\244\000\000\0043\000\000\0044\005\157\0009\004\n\005\160\005L\005M\004\018\003\237\003\007\003\131\000\000\000\000\0006\000\000\004*\003[\0006\004\001\003O\003A\000\000\000\000\003\242\000\000\005\178\003B\000\179\004\002\000\000\003P\000\000\000\000\002t\003\\\003[\006\156\000\000\000\000\003]\000\000\003\233\000\000\003^\003\243\000\000\000\000\000\000\000N\003_\000\000\0006\000\170\003\\\001 \000\000\003O\000\171\003]\000\000\001\t\006\157\003^\006\145\000\179\000\000\006\146\003P\003_\003\244\0005\0043\000\000\0044\001\023\001\210\004\n\000\000\000\000\003?\004\018\003R\000\000\000\000\000\000\000\000\005N\000\000\004*\003[\0009\000\000\000\000\000{\0009\003\235\000\000\000p\000\000\000\000\000\000\000\000\002\217\004r\0042\000\000\000y\003\\\000\000\002\131\000\000\005\156\003]\001 \000O\002e\003^\000\000\002f\000\164\000\000\000\000\003_\000\000\000\000\000\172\001\023\001 \0009\000\000\000\000\003\237\003\007\000\000\000\000\005\157\0006\000\000\005\160\005L\005M\004\001\003O\003A\003Q\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\004y\000\000\000\000\000N\000\000\000\000\000\178\001\211\0005\003\233\001 \001\212\003\243\000\000\000\000\000p\000\000\000\000\000\000\000\000\002\217\004r\0042\0005\000y\000\000\000{\000N\001\t\000\000\000{\000\170\000\000\000\000\000\000\000\000\000\171\003\244\000\000\0043\000\000\004z\003\b\000\000\004\n\000\000\004,\000\000\004\018\000\000\003\007\000\000\005\180\000\000\000\000\000\000\004*\003[\0009\004\001\000\000\003A\005p\003\235\002o\005N\003\012\003B\000\000\000O\0040\000\000\000\000\001\213\0006\003\\\000\000\000\000\000\000\001\214\003]\006\b\003\233\000\000\003^\000\000\005q\005L\005M\0006\003_\000\179\000\000\000O\000\180\001 \000\000\000\000\000\164\003\237\005\156\001\t\000\000\0005\000\172\006\t\005p\006\012\005L\005M\003O\0005\000\000\000\000\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\004{\005\157\000\000\000\181\005\160\005L\005M\005q\005L\005M\000\000\0005\003\243\003\235\000\000\000p\000\000\000\178\000\000\000\000\002\217\004\152\0042\000\000\000y\000\000\000{\000N\0009\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\176\003\244\006a\0043\000\000\004z\002\232\0009\004\n\005N\0006\000\000\004\018\003\237\003\007\000\187\000\000\000\000\0006\002\219\004*\003[\000\000\004\001\003O\003A\000\194\005\206\003\242\000\000\005N\003B\000\179\004\002\001\227\003P\000\000\004\141\000\000\003\\\000\000\0006\000\179\000\000\003]\001\228\003\233\000\000\003^\003\243\005N\000\000\000\000\005N\003_\000\000\000\000\000O\000\000\001 \000\000\000\000\000\164\000\000\000\000\001\t\000\179\000\000\000\172\000\180\000\000\004\154\000\000\000\000\003\244\000\000\0043\000\000\004z\000\000\001\210\004\n\000\000\000{\003?\004\018\003R\0009\000\000\005p\000\000\000\000\000\000\004*\003[\0009\0005\000\000\003D\003\159\003\235\000\181\000p\000\000\000\178\005p\000\000\002\217\004\152\0042\000\000\000y\003\\\005q\005L\005M\000\000\003]\0009\000\000\000\000\003^\000\000\006a\001\229\0005\000\000\003_\000\000\005q\005L\005M\001 \005\191\000\000\000\000\003\237\003\007\000\000\006\b\002\219\000\000\000\000\000\000\000\000\000\000\004\001\003O\003A\000\187\000\000\003\242\0066\001\210\003B\000\179\004\002\003?\003P\003R\000\196\000\000\0006\006\t\000\000\006\012\005L\005M\004\174\003\233\000\000\006\"\003\243\000\000\000\000\000p\000\000\005\189\003M\000\000\002\217\004\b\0042\006e\000y\002\243\000{\000\000\001\t\000\179\000\000\0006\000\180\000\000\004\156\005N\000\000\003\244\0005\0043\000\000\004\155\003\167\000\000\004\n\0005\000\000\005p\004\018\002\248\003\007\005N\000\000\000p\000\000\000\000\004*\003[\002\217\004\001\000\000\003A\000y\003\235\000\181\002\249\000\000\003B\000\000\000\000\000\000\005q\005L\005M\000\000\003\\\000\000\000\000\000\000\0009\003]\000\000\003\233\000\000\003^\000\000\000\000\005N\003\007\002\253\003_\000\000\000\000\000\182\000\000\001 \000\000\002S\000\000\003\237\000\000\001\t\000\000\000\000\0006\000\000\005p\000\000\0009\000\000\003O\0006\000\183\000\000\003\242\000\000\001\210\003V\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\000\000\000\185\000p\000N\005q\005L\005M\000\161\002K\003\243\003\235\000y\000p\001\t\000\000\000\000\000\000\002\217\006e\004\000\004\031\000y\000\000\000\000\001\210\000N\000\000\005N\001\211\000\161\002G\000\000\001\212\005\187\003\244\000\000\0043\000\000\004\155\000\000\000\000\004\n\000\000\000\000\002\248\004\018\003\237\003\007\000\000\005\217\000\000\000\000\000\000\004*\003[\0009\004\001\003O\003A\000\000\004$\003\242\0009\000\000\003B\000\179\004\002\000\000\003P\000O\000\000\000\000\003\\\000{\000\164\006\150\000\000\003]\000\000\003\233\000\165\003^\003\243\0069\004(\000\000\005N\003_\001\t\003\183\001\230\000O\001 \000\000\001\213\000\000\000\164\000\000\001\t\000\000\001\214\004\209\000\165\000\000\004\002\005p\004\160\003\244\000\000\0043\000\000\0044\000\000\001\210\004\n\000\000\000\178\003?\004\018\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\005q\005L\005M\000\000\003\235\000\000\000p\001\232\000\000\000\178\000\000\002\217\000\000\004\000\000\000\000y\003\\\000{\005\012\000\000\005p\003]\005\215\004\n\003\152\003^\000\000\004\018\000\000\000\000\000\000\003_\000\000\003\189\000\000\004*\001 \000\000\001\233\000\000\003\237\003\007\000\000\000\000\005q\005L\005M\000\000\000\000\000\000\004\001\003O\003A\000\000\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\000\005p\000\000\000\000\000\000\001\235\000\000\000\000\000\179\003\233\001 \000\180\004\149\000\000\000\000\000p\000\000\005\213\005N\000\000\002\217\001\227\004\000\002\014\000y\005q\005L\005M\001\t\000\179\000\179\004\225\001\228\000\180\000\000\006\145\004\160\003\244\006\146\004\005\004\151\006\153\000\000\000\181\004\n\000\000\001\023\005p\004\018\000\000\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\0005\004\001\000\000\003A\005N\003\235\000\000\000\181\000\000\003B\001\238\000\000\000\000\005q\005L\005M\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\001 \0005\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\003\237\000\000\001\t\000\000\0005\004\227\000\000\000\000\005N\000\000\004\160\003O\001\240\000\000\000\000\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\000\000\0006\000\000\001\241\000\000\000\000\000N\000\000\000\000\000\000\000\161\002A\004\149\003\235\000\000\000p\000\000\000\000\000\000\005\230\002\217\000\000\004\000\000\000\000y\000\000\000\000\001\210\000N\0006\005N\001\211\000\161\0026\000\000\001\212\000\000\003\244\000\000\004\005\004\151\000\000\000\000\000\000\004\n\000\000\0006\000\000\004\018\003\237\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000\000\005\228\003\242\000\000\000\000\003B\000\179\004\002\000\000\003P\000O\000\000\000\000\003\\\000\000\000\164\0009\000\000\003]\000\000\003\233\000\165\003^\004\149\000\000\000\000\000\000\000\000\003_\000\000\000\000\001\230\000O\001 \000\000\001\213\000\000\000\164\000\000\001\t\000\000\001\214\006j\000\165\0009\000\000\006 \004\160\003\244\000\000\004\005\004\151\000\000\000\000\001\210\004\n\000\000\000\178\003?\004\018\003R\0009\000\000\000\000\000\000\000\000\000\000\004*\003[\006r\000\000\000\000\000\000\000\000\003\235\000\000\000p\001\232\000\000\000\178\000\000\002\217\004\b\0042\000\000\000y\003\\\000\000\000\000\000\000\000\000\003]\006%\000\000\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000{\001\233\000\000\003\237\003\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\001\003O\003A\004\022\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\000\000{\000\000\000\000\000\000\001\235\000\000\000\000\000\179\003\233\000\000\000\180\004\149\000\000\000\000\000p\000\000\004Q\000{\000\000\002\217\001\227\004\000\001\237\000y\000\000\000\000\000\000\001\t\000\179\000\179\000\000\001\228\000\180\004a\000\000\000\000\003\244\000\000\004\005\004\151\000\000\000\000\000\181\004\n\000\000\000\000\000\000\004\018\000\000\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\000\000\003A\000\000\003\235\000\000\000\181\000\000\003B\001\238\000\000\000\000\000\000\000\000\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\003\237\000\000\001\t\000\000\000\000\006x\000\000\000\000\000\000\000\000\004\160\003O\001\240\000\000\000\000\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\001\241\000\000\000\000\000\000\000\000\006\166\000\000\000\000\000\000\003\243\003\235\000\000\000p\000\000\000\000\000\000\000\000\002\217\004\b\0042\000\000\000y\000\000\000\000\000N\000N\000\000\000\000\000\170\000\161\0023\000\000\000\000\000\171\003\244\000\000\0043\000\000\0044\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\003\007\000\000\000\000\000p\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000y\000\000\003\242\000\000\000\000\003B\000\179\004\002\000\000\003P\000\000\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\004\149\000\000\000\000\000\000\000\000\003_\000\000\000\000\000O\000O\001 \000\000\000\000\000\164\000\164\000\000\001\t\000\000\000\000\000\172\000\165\000\000\000\000\000\000\000\000\003\244\000\000\004\005\004\151\000\000\000\000\001\210\004\n\000\000\004\169\003?\004\018\003R\000\000\000\000\000\000\006\142\000\000\000\000\004*\003[\000\000\000\000\006\154\000\000\000\000\003\235\000\000\000p\001\t\000\178\000\178\000\000\002\217\000\000\0042\000\000\000y\003\\\000\000\000\000\000\000\000\000\003]\000\000\000\000\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\003\237\003\007\000\000\000\000\000p\000\000\000\000\000\000\000\000\000\000\004\001\003O\003A\000y\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\000\000\000\000\000p\000\000\000\000\000\000\003\233\000\000\0046\003\243\000\000\000y\000p\000\000\000\000\000\000\000\000\002\217\000\000\004\000\000\000\000y\000\000\000\000\000N\001\t\000\179\000\179\000\170\000\180\000\180\000\000\000\000\000\171\003\244\000\000\0043\000\000\0044\000\000\000\000\004\n\000\000\000\000\000\000\004\018\000\000\003\007\000\000\000\000\006\142\000\000\000\000\004*\003[\000\000\004\001\006\149\003A\000\000\003\235\000\181\000\181\001\t\003B\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\\\000\000\000\000\006\142\000\000\003]\000\000\003\233\006\145\003^\006\144\006\146\000\000\000\000\000\000\003_\001\t\000\000\000O\001\023\001 \000\000\000\000\000\164\003\237\000\000\001\t\000\000\000\000\000\172\000\000\000\000\000\000\000\000\000\000\003O\000\000\000\187\000\000\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\000\198\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \003\255\004\171\003\235\000\000\000p\000\000\000\178\000\000\000\000\002\217\000\000\004\000\000\000\000y\000\000\000\000\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\171\003\244\000\000\0043\000\000\004\173\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000\000\000\000\003\242\000\000\000N\003B\000\179\004\002\001D\003P\000\000\001P\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\006\145\003^\004\003\006\146\000\000\000\000\000\000\003_\000\000\000\000\000O\001\023\001 \000\000\000\000\000\164\000\000\000\000\001\t\000\179\000\000\000\172\000\180\000\000\000\000\006\145\000\000\003\244\006\146\004\005\004\006\000\000\000\000\001\210\004\n\000\000\001\023\003?\004\018\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\000O\001 \004\t\001F\003\235\000\181\000p\000\000\000\178\001G\000\000\002\217\000\000\004\000\000\000\000y\003\\\000\000\000\000\000\000\000\000\003]\000\000\000\000\000\000\003^\001 \000\000\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\003\237\003\007\000\000\000\000\000\000\000\000\000\000\001V\000\000\000\000\004\001\003O\003A\000\187\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\200\000\000\000\000\000\000\000\000\000p\000\000\000\000\000\000\003\233\000\000\000\000\004\003\000\000\000y\000p\000\000\000\000\000\000\000\000\002\217\000\000\004\000\000\000\000y\000\000\000\000\000N\001\t\000\179\000\000\000\170\000\180\000\000\000\000\000\000\000\171\003\244\000\000\004\005\004\006\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\000\000\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\000\000\003A\000\000\003\235\000\181\000\000\000\000\003B\000\179\000\000\000\000\001W\000\000\000\000\000\000\003\\\000\000\000\000\006\142\000\000\003]\000\000\003\233\000\000\003^\006\152\000\000\000\000\000\000\000\000\003_\001\t\000\000\000O\000\000\001 \000\000\000\000\000\164\003\237\000\000\001\t\000\000\000\000\000\172\000\000\000\000\000\000\000\000\000\000\003O\000\000\000\187\000\000\003\242\000\000\001\210\000\000\000\179\004\002\003?\003P\003R\000\202\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001Z\000\000\000\000\000\000\004\003\003\235\000\000\000p\000\000\000\178\000\000\000\000\002\217\000N\004\000\000\000\000y\000\170\001[\000\000\000\000\000\000\000\171\001\149\000\000\000\000\000\000\001]\000\000\003\244\000\000\004\005\004\006\001^\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000\000\000\000\003\242\000\000\000\000\003B\000\179\004\002\000p\003P\000\000\000\000\000\000\003\\\000\000\004}\000\000\000y\003]\000\000\003\233\000\000\003^\004v\000\000\000O\000\000\000\000\003_\000\000\000\164\000\000\000\000\001 \000\000\000\000\000\172\000\000\000N\001\t\000\179\000\000\000\170\000\180\000\000\000\000\006\145\000\171\003\244\006\146\004\005\004x\000\000\000\000\001\210\004\n\000\000\001\023\003?\004\018\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\000\000\000\000\000\178\000\000\003\235\000\181\000p\000\000\000\000\000\000\002a\002\217\000\000\004\000\000\000\000y\003\\\002k\000\000\000\000\000\000\003]\000\000\000\000\001\t\003^\001 \000\000\000\000\000\000\000\000\003_\000\000\002d\000O\000\000\001 \000\000\000\000\000\164\003\237\003\007\000\000\000\000\000\000\000\172\000\000\000\000\000\000\000\000\004\001\003O\003A\000\187\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\204\000\000\000\000\000\000\004u\000\000\000\000\000\000\000\000\003\233\000\000\000\000\004v\000\000\000\000\000p\000\000\000\178\000\000\000\000\002\217\000\000\004\000\000\179\000y\000\000\000\180\000N\001\t\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\171\003\244\000\000\004\005\004x\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\000\000\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\181\004\001\000\000\003A\000\000\003\235\000\000\000\000\000\000\003B\000\000\000\000\000\000\000\000\002l\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\000\000\000O\000\000\001 \000\000\002m\000\164\003\237\002e\001\t\000\179\002f\000\172\000\180\000\187\000\000\000\000\000\000\003O\001\023\000\000\000\000\003\242\000\000\001\210\000\206\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\004\137\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\138\003\235\000\181\000p\000\000\000\178\000\000\000\000\002\217\000N\004\000\000\000\000y\000\170\000\000\001 \000\000\000\000\000\171\000\000\000\000\000\000\000\000\000\000\000\000\003\244\000\000\004\005\004\140\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000\187\000\000\003\242\000\000\000\000\003B\000\179\004\002\000p\003P\000\000\000\208\000\000\003\\\000\000\004\135\000\000\000y\003]\000\000\003\233\000\000\003^\004v\000\000\000O\000\000\000N\003_\000\000\000\164\000\161\0022\001 \000\000\000\000\000\172\000\000\000\000\001\t\000\179\000\000\000\000\000\180\000\000\000\000\000\000\004\148\003\244\000\000\004\005\004x\000\000\000\000\001\210\004\n\000\000\000\000\003?\004\018\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\000\000\000\000\000\178\000\000\003\235\000\181\000p\000\000\000\000\000\000\002a\002\217\000\000\004\000\000\000\000y\003\\\002k\000\000\000\000\000\000\003]\000\000\000O\001\t\003^\000\000\000\000\000\164\000\000\000\000\003_\000\000\002d\000\165\000\000\001 \000\000\000\000\000\000\003\237\003\007\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004\001\003O\003A\000\187\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\222\000\000\000\000\000\000\000\000\000\000\000\178\000\000\000\000\003\233\006n\000\000\004\149\000\000\000\000\000p\000\000\000\000\000\000\000\000\002\217\000N\004\000\000\179\000y\000\170\000\180\000\000\001\t\000\000\000\171\000\000\000\000\000\000\000\000\000\000\004\153\003\244\000\000\004\005\004\151\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\000\000\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\181\004\001\000\000\003A\000\000\003\235\000\000\000\000\000\000\003B\000\000\000\000\000\000\000\000\002l\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\000\000\000\000\000O\000\000\000\000\003_\000\179\000\164\000\000\000\180\001 \000\000\002r\000\172\003\237\002e\001\t\000\000\002f\000\000\000\000\000\187\000\000\000\000\000\000\003O\001\023\000\000\000\000\003\242\000\000\001\210\000\224\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\006z\000\178\004\149\003\235\000\000\000p\000\000\000\000\000\000\000\000\002\217\000N\004\000\000\000\000y\000\170\000\000\001 \000N\000\000\000\171\000\000\001D\000\000\000\000\001P\000\000\003\244\000\000\004\005\004\151\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\003\007\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\004\001\003O\003A\000\000\000\000\003\242\000\000\000\000\003B\000\179\004\002\000\000\003P\000\000\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\006o\000\000\000O\000\000\000\000\003_\000\000\000\164\000\000\000O\001 \000\179\001F\000\172\000\180\001\147\001\t\000\000\001G\000\000\000\000\000\000\000\000\000\000\000\000\003\244\000\000\004\005\006q\000\000\000\000\001\210\004\n\000\000\000\000\003?\004\018\003R\000\000\000\000\000\000\000\000\000\000\000\000\004*\003[\000\181\000\000\006}\000\178\000\000\003\235\001\150\000p\000\000\000\000\001V\000\000\002\217\000\000\004\000\000\000\000y\003\\\000\000\000\000\000\000\000\000\003]\000\000\000\000\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\000\000\000\000\000\000\001 \000\000\000\000\000\000\003\237\003\007\000\000\000\000\000\000\000\000\000\000\002/\000\000\000\000\004\001\003O\003A\000\000\000\000\003\242\000\000\001\210\003B\000\179\004\002\003?\003P\003R\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\233\000\000\000\000\006o\000\000\000\000\000p\000\000\000\000\000\000\000\000\002\217\000\000\004\248\000\179\000y\000N\000\180\000\000\001\t\000\170\000\179\000\000\000\000\001W\000\174\000\000\000\000\003\244\000\000\004\005\006q\000\000\000\000\000\000\004\n\000\000\001\174\001\210\004\018\000\000\003\007\001\211\000\000\000\000\000\000\001\212\004*\003[\000\181\004\001\000\000\003A\000\000\003\235\000\000\000\000\000\000\003B\001\153\000\000\000\000\000\000\000\000\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\233\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000O\000\000\001Z\000\000\001 \000\164\000\000\000\210\003\237\000\000\001\t\000\172\000\000\000\000\000\000\001\b\000\000\000\000\000\000\003O\001[\000\000\001\230\003\242\002L\001\163\001\213\000\179\004\002\001]\003P\000\000\001\214\000\000\000\000\001^\000\000\000\000\000\000\000p\000\000\000\000\000\000\000\000\006o\003\235\000\000\000\178\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\231\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\232\003\244\000\000\004\005\006q\000\000\000\000\000\000\004\n\000\000\000\000\000\000\004\018\003\237\004\249\000\000\000\000\000\000\000\000\000\000\004*\003[\000\000\000\000\003O\000\000\000\000\000\000\003\242\000\000\000\000\001\233\000\179\004\002\001\210\003P\000\000\000\000\003?\003\\\003R\000\000\000\000\002a\003]\000\000\000\000\000\000\003^\003\243\002k\000\000\000\000\000\000\003_\000\000\000p\001\t\000\000\001 \000\000\002\217\001\235\004\248\000\179\000y\002d\000\180\000\000\000\000\000\000\000\000\000\000\000\000\003\244\000\000\004\252\000\000\001\227\003\129\002\017\004\n\000\000\000\000\000\000\004\018\000\179\000\000\000\000\001\228\000\000\003\007\000\219\004*\003[\000\000\000\000\000\000\000\000\000\181\004\001\000\000\003A\000\000\000\000\000\000\000\000\001\210\003B\000\000\002\028\003?\003\\\003R\000\000\000\000\002\020\003]\000\000\000\000\000\000\003^\000\000\003\233\000\000\001\238\000\000\003_\000\212\000p\000\000\000\000\001 \000\000\002\217\000\000\004\248\000\000\000y\000N\000\000\000\000\001\t\000\170\000\000\000\000\000\000\000\183\000\171\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\000\000\185\000\000\003\007\000\000\000\000\000\000\001\240\002l\000\000\000\000\000\000\004\001\000\000\003A\000\000\003\235\000\000\000\000\000\000\003B\000\000\001\241\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\235\000\000\003\233\002e\000\000\000\000\002f\000\000\000\000\000N\000\000\000O\000\000\003?\001\023\003R\000\164\000\000\000\000\003\237\004\251\001\t\000\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003O\000p\000\000\000\000\003\242\000\000\003\157\000\000\000\179\004\002\000y\003P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001 \000\000\003\243\003\235\000\000\000\178\000\000\000\000\004\187\000\000\000N\000\000\000\000\003\188\003?\000\000\003R\000\000\000\000\000\000\000\000\000\000\003\194\000\000\003A\000\000\000\000\003\244\000\000\004\252\003B\000\000\000p\000\000\004\n\000\000\000\000\003\157\004\018\003\237\004\254\000y\000\000\000\000\000\000\004\190\004*\003[\000\000\004\192\003O\000\000\000\000\000\000\003\242\000\000\000\000\000\000\000\179\004\002\000\000\003P\004\199\000\000\001\t\003\\\000\000\003\188\000\000\000\000\003]\000\000\000\000\000\000\003^\003\243\003\194\000\000\003A\000N\003_\000\000\000\000\000\170\003B\001 \000\000\000\000\000\174\000\000\000\179\004\196\000\000\000\180\000\000\003W\000\000\000\000\001\012\004\190\003\244\000p\004\252\004\192\000\000\000\000\003\157\004\n\000\000\000\000\000y\004\018\000\000\000\000\000\000\000\000\000\000\000\000\001\t\004*\003[\000\000\000N\000\000\000\000\000\181\000\161\0021\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\188\000\000\003\\\000\000\000\000\000\000\000\000\003]\000\000\003\194\003O\003^\000\000\000\000\000\164\000\000\000\210\003_\000\179\004D\000\172\003P\001 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\195\000\000\004n\004>\000\187\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\226\000\000\000\000\001\t\000O\000\000\000N\000\000\000\178\000\164\003?\000\000\003R\000\000\000\000\000\165\003O\000\000\000\000\004E\000\000\000\000\000\000\004\198\000\179\004D\000\000\003P\000p\000\000\000\000\004_\003[\003\157\000\000\000N\000\000\000y\000\000\000\170\000\000\003\243\000\000\000\000\000\174\000N\000\000\000\000\000\000\000\170\003\\\000\178\000\000\000\000\000\171\003]\000\000\000p\004\189\003^\000\000\000\000\000\000\003\188\000\000\003_\000y\000\000\000\000\000\000\001 \000\000\003\194\004E\003A\000\000\000\000\004M\000\000\000N\003B\000\000\000\000\000\170\000\000\004_\003[\000\000\000\174\000\000\000\000\000\000\000\000\000\179\004D\004\190\000\180\000\000\000\000\004\192\000\000\000O\000\000\000\000\003\\\000\000\000\164\000\000\000\210\003]\000\000\000O\000\172\003^\001\t\000\000\000\164\000\000\000\000\003_\000\000\000\219\000\172\000\000\001 \000\000\000\000\000\000\000\181\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\179\000\000\000\174\000\180\000\000\000\000\004E\001\t\000\000\000O\004M\000\000\000\178\000\000\000\164\000p\000\210\000\000\004_\000\000\000\172\000\212\000\178\000\000\000y\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000N\000\000\000\000\000\181\000\161\0020\000\000\0029\000\183\001\012\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\000\000\185\000\178\001 \000\000\000O\003O\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000\179\004D\000\172\003P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\n\000\000\003\243\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000O\000\000\000\180\001\t\000\000\000\164\000\000\000\000\000\178\000\179\000\000\000\165\000\180\000\000\000N\000\000\000\000\000\000\001D\004E\000\000\001P\000\000\004M\000\000\000\000\000\000\001\014\000\000\000\000\000\000\004_\003[\000\000\000\181\001\n\000p\001\012\000\000\000\000\000\000\000\000\000\000\000\179\000\181\000y\000\180\000\178\000\000\000\000\003\\\000\000\001\020\000\000\000\000\003]\000\000\000\000\000\000\003^\001\023\000\000\000\000\000\212\000\000\003_\000\000\000\000\000\000\000\000\001 \001\014\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000O\000N\000\183\001F\000\000\001D\000\220\000\000\001P\001G\000\214\000\000\002=\000\179\000N\000\000\000\180\000\185\001D\001 \000\000\001P\000\000\000p\000\000\000\000\000\000\000\212\000\000\000\000\000\000\000\000\000y\000\000\000\000\000\000\000p\000\000\000\000\000\000\001\135\001\014\001\t\000\000\000\000\000y\000\183\001V\000\181\000\000\000\220\000\000\000\179\000\000\000\214\000\180\000\000\000\000\000\000\000\000\000\000\000\185\000\000\000\000\000\000\000\000\001\020\000O\000\000\000\000\001F\000\000\000\000\000\000\001\023\000\000\001G\000\212\000\000\000\000\000O\000N\000\000\001F\000\000\001D\000\000\000\181\001P\001G\000\000\000\000\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\000\000\220\000\000\000\000\000p\000\214\000\000\000\000\001\135\000\000\001\t\000\000\000\185\000y\001 \001V\000\000\000\000\000\000\000\000\000\000\001\135\000\000\001\t\000\000\000\000\000\000\000\000\001V\000\000\000\000\000N\000\000\000\179\000\000\000\170\001W\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000O\000N\000\000\001F\000\000\001D\000N\000\000\001P\001G\000\170\001\136\001\137\000\000\000\000\000\171\000N\000\000\000\000\000\000\000\170\000\000\000\000\000p\000\000\000\174\000\000\000\000\000\000\000\000\000\000\000\000\000y\000\000\000\000\000\000\001X\000\000\001Y\000\000\001\135\000\000\001\t\000\000\000\000\000\000\001\023\001V\001Z\000O\000\000\000\000\000\179\000\000\000\164\001W\000\210\000\000\000\000\000\000\000\172\000\000\000\000\000\000\000\000\000\179\001[\000O\001W\000\000\001F\001\\\000O\000\215\000\000\001]\001G\000\164\001\136\001\218\000\000\001^\000O\000\172\000\000\001 \001\127\000\164\000\000\000\210\000\000\001\136\003F\000\172\000\000\000\000\000\178\000\000\000\000\000\000\000\000\000\000\000\000\001X\000\000\001Y\001b\001\135\000\000\001\t\000\000\000\000\000\000\001\023\001V\001Z\001X\000\000\001Y\000\178\000\000\000\000\000\000\000N\000\000\000\000\001\023\001D\001Z\000\178\001P\000\000\000\179\001[\000\000\001W\000\000\000\000\001\\\000\000\000\000\000\000\001]\000\000\000\000\000p\001[\000\000\001^\000\000\000\000\001\\\001 \001\127\000y\001]\000\000\000\000\001\136\003\239\000\000\001^\000\000\000\000\000N\001 \001\127\000\000\000\161\000\163\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000\000\001X\000\180\001Y\000\000\000\000\000\000\000O\000\000\000\000\001F\001\023\000\000\001Z\000\000\000\000\001G\000\179\000\000\000\000\001W\000\000\000\179\000\000\000\000\000\180\000\000\000\219\000\000\000\000\000\000\001[\000\179\000N\000\181\000\180\001\\\000\170\000\000\000\000\001]\000\000\000\174\001\136\004\012\000\000\001^\001\135\000O\001\t\001 \001\127\000\000\000\164\001V\000p\000\000\000\181\000\000\000\165\000\219\000\000\000\000\000\212\000y\000\000\000\000\000\181\001X\000\000\001Y\000\000\000\000\006+\000\000\000\000\000\000\000\000\001\023\000\000\001Z\000\000\000\183\000\000\000p\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000y\000\000\000\178\000\212\000\185\001[\000O\006\b\000\000\000\000\001\\\000\164\000\187\000\210\001]\000\000\000\000\000\172\000\000\000\000\001^\000\000\000\183\000\228\001 \001\127\000\220\000\000\000\000\000\000\000\214\006\t\000\000\006\012\005L\005M\000\000\000\185\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000N\001\t\001W\000\000\000\170\000\000\000\178\000\000\000\000\000\174\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000p\000\000\000\000\001\136\004G\000\000\000\000\000\000\001\t\000y\000p\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000y\000\000\000\180\000N\000\000\000\000\000\000\000\170\000\000\001X\000\000\001Y\000\171\000\000\000\000\000\000\000\000\000\000\000\000\001\023\000\000\001Z\000\000\000\000\000\000\000O\000\000\005N\006.\000\000\000\164\000\000\000\210\000\000\000\181\000O\000\172\000\000\000\000\001[\000\164\000\000\000\210\000\000\001\\\000\000\000\172\000\000\001]\000\000\000\179\000\000\000\000\000\180\001^\000\000\000\000\000\000\001 \001\127\000\000\000N\000\000\000\000\000\000\000\170\000\000\001\t\000\000\000O\000\174\000\000\000\178\000\000\000\164\000\000\000\000\001\t\001.\000\000\000\172\000\000\000\178\000p\000\000\000\181\000\000\000\000\000\000\000\000\000N\000\000\000y\000\000\001D\000\000\000\000\001P\000\000\000\000\000N\000\000\000\000\002;\000\170\000\000\000\000\000\000\000\000\000\171\000\000\001\023\000p\000\000\000\212\000\000\000\178\000\000\000\000\000\000\000\000\000y\000\000\000\000\000N\000\000\000\000\000O\001D\000\000\000\000\001P\000\164\000\183\000\210\000\000\000\000\000\220\000\172\000\000\002\192\000\214\000\000\000\000\000\000\000\000\000p\000\000\000\185\0061\001 \000\000\000\000\000\000\000\000\000y\000O\000\179\000\000\001F\000\180\000\000\000\000\000\000\000\000\001G\000O\000\179\000\000\001\t\000\180\000\164\000\000\000\000\000\178\000\000\000\000\000\172\000\000\002\197\000\000\000\000\000\000\000\000\000\000\001.\000\000\000\000\000\000\000\000\000O\000\000\000\181\001F\000\000\001&\001\134\000\000\001\t\001G\000\000\000\179\000\181\001V\000\180\000\000\000\000\000\000\000N\000\000\0024\000\000\001D\000\178\000\000\001P\000\000\000\000\001\023\000\000\001(\000\212\000\000\000\000\000\000\000\000\000\000\000\000\001\023\000\000\000p\000\212\001\t\000\000\000\000\000\000\000\181\001V\000\000\000y\000\183\000\000\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\183\000\000\000\000\000\000\000\220\000\185\000\000\001 \000\214\000\179\000\000\000\000\000\180\000\000\000\000\000\185\000\000\001 \000\000\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\000\001F\000\000\000\000\000\000\000\000\000\000\001G\000\187\000\000\000\000\001.\000\179\000\000\000\000\001W\000\000\000\000\000\181\000\230\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\0010\000\000\001U\000\000\001\t\000\000\000\000\000\000\001\023\001V\000\179\000\212\000\000\001W\000\000\000\000\000\000\000\000\000N\000\000\000\000\000\181\001D\000\000\000\000\001P\000\000\001X\000\000\001Y\000\183\000\000\000\000\000p\000\220\000\000\000\000\001\023\000\214\001Z\000p\000\000\000y\000\000\000\000\000\185\000\000\001 \000\000\000y\000\000\000\000\000N\000\000\000\000\000\000\001D\001[\000\000\001P\000\000\001X\001\\\001Y\000\000\000\000\001]\000\000\000\000\000\187\001\130\001\023\001^\001Z\000p\000\000\001 \001\127\000\000\000\000\000\232\000\000\000\000\000y\000O\000\000\000\000\001F\000\000\000\000\000\000\001[\000\000\001G\000\179\000\000\001\\\001W\000\000\000\000\001]\000\000\000\000\000\000\000\000\002a\001^\000\000\000\000\000\000\001 \001\131\002k\000\000\000\000\000\000\000\000\000\000\000O\001\t\000\000\001F\000\000\000\000\001\129\000\000\001\t\001G\002d\000\000\000\000\001V\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\001X\000\000\001Y\000\000\000\000\000\000\000\000\000\000\000\000\000p\001\023\000\000\001Z\001\133\000\000\001\t\000\000\000N\000y\000\000\001V\000\161\002)\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001[\000\000\000\000\000N\000\000\001\\\000\000\000\170\000\000\001]\000\000\000\000\000\171\000\000\000\000\001^\000\000\000\000\000\000\001 \001\127\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000N\000\000\000\172\000\000\000\161\001;\000\000\000\000\000\000\000\179\000\000\000\000\001W\000\000\000N\000\000\000\000\000\000\000\170\000\000\000\000\000O\000\000\000\174\002l\000\000\000\164\000\000\000\000\000\000\000\000\000\000\000\165\001\t\000\000\000\000\000p\000O\000\178\000\000\000\000\000\000\000\164\000\179\000\000\000y\001W\000\000\000\172\002\245\000\000\000\000\002e\000\000\000\000\002f\000\000\000\000\000\000\000\000\001X\000\000\001Y\001\023\000\000\000\000\000O\000\000\000\178\000N\001\023\000\164\001Z\000\161\001>\000\000\000\000\000\165\000\000\000\000\000O\000\000\000\000\000\000\000\178\000\164\000\000\000\210\000\000\000N\001[\000\172\000\000\000\170\001X\001\\\001Y\000\000\000\174\001]\000\000\000\000\001 \000\000\001\023\001^\001Z\000\000\000\000\001 \001\127\000p\000\000\000\178\000\000\000\000\000\000\000\000\000\000\000\000\000y\000\000\001\t\000\179\001[\000\000\000\180\000\178\000\000\001\\\000\000\000\000\000\000\001]\000\000\000O\000\000\000\000\000\000\001^\000\164\000\000\000\000\001 \001\127\000\000\000\165\000\000\000\000\000\000\000\000\001\168\000\000\000\179\000\000\000O\000\180\000\000\000\181\000\000\000\164\000\000\000\210\000\000\000N\000\000\000\172\000\000\000\170\000\179\000\000\000\000\000\180\000\174\000\000\000\000\001\170\000\000\000\000\000\000\000\000\000\000\000\178\000\000\001\023\000N\000p\000\212\000\181\000\170\000\000\000\000\000\000\000\000\000\174\000y\000\000\001\t\000\179\000\000\000\000\000\180\000\178\000\000\000\181\000\000\000\183\000p\000\000\000\000\000\220\000\000\000\179\000\000\000\214\000\180\000y\000\000\000\000\000\000\000\000\000\185\000\000\001 \000\000\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\000\000\181\000\000\000\164\000\000\000\210\000\000\000\000\001.\000\172\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000O\000\187\000N\000\000\000\000\000\164\003?\000\210\003R\000N\000\000\000\172\000\234\000\170\002?\000\000\000\179\000\000\000\174\000\180\000\000\001\t\001\023\000\000\000p\000\212\000\178\000\000\000\000\000\000\000N\000p\000\000\000y\000\161\001A\000\179\000\000\000\000\000\180\000y\000\000\001\t\000\000\000\183\000\000\000\000\000\178\000\220\000N\000\000\000\181\000\214\000\161\001\195\000\000\000\000\000\000\000\000\000\185\000\000\001 \000\000\000\000\001.\000\000\000\000\000\000\000O\000\000\003A\000\181\000\000\000\000\000\000\000O\003B\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000\000\000\000\000\172\000\000\000\000\002E\000\000\000\000\000\000\000\000\000\000\000\000\000O\001\023\000\000\000\000\000\212\000\164\000\000\000\000\000\000\000\000\000\000\000\165\000\000\000\000\001\t\000\179\000\000\000\000\000\180\000O\000\000\001\t\000\000\000\183\000\164\000\000\000\178\000\220\000\000\000\000\000\165\000\214\000\000\000\000\000\000\000\000\000\179\000\000\000\185\000\180\001 \000\000\000\000\001.\000\000\003W\000\000\000\178\001\012\000\000\000\181\000\000\001\210\000\000\000\000\000\000\003?\000\000\003R\000\000\000\000\000\000\000\000\000\000\001.\000\000\000\178\000\000\002I\000\000\000\000\000\181\000\000\000\000\000\000\000\000\001\023\000\000\000\000\000\212\000\000\003\226\004\222\000\000\000\000\000\000\000\000\001\210\000\000\003\021\000\000\003?\000\000\003R\000\000\000\000\003O\001\023\000\183\000\000\000\212\000\000\000\220\000\000\000\179\000\000\000\214\003P\000\000\000\000\000\000\000\179\000\000\000\185\000\180\001 \003\226\004o\001\230\000\183\003A\003Y\000\000\000\220\000\000\000\000\003B\000\214\000\000\000\000\000\000\000\000\000\179\000\000\000\185\000\180\001 \000\000\000\000\003*\000\000\003\233\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\179\001\210\001\230\000\180\003A\003?\001\020\003R\000\000\000\000\003B\000\000\000\000\003,\001\023\003[\000\181\000\000\000\000\000\000\000\000\001\023\000\000\000\000\000\212\003\233\000\000\000\000\000\000\000\000\003\226\004=\000\000\003\\\000\000\000\181\000\000\000\000\003]\000\000\000\000\000\000\003^\000\183\003\235\000\000\000\000\000\220\003_\000\000\000\000\000\214\000\000\001 \000\000\000\000\000\000\001\210\000\185\000\000\001 \003?\000\000\003R\000\000\000\000\000\000\001\230\000\000\003A\000\000\000\000\000N\000\000\000\000\003B\000\161\001\204\000\000\003\235\003\237\000\000\000\000\000\000\000\000\000\000\003\226\003\227\001\210\000\000\003\233\003O\003?\000\000\003R\003\242\000\000\000\000\000\000\000\179\000\000\000\000\003P\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\237\003\243\003\226\003\241\000\000\000\000\000\000\000\000\001\230\000\000\003A\003O\000\000\000\000\000\000\003\242\003B\000\000\000\000\000\179\000\000\000\000\003P\000O\000\000\000\000\003\244\000\000\000\164\003\235\000\000\003\233\000\000\000\000\000\165\000\000\003\243\000\000\000\000\001\230\000\000\003A\000\000\000\000\000\000\000\000\003[\003B\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\244\003\233\000\000\003\\\003\237\000\000\000\000\000\000\003]\000\178\000\000\000\000\003^\000\000\000\000\003O\000\000\000\000\003_\003\242\003[\000\000\000\000\000\179\003\235\000\000\003P\001\210\000\000\000\000\000\000\003?\000\000\003R\000\000\000\000\000\000\000\000\003\\\000\000\003\243\000\000\000\000\003]\000\000\000\000\000\000\003^\000\000\000\000\000\000\000\000\000\000\003_\000\000\003\235\003\226\004C\001\210\000\000\003\237\000\000\003?\000\000\003R\003\244\000\000\000\000\000\000\000\000\000\000\003O\000\000\000\000\000\000\003\242\000\000\000\000\000\000\000\179\000\000\000\000\003P\000\000\000\000\003[\000\000\003\226\004q\000\000\000\000\003\237\000\000\001\230\000\179\003A\003\243\000\180\000\000\000\000\000\000\003B\003O\003\\\000\000\000\000\003\242\000\000\003]\000\000\000\179\000\000\003^\003P\000\000\000\000\003\233\000\000\003_\000\000\000\000\003\244\000\000\000\000\001\230\000\000\003A\003\243\000\000\000\181\000\000\000\000\003B\000\000\001\210\000\000\000\000\000\000\003?\000\000\003R\003[\000\000\000\000\000\000\000\000\000\000\003\233\000\000\000N\000\000\000\000\003\244\000\170\000\000\000\000\000\000\000\000\000\174\003\\\000\000\000\000\000\000\004h\003]\000\000\000\000\000\000\003^\001\210\003\235\000\000\003[\001\211\003_\000\000\000\000\001\212\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\210\000\000\003\\\000\000\001\211\000\000\000\000\003]\001\212\000\000\000\000\003^\001\230\003\235\003A\000N\000\000\003_\003\237\000\170\003B\000\000\000\000\000\000\000\174\000\000\000\000\000O\000\000\003O\000\000\000\000\000\164\003\242\000\210\003\233\000\000\000\179\000\172\000\000\003P\000\000\000\000\000\000\000\000\000\000\000\000\001\230\000\000\003\237\000\000\001\213\000\000\000\000\003\243\000\000\000\000\001\214\000\000\000\000\003O\000\000\000\000\000\000\003\242\000\000\001\230\000\000\000\179\000\000\001\213\003P\000\000\000\000\000\178\000\000\001\214\000\000\000\000\003\244\000\000\000O\000\000\000\000\001\231\003\243\000\164\000\000\000\210\003\235\000\000\000\000\000\172\001\232\000\000\000\000\000\000\000\000\000\000\003[\000\000\001\165\000\000\002!\000\000\000\000\000\000\000\000\000\000\000\000\003\244\000\000\001\232\000\000\000\000\000\000\000\000\003\\\000\000\000\000\000\000\000\000\003]\001\210\001\233\003\237\003^\001\211\000\178\000\000\003[\001\212\003_\000\000\000\000\000\000\003O\000\000\000\000\000\000\003\242\000\000\000\000\001\233\000\179\000\000\000\000\003P\003\\\000\000\000\000\000\000\000\000\003]\000\000\001\235\000\000\003^\000\000\000\179\000\000\003\243\000\180\003_\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\227\006t\002\017\001\235\000\000\000\000\000\000\000\000\000\179\000\000\000\000\001\228\000\000\000\000\000\000\003\244\001\014\000\000\001\230\001\227\000\000\002\017\001\213\000\181\000\000\000\000\000\000\000\179\001\214\000\000\001\228\000\000\002\028\000\000\000\000\003[\000\000\002\030\002\020\000\000\000\000\000\000\000\179\000\000\000\000\000\180\000\000\001\238\000\000\000\000\000\000\000\000\000\212\003\\\000\000\002\019\000\000\002\020\003]\000\000\000\000\001\210\003^\000\000\001\232\001\211\001\238\000\000\003_\001\212\002 \000\183\000\000\000\000\000\000\000\220\000\000\000\181\000\000\000\214\000\000\001\210\000\000\000\000\000\000\001\211\000\185\000\000\000\000\001\212\001\240\000\000\000N\000\000\000\000\001\233\000\170\000\000\000\000\000\000\000\000\000\171\000\000\000\000\000N\001\241\000\212\000\000\000\170\001\240\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\241\000\183\001\235\001\230\000\000\000\220\000\000\001\213\000\000\000\214\000\000\000\000\000\000\001\214\000\000\000\000\000\185\000\000\001\227\000\000\002\017\000N\000\000\001\230\000\000\000\170\000\179\001\213\000\000\001\228\000\174\000\000\000\000\001\214\000O\000\000\000\000\000\000\000\000\000\164\002\023\000\000\000\000\000\000\000\000\000\172\000O\000\000\000\000\001\232\000\000\000\164\000\000\000\210\000\000\000\000\002\020\000\172\000\000\000\000\002\026\000\000\000\000\000\000\000\000\001\238\000N\000\000\000\000\001\232\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000N\001\233\000\178\000\000\000\170\000\000\000\000\000\000\000O\000\174\000\000\000\000\000\000\000\164\000\178\000\210\000\000\000\000\000\000\000\172\000\000\001\233\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\240\000\000\000\000\001\235\000\000\000\000\000\000\000\000\000p\000\000\000\000\000\000\000\000\000\000\000\000\001\241\000\000\000y\000\000\001\227\000\000\002\017\000\000\001\235\000O\000\000\000\178\000\179\000\000\000\164\001\228\000\210\000\000\000\000\000\000\000\172\000\000\000O\000\000\001\227\000\000\002\017\000\164\000\000\000\210\000\000\000\000\000\179\000\172\000\000\001\228\000\000\000\000\000\000\000\000\000\000\000\000\002\020\000\179\000\000\000N\000\180\000\000\000\000\000\170\002\222\001\238\000\000\000\000\000\174\000\179\000\178\000N\000\180\000\000\000\000\000\170\002\020\000\000\000\000\002a\000\174\000\000\000\000\000\178\000\000\001\238\002k\000\000\000\000\000\000\000\000\000\000\000\181\001\t\000\000\000\000\000\000\002 \000\000\000\000\000\000\000\000\002d\000\000\000\181\002\239\000\000\000\000\001\240\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\241\000\000\000O\000\000\000\000\001\240\000\000\000\164\000\000\000\210\000\212\000\000\000\000\000\172\000O\002 \000\000\000\187\000\000\000\164\001\241\000\210\000\181\000\000\000\000\000\172\000\000\002\251\000\236\000\183\000\000\000\000\000\179\000\220\000\000\000\180\000\000\000\214\003c\000\000\003\003\000\000\000\000\000\000\000\185\000\179\000\000\000\000\000\180\000\178\000\000\000\212\000\000\000\000\000N\000\000\000\000\000\000\000\170\000\000\002 \000\178\000\000\000\174\000\000\000\000\000\000\000\181\000\000\000\000\000\183\000\000\000\000\002 \000\220\000\000\000\000\000\000\000\214\000\000\000\181\000\000\002l\000\000\000N\000\185\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\212\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003\170\000\000\000\212\002e\000\000\000\000\002f\000\000\000\183\000\000\000\000\000\000\000\220\000O\001\023\000\000\000\214\000\000\000\164\000\000\000\210\000\183\003\n\000\185\000\172\000\220\000\000\000\179\000N\000\214\000\180\000\000\000\170\000\000\000\000\000\000\000\185\000\174\000\000\000\179\000\000\000\000\000\180\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000\000\001 \000\172\002 \000\000\000\000\000\000\000\000\000\178\000\000\000\181\000\000\000\000\000\000\000\000\000\219\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000N\000\000\000\178\000\212\000\170\000\000\000O\000\000\000\000\000\174\000\000\000\164\000\000\000\210\000\000\000\212\000\000\000\172\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\183\000\000\000\000\000\185\000\220\000N\000\000\000\000\000\214\000\170\000\000\000\000\000\000\000\000\000\174\000\185\000\000\000\000\003\162\000\178\000\000\000\000\000O\000\179\000\000\000\000\000\180\000\164\000\000\000\210\000\000\000\000\000O\000\172\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000\000\000\000\000\172\000\000\000\000\000\000\000\000\003\174\000\000\000\000\002 \000\000\000\179\000\000\000\000\000\180\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\178\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\210\000\178\000\000\002 \000\172\000\000\000\000\000\000\000\000\000\212\000\181\000\000\000\000\000\000\000\000\000\000\000N\003\197\000\000\000\000\000\170\003\179\000\000\000\000\000\000\000\171\000\179\000\000\000\183\000\180\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\212\000\178\000N\000\000\000\185\000\000\000\161\001\207\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002 \000\000\000\000\000\000\000\183\000\000\000\000\000\181\000\220\000\000\000\000\000N\000\214\000\000\000\000\000\170\000\000\003\186\000\000\000\185\000\174\000\000\000\179\000\000\000\000\000\180\000\000\003\192\000O\000\000\000\000\000\000\000\179\000\164\000\000\000\180\000\212\000N\000\000\000\172\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\002 \000\000\000\000\000O\000\000\000\183\000\000\000\181\000\164\000\220\002 \000\000\000\000\000\214\000\165\000\000\000\000\000\181\000\000\000\000\000\185\000\179\000\000\000\000\000\180\000\178\000N\000O\000\000\000\000\000\170\000\000\000\164\000\000\000\210\000\174\000\212\000\000\000\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\000\000\000\000\000\219\000\178\003\199\000\000\000O\000\000\000\183\000\181\000\000\000\164\000\220\000\210\000\000\000\000\000\214\000\172\000\183\000\000\000\000\000\000\000\220\000\185\000\000\000\000\000\214\000\178\000\000\000\000\000N\000\000\000\000\000\185\000\170\000\000\000\000\000\000\000\212\000\174\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000N\000\210\000\178\000\000\000\170\000\172\000\183\000\000\000\000\000\174\000\220\000\000\000\179\000\000\000\214\000\180\000\000\000\000\000\000\000\000\000N\000\185\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000N\000\000\000\000\000\179\000\170\000\000\000\180\000\178\000\000\000\171\000\000\000O\000\000\000\181\000\000\000\000\000\164\000\000\000\210\000N\000\000\000\000\000\172\000\161\003\023\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\181\000\210\000\000\000\000\000\000\000\172\000\000\000\000\000\000\000\000\004\016\000\000\000\000\000\000\000O\000\179\000\000\000\219\000\180\000\164\000\178\000\210\000N\000\187\000\181\000\172\000\170\000\000\000O\000\000\000\000\000\174\000\000\000\164\000\238\000\000\000\000\000\000\004?\000\172\000\000\000\178\000\000\002 \000\000\000\000\000\000\000O\000\000\004\029\000\181\000\000\000\164\000\212\000\179\000\000\000\000\000\180\000\165\000N\000\000\000\178\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\183\000N\000\000\000\178\000\220\000\161\0036\000\212\000\214\000\000\002 \000\000\000\000\000\000\000\000\000\185\000O\000\181\000\000\000\000\000\000\000\164\000\178\000\210\000\000\000\000\000\183\000\172\004&\000\000\000\220\000\000\000\000\000\179\000\214\000\000\000\180\000\000\000\000\000\000\004A\000\185\000\000\000\000\000\000\000\000\000\212\000\000\000\000\004.\000\000\000\000\000\000\000O\000\179\000\000\000\000\000\180\000\164\000\000\000\210\002 \000N\000\178\000\172\000\183\000\170\000O\000\181\000\220\000\000\000\174\000\164\000\214\000\179\000\000\000\000\000\180\000\165\000\000\000\185\000\000\002 \000\000\000\000\000\000\000\000\000\000\000\179\000\181\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\212\000\000\000\000\000\178\000\000\000\219\000\000\000\000\000\000\000\000\000\179\000\000\000\181\000\180\000\000\000\000\000N\000\178\000\000\000\183\000\170\000\212\000\000\000\220\000\000\000\174\000\181\000\214\000\000\000\000\000\000\000O\000\000\000\000\000\185\000\000\000\164\000\000\000\210\000\000\000\183\000\212\000\172\000\000\000\220\000\181\000\000\000\000\000\214\000\000\000\000\000\179\000\000\000\000\000\180\000\185\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\187\000\185\000\000\000\000\000\178\000\219\000\000\000\000\000O\004K\000\000\000\240\000\181\000\164\000\179\000\210\000N\000\180\000\000\000\172\000\170\000\000\000\000\000\000\000\000\000\171\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000N\000\000\000\000\000\000\000\170\000\212\002 \000\000\000\000\000\174\000\000\000\000\000\000\000\181\000N\000\000\000\000\000\000\000\170\000\178\000\000\000\000\000\000\000\174\000\183\000\000\000\000\000\181\000\220\000\000\000\000\000\000\000\214\000\000\006P\000\000\000\000\000\000\000\000\000\185\000\000\000\000\000\212\000\000\000\000\000N\000O\000\000\004X\000\170\000\000\000\164\000\000\000\179\000\174\000\000\000\180\000\172\000N\000\000\000\000\000\183\000\170\000\000\000\000\000\220\000O\000\174\000\000\000\214\000\000\000\164\000\000\000\210\000\000\000\000\000\185\000\172\006\181\000\000\000O\002 \000\000\000\000\000\000\000\164\000\000\000\210\000\181\000\000\000\000\000\172\000\000\000\178\000\000\000\000\000N\000\000\000\000\004]\000\170\000\000\000\000\000\000\000\179\000\174\000\000\000\180\000\000\000\000\000\000\000O\000\000\000\178\000\000\000\000\000\164\000\212\000\210\000\000\000\000\000\000\000\172\000\000\000O\000\000\000\000\000\178\000\000\000\164\000\000\000\210\002 \000\000\000\000\000\172\000\183\000N\000\000\000\181\000\220\000\170\000\000\000\000\000\214\000\000\000\174\000\000\000\000\000\000\000N\000\185\000\000\000\000\000\170\000\000\000\000\000\000\000\178\000\174\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\212\000\210\000\000\000\178\000\000\000\172\000\000\000\000\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\000\000\220\000\000\004d\000\000\000\214\000\000\000\000\000\179\000\000\000\000\000\180\000\185\000O\000\000\000\000\000\000\000\000\000\164\000\178\000\210\000\000\000\179\000\181\000\172\000\180\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\210\000\000\000\000\002 \000\172\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\006Q\000\000\000\000\000\179\000\000\000\000\000\180\000\181\000\000\000\000\000\178\000\000\000\000\000\000\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\187\000\212\000\178\000\000\000N\000\000\000\000\000\000\000\161\0039\001\002\000\242\000\000\000\000\000\000\000\212\000\000\000\181\000\000\000\000\000\183\000\000\000\000\006Q\000\220\000\000\000\000\000\000\000\214\000\000\000\181\000\000\000\000\000\179\000\183\000\185\000\180\000\000\000\220\000\000\000\000\000N\000\214\000\000\000\000\000\170\000\212\000\000\000\000\000\185\000\174\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\000\000\001\016\000N\000N\000\000\000\183\000\170\000\170\000\181\000\220\000O\000\174\000\174\000\214\000\179\000\164\000\000\000\180\000\183\000N\000\185\000\165\000\220\000\170\000\000\000\000\000\214\000\179\000\174\000\000\000\180\000\000\000\000\000\185\000\000\000\000\000N\000\212\000\000\000\000\000\161\003<\001\140\000\000\000\000\000\000\000\000\000O\000\000\000\181\000\000\000\000\000\164\000\000\000\210\001\157\000\183\000\178\000\172\000\000\000\220\000\000\000\181\000\000\000\214\000\000\000\000\000\000\000O\000O\000\000\000\185\000\000\000\164\000\164\000\210\000\210\000N\000\212\000\172\000\172\000\170\000\000\000\000\000\000\000O\000\174\000\000\000\000\000\000\000\164\000\212\000\210\000\000\000\178\000N\000\172\000\183\000\000\000\170\000\000\000\220\000O\000\000\000\174\000\214\000\000\000\164\000\000\000\000\000\183\000\000\000\185\000\165\000\220\000\178\000\178\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\000\000\185\000\000\000\000\000\000\000\000\000\000\000\000\000\178\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000O\000\000\000\180\000\000\000\000\000\164\000\178\000\210\000\000\000\000\000\000\000\172\000\000\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000N\000\210\000\000\000\000\000\170\000\172\000\000\000\000\000\000\000\174\000\181\000\000\000\179\000\000\000\000\000\180\000\000\000N\000\000\000\000\000\000\000\170\000\000\000\178\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000\179\000\000\000\180\000\180\000\000\000\000\001\177\000\178\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001\179\001\221\000\000\000\000\000\000\000O\000\179\000\181\000\181\000\180\000\164\000\000\000\210\000\000\000\000\000\212\000\172\002\205\000\000\000\000\000\000\000\000\000O\000\000\000\181\000\000\000\000\000\164\000\000\000\210\000\000\000N\000\000\000\172\000\183\000\170\000\212\000\212\000\220\000\000\000\174\000\181\000\214\000\000\000\000\000\000\000\000\000\179\000\000\000\185\000\180\000\000\000\178\000\212\000\000\000\183\000\183\000\000\000\000\000\220\000\220\000\000\000\000\000\214\000\214\000\179\000\000\000\000\000\180\000\178\000\185\000\185\000\183\000\000\000\000\002\211\000\220\000\000\000\000\000\000\000\214\000\000\000\181\000\000\000\000\000\000\000\000\000\185\000\000\000\000\000\000\000\000\000\000\003\026\000\000\000\000\000\000\000O\000\000\000\000\000\181\000\000\000\164\000N\000\210\000\000\000\000\000\170\000\172\000\000\000\000\000\212\000\174\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000N\000\000\000\212\000\183\000\170\000\000\000\000\000\220\000\000\000\174\000\179\000\214\000\000\000\180\000\000\000\000\000\000\000\178\000\185\000\000\000\000\000\183\000\000\000\000\000\000\000\220\000\000\000\179\000\000\000\214\000\180\000\000\000\000\000\000\000\000\000\000\000\185\000\000\003\031\000\000\000\000\000\000\000O\000\000\000\000\000\181\000\000\000\164\000\000\000\210\000\000\000\000\000O\000\172\000\000\003#\000\000\000\164\000\000\000\210\000\000\000\000\000\181\000\172\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\210\000\212\000N\000\000\000\172\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\000\000\000\000\000\000\178\000\000\000\212\000\000\000\183\000N\000\000\000\000\000\220\000\170\000\178\000\000\000\214\000\179\000\171\000\000\000\180\000\000\000\000\000\185\000\000\000\183\000\000\000\000\000\178\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\000\000\185\000\000\000\000\000\000\000\000\003I\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000N\000O\000\000\000\000\000\170\000\000\000\164\000\000\000\210\000\174\000N\000\000\000\172\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000O\000\000\000\000\000\000\000N\000\164\000\212\000\000\000\170\000\000\000\000\000\172\000\000\000\174\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000\183\000\000\000\180\000\178\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\179\000\000\000\185\000\180\003\148\000\000\000\000\000\000\000O\000\178\000\000\000\181\000\000\000\164\003\230\000\210\000\000\000\000\000O\000\172\000\000\000\181\000\000\000\164\000\000\000\210\000\000\000\000\004\180\000\172\000\000\000\000\000O\000\000\000\000\000\181\000\000\000\164\000N\000\210\000\212\000\000\000\170\000\172\000\000\000\000\000\000\000\174\000N\000\000\000\212\000\000\000\170\000\000\000\000\000\178\000\000\000\174\000\000\000\183\000\000\000\000\000\000\000\220\000\212\000\178\000\000\000\214\000\000\000\183\000\000\000\000\000\000\000\220\000\185\000\179\000\000\000\214\000\180\000\178\000\000\000\000\000\000\000\183\000\185\000\000\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\179\000\000\000\000\000\180\000\185\000\000\000\000\000\000\000\000\004\213\000O\000\000\000\000\000\000\000\000\000\164\000\181\000\210\000\000\000N\000O\000\172\000\000\000\170\000\000\000\164\000\000\000\210\000\174\000\000\000\000\000\172\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000\178\000\000\000\180\000\000\000\000\000\000\000\000\000\183\000\000\000\000\000\178\000\220\000\000\000\179\000\000\000\214\000\180\004\233\000\000\000\000\000\000\000\000\000\185\000\000\000\181\000\000\000\187\004\235\000O\000\000\000\000\000\000\000\000\000\164\000\181\000\210\000\000\000\244\000\000\000\172\000\000\004\237\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000N\000\000\000\212\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000N\000\000\000\212\000\000\000\170\000\000\000\000\000\000\000\000\000\174\000\000\000\183\000\000\000N\000\178\000\220\000\212\000\170\000\000\000\214\000\000\000\183\000\171\000\000\000\179\000\220\000\185\000\180\000\000\000\214\000\000\000\000\000\000\000\000\000\179\000\183\000\185\000\180\000\000\000\220\000\000\000\000\000\000\000\214\000\000\000\000\000\000\000\000\000\000\000\000\000\185\000\000\004\243\000\000\000\000\000\000\000O\000\000\000\000\000\181\000\000\000\164\005\004\000\000\000\000\000\000\000O\000\172\000\000\000\181\000\000\000\164\000\000\000\000\000\000\000\000\000N\000\172\000\000\000O\000\170\000\000\000\000\000\000\000\164\000\171\000\000\000\000\000\212\000\000\000\172\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\000\179\000N\000\000\000\180\000\178\000\170\000\000\000\000\000\183\000\000\000\171\000\000\000\220\000\000\000\178\000\000\000\214\000\000\000\183\000\000\000\000\000\000\000\220\000\185\000\000\000\000\000\214\000\178\005\018\000\000\000N\000\000\000\000\000\185\000\170\000\181\000\000\000\000\000\000\000\171\000\000\000\000\000N\000O\000\000\000\000\000\170\000\000\000\164\000\000\000\000\000\171\000N\000\000\000\172\000\000\000\170\000\000\000\000\000\000\000\000\000\171\000\000\000\000\000\212\000\000\000\000\000O\000\000\000\000\000\000\000\000\000\164\000\000\000\000\000N\000\000\000\000\000\172\000\170\000\000\000\000\000\000\000\183\000\171\000\000\000\000\000\220\000\000\000\179\000\178\000\214\000\180\000\000\000\000\000\000\000O\000\000\000\185\000\179\000\000\000\164\000\180\000\000\000\000\000\000\000\000\000\172\000O\000\000\000\000\000\000\000\179\000\164\000\178\000\180\000\000\000\000\000O\000\172\000\000\000\000\001d\000\164\000\181\000\000\000\000\000\000\000\000\000\172\000\000\000\000\003e\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\178\000\000\000\000\000\164\000\181\000\000\000\000\000\000\000\000\000\172\000\212\000\000\000\178\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\212\000N\000\178\000\000\000\000\000\170\000\000\000\000\000\000\000\183\000\171\000\000\000\179\000\218\000\000\000\180\000\000\000\214\000\000\000\183\000\000\000\000\000N\000\218\000\185\000\178\000\170\000\214\000\000\000\000\000\000\000\171\000\187\000\000\000\185\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\246\000\000\000\000\000\000\000\181\000\000\000\000\000N\000\000\000N\000\000\000\170\000\000\000\170\000\000\000\000\000\171\000\000\000\171\000\000\000\000\000\000\000\179\000N\000O\000\180\000\000\000\170\000\181\000\164\000\000\000\000\000\171\000\000\000\179\000\172\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000O\000\000\000\180\000\000\000\000\000\164\000\000\000\187\000\000\000\000\000\000\000\172\000\181\000\000\000\000\000\000\000\000\000\000\000\248\000\000\000\000\000\000\000\179\000\000\000\181\000\180\000\178\000\000\000O\000\000\000O\000\187\000\000\000\164\000\181\000\164\000N\000\000\000\000\000\172\000\170\000\172\000\250\000\000\000O\000\171\000\000\000\178\000\000\000\164\000\000\000\000\000\000\000\000\000\000\000\172\000\000\000\181\000\000\000N\000\187\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\171\000\000\000\000\000\252\000\187\000\000\000\000\000\178\000N\000\178\000\000\000\000\000\170\000\000\000\187\001`\000\000\000\171\000\000\000\000\000\000\000\000\000\000\000\178\000\000\001f\000\000\000\000\000\000\000\000\000\000\000\000\000N\000\000\000O\000\000\000\170\000\187\000\000\000\164\000\000\000\171\000\000\000\179\000\000\000\172\000\180\000N\001h\000\000\000\000\000\170\000\000\000\000\000N\000\000\000\171\000O\000\170\000\000\000\000\000\000\000\164\000\171\000\179\000\000\000\000\000\180\000\172\000\000\000\000\000\000\000\000\000\000\000O\000\000\000\000\000\000\000\181\000\164\000\000\000\178\000\000\000\000\000N\000\172\000\000\000\000\000\170\000\000\000\000\000\000\000\179\000\171\000\179\000\180\000\000\000\180\000O\000\181\000\000\000\000\000\000\000\164\000\178\000\000\000\000\000\000\000\179\000\172\000N\000\180\000\000\000O\000\170\000\000\000\000\000\000\000\164\000\171\000O\000\178\000\000\000\000\000\172\000\164\000\187\000\181\000\000\000\181\000\000\000\172\000\000\000\000\000\000\000\000\000\000\001j\000\000\000\000\000\000\000\000\000\000\000\181\000N\000\178\000\000\000\187\000\170\000\000\000O\000\000\000\000\000\171\000\000\000\164\000\000\000\000\001l\000\000\000\178\000\172\000\000\000\000\000\000\000\000\000\179\000\178\000\000\000\180\000\000\000\000\000\000\000\000\000\000\000\187\000O\000\187\000\000\000\000\000\000\000\164\000\000\000\000\000\000\000\000\001n\000\172\001p\000\179\000\000\000\187\000\180\000\000\000\000\000\000\000N\000\178\000\000\000\000\000\170\000\181\001r\000\000\000\000\000\171\000\179\000\000\000\000\000\180\000O\000\000\000\000\000N\000\000\000\164\000\000\000\170\000\000\000\000\000\000\000\172\000\171\000\178\000\181\000N\000\000\000\000\000\000\000\170\000\179\000\000\000\000\000\180\000\171\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\179\000\000\000\000\000\180\000\187\000N\000\000\000\179\000\000\000\170\000\180\000\000\000\178\000\000\000\171\001t\000\000\000O\000\000\000\000\000\181\000\000\000\164\000\000\000\000\000\000\000\000\000\187\000\172\000\000\000\000\000\000\000\000\000\000\000O\000\181\000\000\000\179\001v\000\164\000\180\000\000\000\181\000\000\000\187\000\172\000O\000p\000\000\000\000\000N\000\164\000\000\000\000\000\170\001x\000y\000\172\000N\000\171\000\000\000\000\000\170\000\179\000\178\000\000\000\180\000\171\000\187\000\000\000\000\000O\000\181\000\000\000\000\000\000\000\164\000\000\000\000\001z\000\000\000\178\000\172\000\187\000\000\000\000\000\000\000N\000\000\000\000\000\187\000\170\000\000\000\178\001|\000\000\000\171\000\179\000\181\000\000\000\180\001~\000N\000\000\000\000\000\000\000\170\000\000\000\000\000\000\000\000\000\171\000\000\000\000\000\000\000\000\000O\000\000\000\178\002a\000\187\000\164\000\000\000\000\000O\000\000\002k\000\172\000\000\000\164\000\000\001\243\000\181\001\t\000\000\000\172\000\000\000\000\000\000\000N\000\000\000\000\002d\000\170\000\000\000\000\000\187\000\000\000\171\000\179\000\000\000N\000\180\000O\000\000\000\170\000\000\001\245\000\164\000\000\000\171\000\000\000\000\000\178\000\172\000\000\000\179\000\000\000O\000\180\000\000\000\178\000\000\000\164\000\000\000\000\000\000\000\000\000\179\000\172\000\187\000\180\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\001\247\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\178\000\181\000\000\000\179\000\000\000O\000\180\000\000\000\000\000\000\000\164\000\000\000\000\000\181\000\000\000\178\000\172\000O\000\000\000\000\000\000\000N\000\164\000\000\000\000\000\170\000\000\000\000\000\172\000\000\000\171\000\000\000\187\000\000\000\000\000N\000\000\000\000\000\181\000\170\000\000\000\000\000\000\001\249\000\171\002l\000\000\000\000\000\179\000\187\000\000\000\180\000\178\000\000\000\000\000\000\000\179\000\000\000\000\000\180\001\251\000\187\000\000\000\000\000\178\000\000\000\000\000\000\000\000\000\000\004\025\000\000\001\253\002e\000\000\000\000\002f\000\000\000\000\000\000\000\000\000\000\000\000\000\181\001\023\000\179\000\187\000O\000\180\000\000\000N\000\181\000\164\000\000\000\170\000\000\000\000\001\255\000\172\000\171\000\179\000O\000\000\000\180\000\000\000N\000\164\000\000\000\000\000\170\000\000\000\000\000\172\000\000\000\171\000\000\000\000\000\000\000\000\000\000\000\181\000N\000\000\001 \000\000\000\170\000\000\000\000\000\000\000\000\000\171\000\187\000\000\000\000\000\178\000\181\000\000\000\179\000\000\000\187\000\180\000\000\002\001\000\000\000\000\000\000\000\000\000\000\000\178\000\179\002\003\000p\000\180\000\000\000\000\000\000\000O\000\000\000\000\000\000\000y\000\164\000\000\000\000\000\000\000\000\000\000\000\172\000\187\000\000\000\000\000O\000\181\000\000\000\000\000\000\000\164\000\000\000\000\002\005\000\000\000\000\000\172\000\187\000\181\000\000\000N\000O\000\000\000\000\000\170\000\000\000\164\000\000\002\007\000\171\000\000\000\000\000\172\000\000\000\000\000\000\000\000\000\178\000\000\000N\000\000\000N\000\000\000\170\000\000\000\170\000\000\000\000\000\171\000\000\000\171\000\000\000\178\000\179\000\187\000\000\000\180\002a\000\000\000\000\000p\000\000\000\000\000\000\002k\002\t\000\187\000\179\000\178\000y\000\180\001\t\000N\000\000\000\000\000\000\000\170\002\011\000\000\000\000\002d\000\171\000\000\000\000\000\000\000\000\000O\000\000\000\181\000\000\000\000\000\164\000\000\000\000\000N\000\000\000\000\000\172\000\170\000\000\000\000\000\000\000\181\000\171\000\000\000O\000\000\000O\000\000\000\000\000\164\000\000\000\164\000\000\000\000\000N\000\172\000\000\000\172\000\170\000\000\000\000\000\179\000\000\000\171\000\180\000\000\000\000\000\000\000\000\000\000\000\000\002a\000\178\000\000\000\000\000\187\000\179\000O\002k\000\180\000\000\000\000\000\164\000\000\000\000\001\t\002\r\000\000\000\172\000\187\000\000\000\178\000\179\000\178\002d\000\180\000\181\000N\000\000\000O\003a\000\170\000\000\000\000\000\164\000\000\000\171\000\000\000\000\000\000\000\172\000\181\000\000\000\000\000N\000\000\000\000\000\000\000\170\000\000\000O\000\000\002l\000\171\000\178\000\164\000\000\000\181\000N\000\000\000N\000\172\000\170\000\000\000\170\000\000\000\000\000\171\000\000\000\171\000\000\000\000\000\000\000\000\000\187\000\000\000\178\004!\000\000\000\000\002e\000\000\000\000\002f\000\000\003g\000\000\000\179\000\000\000\187\000\180\001\023\000\000\000O\000\000\000\000\000\000\000\178\000\164\000\000\003i\000\000\000\000\000\000\000\172\000\187\000\179\000\000\000\179\000\180\000O\000\180\000\000\000\000\000\000\000\164\003k\000\000\000\000\000\000\000\000\000\172\000\181\000\000\000O\000\000\000O\002l\000\000\000\164\001 \000\164\000\000\000\000\000\000\000\172\000\000\000\172\000\000\000\179\000\178\000\181\000\180\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\004T\000\000\000\000\002e\000\000\000\178\002f\000\000\000\000\000\179\000\000\000\000\000\180\000\000\001\023\000\000\000\000\000\000\000\187\000\178\000\000\000\178\000\181\000\000\000\000\000\000\000\000\000\000\000\000\003m\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\187\000\000\000\187\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\003o\000\000\003q\000\000\000\000\001 \000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\000\000\000\000\000\000\187\000\000\000\000\000\179\000\000\000\000\000\180\000\000\000\000\000\000\000\000\003s\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\179\000\000\000\187\000\180\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003u\000\179\000\000\000\179\000\180\000\181\000\180\000\000\000\000\000\000\000\187\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003w\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\181\000\000\000\181\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\187\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003y\000\000\000\000\000\000\000\000\000\000\000\187\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003{\000\000\000\000\000\187\000\000\000\187\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\003}\000\000\003\127"))
let semantic_action =
[|
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_aexpr =
-# 2338 "parser_cocci_menhir.mly"
+# 2326 "parser_cocci_menhir.mly"
( Ast0.set_arg_exp _1 )
# 1763 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 136 "parser_cocci_menhir.mly"
+# 110 "parser_cocci_menhir.mly"
(Parse_aux.list_info)
# 1784 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_aexpr =
-# 2340 "parser_cocci_menhir.mly"
+# 2328 "parser_cocci_menhir.mly"
( let (nm,lenname,pure,clt) = _1 in
let nm = P.clt2mcode nm clt in
let lenname =
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_aexpr =
-# 2349 "parser_cocci_menhir.mly"
+# 2337 "parser_cocci_menhir.mly"
( Ast0.set_arg_exp(Ast0.wrap(Ast0.TypeExp(_1))) )
# 1822 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let ty : 'tv_signable_types = Obj.magic ty in
let r : (
-# 119 "parser_cocci_menhir.mly"
+# 93 "parser_cocci_menhir.mly"
(Data.clt)
# 1849 "parser_cocci_menhir.ml"
) = Obj.magic r in
let _startpos = _startpos_r_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_all_basic_types =
-# 718 "parser_cocci_menhir.mly"
+# 706 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Signed r,Some ty)) )
# 1856 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let ty : 'tv_signable_types = Obj.magic ty in
let r : (
-# 119 "parser_cocci_menhir.mly"
+# 93 "parser_cocci_menhir.mly"
(Data.clt)
# 1883 "parser_cocci_menhir.ml"
) = Obj.magic r in
let _startpos = _startpos_r_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_all_basic_types =
-# 720 "parser_cocci_menhir.mly"
+# 708 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Unsigned r,Some ty)) )
# 1890 "parser_cocci_menhir.ml"
in
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_all_basic_types =
-# 721 "parser_cocci_menhir.mly"
+# 709 "parser_cocci_menhir.mly"
( ty )
# 1914 "parser_cocci_menhir.ml"
in
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_all_basic_types =
-# 722 "parser_cocci_menhir.mly"
+# 710 "parser_cocci_menhir.mly"
( ty )
# 1938 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_any_strict =
-# 2385 "parser_cocci_menhir.mly"
+# 2373 "parser_cocci_menhir.mly"
( Ast.WhenAny )
# 1960 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_any_strict =
-# 2386 "parser_cocci_menhir.mly"
+# 2374 "parser_cocci_menhir.mly"
( Ast.WhenStrict )
# 1982 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_any_strict =
-# 2387 "parser_cocci_menhir.mly"
+# 2375 "parser_cocci_menhir.mly"
( Ast.WhenForall )
# 2004 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_any_strict =
-# 2388 "parser_cocci_menhir.mly"
+# 2376 "parser_cocci_menhir.mly"
( Ast.WhenExists )
# 2026 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1559 "parser_cocci_menhir.mly"
+# 1547 "parser_cocci_menhir.mly"
( _1 )
# 2050 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 2082 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1561 "parser_cocci_menhir.mly"
+# 1549 "parser_cocci_menhir.mly"
( P.arith_op Ast.Mul _1 _2 _3 )
# 2090 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 169 "parser_cocci_menhir.mly"
+# 143 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 2122 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1563 "parser_cocci_menhir.mly"
+# 1551 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 2130 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 2162 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1565 "parser_cocci_menhir.mly"
+# 1553 "parser_cocci_menhir.mly"
( P.arith_op Ast.Plus _1 _2 _3 )
# 2170 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 2202 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1567 "parser_cocci_menhir.mly"
+# 1555 "parser_cocci_menhir.mly"
( P.arith_op Ast.Minus _1 _2 _3 )
# 2210 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 2242 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1569 "parser_cocci_menhir.mly"
+# 1557 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 2250 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 2282 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1571 "parser_cocci_menhir.mly"
+# 1559 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 2290 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 167 "parser_cocci_menhir.mly"
+# 141 "parser_cocci_menhir.mly"
(Ast_cocci.logicalOp * Data.clt)
# 2322 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1573 "parser_cocci_menhir.mly"
+# 1561 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.logic_op op _1 clt _3 )
# 2330 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 2362 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1575 "parser_cocci_menhir.mly"
+# 1563 "parser_cocci_menhir.mly"
( P.logic_op Ast.Eq _1 _2 _3 )
# 2370 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 2402 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1577 "parser_cocci_menhir.mly"
+# 1565 "parser_cocci_menhir.mly"
( P.logic_op Ast.NotEq _1 _2 _3 )
# 2410 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 165 "parser_cocci_menhir.mly"
+# 139 "parser_cocci_menhir.mly"
(Data.clt)
# 2442 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1579 "parser_cocci_menhir.mly"
+# 1567 "parser_cocci_menhir.mly"
( P.arith_op Ast.And _1 _2 _3 )
# 2450 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 163 "parser_cocci_menhir.mly"
+# 137 "parser_cocci_menhir.mly"
(Data.clt)
# 2482 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1581 "parser_cocci_menhir.mly"
+# 1569 "parser_cocci_menhir.mly"
( P.arith_op Ast.Or _1 _2 _3 )
# 2490 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 164 "parser_cocci_menhir.mly"
+# 138 "parser_cocci_menhir.mly"
(Data.clt)
# 2522 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1583 "parser_cocci_menhir.mly"
+# 1571 "parser_cocci_menhir.mly"
( P.arith_op Ast.Xor _1 _2 _3 )
# 2530 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 162 "parser_cocci_menhir.mly"
+# 136 "parser_cocci_menhir.mly"
(Data.clt)
# 2562 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1585 "parser_cocci_menhir.mly"
+# 1573 "parser_cocci_menhir.mly"
( P.logic_op Ast.AndLog _1 _2 _3 )
# 2570 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 161 "parser_cocci_menhir.mly"
+# 135 "parser_cocci_menhir.mly"
(Data.clt)
# 2602 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_dot_expressions_ =
-# 1587 "parser_cocci_menhir.mly"
+# 1575 "parser_cocci_menhir.mly"
( P.logic_op Ast.OrLog _1 _2 _3 )
# 2610 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1559 "parser_cocci_menhir.mly"
+# 1547 "parser_cocci_menhir.mly"
( _1 )
# 2634 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 2666 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1561 "parser_cocci_menhir.mly"
+# 1549 "parser_cocci_menhir.mly"
( P.arith_op Ast.Mul _1 _2 _3 )
# 2674 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 169 "parser_cocci_menhir.mly"
+# 143 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 2706 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1563 "parser_cocci_menhir.mly"
+# 1551 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 2714 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 2746 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1565 "parser_cocci_menhir.mly"
+# 1553 "parser_cocci_menhir.mly"
( P.arith_op Ast.Plus _1 _2 _3 )
# 2754 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 2786 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1567 "parser_cocci_menhir.mly"
+# 1555 "parser_cocci_menhir.mly"
( P.arith_op Ast.Minus _1 _2 _3 )
# 2794 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 2826 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1569 "parser_cocci_menhir.mly"
+# 1557 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 2834 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 2866 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1571 "parser_cocci_menhir.mly"
+# 1559 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 2874 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 167 "parser_cocci_menhir.mly"
+# 141 "parser_cocci_menhir.mly"
(Ast_cocci.logicalOp * Data.clt)
# 2906 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1573 "parser_cocci_menhir.mly"
+# 1561 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.logic_op op _1 clt _3 )
# 2914 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 2946 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1575 "parser_cocci_menhir.mly"
+# 1563 "parser_cocci_menhir.mly"
( P.logic_op Ast.Eq _1 _2 _3 )
# 2954 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 2986 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1577 "parser_cocci_menhir.mly"
+# 1565 "parser_cocci_menhir.mly"
( P.logic_op Ast.NotEq _1 _2 _3 )
# 2994 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 165 "parser_cocci_menhir.mly"
+# 139 "parser_cocci_menhir.mly"
(Data.clt)
# 3026 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1579 "parser_cocci_menhir.mly"
+# 1567 "parser_cocci_menhir.mly"
( P.arith_op Ast.And _1 _2 _3 )
# 3034 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 163 "parser_cocci_menhir.mly"
+# 137 "parser_cocci_menhir.mly"
(Data.clt)
# 3066 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1581 "parser_cocci_menhir.mly"
+# 1569 "parser_cocci_menhir.mly"
( P.arith_op Ast.Or _1 _2 _3 )
# 3074 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 164 "parser_cocci_menhir.mly"
+# 138 "parser_cocci_menhir.mly"
(Data.clt)
# 3106 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1583 "parser_cocci_menhir.mly"
+# 1571 "parser_cocci_menhir.mly"
( P.arith_op Ast.Xor _1 _2 _3 )
# 3114 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 162 "parser_cocci_menhir.mly"
+# 136 "parser_cocci_menhir.mly"
(Data.clt)
# 3146 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1585 "parser_cocci_menhir.mly"
+# 1573 "parser_cocci_menhir.mly"
( P.logic_op Ast.AndLog _1 _2 _3 )
# 3154 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 161 "parser_cocci_menhir.mly"
+# 135 "parser_cocci_menhir.mly"
(Data.clt)
# 3186 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_invalid_ =
-# 1587 "parser_cocci_menhir.mly"
+# 1575 "parser_cocci_menhir.mly"
( P.logic_op Ast.OrLog _1 _2 _3 )
# 3194 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1559 "parser_cocci_menhir.mly"
+# 1547 "parser_cocci_menhir.mly"
( _1 )
# 3218 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 3250 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1561 "parser_cocci_menhir.mly"
+# 1549 "parser_cocci_menhir.mly"
( P.arith_op Ast.Mul _1 _2 _3 )
# 3258 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 169 "parser_cocci_menhir.mly"
+# 143 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 3290 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1563 "parser_cocci_menhir.mly"
+# 1551 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 3298 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 3330 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1565 "parser_cocci_menhir.mly"
+# 1553 "parser_cocci_menhir.mly"
( P.arith_op Ast.Plus _1 _2 _3 )
# 3338 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 3370 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1567 "parser_cocci_menhir.mly"
+# 1555 "parser_cocci_menhir.mly"
( P.arith_op Ast.Minus _1 _2 _3 )
# 3378 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 3410 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1569 "parser_cocci_menhir.mly"
+# 1557 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 3418 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 3450 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1571 "parser_cocci_menhir.mly"
+# 1559 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 3458 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 167 "parser_cocci_menhir.mly"
+# 141 "parser_cocci_menhir.mly"
(Ast_cocci.logicalOp * Data.clt)
# 3490 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1573 "parser_cocci_menhir.mly"
+# 1561 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.logic_op op _1 clt _3 )
# 3498 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 3530 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1575 "parser_cocci_menhir.mly"
+# 1563 "parser_cocci_menhir.mly"
( P.logic_op Ast.Eq _1 _2 _3 )
# 3538 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 3570 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1577 "parser_cocci_menhir.mly"
+# 1565 "parser_cocci_menhir.mly"
( P.logic_op Ast.NotEq _1 _2 _3 )
# 3578 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 165 "parser_cocci_menhir.mly"
+# 139 "parser_cocci_menhir.mly"
(Data.clt)
# 3610 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1579 "parser_cocci_menhir.mly"
+# 1567 "parser_cocci_menhir.mly"
( P.arith_op Ast.And _1 _2 _3 )
# 3618 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 163 "parser_cocci_menhir.mly"
+# 137 "parser_cocci_menhir.mly"
(Data.clt)
# 3650 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1581 "parser_cocci_menhir.mly"
+# 1569 "parser_cocci_menhir.mly"
( P.arith_op Ast.Or _1 _2 _3 )
# 3658 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 164 "parser_cocci_menhir.mly"
+# 138 "parser_cocci_menhir.mly"
(Data.clt)
# 3690 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1583 "parser_cocci_menhir.mly"
+# 1571 "parser_cocci_menhir.mly"
( P.arith_op Ast.Xor _1 _2 _3 )
# 3698 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 162 "parser_cocci_menhir.mly"
+# 136 "parser_cocci_menhir.mly"
(Data.clt)
# 3730 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1585 "parser_cocci_menhir.mly"
+# 1573 "parser_cocci_menhir.mly"
( P.logic_op Ast.AndLog _1 _2 _3 )
# 3738 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 161 "parser_cocci_menhir.mly"
+# 135 "parser_cocci_menhir.mly"
(Data.clt)
# 3770 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_eexpr_nest_expressions_ =
-# 1587 "parser_cocci_menhir.mly"
+# 1575 "parser_cocci_menhir.mly"
( P.logic_op Ast.OrLog _1 _2 _3 )
# 3778 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1559 "parser_cocci_menhir.mly"
+# 1547 "parser_cocci_menhir.mly"
( _1 )
# 3802 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 3834 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1561 "parser_cocci_menhir.mly"
+# 1549 "parser_cocci_menhir.mly"
( P.arith_op Ast.Mul _1 _2 _3 )
# 3842 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 169 "parser_cocci_menhir.mly"
+# 143 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 3874 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1563 "parser_cocci_menhir.mly"
+# 1551 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 3882 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 3914 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1565 "parser_cocci_menhir.mly"
+# 1553 "parser_cocci_menhir.mly"
( P.arith_op Ast.Plus _1 _2 _3 )
# 3922 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 3954 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1567 "parser_cocci_menhir.mly"
+# 1555 "parser_cocci_menhir.mly"
( P.arith_op Ast.Minus _1 _2 _3 )
# 3962 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 3994 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1569 "parser_cocci_menhir.mly"
+# 1557 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 4002 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 4034 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1571 "parser_cocci_menhir.mly"
+# 1559 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 4042 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 167 "parser_cocci_menhir.mly"
+# 141 "parser_cocci_menhir.mly"
(Ast_cocci.logicalOp * Data.clt)
# 4074 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1573 "parser_cocci_menhir.mly"
+# 1561 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.logic_op op _1 clt _3 )
# 4082 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 4114 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1575 "parser_cocci_menhir.mly"
+# 1563 "parser_cocci_menhir.mly"
( P.logic_op Ast.Eq _1 _2 _3 )
# 4122 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 4154 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1577 "parser_cocci_menhir.mly"
+# 1565 "parser_cocci_menhir.mly"
( P.logic_op Ast.NotEq _1 _2 _3 )
# 4162 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 165 "parser_cocci_menhir.mly"
+# 139 "parser_cocci_menhir.mly"
(Data.clt)
# 4194 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1579 "parser_cocci_menhir.mly"
+# 1567 "parser_cocci_menhir.mly"
( P.arith_op Ast.And _1 _2 _3 )
# 4202 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 163 "parser_cocci_menhir.mly"
+# 137 "parser_cocci_menhir.mly"
(Data.clt)
# 4234 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1581 "parser_cocci_menhir.mly"
+# 1569 "parser_cocci_menhir.mly"
( P.arith_op Ast.Or _1 _2 _3 )
# 4242 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 164 "parser_cocci_menhir.mly"
+# 138 "parser_cocci_menhir.mly"
(Data.clt)
# 4274 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1583 "parser_cocci_menhir.mly"
+# 1571 "parser_cocci_menhir.mly"
( P.arith_op Ast.Xor _1 _2 _3 )
# 4282 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 162 "parser_cocci_menhir.mly"
+# 136 "parser_cocci_menhir.mly"
(Data.clt)
# 4314 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1585 "parser_cocci_menhir.mly"
+# 1573 "parser_cocci_menhir.mly"
( P.logic_op Ast.AndLog _1 _2 _3 )
# 4322 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 161 "parser_cocci_menhir.mly"
+# 135 "parser_cocci_menhir.mly"
(Data.clt)
# 4354 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_expr_invalid_ =
-# 1587 "parser_cocci_menhir.mly"
+# 1575 "parser_cocci_menhir.mly"
( P.logic_op Ast.OrLog _1 _2 _3 )
# 4362 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_arith_expr_bis =
-# 1592 "parser_cocci_menhir.mly"
+# 1580 "parser_cocci_menhir.mly"
( _1 )
# 4386 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 4418 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1594 "parser_cocci_menhir.mly"
+# 1582 "parser_cocci_menhir.mly"
( P.arith_op Ast.Mul _1 _2 _3 )
# 4426 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 169 "parser_cocci_menhir.mly"
+# 143 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 4458 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1596 "parser_cocci_menhir.mly"
+# 1584 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 4466 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 4498 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1598 "parser_cocci_menhir.mly"
+# 1586 "parser_cocci_menhir.mly"
( P.arith_op Ast.Plus _1 _2 _3 )
# 4506 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
# 4538 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1600 "parser_cocci_menhir.mly"
+# 1588 "parser_cocci_menhir.mly"
( P.arith_op Ast.Minus _1 _2 _3 )
# 4546 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 4578 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1602 "parser_cocci_menhir.mly"
+# 1590 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 4586 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 168 "parser_cocci_menhir.mly"
+# 142 "parser_cocci_menhir.mly"
(Ast_cocci.arithOp * Data.clt)
# 4618 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1604 "parser_cocci_menhir.mly"
+# 1592 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.arith_op op _1 clt _3 )
# 4626 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 167 "parser_cocci_menhir.mly"
+# 141 "parser_cocci_menhir.mly"
(Ast_cocci.logicalOp * Data.clt)
# 4658 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1606 "parser_cocci_menhir.mly"
+# 1594 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in P.logic_op op _1 clt _3 )
# 4666 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 4698 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1608 "parser_cocci_menhir.mly"
+# 1596 "parser_cocci_menhir.mly"
( P.logic_op Ast.Eq _1 _2 _3 )
# 4706 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 166 "parser_cocci_menhir.mly"
+# 140 "parser_cocci_menhir.mly"
(Data.clt)
# 4738 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1610 "parser_cocci_menhir.mly"
+# 1598 "parser_cocci_menhir.mly"
( P.logic_op Ast.NotEq _1 _2 _3 )
# 4746 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 165 "parser_cocci_menhir.mly"
+# 139 "parser_cocci_menhir.mly"
(Data.clt)
# 4778 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1612 "parser_cocci_menhir.mly"
+# 1600 "parser_cocci_menhir.mly"
( P.arith_op Ast.And _1 _2 _3 )
# 4786 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 163 "parser_cocci_menhir.mly"
+# 137 "parser_cocci_menhir.mly"
(Data.clt)
# 4818 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1614 "parser_cocci_menhir.mly"
+# 1602 "parser_cocci_menhir.mly"
( P.arith_op Ast.Or _1 _2 _3 )
# 4826 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 164 "parser_cocci_menhir.mly"
+# 138 "parser_cocci_menhir.mly"
(Data.clt)
# 4858 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1616 "parser_cocci_menhir.mly"
+# 1604 "parser_cocci_menhir.mly"
( P.arith_op Ast.Xor _1 _2 _3 )
# 4866 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_arith_expr_bis = Obj.magic _3 in
let _2 : (
-# 162 "parser_cocci_menhir.mly"
+# 136 "parser_cocci_menhir.mly"
(Data.clt)
# 4898 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_arith_expr_bis =
-# 1618 "parser_cocci_menhir.mly"
+# 1606 "parser_cocci_menhir.mly"
( P.logic_op Ast.AndLog _1 _2 _3 )
# 4906 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_arity =
-# 629 "parser_cocci_menhir.mly"
+# 617 "parser_cocci_menhir.mly"
( Ast.UNIQUE )
# 4928 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_arity =
-# 630 "parser_cocci_menhir.mly"
+# 618 "parser_cocci_menhir.mly"
( Ast.OPT )
# 4950 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_arity =
-# 631 "parser_cocci_menhir.mly"
+# 619 "parser_cocci_menhir.mly"
( Ast.MULTI )
# 4972 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_arity =
-# 632 "parser_cocci_menhir.mly"
+# 620 "parser_cocci_menhir.mly"
( Ast.NONE )
# 4989 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let r : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
# 5020 "parser_cocci_menhir.ml"
) = Obj.magic r in
let i : 'tv_option_eexpr_ = Obj.magic i in
let l : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
# 5026 "parser_cocci_menhir.ml"
) = Obj.magic l in
let _startpos = _startpos_l_ in
let _endpos = _endpos_r_ in
let _v : 'tv_array_dec =
-# 1348 "parser_cocci_menhir.mly"
+# 1336 "parser_cocci_menhir.mly"
( (l,i,r) )
# 5033 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_assign_expr_eexpr_dot_expressions_ =
-# 1530 "parser_cocci_menhir.mly"
+# 1518 "parser_cocci_menhir.mly"
( _1 )
# 5057 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_assign_expr_bis = Obj.magic _3 in
let _2 : (
-# 180 "parser_cocci_menhir.mly"
+# 154 "parser_cocci_menhir.mly"
(Ast_cocci.assignOp * Data.clt)
# 5089 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_assign_expr_eexpr_dot_expressions_ =
-# 1532 "parser_cocci_menhir.mly"
+# 1520 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in
Ast0.wrap(Ast0.Assignment(_1,P.clt2mcode op clt,
Ast0.set_arg_exp _3,false)) )
} = _menhir_stack in
let _3 : 'tv_assign_expr_bis = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 5131 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_assign_expr_eexpr_dot_expressions_ =
-# 1536 "parser_cocci_menhir.mly"
+# 1524 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.Assignment
(_1,P.clt2mcode Ast.SimpleAssign _2,Ast0.set_arg_exp _3,false)) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_assign_expr_eexpr_nest_expressions_ =
-# 1530 "parser_cocci_menhir.mly"
+# 1518 "parser_cocci_menhir.mly"
( _1 )
# 5165 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_assign_expr_bis = Obj.magic _3 in
let _2 : (
-# 180 "parser_cocci_menhir.mly"
+# 154 "parser_cocci_menhir.mly"
(Ast_cocci.assignOp * Data.clt)
# 5197 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_assign_expr_eexpr_nest_expressions_ =
-# 1532 "parser_cocci_menhir.mly"
+# 1520 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in
Ast0.wrap(Ast0.Assignment(_1,P.clt2mcode op clt,
Ast0.set_arg_exp _3,false)) )
} = _menhir_stack in
let _3 : 'tv_assign_expr_bis = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 5239 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_assign_expr_eexpr_nest_expressions_ =
-# 1536 "parser_cocci_menhir.mly"
+# 1524 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.Assignment
(_1,P.clt2mcode Ast.SimpleAssign _2,Ast0.set_arg_exp _3,false)) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_assign_expr_expr_invalid_ =
-# 1530 "parser_cocci_menhir.mly"
+# 1518 "parser_cocci_menhir.mly"
( _1 )
# 5273 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_assign_expr_bis = Obj.magic _3 in
let _2 : (
-# 180 "parser_cocci_menhir.mly"
+# 154 "parser_cocci_menhir.mly"
(Ast_cocci.assignOp * Data.clt)
# 5305 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_assign_expr_expr_invalid_ =
-# 1532 "parser_cocci_menhir.mly"
+# 1520 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in
Ast0.wrap(Ast0.Assignment(_1,P.clt2mcode op clt,
Ast0.set_arg_exp _3,false)) )
} = _menhir_stack in
let _3 : 'tv_assign_expr_bis = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 5347 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_assign_expr_expr_invalid_ =
-# 1536 "parser_cocci_menhir.mly"
+# 1524 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.Assignment
(_1,P.clt2mcode Ast.SimpleAssign _2,Ast0.set_arg_exp _3,false)) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_assign_expr_bis =
-# 1541 "parser_cocci_menhir.mly"
+# 1529 "parser_cocci_menhir.mly"
( _1 )
# 5381 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_assign_expr_bis = Obj.magic _3 in
let _2 : (
-# 180 "parser_cocci_menhir.mly"
+# 154 "parser_cocci_menhir.mly"
(Ast_cocci.assignOp * Data.clt)
# 5413 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_assign_expr_bis =
-# 1543 "parser_cocci_menhir.mly"
+# 1531 "parser_cocci_menhir.mly"
( let (op,clt) = _2 in
Ast0.wrap(Ast0.Assignment(_1,P.clt2mcode op clt,
Ast0.set_arg_exp _3,false)) )
} = _menhir_stack in
let _3 : 'tv_assign_expr_bis = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 5455 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_assign_expr_bis =
-# 1547 "parser_cocci_menhir.mly"
+# 1535 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.Assignment
(_1,P.clt2mcode Ast.SimpleAssign _2,Ast0.set_arg_exp _3,false)) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_basic_expr_eexpr_dot_expressions_ =
-# 1527 "parser_cocci_menhir.mly"
+# 1515 "parser_cocci_menhir.mly"
( _1 )
# 5489 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_basic_expr_eexpr_nest_expressions_ =
-# 1527 "parser_cocci_menhir.mly"
+# 1515 "parser_cocci_menhir.mly"
( _1 )
# 5513 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_basic_expr_expr_invalid_ =
-# 1527 "parser_cocci_menhir.mly"
+# 1515 "parser_cocci_menhir.mly"
( _1 )
# 5537 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_fun_start = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 5569 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
# 5574 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_case_line =
-# 1205 "parser_cocci_menhir.mly"
+# 1193 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.Default(P.clt2mcode "default" _1,P.clt2mcode ":" _2,_3)) )
# 5582 "parser_cocci_menhir.ml"
} = _menhir_stack in
let _4 : 'tv_fun_start = Obj.magic _4 in
let _3 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 5619 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_eexpr = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
# 5625 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_case_line =
-# 1208 "parser_cocci_menhir.mly"
+# 1196 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Case(P.clt2mcode "case" _1,_2,P.clt2mcode ":" _3,_4)) )
# 5632 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_cast_expr_eexpr_dot_expressions_ =
-# 1623 "parser_cocci_menhir.mly"
+# 1611 "parser_cocci_menhir.mly"
( _1 )
# 5656 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let e : 'tv_cast_expr_eexpr_dot_expressions_ = Obj.magic e in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 5693 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_ctype = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 5699 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let _startpos = _startpos_lp_ in
let _endpos = _endpos_e_ in
let _v : 'tv_cast_expr_eexpr_dot_expressions_ =
-# 1625 "parser_cocci_menhir.mly"
+# 1613 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, t,
P.clt2mcode ")" rp, e)) )
# 5707 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_cast_expr_eexpr_invalid_ =
-# 1623 "parser_cocci_menhir.mly"
+# 1611 "parser_cocci_menhir.mly"
( _1 )
# 5731 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let e : 'tv_cast_expr_eexpr_invalid_ = Obj.magic e in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 5768 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_ctype = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 5774 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let _startpos = _startpos_lp_ in
let _endpos = _endpos_e_ in
let _v : 'tv_cast_expr_eexpr_invalid_ =
-# 1625 "parser_cocci_menhir.mly"
+# 1613 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, t,
P.clt2mcode ")" rp, e)) )
# 5782 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_cast_expr_eexpr_nest_expressions_ =
-# 1623 "parser_cocci_menhir.mly"
+# 1611 "parser_cocci_menhir.mly"
( _1 )
# 5806 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let e : 'tv_cast_expr_eexpr_nest_expressions_ = Obj.magic e in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 5843 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_ctype = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 5849 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let _startpos = _startpos_lp_ in
let _endpos = _endpos_e_ in
let _v : 'tv_cast_expr_eexpr_nest_expressions_ =
-# 1625 "parser_cocci_menhir.mly"
+# 1613 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, t,
P.clt2mcode ")" rp, e)) )
# 5857 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_cast_expr_expr_invalid_ =
-# 1623 "parser_cocci_menhir.mly"
+# 1611 "parser_cocci_menhir.mly"
( _1 )
# 5881 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let e : 'tv_cast_expr_expr_invalid_ = Obj.magic e in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 5918 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_ctype = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 5924 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let _startpos = _startpos_lp_ in
let _endpos = _endpos_e_ in
let _v : 'tv_cast_expr_expr_invalid_ =
-# 1625 "parser_cocci_menhir.mly"
+# 1613 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Cast (P.clt2mcode "(" lp, t,
P.clt2mcode ")" rp, e)) )
# 5932 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_choose_iso =
-# 310 "parser_cocci_menhir.mly"
+# 284 "parser_cocci_menhir.mly"
( List.map P.id2name _2 )
# 5960 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_any_strict_ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 5984 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_ctype_ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6008 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_d_ident_ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6032 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_ident_or_const_ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6056 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_meta_ident_ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6080 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_pure_ident_ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6104 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_pure_ident_or_meta_ident_ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6128 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_pure_ident_or_meta_ident_with_econstraint_not_ceq_or_sub__ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6152 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_pure_ident_or_meta_ident_with_econstraint_re_or_not_eqe_or_sub__ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6176 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_pure_ident_or_meta_ident_with_idconstraint_re_or_not_eqid__ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6200 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_pure_ident_or_meta_ident_with_idconstraint_virt_re_or_not_eqid__ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6224 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_pure_ident_or_meta_ident_with_seed_ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6248 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_pure_ident_or_meta_ident_with_x_eq_not_pos__ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6272 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_comma_list_typedef_ident_ =
-# 2363 "parser_cocci_menhir.mly"
+# 2351 "parser_cocci_menhir.mly"
( _1 )
# 6296 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_cond_expr_eexpr_dot_expressions_ =
-# 1552 "parser_cocci_menhir.mly"
+# 1540 "parser_cocci_menhir.mly"
( _1 )
# 6320 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let r : 'tv_eargexpr = Obj.magic r in
let dd : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 6362 "parser_cocci_menhir.ml"
) = Obj.magic dd in
let t : 'tv_option_eexpr_ = Obj.magic t in
let w : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 6368 "parser_cocci_menhir.ml"
) = Obj.magic w in
let _startpos = _startpos_l_ in
let _endpos = _endpos_r_ in
let _v : 'tv_cond_expr_eexpr_dot_expressions_ =
-# 1555 "parser_cocci_menhir.mly"
+# 1543 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.CondExpr (l, P.clt2mcode "?" w, t,
P.clt2mcode ":" dd, r)) )
# 6377 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_cond_expr_eexpr_nest_expressions_ =
-# 1552 "parser_cocci_menhir.mly"
+# 1540 "parser_cocci_menhir.mly"
( _1 )
# 6401 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let r : 'tv_eargexpr = Obj.magic r in
let dd : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 6443 "parser_cocci_menhir.ml"
) = Obj.magic dd in
let t : 'tv_option_eexpr_ = Obj.magic t in
let w : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 6449 "parser_cocci_menhir.ml"
) = Obj.magic w in
let _startpos = _startpos_l_ in
let _endpos = _endpos_r_ in
let _v : 'tv_cond_expr_eexpr_nest_expressions_ =
-# 1555 "parser_cocci_menhir.mly"
+# 1543 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.CondExpr (l, P.clt2mcode "?" w, t,
P.clt2mcode ":" dd, r)) )
# 6458 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_cond_expr_expr_invalid_ =
-# 1552 "parser_cocci_menhir.mly"
+# 1540 "parser_cocci_menhir.mly"
( _1 )
# 6482 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let r : 'tv_eargexpr = Obj.magic r in
let dd : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 6524 "parser_cocci_menhir.ml"
) = Obj.magic dd in
let t : 'tv_option_eexpr_ = Obj.magic t in
let w : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 6530 "parser_cocci_menhir.ml"
) = Obj.magic w in
let _startpos = _startpos_l_ in
let _endpos = _endpos_r_ in
let _v : 'tv_cond_expr_expr_invalid_ =
-# 1555 "parser_cocci_menhir.mly"
+# 1543 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.CondExpr (l, P.clt2mcode "?" w, t,
P.clt2mcode ":" dd, r)) )
# 6539 "parser_cocci_menhir.ml"
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 122 "parser_cocci_menhir.mly"
+# 96 "parser_cocci_menhir.mly"
(Data.clt)
# 6560 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_const_vol =
-# 1101 "parser_cocci_menhir.mly"
+# 1089 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.Const _1 )
# 6567 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 122 "parser_cocci_menhir.mly"
+# 96 "parser_cocci_menhir.mly"
(Data.clt)
# 6588 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_const_vol =
-# 1102 "parser_cocci_menhir.mly"
+# 1090 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.Volatile _1 )
# 6595 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_continue_list_aexpr_TEllipsis_ =
-# 2139 "parser_cocci_menhir.mly"
+# 2127 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
# 6619 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 6645 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_aexpr_TEllipsis_ =
-# 2141 "parser_cocci_menhir.mly"
+# 2129 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
# 6654 "parser_cocci_menhir.ml"
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_aexpr_TEllipsis_ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 6686 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_continue_list_aexpr_TEllipsis_ =
-# 2144 "parser_cocci_menhir.mly"
+# 2132 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_aexpr_TEllipsis_ =
-# 2147 "parser_cocci_menhir.mly"
+# 2135 "parser_cocci_menhir.mly"
( _2 )
# 6724 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_continue_list_dparam_TEllipsis_ =
-# 2139 "parser_cocci_menhir.mly"
+# 2127 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
# 6748 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 6774 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_dparam_TEllipsis_ =
-# 2141 "parser_cocci_menhir.mly"
+# 2129 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
# 6783 "parser_cocci_menhir.ml"
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_dparam_TEllipsis_ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 6815 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_continue_list_dparam_TEllipsis_ =
-# 2144 "parser_cocci_menhir.mly"
+# 2132 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_dparam_TEllipsis_ =
-# 2147 "parser_cocci_menhir.mly"
+# 2135 "parser_cocci_menhir.mly"
( _2 )
# 6853 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_continue_list_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ =
-# 2139 "parser_cocci_menhir.mly"
+# 2127 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
# 6877 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 6903 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ =
-# 2141 "parser_cocci_menhir.mly"
+# 2129 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
# 6912 "parser_cocci_menhir.ml"
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 6944 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_continue_list_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ =
-# 2144 "parser_cocci_menhir.mly"
+# 2132 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ =
-# 2147 "parser_cocci_menhir.mly"
+# 2135 "parser_cocci_menhir.mly"
( _2 )
# 6982 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_continue_list_initialize2_edots_when_TEllipsis_initialize__ =
-# 2139 "parser_cocci_menhir.mly"
+# 2127 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
# 7006 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 7032 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_initialize2_edots_when_TEllipsis_initialize__ =
-# 2141 "parser_cocci_menhir.mly"
+# 2129 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
# 7041 "parser_cocci_menhir.ml"
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_initialize2_edots_when_TEllipsis_initialize__ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 7073 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_continue_list_initialize2_edots_when_TEllipsis_initialize__ =
-# 2144 "parser_cocci_menhir.mly"
+# 2132 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_initialize2_edots_when_TEllipsis_initialize__ =
-# 2147 "parser_cocci_menhir.mly"
+# 2135 "parser_cocci_menhir.mly"
( _2 )
# 7111 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_continue_list_one_dec_decl__TEllipsis_ =
-# 2139 "parser_cocci_menhir.mly"
+# 2127 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
# 7135 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 7161 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_one_dec_decl__TEllipsis_ =
-# 2141 "parser_cocci_menhir.mly"
+# 2129 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
# 7170 "parser_cocci_menhir.ml"
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_one_dec_decl__TEllipsis_ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 7202 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_continue_list_one_dec_decl__TEllipsis_ =
-# 2144 "parser_cocci_menhir.mly"
+# 2132 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_one_dec_decl__TEllipsis_ =
-# 2147 "parser_cocci_menhir.mly"
+# 2135 "parser_cocci_menhir.mly"
( _2 )
# 7240 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_continue_list_one_dec_name_opt_decl__TEllipsis_ =
-# 2139 "parser_cocci_menhir.mly"
+# 2127 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
# 7264 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 7290 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_one_dec_name_opt_decl__TEllipsis_ =
-# 2141 "parser_cocci_menhir.mly"
+# 2129 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
# 7299 "parser_cocci_menhir.ml"
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_one_dec_name_opt_decl__TEllipsis_ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 7331 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_continue_list_one_dec_name_opt_decl__TEllipsis_ =
-# 2144 "parser_cocci_menhir.mly"
+# 2132 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_list_one_dec_name_opt_decl__TEllipsis_ =
-# 2147 "parser_cocci_menhir.mly"
+# 2135 "parser_cocci_menhir.mly"
( _2 )
# 7369 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_continue_struct_decl_list =
-# 801 "parser_cocci_menhir.mly"
+# 789 "parser_cocci_menhir.mly"
( [] )
# 7386 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_continue_struct_decl_list =
-# 802 "parser_cocci_menhir.mly"
+# 790 "parser_cocci_menhir.mly"
( _1@_2 )
# 7416 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_continue_struct_decl_list =
-# 803 "parser_cocci_menhir.mly"
+# 791 "parser_cocci_menhir.mly"
( _1 )
# 7440 "parser_cocci_menhir.ml"
in
in
-# 726 "parser_cocci_menhir.mly"
+# 714 "parser_cocci_menhir.mly"
( List.fold_left
(function prev ->
function (star,cv) ->
in
-# 726 "parser_cocci_menhir.mly"
+# 714 "parser_cocci_menhir.mly"
( List.fold_left
(function prev ->
function (star,cv) ->
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let r : (
-# 119 "parser_cocci_menhir.mly"
+# 93 "parser_cocci_menhir.mly"
(Data.clt)
# 7550 "parser_cocci_menhir.ml"
) = Obj.magic r in
let _startpos = _startpos_r_ in
let _endpos = _endpos_r_ in
let _v : 'tv_ctype =
-# 732 "parser_cocci_menhir.mly"
+# 720 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Signed r,None)) )
# 7557 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let r : (
-# 119 "parser_cocci_menhir.mly"
+# 93 "parser_cocci_menhir.mly"
(Data.clt)
# 7578 "parser_cocci_menhir.ml"
) = Obj.magic r in
let _startpos = _startpos_r_ in
let _endpos = _endpos_r_ in
let _v : 'tv_ctype =
-# 734 "parser_cocci_menhir.mly"
+# 722 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Signed(P.clt2mcode Ast.Unsigned r,None)) )
# 7585 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 7616 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_midzero_list_ctype_ctype_ = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 7622 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let _startpos = _startpos_lp_ in
let _endpos = _endpos_rp_ in
let _v : 'tv_ctype =
-# 736 "parser_cocci_menhir.mly"
+# 724 "parser_cocci_menhir.mly"
( let (mids,code) = t in
Ast0.wrap
(Ast0.DisjType(P.clt2mcode "(" lp,code,mids, P.clt2mcode ")" rp)) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_d_ident =
-# 1346 "parser_cocci_menhir.mly"
+# 1334 "parser_cocci_menhir.mly"
( (_1, function t -> P.arrayify t _2) )
# 7661 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_dargexpr =
-# 1484 "parser_cocci_menhir.mly"
+# 1472 "parser_cocci_menhir.mly"
( _1 )
# 7685 "parser_cocci_menhir.ml"
in
let _startpos = _startpos_t_ in
let _endpos = _endpos_a_ in
let _v : 'tv_decl =
-# 1074 "parser_cocci_menhir.mly"
+# 1062 "parser_cocci_menhir.mly"
( let t = P.arrayify t a in Ast0.wrap(Ast0.Param(t, Some i)) )
# 7721 "parser_cocci_menhir.ml"
in
let _startpos = _startpos_t_ in
let _endpos = _endpos_t_ in
let _v : 'tv_decl =
-# 1075 "parser_cocci_menhir.mly"
+# 1063 "parser_cocci_menhir.mly"
( (*verify in FunDecl*) Ast0.wrap(Ast0.Param(t, None)) )
# 7745 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let rp1 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 7801 "parser_cocci_menhir.ml"
) = Obj.magic rp1 in
let d : 'tv_decl_list_name_opt_decl_ = Obj.magic d in
let lp1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 7807 "parser_cocci_menhir.ml"
) = Obj.magic lp1 in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 7812 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let i : 'tv_disj_ident = Obj.magic i in
let s : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 7818 "parser_cocci_menhir.ml"
) = Obj.magic s in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 7823 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let _startpos = _startpos_t_ in
let _endpos = _endpos_rp1_ in
let _v : 'tv_decl =
-# 1078 "parser_cocci_menhir.mly"
+# 1066 "parser_cocci_menhir.mly"
( let fnptr =
Ast0.wrap
(Ast0.FunctionPointer
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 134 "parser_cocci_menhir.mly"
+# 108 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 7857 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl =
-# 1085 "parser_cocci_menhir.mly"
+# 1073 "parser_cocci_menhir.mly"
( let (nm,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaParam(P.clt2mcode nm clt,pure)) )
# 7865 "parser_cocci_menhir.ml"
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 7886 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl =
-# 1087 "parser_cocci_menhir.mly"
+# 1075 "parser_cocci_menhir.mly"
( tmeta_to_param _1 )
# 7893 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
# 7914 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl_ident =
-# 2063 "parser_cocci_menhir.mly"
+# 2051 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Id(P.id2mcode _1)) )
# 7921 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 132 "parser_cocci_menhir.mly"
+# 106 "parser_cocci_menhir.mly"
(Parse_aux.idinfo)
# 7942 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl_ident =
-# 2065 "parser_cocci_menhir.mly"
+# 2053 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,Ast.NoVal,pure)) )
# 7950 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl_list_decl_ =
-# 2087 "parser_cocci_menhir.mly"
+# 2075 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.DOTS
(_1
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl_list_name_opt_decl_ =
-# 2087 "parser_cocci_menhir.mly"
+# 2075 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.DOTS
(_1
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 134 "parser_cocci_menhir.mly"
+# 108 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 8027 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl_statement =
-# 1410 "parser_cocci_menhir.mly"
+# 1398 "parser_cocci_menhir.mly"
( let (nm,pure,clt) = _1 in
[Ast0.wrap(Ast0.MetaStmt(P.clt2mcode nm clt,pure))] )
# 8035 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl_statement =
-# 1413 "parser_cocci_menhir.mly"
+# 1401 "parser_cocci_menhir.mly"
( List.map
(function x ->
Ast0.wrap
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl_statement =
-# 1418 "parser_cocci_menhir.mly"
+# 1406 "parser_cocci_menhir.mly"
( [_1] )
# 8087 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 8118 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let t : 'tv_midzero_list_fun_start_fun_start_ = Obj.magic t in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 8124 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_decl_statement =
-# 1427 "parser_cocci_menhir.mly"
+# 1415 "parser_cocci_menhir.mly"
( let (mids,code) = t in
if List.for_all
(function x ->
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 134 "parser_cocci_menhir.mly"
+# 108 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 8160 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl_statement_expr =
-# 1440 "parser_cocci_menhir.mly"
+# 1428 "parser_cocci_menhir.mly"
( let (nm,pure,clt) = _1 in
[Ast0.wrap(Ast0.MetaStmt(P.clt2mcode nm clt,pure))] )
# 8168 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl_statement_expr =
-# 1443 "parser_cocci_menhir.mly"
+# 1431 "parser_cocci_menhir.mly"
( List.map
(function x ->
Ast0.wrap
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl_statement_expr =
-# 1448 "parser_cocci_menhir.mly"
+# 1436 "parser_cocci_menhir.mly"
( [_1] )
# 8220 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 8251 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let t : 'tv_midzero_list_fun_after_stm_fun_after_dots_or_ = Obj.magic t in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 8257 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_decl_statement_expr =
-# 1457 "parser_cocci_menhir.mly"
+# 1445 "parser_cocci_menhir.mly"
( let (mids,code) = t in
if List.for_all (function [] -> true | _ -> false) code
then []
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8297 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let _startpos = _startpos_t_ in
let _endpos = _endpos_pv_ in
let _v : 'tv_decl_var =
-# 1220 "parser_cocci_menhir.mly"
+# 1208 "parser_cocci_menhir.mly"
( [Ast0.wrap(Ast0.TyDecl(t,P.clt2mcode ";" pv))] )
# 8305 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 8326 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_decl_var =
-# 1221 "parser_cocci_menhir.mly"
+# 1209 "parser_cocci_menhir.mly"
( [P.meta_decl _1] )
# 8333 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8364 "parser_cocci_menhir.ml"
) = Obj.magic pv in
in
-# 1223 "parser_cocci_menhir.mly"
+# 1211 "parser_cocci_menhir.mly"
( List.map
(function (id,fn) ->
Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)))
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8419 "parser_cocci_menhir.ml"
) = Obj.magic pv in
in
-# 1223 "parser_cocci_menhir.mly"
+# 1211 "parser_cocci_menhir.mly"
( List.map
(function (id,fn) ->
Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)))
let _startpos = _startpos_f_ in
let _endpos = _endpos_f_ in
let _v : 'tv_decl_var =
-# 1227 "parser_cocci_menhir.mly"
+# 1215 "parser_cocci_menhir.mly"
( [f] )
# 8464 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8505 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8511 "parser_cocci_menhir.ml"
) = Obj.magic q in
in
-# 1229 "parser_cocci_menhir.mly"
+# 1217 "parser_cocci_menhir.mly"
(let (id,fn) = d in
[Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv))])
# 8528 "parser_cocci_menhir.ml"
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8574 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8580 "parser_cocci_menhir.ml"
) = Obj.magic q in
in
-# 1229 "parser_cocci_menhir.mly"
+# 1217 "parser_cocci_menhir.mly"
(let (id,fn) = d in
[Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv))])
# 8599 "parser_cocci_menhir.ml"
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8630 "parser_cocci_menhir.ml"
) = Obj.magic pv in
in
-# 1234 "parser_cocci_menhir.mly"
+# 1222 "parser_cocci_menhir.mly"
( List.map
(function (id,fn) ->
let idtype =
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8694 "parser_cocci_menhir.ml"
) = Obj.magic pv in
in
-# 1234 "parser_cocci_menhir.mly"
+# 1222 "parser_cocci_menhir.mly"
( List.map
(function (id,fn) ->
let idtype =
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8760 "parser_cocci_menhir.ml"
) = Obj.magic pv in
in
-# 1234 "parser_cocci_menhir.mly"
+# 1222 "parser_cocci_menhir.mly"
( List.map
(function (id,fn) ->
let idtype =
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8831 "parser_cocci_menhir.ml"
) = Obj.magic pv in
in
-# 1234 "parser_cocci_menhir.mly"
+# 1222 "parser_cocci_menhir.mly"
( List.map
(function (id,fn) ->
let idtype =
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8904 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8910 "parser_cocci_menhir.ml"
) = Obj.magic q in
in
-# 1242 "parser_cocci_menhir.mly"
+# 1230 "parser_cocci_menhir.mly"
( let (id,fn) = d in
!Data.add_type_name (P.id2name i);
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8983 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 8989 "parser_cocci_menhir.ml"
) = Obj.magic q in
in
-# 1242 "parser_cocci_menhir.mly"
+# 1230 "parser_cocci_menhir.mly"
( let (id,fn) = d in
!Data.add_type_name (P.id2name i);
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9064 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9070 "parser_cocci_menhir.ml"
) = Obj.magic q in
in
-# 1242 "parser_cocci_menhir.mly"
+# 1230 "parser_cocci_menhir.mly"
( let (id,fn) = d in
!Data.add_type_name (P.id2name i);
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9150 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9156 "parser_cocci_menhir.ml"
) = Obj.magic q in
in
-# 1242 "parser_cocci_menhir.mly"
+# 1230 "parser_cocci_menhir.mly"
( let (id,fn) = d in
!Data.add_type_name (P.id2name i);
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9248 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let rp2 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 9253 "parser_cocci_menhir.ml"
) = Obj.magic rp2 in
let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in
let lp2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 9259 "parser_cocci_menhir.ml"
) = Obj.magic lp2 in
let rp1 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 9264 "parser_cocci_menhir.ml"
) = Obj.magic rp1 in
let d : 'tv_d_ident = Obj.magic d in
let st : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 9270 "parser_cocci_menhir.ml"
) = Obj.magic st in
let lp1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 9275 "parser_cocci_menhir.ml"
) = Obj.magic lp1 in
in
-# 1252 "parser_cocci_menhir.mly"
+# 1240 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let t =
Ast0.wrap
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9362 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let rp2 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 9367 "parser_cocci_menhir.ml"
) = Obj.magic rp2 in
let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in
let lp2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 9373 "parser_cocci_menhir.ml"
) = Obj.magic lp2 in
let rp1 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 9378 "parser_cocci_menhir.ml"
) = Obj.magic rp1 in
let d : 'tv_d_ident = Obj.magic d in
let st : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 9384 "parser_cocci_menhir.ml"
) = Obj.magic st in
let lp1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 9389 "parser_cocci_menhir.ml"
) = Obj.magic lp1 in
in
-# 1252 "parser_cocci_menhir.mly"
+# 1240 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let t =
Ast0.wrap
};
} = _menhir_stack in
let _5 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9453 "parser_cocci_menhir.ml"
) = Obj.magic _5 in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 9458 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr_list_option = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 9464 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : 'tv_decl_var =
-# 1260 "parser_cocci_menhir.mly"
+# 1248 "parser_cocci_menhir.mly"
( [Ast0.wrap(Ast0.MacroDecl(_1,P.clt2mcode "(" _2,_3,
P.clt2mcode ")" _4,P.clt2mcode ";" _5))] )
# 9473 "parser_cocci_menhir.ml"
};
} = _menhir_stack in
let _7 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9524 "parser_cocci_menhir.ml"
) = Obj.magic _7 in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9530 "parser_cocci_menhir.ml"
) = Obj.magic q in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 9535 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr_list_option = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 9541 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : 'tv_decl_var =
-# 1263 "parser_cocci_menhir.mly"
+# 1251 "parser_cocci_menhir.mly"
( [Ast0.wrap
(Ast0.MacroDeclInit
(_1,P.clt2mcode "(" _2,_3,
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9624 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9630 "parser_cocci_menhir.ml"
) = Obj.magic q in
let rp2 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 9635 "parser_cocci_menhir.ml"
) = Obj.magic rp2 in
let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in
let lp2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 9641 "parser_cocci_menhir.ml"
) = Obj.magic lp2 in
let rp1 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 9646 "parser_cocci_menhir.ml"
) = Obj.magic rp1 in
let d : 'tv_d_ident = Obj.magic d in
let st : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 9652 "parser_cocci_menhir.ml"
) = Obj.magic st in
let lp1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 9657 "parser_cocci_menhir.ml"
) = Obj.magic lp1 in
in
-# 1272 "parser_cocci_menhir.mly"
+# 1260 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let t =
Ast0.wrap
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9754 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9760 "parser_cocci_menhir.ml"
) = Obj.magic q in
let rp2 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 9765 "parser_cocci_menhir.ml"
) = Obj.magic rp2 in
let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in
let lp2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 9771 "parser_cocci_menhir.ml"
) = Obj.magic lp2 in
let rp1 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 9776 "parser_cocci_menhir.ml"
) = Obj.magic rp1 in
let d : 'tv_d_ident = Obj.magic d in
let st : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 9782 "parser_cocci_menhir.ml"
) = Obj.magic st in
let lp1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 9787 "parser_cocci_menhir.ml"
) = Obj.magic lp1 in
in
-# 1272 "parser_cocci_menhir.mly"
+# 1260 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let t =
Ast0.wrap
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 9846 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let id : 'tv_comma_list_typedef_ident_ = Obj.magic id in
let t : 'tv_typedef_ctype = Obj.magic t in
let s : (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
# 9853 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_pv_ in
let _v : 'tv_decl_var =
-# 1280 "parser_cocci_menhir.mly"
+# 1268 "parser_cocci_menhir.mly"
( let s = P.clt2mcode "typedef" s in
List.map
(function id ->
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_define_param_list_option =
-# 997 "parser_cocci_menhir.mly"
+# 985 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.DOTS
(_1
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 153 "parser_cocci_menhir.mly"
+# 127 "parser_cocci_menhir.mly"
(Data.clt * token)
# 9913 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_defineop =
-# 941 "parser_cocci_menhir.mly"
+# 929 "parser_cocci_menhir.mly"
( let (clt,ident) = _1 in
let aft = P.get_aft clt in (* move stuff after the define to the ident *)
function body ->
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 9973 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_define_param_list_option = Obj.magic _2 in
let _1 : (
-# 154 "parser_cocci_menhir.mly"
+# 128 "parser_cocci_menhir.mly"
(Data.clt * token * int * int)
# 9979 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_defineop =
-# 965 "parser_cocci_menhir.mly"
+# 953 "parser_cocci_menhir.mly"
( let (clt,ident,parenoff,parencol) = _1 in
let aft = P.get_aft clt in (* move stuff after the define to the ( *)
(* clt is the start of the #define itself *)
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 114 "parser_cocci_menhir.mly"
+# 88 "parser_cocci_menhir.mly"
(string)
# 10031 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_dep =
-# 299 "parser_cocci_menhir.mly"
+# 273 "parser_cocci_menhir.mly"
( Ast0.Dep _1 )
# 10038 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 114 "parser_cocci_menhir.mly"
+# 88 "parser_cocci_menhir.mly"
(string)
# 10063 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_dep =
-# 300 "parser_cocci_menhir.mly"
+# 274 "parser_cocci_menhir.mly"
( Ast0.AntiDep (Ast0.Dep _2) )
# 10070 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_dep =
-# 302 "parser_cocci_menhir.mly"
+# 276 "parser_cocci_menhir.mly"
( Ast0.AntiDep _3 )
# 10106 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 114 "parser_cocci_menhir.mly"
+# 88 "parser_cocci_menhir.mly"
(string)
# 10131 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_dep =
-# 303 "parser_cocci_menhir.mly"
+# 277 "parser_cocci_menhir.mly"
( Ast0.EverDep _2 )
# 10138 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 114 "parser_cocci_menhir.mly"
+# 88 "parser_cocci_menhir.mly"
(string)
# 10163 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_dep =
-# 304 "parser_cocci_menhir.mly"
+# 278 "parser_cocci_menhir.mly"
( Ast0.NeverDep _2 )
# 10170 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_dep =
-# 305 "parser_cocci_menhir.mly"
+# 279 "parser_cocci_menhir.mly"
( Ast0.AndDep(_1, _3) )
# 10204 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_dep =
-# 306 "parser_cocci_menhir.mly"
+# 280 "parser_cocci_menhir.mly"
( Ast0.OrDep (_1, _3) )
# 10238 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_dep =
-# 307 "parser_cocci_menhir.mly"
+# 281 "parser_cocci_menhir.mly"
( _2 )
# 10270 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_depends =
-# 295 "parser_cocci_menhir.mly"
+# 269 "parser_cocci_menhir.mly"
( Ast0.NoDep )
# 10287 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_parents_ in
let _v : 'tv_depends =
-# 296 "parser_cocci_menhir.mly"
+# 270 "parser_cocci_menhir.mly"
( parents )
# 10319 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _2 : 'tv_disj_ident = Obj.magic _2 in
let _1 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 10346 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_designator =
-# 1396 "parser_cocci_menhir.mly"
+# 1384 "parser_cocci_menhir.mly"
( Ast0.DesignatorField (P.clt2mcode "." _1,_2) )
# 10353 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _3 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
# 10384 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_eexpr = Obj.magic _2 in
let _1 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
# 10390 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_designator =
-# 1398 "parser_cocci_menhir.mly"
+# 1386 "parser_cocci_menhir.mly"
( Ast0.DesignatorIndex (P.clt2mcode "[" _1,_2,P.clt2mcode "]" _3) )
# 10397 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _5 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
# 10438 "parser_cocci_menhir.ml"
) = Obj.magic _5 in
let _4 : 'tv_eexpr = Obj.magic _4 in
let _3 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 10444 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_eexpr = Obj.magic _2 in
let _1 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
# 10450 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : 'tv_designator =
-# 1400 "parser_cocci_menhir.mly"
+# 1388 "parser_cocci_menhir.mly"
( Ast0.DesignatorRange (P.clt2mcode "[" _1,_2,P.clt2mcode "..." _3,
_4,P.clt2mcode "]" _5) )
# 10458 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_dexpr =
-# 1483 "parser_cocci_menhir.mly"
+# 1471 "parser_cocci_menhir.mly"
( _1 )
# 10482 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_disable =
-# 313 "parser_cocci_menhir.mly"
+# 287 "parser_cocci_menhir.mly"
( List.map P.id2name _2 )
# 10510 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_disj_ident =
-# 2051 "parser_cocci_menhir.mly"
+# 2039 "parser_cocci_menhir.mly"
( _1 )
# 10534 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 10565 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_midzero_list_disj_ident_disj_ident_ = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 10571 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let _startpos = _startpos_lp_ in
let _endpos = _endpos_rp_ in
let _v : 'tv_disj_ident =
-# 2053 "parser_cocci_menhir.mly"
+# 2041 "parser_cocci_menhir.mly"
( let (mids,code) = t in
Ast0.wrap
(Ast0.DisjId(P.clt2mcode "(" lp,code,mids, P.clt2mcode ")" rp)) )
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 10601 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_dot_expressions =
-# 1493 "parser_cocci_menhir.mly"
+# 1481 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Edots(P.clt2mcode "..." _1,None)) )
# 10608 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_dot_expressions =
-# 1494 "parser_cocci_menhir.mly"
+# 1482 "parser_cocci_menhir.mly"
( _1 )
# 10632 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_dparam =
-# 993 "parser_cocci_menhir.mly"
+# 981 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.DParam _1) )
# 10656 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_eargexpr =
-# 1481 "parser_cocci_menhir.mly"
+# 1469 "parser_cocci_menhir.mly"
( _1 )
# 10680 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 10701 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : 'tv_edots_when_TEllipsis_eexpr_ =
-# 2373 "parser_cocci_menhir.mly"
+# 2361 "parser_cocci_menhir.mly"
( (d,None) )
# 10708 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let w : 'tv_eexpr = Obj.magic w in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 10747 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos__5_ in
let _v : 'tv_edots_when_TEllipsis_eexpr_ =
-# 2374 "parser_cocci_menhir.mly"
+# 2362 "parser_cocci_menhir.mly"
( (d,Some w) )
# 10754 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 10775 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : 'tv_edots_when_TEllipsis_enum_decl_one_ =
-# 2373 "parser_cocci_menhir.mly"
+# 2361 "parser_cocci_menhir.mly"
( (d,None) )
# 10782 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let w : 'tv_enum_decl_one = Obj.magic w in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 10821 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos__5_ in
let _v : 'tv_edots_when_TEllipsis_enum_decl_one_ =
-# 2374 "parser_cocci_menhir.mly"
+# 2362 "parser_cocci_menhir.mly"
( (d,Some w) )
# 10828 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 10849 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : 'tv_edots_when_TEllipsis_initialize_ =
-# 2373 "parser_cocci_menhir.mly"
+# 2361 "parser_cocci_menhir.mly"
( (d,None) )
# 10856 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let w : 'tv_initialize = Obj.magic w in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 10895 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos__5_ in
let _v : 'tv_edots_when_TEllipsis_initialize_ =
-# 2374 "parser_cocci_menhir.mly"
+# 2362 "parser_cocci_menhir.mly"
( (d,Some w) )
# 10902 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 10923 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : 'tv_edots_when_TEllipsis_struct_decl_one_ =
-# 2373 "parser_cocci_menhir.mly"
+# 2361 "parser_cocci_menhir.mly"
( (d,None) )
# 10930 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let w : 'tv_struct_decl_one = Obj.magic w in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
# 10969 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos__5_ in
let _v : 'tv_edots_when_TEllipsis_struct_decl_one_ =
-# 2374 "parser_cocci_menhir.mly"
+# 2362 "parser_cocci_menhir.mly"
( (d,Some w) )
# 10976 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_eexpr =
-# 1480 "parser_cocci_menhir.mly"
+# 1468 "parser_cocci_menhir.mly"
( _1 )
# 11000 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_eexpr_list_option =
-# 2353 "parser_cocci_menhir.mly"
+# 2341 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.DOTS
(_1
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_empty_list_start_aexpr_TEllipsis_ =
-# 2115 "parser_cocci_menhir.mly"
+# 2103 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [] )
# 11045 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_empty_list_start_aexpr_TEllipsis_ =
-# 2116 "parser_cocci_menhir.mly"
+# 2104 "parser_cocci_menhir.mly"
( _1 )
# 11069 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_empty_list_start_dparam_TEllipsis_ =
-# 2115 "parser_cocci_menhir.mly"
+# 2103 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [] )
# 11086 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_empty_list_start_dparam_TEllipsis_ =
-# 2116 "parser_cocci_menhir.mly"
+# 2104 "parser_cocci_menhir.mly"
( _1 )
# 11110 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_empty_list_start_initialize2_edots_when_TEllipsis_initialize__ =
-# 2115 "parser_cocci_menhir.mly"
+# 2103 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [] )
# 11127 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_empty_list_start_initialize2_edots_when_TEllipsis_initialize__ =
-# 2116 "parser_cocci_menhir.mly"
+# 2104 "parser_cocci_menhir.mly"
( _1 )
# 11151 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_empty_list_start_one_dec_decl__TEllipsis_ =
-# 2115 "parser_cocci_menhir.mly"
+# 2103 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [] )
# 11168 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_empty_list_start_one_dec_decl__TEllipsis_ =
-# 2116 "parser_cocci_menhir.mly"
+# 2104 "parser_cocci_menhir.mly"
( _1 )
# 11192 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_empty_list_start_one_dec_name_opt_decl__TEllipsis_ =
-# 2115 "parser_cocci_menhir.mly"
+# 2103 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [] )
# 11209 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_empty_list_start_one_dec_name_opt_decl__TEllipsis_ =
-# 2116 "parser_cocci_menhir.mly"
+# 2104 "parser_cocci_menhir.mly"
( _1 )
# 11233 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_enum_decl_list =
-# 839 "parser_cocci_menhir.mly"
+# 827 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.DOTS(_1 P.mkedots (fun c -> Ast0.EComma c))) )
# 11257 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_enum_decl_one =
-# 810 "parser_cocci_menhir.mly"
+# 798 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Ident(_1)) )
# 11281 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_enum_val = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 11313 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_enum_decl_one =
-# 812 "parser_cocci_menhir.mly"
+# 800 "parser_cocci_menhir.mly"
( let id = Ast0.wrap(Ast0.Ident(_1)) in
Ast0.wrap
(Ast0.Assignment
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_enum_val =
-# 819 "parser_cocci_menhir.mly"
+# 807 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Ident(_1)) )
# 11349 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
# 11370 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_enum_val =
-# 821 "parser_cocci_menhir.mly"
+# 809 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) )
# 11378 "parser_cocci_menhir.ml"
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 11399 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_enum_val =
-# 823 "parser_cocci_menhir.mly"
+# 811 "parser_cocci_menhir.mly"
( tmeta_to_exp _1 )
# 11406 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
# 11427 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_enum_val =
-# 825 "parser_cocci_menhir.mly"
+# 813 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.CONST,pure)) )
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
# 11457 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_enum_val =
-# 829 "parser_cocci_menhir.mly"
+# 817 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ANY,pure)) )
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
# 11487 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_enum_val =
-# 833 "parser_cocci_menhir.mly"
+# 821 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ID,pure)) )
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_exists =
-# 316 "parser_cocci_menhir.mly"
+# 290 "parser_cocci_menhir.mly"
( Ast.Exists )
# 11518 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_exists =
-# 317 "parser_cocci_menhir.mly"
+# 291 "parser_cocci_menhir.mly"
( Ast.Forall )
# 11540 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_exists =
-# 318 "parser_cocci_menhir.mly"
+# 292 "parser_cocci_menhir.mly"
( Ast.Undetermined )
# 11557 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_expr =
-# 1478 "parser_cocci_menhir.mly"
+# 1466 "parser_cocci_menhir.mly"
( _1 )
# 11581 "parser_cocci_menhir.ml"
in
let _startpos = _startpos_r_ in
let _endpos = _endpos_r_ in
let _v : 'tv_expr_dots_TEllipsis_ =
-# 1751 "parser_cocci_menhir.mly"
+# 1739 "parser_cocci_menhir.mly"
( r )
# 11605 "parser_cocci_menhir.ml"
in
let _startpos = _startpos_m_ in
let _endpos = _endpos_m_ in
let _v : 'tv_expression_type =
-# 577 "parser_cocci_menhir.mly"
+# 565 "parser_cocci_menhir.mly"
( P.ty_pointerify Type_cocci.Unknown m )
# 11629 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_m_ in
let _v : 'tv_expression_type =
-# 579 "parser_cocci_menhir.mly"
+# 567 "parser_cocci_menhir.mly"
( P.ty_pointerify (Type_cocci.EnumName Type_cocci.NoName) m )
# 11657 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_m_ in
let _v : 'tv_expression_type =
-# 581 "parser_cocci_menhir.mly"
+# 569 "parser_cocci_menhir.mly"
( P.ty_pointerify
(Type_cocci.StructUnionName (Type_cocci.Struct,Type_cocci.NoName)) m )
# 11686 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos_m_ in
let _v : 'tv_expression_type =
-# 584 "parser_cocci_menhir.mly"
+# 572 "parser_cocci_menhir.mly"
( P.ty_pointerify
(Type_cocci.StructUnionName (Type_cocci.Union,Type_cocci.NoName)) m )
# 11715 "parser_cocci_menhir.ml"
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_extends =
-# 290 "parser_cocci_menhir.mly"
+# 264 "parser_cocci_menhir.mly"
( () )
# 11732 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let parent : (
-# 114 "parser_cocci_menhir.mly"
+# 88 "parser_cocci_menhir.mly"
(string)
# 11757 "parser_cocci_menhir.ml"
) = Obj.magic parent in
let _startpos = _startpos__1_ in
let _endpos = _endpos_parent_ in
let _v : 'tv_extends =
-# 292 "parser_cocci_menhir.mly"
+# 266 "parser_cocci_menhir.mly"
( !Data.install_bindings (parent) )
# 11764 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 155 "parser_cocci_menhir.mly"
+# 129 "parser_cocci_menhir.mly"
(string * Data.clt)
# 11790 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 155 "parser_cocci_menhir.mly"
+# 129 "parser_cocci_menhir.mly"
(string * Data.clt)
# 11795 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_filespec =
-# 876 "parser_cocci_menhir.mly"
+# 864 "parser_cocci_menhir.mly"
( [Ast0.wrap
(Ast0.FILEINFO(P.id2mcode _1,
P.id2mcode _2))] )
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_fn_ident =
-# 2026 "parser_cocci_menhir.mly"
+# 2014 "parser_cocci_menhir.mly"
( _1 )
# 11828 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 131 "parser_cocci_menhir.mly"
+# 105 "parser_cocci_menhir.mly"
(Parse_aux.idinfo)
# 11849 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_fn_ident =
-# 2028 "parser_cocci_menhir.mly"
+# 2016 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaFunc(P.clt2mcode nm clt,constraints,pure)) )
# 11857 "parser_cocci_menhir.ml"
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 131 "parser_cocci_menhir.mly"
+# 105 "parser_cocci_menhir.mly"
(Parse_aux.idinfo)
# 11878 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_fn_ident =
-# 2031 "parser_cocci_menhir.mly"
+# 2019 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,clt) = _1 in
Ast0.wrap
(Ast0.MetaLocalFunc(P.clt2mcode nm clt,constraints,pure)) )
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_fninfo =
-# 1029 "parser_cocci_menhir.mly"
+# 1017 "parser_cocci_menhir.mly"
( [] )
# 11904 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fninfo =
-# 1031 "parser_cocci_menhir.mly"
+# 1019 "parser_cocci_menhir.mly"
( try
let _ =
List.find (function Ast0.FStorage(_) -> true | _ -> false) _2 in
let _startpos = _startpos_t_ in
let _endpos = _endpos_r_ in
let _v : 'tv_fninfo =
-# 1036 "parser_cocci_menhir.mly"
+# 1024 "parser_cocci_menhir.mly"
( (Ast0.FType(t))::r )
# 11968 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _2 : 'tv_fninfo = Obj.magic _2 in
let _1 : (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
# 11995 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fninfo =
-# 1038 "parser_cocci_menhir.mly"
+# 1026 "parser_cocci_menhir.mly"
( try
let _ = List.find (function Ast0.FInline(_) -> true | _ -> false) _2 in
raise (Semantic_cocci.Semantic "duplicate inline")
} = _menhir_stack in
let _2 : 'tv_fninfo = Obj.magic _2 in
let _1 : (
-# 123 "parser_cocci_menhir.mly"
+# 97 "parser_cocci_menhir.mly"
(string * Data.clt)
# 12032 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fninfo =
-# 1043 "parser_cocci_menhir.mly"
+# 1031 "parser_cocci_menhir.mly"
( try
let _ = List.find (function Ast0.FAttr(_) -> true | _ -> false) _2 in
raise (Semantic_cocci.Semantic "multiple attributes")
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_fninfo_nt =
-# 1049 "parser_cocci_menhir.mly"
+# 1037 "parser_cocci_menhir.mly"
( [] )
# 12059 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fninfo_nt =
-# 1051 "parser_cocci_menhir.mly"
+# 1039 "parser_cocci_menhir.mly"
( try
let _ =
List.find (function Ast0.FStorage(_) -> true | _ -> false) _2 in
} = _menhir_stack in
let _2 : 'tv_fninfo_nt = Obj.magic _2 in
let _1 : (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
# 12120 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fninfo_nt =
-# 1057 "parser_cocci_menhir.mly"
+# 1045 "parser_cocci_menhir.mly"
( try
let _ = List.find (function Ast0.FInline(_) -> true | _ -> false) _2 in
raise (Semantic_cocci.Semantic "duplicate inline")
} = _menhir_stack in
let _2 : 'tv_fninfo_nt = Obj.magic _2 in
let _1 : (
-# 123 "parser_cocci_menhir.mly"
+# 97 "parser_cocci_menhir.mly"
(string * Data.clt)
# 12157 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fninfo_nt =
-# 1062 "parser_cocci_menhir.mly"
+# 1050 "parser_cocci_menhir.mly"
( try
let _ = List.find (function Ast0.FAttr(_) -> true | _ -> false) _2 in
raise (Semantic_cocci.Semantic "duplicate init")
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_fun_after_dots =
-# 2286 "parser_cocci_menhir.mly"
+# 2274 "parser_cocci_menhir.mly"
([])
# 12184 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fun_after_dots =
-# 2287 "parser_cocci_menhir.mly"
+# 2275 "parser_cocci_menhir.mly"
(_2)
# 12212 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fun_after_dots =
-# 2288 "parser_cocci_menhir.mly"
+# 2276 "parser_cocci_menhir.mly"
(Ast0.wrap(Ast0.Exp(_1))::_2)
# 12242 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fun_after_dots =
-# 2289 "parser_cocci_menhir.mly"
+# 2277 "parser_cocci_menhir.mly"
(_1@_2)
# 12272 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_fun_after_dots_or =
-# 2296 "parser_cocci_menhir.mly"
+# 2284 "parser_cocci_menhir.mly"
([])
# 12289 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fun_after_dots_or =
-# 2297 "parser_cocci_menhir.mly"
+# 2285 "parser_cocci_menhir.mly"
(_2)
# 12317 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fun_after_dots_or =
-# 2298 "parser_cocci_menhir.mly"
+# 2286 "parser_cocci_menhir.mly"
(Ast0.wrap(Ast0.Exp(_1))::_2)
# 12347 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fun_after_dots_or =
-# 2299 "parser_cocci_menhir.mly"
+# 2287 "parser_cocci_menhir.mly"
(_1@_2)
# 12377 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fun_after_exp =
-# 2292 "parser_cocci_menhir.mly"
+# 2280 "parser_cocci_menhir.mly"
(_1::_2)
# 12407 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_fun_after_exp_or =
-# 2302 "parser_cocci_menhir.mly"
+# 2290 "parser_cocci_menhir.mly"
([])
# 12424 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fun_after_exp_or =
-# 2303 "parser_cocci_menhir.mly"
+# 2291 "parser_cocci_menhir.mly"
(_1::_2)
# 12454 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_fun_after_stm =
-# 2281 "parser_cocci_menhir.mly"
+# 2269 "parser_cocci_menhir.mly"
([])
# 12471 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fun_after_stm =
-# 2282 "parser_cocci_menhir.mly"
+# 2270 "parser_cocci_menhir.mly"
(_1::_2)
# 12501 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_fun_after_stm =
-# 2283 "parser_cocci_menhir.mly"
+# 2271 "parser_cocci_menhir.mly"
(_1@_2)
# 12531 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_fun_start =
-# 2278 "parser_cocci_menhir.mly"
+# 2266 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.DOTS(_1)) )
# 12555 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_func_ident =
-# 2017 "parser_cocci_menhir.mly"
+# 2005 "parser_cocci_menhir.mly"
( _1 )
# 12579 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 131 "parser_cocci_menhir.mly"
+# 105 "parser_cocci_menhir.mly"
(Parse_aux.idinfo)
# 12600 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_func_ident =
-# 2019 "parser_cocci_menhir.mly"
+# 2007 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaFunc(P.clt2mcode nm clt,constraints,pure)) )
# 12608 "parser_cocci_menhir.ml"
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 131 "parser_cocci_menhir.mly"
+# 105 "parser_cocci_menhir.mly"
(Parse_aux.idinfo)
# 12629 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_func_ident =
-# 2022 "parser_cocci_menhir.mly"
+# 2010 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,clt) = _1 in
Ast0.wrap
(Ast0.MetaLocalFunc(P.clt2mcode nm clt,constraints,pure)) )
};
} = _menhir_stack in
let rb : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
# 12698 "parser_cocci_menhir.ml"
) = Obj.magic rb in
let b : 'tv_fun_start = Obj.magic b in
let lb : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
# 12704 "parser_cocci_menhir.ml"
) = Obj.magic lb in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 12709 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let d : 'tv_decl_list_decl_ = Obj.magic d in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 12715 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let _startpos = _startpos_f_ in
let _endpos = _endpos_rb_ in
let _v : 'tv_fundecl =
-# 1020 "parser_cocci_menhir.mly"
+# 1008 "parser_cocci_menhir.mly"
( P.verify_parameter_declarations (Ast0.undots d);
Ast0.wrap(Ast0.FunDecl((Ast0.default_info(),Ast0.context_befaft()),
f, i,
};
} = _menhir_stack in
let pt : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 12776 "parser_cocci_menhir.ml"
) = Obj.magic pt in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 12781 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let d : 'tv_decl_list_name_opt_decl_ = Obj.magic d in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 12787 "parser_cocci_menhir.ml"
) = Obj.magic lp in
in
-# 1008 "parser_cocci_menhir.mly"
+# 996 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.UnInit
(s,
};
} = _menhir_stack in
let pt : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 12860 "parser_cocci_menhir.ml"
) = Obj.magic pt in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
# 12865 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let d : 'tv_decl_list_name_opt_decl_ = Obj.magic d in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 12871 "parser_cocci_menhir.ml"
) = Obj.magic lp in
in
-# 1008 "parser_cocci_menhir.mly"
+# 996 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.UnInit
(s,
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_ident =
-# 2036 "parser_cocci_menhir.mly"
+# 2024 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Id(P.id2mcode _1)) )
# 12919 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_ident =
-# 2037 "parser_cocci_menhir.mly"
+# 2025 "parser_cocci_menhir.mly"
( _1 )
# 12943 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 130 "parser_cocci_menhir.mly"
+# 104 "parser_cocci_menhir.mly"
(Parse_aux.midinfo)
# 12964 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_ident =
-# 2039 "parser_cocci_menhir.mly"
+# 2027 "parser_cocci_menhir.mly"
( let (nm,constraints,seed,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,seed,pure)) )
# 12972 "parser_cocci_menhir.ml"
let _startpos = _startpos_i_ in
let _endpos = _endpos_i_ in
let _v : 'tv_ident_or_const =
-# 1989 "parser_cocci_menhir.mly"
+# 1977 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Ident(Ast0.wrap(Ast0.Id(P.id2mcode i)))) )
# 12996 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_ident_or_const =
-# 1990 "parser_cocci_menhir.mly"
+# 1978 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Ident(_1)) )
# 13020 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
# 13041 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_ident_or_const =
-# 1992 "parser_cocci_menhir.mly"
+# 1980 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) )
# 13049 "parser_cocci_menhir.ml"
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 152 "parser_cocci_menhir.mly"
+# 126 "parser_cocci_menhir.mly"
(string * Data.clt)
# 13070 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_incl =
-# 329 "parser_cocci_menhir.mly"
+# 303 "parser_cocci_menhir.mly"
( let (x,_) = _1 in Data.Include(x) )
# 13077 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
# 13102 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_incl =
-# 330 "parser_cocci_menhir.mly"
+# 304 "parser_cocci_menhir.mly"
( Data.Iso(Common.Left(P.id2name _2)) )
# 13109 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _2 : (
-# 151 "parser_cocci_menhir.mly"
+# 125 "parser_cocci_menhir.mly"
(string)
# 13134 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_incl =
-# 331 "parser_cocci_menhir.mly"
+# 305 "parser_cocci_menhir.mly"
( Data.Iso(Common.Right _2) )
# 13141 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_incl =
-# 333 "parser_cocci_menhir.mly"
+# 307 "parser_cocci_menhir.mly"
( let names = List.map P.id2name _2 in
Iteration.parsed_virtual_rules :=
Common.union_set names !Iteration.parsed_virtual_rules;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 220 "parser_cocci_menhir.mly"
+# 194 "parser_cocci_menhir.mly"
(Data.incl_iso list)
# 13204 "parser_cocci_menhir.ml"
) =
-# 325 "parser_cocci_menhir.mly"
+# 299 "parser_cocci_menhir.mly"
( _1 )
# 13208 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 220 "parser_cocci_menhir.mly"
+# 194 "parser_cocci_menhir.mly"
(Data.incl_iso list)
# 13236 "parser_cocci_menhir.ml"
) =
-# 326 "parser_cocci_menhir.mly"
+# 300 "parser_cocci_menhir.mly"
( _1 )
# 13240 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 152 "parser_cocci_menhir.mly"
+# 126 "parser_cocci_menhir.mly"
(string * Data.clt)
# 13261 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_includes =
-# 882 "parser_cocci_menhir.mly"
+# 870 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.Include(P.clt2mcode "#include"
(P.drop_pos (P.drop_aft (P.id2clt _1))),
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 152 "parser_cocci_menhir.mly"
+# 126 "parser_cocci_menhir.mly"
(string * Data.clt)
# 13298 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_includes =
-# 893 "parser_cocci_menhir.mly"
+# 881 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.Include(P.clt2mcode "#include"
(P.drop_pos (P.drop_aft (P.id2clt _1))),
};
} = _menhir_stack in
let _1 : (
-# 153 "parser_cocci_menhir.mly"
+# 127 "parser_cocci_menhir.mly"
(Data.clt * token)
# 13339 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_includes =
-# 904 "parser_cocci_menhir.mly"
+# 892 "parser_cocci_menhir.mly"
( let (clt,ident) = _1 in
let aft = P.get_aft clt in (* move stuff after the define to the ident *)
Ast0.wrap
let _startpos = _startpos_d_ in
let _endpos = _endpos__2_ in
let _v : 'tv_includes =
-# 924 "parser_cocci_menhir.mly"
+# 912 "parser_cocci_menhir.mly"
( d (Ast0.wrap(Ast0.DOTS([]))) )
# 13392 "parser_cocci_menhir.ml"
in
let _startpos = _startpos_d_ in
let _endpos = _endpos__3_ in
let _v : 'tv_includes =
-# 926 "parser_cocci_menhir.mly"
+# 914 "parser_cocci_menhir.mly"
( let ty = Ast0.wrap(Ast0.TopExp(Ast0.wrap(Ast0.TypeExp(t)))) in
d (Ast0.wrap(Ast0.DOTS([ty]))) )
# 13427 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_includes =
-# 929 "parser_cocci_menhir.mly"
+# 917 "parser_cocci_menhir.mly"
( let body =
match b with
[e] ->
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_initialize =
-# 1352 "parser_cocci_menhir.mly"
+# 1340 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.InitExpr(_1)) )
# 13493 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _3 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
# 13524 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_initialize_list = Obj.magic _2 in
let _1 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
# 13530 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_initialize =
-# 1354 "parser_cocci_menhir.mly"
+# 1342 "parser_cocci_menhir.mly"
( if P.struct_initializer _2
then
let il = P.drop_dot_commas _2 in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 13563 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_initialize =
-# 1361 "parser_cocci_menhir.mly"
+# 1349 "parser_cocci_menhir.mly"
(let (nm,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaInit(P.clt2mcode nm clt,pure)) )
# 13571 "parser_cocci_menhir.ml"
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_initialize2 =
-# 1367 "parser_cocci_menhir.mly"
+# 1355 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.InitExpr(_1)) )
# 13595 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_initialize2 =
-# 1368 "parser_cocci_menhir.mly"
+# 1356 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.InitExpr(_1)) )
# 13619 "parser_cocci_menhir.ml"
in
};
} = _menhir_stack in
let _3 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
# 13650 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_initialize_list = Obj.magic _2 in
let _1 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
# 13656 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_initialize2 =
-# 1370 "parser_cocci_menhir.mly"
+# 1358 "parser_cocci_menhir.mly"
( if P.struct_initializer _2
then
let il = P.drop_dot_commas _2 in
} = _menhir_stack in
let _3 : 'tv_initialize2 = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
# 13700 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_initialize2 =
-# 1378 "parser_cocci_menhir.mly"
+# 1366 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.InitGccExt(_1,P.clt2mcode "=" _2,_3)) )
# 13708 "parser_cocci_menhir.ml"
in
} = _menhir_stack in
let _3 : 'tv_initialize2 = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
# 13740 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_initialize2 =
-# 1380 "parser_cocci_menhir.mly"
+# 1368 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.InitGccName(_1,P.clt2mcode ":" _2,_3)) )
# 13748 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
# 13769 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_initialize2 =
-# 1382 "parser_cocci_menhir.mly"
+# 1370 "parser_cocci_menhir.mly"
(let (nm,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaInit(P.clt2mcode nm clt,pure)) )
# 13777 "parser_cocci_menhir.ml"
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 136 "parser_cocci_menhir.mly"
+# 110 "parser_cocci_menhir.mly"
(Parse_aux.list_info)
# 13798 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_initialize2 =
-# 1385 "parser_cocci_menhir.mly"
+# 1373 "parser_cocci_menhir.mly"
(let (nm,lenname,pure,clt) = _1 in
let nm = P.clt2mcode nm clt in
let lenname =
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_initialize_list =
-# 1405 "parser_cocci_menhir.mly"
+# 1393 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.DOTS(_1 P.mkidots (fun c -> Ast0.IComma c))) )
# 13836 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_invalid =
-# 1490 "parser_cocci_menhir.mly"
+# 1478 "parser_cocci_menhir.mly"
( raise (Semantic_cocci.Semantic "not matchable") )
# 13858 "parser_cocci_menhir.ml"
in
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_is_expression =
-# 321 "parser_cocci_menhir.mly"
+# 295 "parser_cocci_menhir.mly"
( false )
# 13875 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_is_expression =
-# 322 "parser_cocci_menhir.mly"
+# 296 "parser_cocci_menhir.mly"
( true )
# 13897 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_t_ in
let _v : 'tv_iso_ctype_ =
-# 2429 "parser_cocci_menhir.mly"
+# 2417 "parser_cocci_menhir.mly"
( Common.Left t )
# 13925 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_t_ in
let _v : 'tv_iso_ctype_ =
-# 2430 "parser_cocci_menhir.mly"
+# 2418 "parser_cocci_menhir.mly"
( Common.Right t )
# 13953 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_t_ in
let _v : 'tv_iso_decl_var_ =
-# 2429 "parser_cocci_menhir.mly"
+# 2417 "parser_cocci_menhir.mly"
( Common.Left t )
# 13981 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_t_ in
let _v : 'tv_iso_decl_var_ =
-# 2430 "parser_cocci_menhir.mly"
+# 2418 "parser_cocci_menhir.mly"
( Common.Right t )
# 14009 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_t_ in
let _v : 'tv_iso_eexpr_ =
-# 2429 "parser_cocci_menhir.mly"
+# 2417 "parser_cocci_menhir.mly"
( Common.Left t )
# 14037 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_t_ in
let _v : 'tv_iso_eexpr_ =
-# 2430 "parser_cocci_menhir.mly"
+# 2418 "parser_cocci_menhir.mly"
( Common.Right t )
# 14065 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_t_ in
let _v : 'tv_iso_iso_statement_ =
-# 2429 "parser_cocci_menhir.mly"
+# 2417 "parser_cocci_menhir.mly"
( Common.Left t )
# 14093 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_t_ in
let _v : 'tv_iso_iso_statement_ =
-# 2430 "parser_cocci_menhir.mly"
+# 2418 "parser_cocci_menhir.mly"
( Common.Right t )
# 14121 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_t_ in
let _v : 'tv_iso_nest_start_ =
-# 2429 "parser_cocci_menhir.mly"
+# 2417 "parser_cocci_menhir.mly"
( Common.Left t )
# 14149 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos_t_ in
let _v : 'tv_iso_nest_start_ =
-# 2430 "parser_cocci_menhir.mly"
+# 2418 "parser_cocci_menhir.mly"
( Common.Right t )
# 14177 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (
-# 236 "parser_cocci_menhir.mly"
+# 210 "parser_cocci_menhir.mly"
(Ast0_cocci.anything list list)
# 14215 "parser_cocci_menhir.ml"
) =
-# 2397 "parser_cocci_menhir.mly"
+# 2385 "parser_cocci_menhir.mly"
( let fn x = Ast0.ExprTag x in P.iso_adjust fn fn e1 el )
# 14219 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (
-# 236 "parser_cocci_menhir.mly"
+# 210 "parser_cocci_menhir.mly"
(Ast0_cocci.anything list list)
# 14257 "parser_cocci_menhir.ml"
) =
-# 2399 "parser_cocci_menhir.mly"
+# 2387 "parser_cocci_menhir.mly"
( let fn x = Ast0.ArgExprTag x in P.iso_adjust fn fn e1 el )
# 14261 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (
-# 236 "parser_cocci_menhir.mly"
+# 210 "parser_cocci_menhir.mly"
(Ast0_cocci.anything list list)
# 14299 "parser_cocci_menhir.ml"
) =
-# 2401 "parser_cocci_menhir.mly"
+# 2389 "parser_cocci_menhir.mly"
( let fn x = Ast0.TestExprTag x in P.iso_adjust fn fn e1 el )
# 14303 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (
-# 236 "parser_cocci_menhir.mly"
+# 210 "parser_cocci_menhir.mly"
(Ast0_cocci.anything list list)
# 14341 "parser_cocci_menhir.ml"
) =
-# 2403 "parser_cocci_menhir.mly"
+# 2391 "parser_cocci_menhir.mly"
( let ffn x = Ast0.ExprTag x in
let fn x = Ast0.TestExprTag x in
P.iso_adjust ffn fn e1 el )
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (
-# 236 "parser_cocci_menhir.mly"
+# 210 "parser_cocci_menhir.mly"
(Ast0_cocci.anything list list)
# 14385 "parser_cocci_menhir.ml"
) =
-# 2407 "parser_cocci_menhir.mly"
+# 2395 "parser_cocci_menhir.mly"
( let fn x = Ast0.StmtTag x in P.iso_adjust fn fn s1 sl )
# 14389 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (
-# 236 "parser_cocci_menhir.mly"
+# 210 "parser_cocci_menhir.mly"
(Ast0_cocci.anything list list)
# 14427 "parser_cocci_menhir.ml"
) =
-# 2409 "parser_cocci_menhir.mly"
+# 2397 "parser_cocci_menhir.mly"
( let fn x = Ast0.TypeCTag x in P.iso_adjust fn fn t1 tl )
# 14431 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (
-# 236 "parser_cocci_menhir.mly"
+# 210 "parser_cocci_menhir.mly"
(Ast0_cocci.anything list list)
# 14469 "parser_cocci_menhir.ml"
) =
-# 2411 "parser_cocci_menhir.mly"
+# 2399 "parser_cocci_menhir.mly"
( let fn x = Ast0.DotsStmtTag x in P.iso_adjust fn fn e1 el )
# 14473 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : (
-# 236 "parser_cocci_menhir.mly"
+# 210 "parser_cocci_menhir.mly"
(Ast0_cocci.anything list list)
# 14511 "parser_cocci_menhir.ml"
) =
-# 2413 "parser_cocci_menhir.mly"
+# 2401 "parser_cocci_menhir.mly"
( let check_one = function
[x] -> x
| _ ->
let _startpos = _startpos_m_ in
let _endpos = _endpos_m_ in
let _v : (
-# 239 "parser_cocci_menhir.mly"
+# 213 "parser_cocci_menhir.mly"
((Ast_cocci.metavar,Ast_cocci.metavar) Common.either list)
# 14552 "parser_cocci_menhir.ml"
) =
-# 256 "parser_cocci_menhir.mly"
+# 230 "parser_cocci_menhir.mly"
( m "" )
# 14556 "parser_cocci_menhir.ml"
in
let _startpos = _startpos_nm_ in
let _endpos = _endpos__2_ in
let _v : (
-# 223 "parser_cocci_menhir.mly"
+# 197 "parser_cocci_menhir.mly"
(Ast_cocci.rulename)
# 14584 "parser_cocci_menhir.ml"
) =
-# 271 "parser_cocci_menhir.mly"
+# 245 "parser_cocci_menhir.mly"
( P.make_iso_rule_name_result (P.id2name nm) )
# 14588 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_iso_statement =
-# 1195 "parser_cocci_menhir.mly"
+# 1183 "parser_cocci_menhir.mly"
( _1 )
# 14612 "parser_cocci_menhir.ml"
in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_iso_statement =
-# 1197 "parser_cocci_menhir.mly"
+# 1185 "parser_cocci_menhir.mly"
( match _1 with
[decl] ->
Ast0.wrap
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
# 14661 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_iter_ident =
-# 2070 "parser_cocci_menhir.mly"
+# 2058 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Id(P.id2mcode _1)) )
# 14668 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 132 "parser_cocci_menhir.mly"
+# 106 "parser_cocci_menhir.mly"
(Parse_aux.idinfo)
# 14689 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_iter_ident =
-# 2072 "parser_cocci_menhir.mly"
+# 2060 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,Ast.NoVal,pure)) )
# 14697 "parser_cocci_menhir.ml"
} = _menhir_stack in
let xs : 'tv_list_TMul_ = Obj.magic xs in
let x : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
# 14741 "parser_cocci_menhir.ml"
) = Obj.magic x in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_list_len =
-# 425 "parser_cocci_menhir.mly"
+# 399 "parser_cocci_menhir.mly"
( Common.Left _1 )
# 15821 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
# 15842 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_list_len =
-# 426 "parser_cocci_menhir.mly"
+# 400 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in Common.Right (int_of_string x) )
# 15849 "parser_cocci_menhir.ml"
in
MenhirLib.EngineTypes.endp = _endpos;
MenhirLib.EngineTypes.next = _menhir_stack;
});
+ (fun _menhir_env ->
+ let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
+ let {
+ MenhirLib.EngineTypes.semv = _3;
+ MenhirLib.EngineTypes.startp = _startpos__3_;
+ MenhirLib.EngineTypes.endp = _endpos__3_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.startp = _startpos__2_;
+ MenhirLib.EngineTypes.endp = _endpos__2_;
+ MenhirLib.EngineTypes.next = {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.startp = _startpos__1_;
+ MenhirLib.EngineTypes.endp = _endpos__1_;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ };
+ };
+ } = _menhir_stack in
+ let _3 : 'tv_pure_ident = Obj.magic _3 in
+ let _startpos = _startpos__1_ in
+ let _endpos = _endpos__3_ in
+ let _v : 'tv_list_len =
+# 402 "parser_cocci_menhir.mly"
+ ( let nm = ("virtual",P.id2name _3) in
+ Iteration.parsed_virtual_identifiers :=
+ Common.union_set [snd nm]
+ !Iteration.parsed_virtual_identifiers;
+ try
+ Common.Right (int_of_string
+ (List.assoc (snd nm) !Flag.defined_virtual_env))
+ with Not_found | Failure "int_of_string" ->
+ begin
+ Common.Left (Some "virtual",P.id2name _3)
+ end
+ )
+# 15892 "parser_cocci_menhir.ml"
+ in
+ _menhir_env.MenhirLib.EngineTypes.stack <- {
+ MenhirLib.EngineTypes.state = _menhir_s;
+ MenhirLib.EngineTypes.semv = Obj.repr _v;
+ MenhirLib.EngineTypes.startp = _startpos;
+ MenhirLib.EngineTypes.endp = _endpos;
+ MenhirLib.EngineTypes.next = _menhir_stack;
+ });
(fun _menhir_env ->
let _menhir_stack = _menhir_env.MenhirLib.EngineTypes.stack in
let _menhir_s = _menhir_env.MenhirLib.EngineTypes.current in
let _v : 'tv_loption_choose_iso_ =
# 57 "standard.mly"
( [] )
-# 15866 "parser_cocci_menhir.ml"
+# 15909 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_loption_choose_iso_ =
# 59 "standard.mly"
( x )
-# 15890 "parser_cocci_menhir.ml"
+# 15933 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_loption_disable_ =
# 57 "standard.mly"
( [] )
-# 15907 "parser_cocci_menhir.ml"
+# 15950 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_loption_disable_ =
# 59 "standard.mly"
( x )
-# 15931 "parser_cocci_menhir.ml"
+# 15974 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_loption_filespec_ =
# 57 "standard.mly"
( [] )
-# 15948 "parser_cocci_menhir.ml"
+# 15991 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_loption_filespec_ =
# 59 "standard.mly"
( x )
-# 15972 "parser_cocci_menhir.ml"
+# 16015 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_loption_minus_start_ =
# 57 "standard.mly"
( [] )
-# 15989 "parser_cocci_menhir.ml"
+# 16032 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_loption_minus_start_ =
# 59 "standard.mly"
( x )
-# 16013 "parser_cocci_menhir.ml"
+# 16056 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_loption_not_pos_ =
# 57 "standard.mly"
( [] )
-# 16030 "parser_cocci_menhir.ml"
+# 16073 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_loption_not_pos_ =
# 59 "standard.mly"
( x )
-# 16054 "parser_cocci_menhir.ml"
+# 16097 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_loption_plus_start_ =
# 57 "standard.mly"
( [] )
-# 16071 "parser_cocci_menhir.ml"
+# 16114 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_loption_plus_start_ =
# 59 "standard.mly"
( x )
-# 16095 "parser_cocci_menhir.ml"
+# 16138 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 16116 "parser_cocci_menhir.ml"
+# 16159 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_mctype =
-# 743 "parser_cocci_menhir.mly"
+# 731 "parser_cocci_menhir.mly"
( tmeta_to_type _1 )
-# 16123 "parser_cocci_menhir.ml"
+# 16166 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_mctype =
-# 744 "parser_cocci_menhir.mly"
+# 732 "parser_cocci_menhir.mly"
(_1)
-# 16147 "parser_cocci_menhir.ml"
+# 16190 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_t_ in
let _endpos = _endpos_t_ in
let _v : 'tv_meta_exp_type =
-# 621 "parser_cocci_menhir.mly"
+# 609 "parser_cocci_menhir.mly"
( [Ast0_cocci.ast0_type_to_type t] )
-# 16171 "parser_cocci_menhir.ml"
+# 16214 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_t_ in
let _endpos = _endpos__3_ in
let _v : 'tv_meta_exp_type =
-# 623 "parser_cocci_menhir.mly"
+# 611 "parser_cocci_menhir.mly"
( [Type_cocci.Array (Ast0_cocci.ast0_type_to_type t)] )
-# 16203 "parser_cocci_menhir.ml"
+# 16246 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_m_ in
let _v : 'tv_meta_exp_type =
-# 625 "parser_cocci_menhir.mly"
+# 613 "parser_cocci_menhir.mly"
( List.map
(function x -> P.ty_pointerify (Ast0_cocci.ast0_type_to_type x) m)
t )
-# 16243 "parser_cocci_menhir.ml"
+# 16286 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_pure_ident = Obj.magic _3 in
let _1 : (
-# 114 "parser_cocci_menhir.mly"
+# 88 "parser_cocci_menhir.mly"
(string)
-# 16274 "parser_cocci_menhir.ml"
+# 16317 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_meta_ident =
-# 1794 "parser_cocci_menhir.mly"
+# 1782 "parser_cocci_menhir.mly"
( (Some _1,P.id2name _3) )
-# 16281 "parser_cocci_menhir.ml"
+# 16324 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_pure_ident_kwd = Obj.magic _3 in
let _1 : (
-# 114 "parser_cocci_menhir.mly"
+# 88 "parser_cocci_menhir.mly"
(string)
-# 16312 "parser_cocci_menhir.ml"
+# 16355 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_meta_ident =
-# 1795 "parser_cocci_menhir.mly"
+# 1783 "parser_cocci_menhir.mly"
( (Some _1,_3) )
-# 16319 "parser_cocci_menhir.ml"
+# 16362 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_m_ in
let _endpos = _endpos_m_ in
let _v : (
-# 231 "parser_cocci_menhir.mly"
+# 205 "parser_cocci_menhir.mly"
((Ast_cocci.metavar,Ast_cocci.metavar) Common.either list)
-# 16343 "parser_cocci_menhir.ml"
+# 16386 "parser_cocci_menhir.ml"
) =
-# 255 "parser_cocci_menhir.mly"
+# 229 "parser_cocci_menhir.mly"
( m (!Ast0.rule_name) )
-# 16347 "parser_cocci_menhir.ml"
+# 16390 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 437 "parser_cocci_menhir.mly"
+# 425 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let tok = check_meta(Ast.MetaMetaDecl(arity,name)) in
!Data.add_meta_meta name pure; tok) )
-# 16394 "parser_cocci_menhir.ml"
+# 16437 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 16400 "parser_cocci_menhir.ml"
+# 16443 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 441 "parser_cocci_menhir.mly"
+# 429 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let tok = check_meta(Ast.MetaParamDecl(arity,name)) in
!Data.add_param_meta name pure; tok) )
-# 16447 "parser_cocci_menhir.ml"
+# 16490 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 16453 "parser_cocci_menhir.ml"
+# 16496 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__6_ in
let _v : 'tv_metadec = let kindfn =
-# 445 "parser_cocci_menhir.mly"
+# 433 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let len = Ast.AnyLen in
let tok = check_meta(Ast.MetaParamListDecl(arity,name,len)) in
!Data.add_paramlist_meta name len pure; tok) )
-# 16505 "parser_cocci_menhir.ml"
+# 16548 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 16511 "parser_cocci_menhir.ml"
+# 16554 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__6_ in
let _v : 'tv_metadec = let kindfn =
-# 450 "parser_cocci_menhir.mly"
+# 438 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let len = Ast.AnyLen in
let tok = check_meta(Ast.MetaExpListDecl(arity,name,len)) in
!Data.add_explist_meta name len pure; tok) )
-# 16563 "parser_cocci_menhir.ml"
+# 16606 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 16569 "parser_cocci_menhir.ml"
+# 16612 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 455 "parser_cocci_menhir.mly"
+# 443 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let tok = check_meta(Ast.MetaTypeDecl(arity,name)) in
!Data.add_type_meta name pure; tok) )
-# 16616 "parser_cocci_menhir.ml"
+# 16659 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 16622 "parser_cocci_menhir.ml"
+# 16665 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 459 "parser_cocci_menhir.mly"
+# 447 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let tok = check_meta(Ast.MetaInitDecl(arity,name)) in
!Data.add_init_meta name pure; tok) )
-# 16669 "parser_cocci_menhir.ml"
+# 16712 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 16675 "parser_cocci_menhir.ml"
+# 16718 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__6_ in
let _v : 'tv_metadec = let kindfn =
-# 463 "parser_cocci_menhir.mly"
+# 451 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let len = Ast.AnyLen in
let tok = check_meta(Ast.MetaInitListDecl(arity,name,len)) in
!Data.add_initlist_meta name len pure; tok) )
-# 16727 "parser_cocci_menhir.ml"
+# 16770 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 16733 "parser_cocci_menhir.ml"
+# 16776 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 468 "parser_cocci_menhir.mly"
+# 456 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let tok = check_meta(Ast.MetaStmDecl(arity,name)) in
!Data.add_stm_meta name pure; tok) )
-# 16780 "parser_cocci_menhir.ml"
+# 16823 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 16786 "parser_cocci_menhir.ml"
+# 16829 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 472 "parser_cocci_menhir.mly"
+# 460 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let tok = check_meta(Ast.MetaDeclDecl(arity,name)) in
!Data.add_decl_meta name pure; tok) )
-# 16833 "parser_cocci_menhir.ml"
+# 16876 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 16839 "parser_cocci_menhir.ml"
+# 16882 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 476 "parser_cocci_menhir.mly"
+# 464 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let tok = check_meta(Ast.MetaFieldDecl(arity,name)) in
!Data.add_field_meta name pure; tok) )
-# 16886 "parser_cocci_menhir.ml"
+# 16929 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 16892 "parser_cocci_menhir.ml"
+# 16935 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__6_ in
let _v : 'tv_metadec = let kindfn =
-# 480 "parser_cocci_menhir.mly"
+# 468 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let len = Ast.AnyLen in
let tok = check_meta(Ast.MetaFieldListDecl(arity,name,len)) in
!Data.add_field_list_meta name len pure; tok) )
-# 16944 "parser_cocci_menhir.ml"
+# 16987 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 16950 "parser_cocci_menhir.ml"
+# 16993 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__6_ in
let _v : 'tv_metadec = let kindfn =
-# 485 "parser_cocci_menhir.mly"
+# 473 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta ->
let tok = check_meta(Ast.MetaStmListDecl(arity,name)) in
!Data.add_stmlist_meta name pure; tok) )
-# 17001 "parser_cocci_menhir.ml"
+# 17044 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 17007 "parser_cocci_menhir.ml"
+# 17050 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 489 "parser_cocci_menhir.mly"
+# 477 "parser_cocci_menhir.mly"
( (fun arity (_,name) pure check_meta ->
if arity = Ast.NONE && pure = Ast0.Impure
then (!Data.add_type_name name; [])
else raise (Semantic_cocci.Semantic "bad typedef")) )
-# 17055 "parser_cocci_menhir.ml"
+# 17098 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 17061 "parser_cocci_menhir.ml"
+# 17104 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__6_ in
let _v : 'tv_metadec = let kindfn =
-# 494 "parser_cocci_menhir.mly"
+# 482 "parser_cocci_menhir.mly"
( (fun arity (_,name) pure check_meta ->
if arity = Ast.NONE && pure = Ast0.Impure
then (!Data.add_declarer_name name; [])
else raise (Semantic_cocci.Semantic "bad declarer")) )
-# 17113 "parser_cocci_menhir.ml"
+# 17156 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 17119 "parser_cocci_menhir.ml"
+# 17162 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__6_ in
let _v : 'tv_metadec = let kindfn =
-# 499 "parser_cocci_menhir.mly"
+# 487 "parser_cocci_menhir.mly"
( (fun arity (_,name) pure check_meta ->
if arity = Ast.NONE && pure = Ast0.Impure
then (!Data.add_iterator_name name; [])
else raise (Semantic_cocci.Semantic "bad iterator")) )
-# 17171 "parser_cocci_menhir.ml"
+# 17214 "parser_cocci_menhir.ml"
in
-# 345 "parser_cocci_menhir.mly"
+# 319 "parser_cocci_menhir.mly"
( P.create_metadec ar ispure kindfn ids )
-# 17177 "parser_cocci_menhir.ml"
+# 17220 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__4_ in
let _v : 'tv_metadec = let kindfn =
-# 430 "parser_cocci_menhir.mly"
+# 418 "parser_cocci_menhir.mly"
( (fun name check_meta seed ->
let tok = check_meta(Ast.MetaFreshIdDecl(name,seed)) in
!Data.add_fresh_id_meta name seed; tok) )
-# 17216 "parser_cocci_menhir.ml"
+# 17259 "parser_cocci_menhir.ml"
in
-# 348 "parser_cocci_menhir.mly"
+# 322 "parser_cocci_menhir.mly"
( P.create_fresh_metadec kindfn ids )
-# 17222 "parser_cocci_menhir.ml"
+# 17265 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 506 "parser_cocci_menhir.mly"
+# 494 "parser_cocci_menhir.mly"
(
let idfn arity name pure check_meta constraints =
let tok = check_meta(Ast.MetaIdDecl(arity,name)) in
let tok = check_meta(Ast.MetaIdDecl(arity,name)) in
!Data.add_virt_id_meta_not_found name pure; tok in
(idfn,virtfn) )
-# 17282 "parser_cocci_menhir.ml"
+# 17325 "parser_cocci_menhir.ml"
in
-# 354 "parser_cocci_menhir.mly"
+# 328 "parser_cocci_menhir.mly"
( let (normal,virt) = Common.partition_either (fun x -> x) ids in
let (idfn,virtfn) = kindfn in
function cr ->
(P.create_metadec_with_constraints ar ispure idfn normal cr) @
(P.create_metadec_virt ar ispure virtfn virt cr) )
-# 17292 "parser_cocci_menhir.ml"
+# 17335 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 525 "parser_cocci_menhir.mly"
+# 513 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
let tok = check_meta(Ast.MetaFuncDecl(arity,name)) in
!Data.add_func_meta name constraints pure; tok) )
-# 17339 "parser_cocci_menhir.ml"
+# 17382 "parser_cocci_menhir.ml"
in
-# 363 "parser_cocci_menhir.mly"
+# 337 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 17345 "parser_cocci_menhir.ml"
+# 17388 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__6_ in
let _v : 'tv_metadec = let kindfn =
-# 529 "parser_cocci_menhir.mly"
+# 517 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
let tok = check_meta(Ast.MetaLocalFuncDecl(arity,name)) in
!Data.add_local_func_meta name constraints pure;
tok) )
-# 17397 "parser_cocci_menhir.ml"
+# 17440 "parser_cocci_menhir.ml"
in
-# 363 "parser_cocci_menhir.mly"
+# 337 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 17403 "parser_cocci_menhir.ml"
+# 17446 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 534 "parser_cocci_menhir.mly"
+# 522 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
let tok = check_meta(Ast.MetaDeclarerDecl(arity,name)) in
!Data.add_declarer_meta name constraints pure; tok) )
-# 17450 "parser_cocci_menhir.ml"
+# 17493 "parser_cocci_menhir.ml"
in
-# 363 "parser_cocci_menhir.mly"
+# 337 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 17456 "parser_cocci_menhir.ml"
+# 17499 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 538 "parser_cocci_menhir.mly"
+# 526 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
let tok = check_meta(Ast.MetaIteratorDecl(arity,name)) in
!Data.add_iterator_meta name constraints pure; tok) )
-# 17503 "parser_cocci_menhir.ml"
+# 17546 "parser_cocci_menhir.ml"
in
-# 363 "parser_cocci_menhir.mly"
+# 337 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 17509 "parser_cocci_menhir.ml"
+# 17552 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 544 "parser_cocci_menhir.mly"
+# 532 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
let tok = check_meta(Ast.MetaErrDecl(arity,name)) in
!Data.add_err_meta name constraints pure; tok) )
-# 17556 "parser_cocci_menhir.ml"
+# 17599 "parser_cocci_menhir.ml"
in
-# 368 "parser_cocci_menhir.mly"
+# 342 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 17562 "parser_cocci_menhir.ml"
+# 17605 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
# 39 "standard.mly"
( None )
-# 17615 "parser_cocci_menhir.ml"
+# 17658 "parser_cocci_menhir.ml"
in
-# 548 "parser_cocci_menhir.mly"
+# 536 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
match l with
None ->
| Some _ ->
!Data.add_local_idexp_meta ty name constraints pure;
check_meta(Ast.MetaLocalIdExpDecl(arity,name,ty))) )
-# 17628 "parser_cocci_menhir.ml"
+# 17671 "parser_cocci_menhir.ml"
in
-# 368 "parser_cocci_menhir.mly"
+# 342 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 17634 "parser_cocci_menhir.ml"
+# 17677 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
# 41 "standard.mly"
( Some x )
-# 17695 "parser_cocci_menhir.ml"
+# 17738 "parser_cocci_menhir.ml"
in
-# 548 "parser_cocci_menhir.mly"
+# 536 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
match l with
None ->
| Some _ ->
!Data.add_local_idexp_meta ty name constraints pure;
check_meta(Ast.MetaLocalIdExpDecl(arity,name,ty))) )
-# 17708 "parser_cocci_menhir.ml"
+# 17751 "parser_cocci_menhir.ml"
in
-# 368 "parser_cocci_menhir.mly"
+# 342 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 17714 "parser_cocci_menhir.ml"
+# 17757 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let m = m0 in
let l = l0 in
-# 557 "parser_cocci_menhir.mly"
+# 545 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
let ty = Some [P.ty_pointerify Type_cocci.Unknown m] in
match l with
| Some _ ->
!Data.add_local_idexp_meta ty name constraints pure;
check_meta(Ast.MetaLocalIdExpDecl(arity,name,ty))) )
-# 17781 "parser_cocci_menhir.ml"
+# 17824 "parser_cocci_menhir.ml"
in
-# 368 "parser_cocci_menhir.mly"
+# 342 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 17787 "parser_cocci_menhir.ml"
+# 17830 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_metadec = let kindfn =
let ty = ty0 in
-# 567 "parser_cocci_menhir.mly"
+# 555 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
let ty = Some [ty] in
let tok = check_meta(Ast.MetaExpDecl(arity,name,ty)) in
!Data.add_exp_meta ty name constraints pure; tok) )
-# 17842 "parser_cocci_menhir.ml"
+# 17885 "parser_cocci_menhir.ml"
in
-# 368 "parser_cocci_menhir.mly"
+# 342 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 17848 "parser_cocci_menhir.ml"
+# 17891 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
# 39 "standard.mly"
( None )
-# 17894 "parser_cocci_menhir.ml"
+# 17937 "parser_cocci_menhir.ml"
in
-# 572 "parser_cocci_menhir.mly"
+# 560 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
let tok = check_meta(Ast.MetaConstDecl(arity,name,ty)) in
!Data.add_const_meta ty name constraints pure; tok) )
-# 17902 "parser_cocci_menhir.ml"
+# 17945 "parser_cocci_menhir.ml"
in
-# 368 "parser_cocci_menhir.mly"
+# 342 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 17908 "parser_cocci_menhir.ml"
+# 17951 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
# 41 "standard.mly"
( Some x )
-# 17962 "parser_cocci_menhir.ml"
+# 18005 "parser_cocci_menhir.ml"
in
-# 572 "parser_cocci_menhir.mly"
+# 560 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
let tok = check_meta(Ast.MetaConstDecl(arity,name,ty)) in
!Data.add_const_meta ty name constraints pure; tok) )
-# 17970 "parser_cocci_menhir.ml"
+# 18013 "parser_cocci_menhir.ml"
in
-# 368 "parser_cocci_menhir.mly"
+# 342 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 17976 "parser_cocci_menhir.ml"
+# 18019 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _endpos = _endpos__5_ in
let _v : 'tv_metadec = let kindfn =
-# 590 "parser_cocci_menhir.mly"
+# 578 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
let tok = check_meta(Ast.MetaExpDecl(arity,name,None)) in
!Data.add_exp_meta None name constraints pure; tok) )
-# 18023 "parser_cocci_menhir.ml"
+# 18066 "parser_cocci_menhir.ml"
in
-# 373 "parser_cocci_menhir.mly"
+# 347 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 18029 "parser_cocci_menhir.ml"
+# 18072 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_metadec = let kindfn =
let vl = vl0 in
-# 594 "parser_cocci_menhir.mly"
+# 582 "parser_cocci_menhir.mly"
( (fun arity name pure check_meta constraints ->
let ty = Some vl in
(match constraints with
let tok = check_meta(Ast.MetaExpDecl(arity,name,ty)) in
!Data.add_exp_meta ty name constraints pure; tok)
)
-# 18100 "parser_cocci_menhir.ml"
+# 18143 "parser_cocci_menhir.ml"
in
-# 373 "parser_cocci_menhir.mly"
+# 347 "parser_cocci_menhir.mly"
( P.create_metadec_with_constraints ar ispure kindfn ids )
-# 18106 "parser_cocci_menhir.ml"
+# 18149 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_ar_ in
let _endpos = _endpos__5_ in
let _v : 'tv_metadec =
-# 379 "parser_cocci_menhir.mly"
+# 353 "parser_cocci_menhir.mly"
( (if !Data.in_generating
then failwith "position variables not allowed in a generated rule file");
let kindfn arity name pure check_meta constraints =
let any = match a with None -> Ast.PER | Some _ -> Ast.ALL in
!Data.add_pos_meta name constraints any; tok in
P.create_metadec_with_constraints ar false kindfn ids )
-# 18156 "parser_cocci_menhir.ml"
+# 18199 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_ar_ in
let _endpos = _endpos__9_ in
let _v : 'tv_metadec =
-# 389 "parser_cocci_menhir.mly"
+# 363 "parser_cocci_menhir.mly"
( P.create_len_metadec ar ispure
(fun lenname arity name pure check_meta ->
let tok = check_meta(Ast.MetaParamListDecl(arity,name,lenname)) in
!Data.add_paramlist_meta name lenname pure; tok)
len ids )
-# 18222 "parser_cocci_menhir.ml"
+# 18265 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_ar_ in
let _endpos = _endpos__9_ in
let _v : 'tv_metadec =
-# 397 "parser_cocci_menhir.mly"
+# 371 "parser_cocci_menhir.mly"
( P.create_len_metadec ar ispure
(fun lenname arity name pure check_meta ->
let tok = check_meta(Ast.MetaExpListDecl(arity,name,lenname)) in
!Data.add_explist_meta name lenname pure; tok)
len ids )
-# 18288 "parser_cocci_menhir.ml"
+# 18331 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_ar_ in
let _endpos = _endpos__9_ in
let _v : 'tv_metadec =
-# 405 "parser_cocci_menhir.mly"
+# 379 "parser_cocci_menhir.mly"
( P.create_len_metadec ar ispure
(fun lenname arity name pure check_meta ->
let tok = check_meta(Ast.MetaFieldListDecl(arity,name,lenname)) in
!Data.add_field_list_meta name lenname pure; tok)
len ids )
-# 18354 "parser_cocci_menhir.ml"
+# 18397 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_ar_ in
let _endpos = _endpos__9_ in
let _v : 'tv_metadec =
-# 413 "parser_cocci_menhir.mly"
+# 387 "parser_cocci_menhir.mly"
( P.create_len_metadec ar ispure
(fun lenname arity name pure check_meta ->
let tok = check_meta(Ast.MetaInitListDecl(arity,name,lenname)) in
!Data.add_initlist_meta name lenname pure; tok)
len ids )
-# 18420 "parser_cocci_menhir.ml"
+# 18463 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_metadec =
-# 419 "parser_cocci_menhir.mly"
+# 393 "parser_cocci_menhir.mly"
( (fun _ ->
let add_sym = fun (nm,_) -> !Data.add_symbol_meta nm in
List.iter add_sym ids; [])
)
-# 18455 "parser_cocci_menhir.ml"
+# 18498 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_mident =
-# 2043 "parser_cocci_menhir.mly"
+# 2031 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Id(P.id2mcode _1)) )
-# 18479 "parser_cocci_menhir.ml"
+# 18522 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_mident =
-# 2044 "parser_cocci_menhir.mly"
+# 2032 "parser_cocci_menhir.mly"
( _1 )
-# 18503 "parser_cocci_menhir.ml"
+# 18546 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 18524 "parser_cocci_menhir.ml"
+# 18567 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_mident =
-# 2045 "parser_cocci_menhir.mly"
+# 2033 "parser_cocci_menhir.mly"
( tmeta_to_ident _1 )
-# 18531 "parser_cocci_menhir.ml"
+# 18574 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 130 "parser_cocci_menhir.mly"
+# 104 "parser_cocci_menhir.mly"
(Parse_aux.midinfo)
-# 18552 "parser_cocci_menhir.ml"
+# 18595 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_mident =
-# 2047 "parser_cocci_menhir.mly"
+# 2035 "parser_cocci_menhir.mly"
( let (nm,constraints,seed,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaId(P.clt2mcode nm clt,constraints,seed,pure)) )
-# 18560 "parser_cocci_menhir.ml"
+# 18603 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_midzero_list_ctype_ctype_ =
-# 2367 "parser_cocci_menhir.mly"
+# 2355 "parser_cocci_menhir.mly"
( let (mids,code) = List.split b in (mids,(a::code)) )
-# 18590 "parser_cocci_menhir.ml"
+# 18633 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_midzero_list_disj_ident_disj_ident_ =
-# 2367 "parser_cocci_menhir.mly"
+# 2355 "parser_cocci_menhir.mly"
( let (mids,code) = List.split b in (mids,(a::code)) )
-# 18620 "parser_cocci_menhir.ml"
+# 18663 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_midzero_list_eexpr_eexpr_ =
-# 2367 "parser_cocci_menhir.mly"
+# 2355 "parser_cocci_menhir.mly"
( let (mids,code) = List.split b in (mids,(a::code)) )
-# 18650 "parser_cocci_menhir.ml"
+# 18693 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_midzero_list_expr_eexpr_ =
-# 2367 "parser_cocci_menhir.mly"
+# 2355 "parser_cocci_menhir.mly"
( let (mids,code) = List.split b in (mids,(a::code)) )
-# 18680 "parser_cocci_menhir.ml"
+# 18723 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_midzero_list_fun_after_stm_fun_after_dots_or_ =
-# 2367 "parser_cocci_menhir.mly"
+# 2355 "parser_cocci_menhir.mly"
( let (mids,code) = List.split b in (mids,(a::code)) )
-# 18710 "parser_cocci_menhir.ml"
+# 18753 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_midzero_list_fun_start_fun_start_ =
-# 2367 "parser_cocci_menhir.mly"
+# 2355 "parser_cocci_menhir.mly"
( let (mids,code) = List.split b in (mids,(a::code)) )
-# 18740 "parser_cocci_menhir.ml"
+# 18783 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_midzero_list_mctype_mctype_ =
-# 2367 "parser_cocci_menhir.mly"
+# 2355 "parser_cocci_menhir.mly"
( let (mids,code) = List.split b in (mids,(a::code)) )
-# 18770 "parser_cocci_menhir.ml"
+# 18813 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_midzero_list_rule_elem_statement_rule_elem_statement_ =
-# 2367 "parser_cocci_menhir.mly"
+# 2355 "parser_cocci_menhir.mly"
( let (mids,code) = List.split b in (mids,(a::code)) )
-# 18800 "parser_cocci_menhir.ml"
+# 18843 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_midzero_list_statement_statement_ =
-# 2367 "parser_cocci_menhir.mly"
+# 2355 "parser_cocci_menhir.mly"
( let (mids,code) = List.split b in (mids,(a::code)) )
-# 18830 "parser_cocci_menhir.ml"
+# 18873 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_midzero_list_struct_decl_one_struct_decl_one_ =
-# 2367 "parser_cocci_menhir.mly"
+# 2355 "parser_cocci_menhir.mly"
( let (mids,code) = List.split b in (mids,(a::code)) )
-# 18860 "parser_cocci_menhir.ml"
+# 18903 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_f_ in
let _endpos = _endpos_b_ in
let _v : 'tv_minus_body =
-# 850 "parser_cocci_menhir.mly"
+# 838 "parser_cocci_menhir.mly"
( match f@b(*@ew*) with
[] -> raise (Semantic_cocci.Semantic "minus slice can't be empty")
| code -> code )
-# 18892 "parser_cocci_menhir.ml"
+# 18935 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_f_ in
let _endpos = _endpos_b_ in
let _v : 'tv_minus_exp_body =
-# 864 "parser_cocci_menhir.mly"
+# 852 "parser_cocci_menhir.mly"
( match f@[b](*@ew*) with
[] -> raise (Semantic_cocci.Semantic "minus slice can't be empty")
| code -> code )
-# 18924 "parser_cocci_menhir.ml"
+# 18967 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 211 "parser_cocci_menhir.mly"
+# 185 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 18952 "parser_cocci_menhir.ml"
+# 18995 "parser_cocci_menhir.ml"
) =
-# 251 "parser_cocci_menhir.mly"
+# 225 "parser_cocci_menhir.mly"
( _1 )
-# 18956 "parser_cocci_menhir.ml"
+# 18999 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_m_ in
let _endpos = _endpos__2_ in
let _v : (
-# 211 "parser_cocci_menhir.mly"
+# 185 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 18984 "parser_cocci_menhir.ml"
+# 19027 "parser_cocci_menhir.ml"
) =
-# 251 "parser_cocci_menhir.mly"
+# 225 "parser_cocci_menhir.mly"
( m )
-# 18988 "parser_cocci_menhir.ml"
+# 19031 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_m_ in
let _endpos = _endpos__2_ in
let _v : (
-# 211 "parser_cocci_menhir.mly"
+# 185 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 19016 "parser_cocci_menhir.ml"
+# 19059 "parser_cocci_menhir.ml"
) =
-# 252 "parser_cocci_menhir.mly"
+# 226 "parser_cocci_menhir.mly"
( m )
-# 19020 "parser_cocci_menhir.ml"
+# 19063 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 208 "parser_cocci_menhir.mly"
+# 182 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 19048 "parser_cocci_menhir.ml"
+# 19091 "parser_cocci_menhir.ml"
) =
-# 247 "parser_cocci_menhir.mly"
+# 221 "parser_cocci_menhir.mly"
( _1 )
-# 19052 "parser_cocci_menhir.ml"
+# 19095 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_m_ in
let _endpos = _endpos__2_ in
let _v : (
-# 208 "parser_cocci_menhir.mly"
+# 182 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 19080 "parser_cocci_menhir.ml"
+# 19123 "parser_cocci_menhir.ml"
) =
-# 247 "parser_cocci_menhir.mly"
+# 221 "parser_cocci_menhir.mly"
( m )
-# 19084 "parser_cocci_menhir.ml"
+# 19127 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_m_ in
let _endpos = _endpos__2_ in
let _v : (
-# 208 "parser_cocci_menhir.mly"
+# 182 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 19112 "parser_cocci_menhir.ml"
+# 19155 "parser_cocci_menhir.ml"
) =
-# 248 "parser_cocci_menhir.mly"
+# 222 "parser_cocci_menhir.mly"
( m )
-# 19116 "parser_cocci_menhir.ml"
+# 19159 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_minus_start =
-# 2192 "parser_cocci_menhir.mly"
+# 2180 "parser_cocci_menhir.mly"
( [Ast0.wrap(Ast0.OTHER(_1))] )
-# 19140 "parser_cocci_menhir.ml"
+# 19183 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_minus_start =
-# 2193 "parser_cocci_menhir.mly"
+# 2181 "parser_cocci_menhir.mly"
( [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Ty(_1))))] )
-# 19164 "parser_cocci_menhir.ml"
+# 19207 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_minus_start =
-# 2194 "parser_cocci_menhir.mly"
+# 2182 "parser_cocci_menhir.mly"
( [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.TopInit(_1))))] )
-# 19188 "parser_cocci_menhir.ml"
+# 19231 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_minus_start =
-# 2196 "parser_cocci_menhir.mly"
+# 2184 "parser_cocci_menhir.mly"
( List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) _1 )
-# 19212 "parser_cocci_menhir.ml"
+# 19255 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let a : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 19233 "parser_cocci_menhir.ml"
+# 19276 "parser_cocci_menhir.ml"
) = Obj.magic a in
let _startpos = _startpos_a_ in
let _endpos = _endpos_a_ in
# 39 "standard.mly"
( None )
-# 19241 "parser_cocci_menhir.ml"
+# 19284 "parser_cocci_menhir.ml"
in
-# 740 "parser_cocci_menhir.mly"
+# 728 "parser_cocci_menhir.mly"
( (a,b) )
-# 19247 "parser_cocci_menhir.ml"
+# 19290 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let x0 : 'tv_const_vol = Obj.magic x0 in
let a : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 19274 "parser_cocci_menhir.ml"
+# 19317 "parser_cocci_menhir.ml"
) = Obj.magic a in
let _startpos = _startpos_a_ in
let _endpos = _endpos_x0_ in
# 41 "standard.mly"
( Some x )
-# 19283 "parser_cocci_menhir.ml"
+# 19326 "parser_cocci_menhir.ml"
in
-# 740 "parser_cocci_menhir.mly"
+# 728 "parser_cocci_menhir.mly"
( (a,b) )
-# 19289 "parser_cocci_menhir.ml"
+# 19332 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let b : 'tv_ctype = Obj.magic b in
let a : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 19316 "parser_cocci_menhir.ml"
+# 19359 "parser_cocci_menhir.ml"
) = Obj.magic a in
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_mzl_ctype_ =
-# 2370 "parser_cocci_menhir.mly"
+# 2358 "parser_cocci_menhir.mly"
( (P.clt2mcode "|" a, b) )
-# 19323 "parser_cocci_menhir.ml"
+# 19366 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let b : 'tv_disj_ident = Obj.magic b in
let a : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 19350 "parser_cocci_menhir.ml"
+# 19393 "parser_cocci_menhir.ml"
) = Obj.magic a in
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_mzl_disj_ident_ =
-# 2370 "parser_cocci_menhir.mly"
+# 2358 "parser_cocci_menhir.mly"
( (P.clt2mcode "|" a, b) )
-# 19357 "parser_cocci_menhir.ml"
+# 19400 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let b : 'tv_eexpr = Obj.magic b in
let a : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 19384 "parser_cocci_menhir.ml"
+# 19427 "parser_cocci_menhir.ml"
) = Obj.magic a in
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_mzl_eexpr_ =
-# 2370 "parser_cocci_menhir.mly"
+# 2358 "parser_cocci_menhir.mly"
( (P.clt2mcode "|" a, b) )
-# 19391 "parser_cocci_menhir.ml"
+# 19434 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let b : 'tv_fun_after_dots_or = Obj.magic b in
let a : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 19418 "parser_cocci_menhir.ml"
+# 19461 "parser_cocci_menhir.ml"
) = Obj.magic a in
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_mzl_fun_after_dots_or_ =
-# 2370 "parser_cocci_menhir.mly"
+# 2358 "parser_cocci_menhir.mly"
( (P.clt2mcode "|" a, b) )
-# 19425 "parser_cocci_menhir.ml"
+# 19468 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let b : 'tv_fun_start = Obj.magic b in
let a : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 19452 "parser_cocci_menhir.ml"
+# 19495 "parser_cocci_menhir.ml"
) = Obj.magic a in
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_mzl_fun_start_ =
-# 2370 "parser_cocci_menhir.mly"
+# 2358 "parser_cocci_menhir.mly"
( (P.clt2mcode "|" a, b) )
-# 19459 "parser_cocci_menhir.ml"
+# 19502 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let b : 'tv_mctype = Obj.magic b in
let a : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 19486 "parser_cocci_menhir.ml"
+# 19529 "parser_cocci_menhir.ml"
) = Obj.magic a in
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_mzl_mctype_ =
-# 2370 "parser_cocci_menhir.mly"
+# 2358 "parser_cocci_menhir.mly"
( (P.clt2mcode "|" a, b) )
-# 19493 "parser_cocci_menhir.ml"
+# 19536 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let b : 'tv_rule_elem_statement = Obj.magic b in
let a : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 19520 "parser_cocci_menhir.ml"
+# 19563 "parser_cocci_menhir.ml"
) = Obj.magic a in
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_mzl_rule_elem_statement_ =
-# 2370 "parser_cocci_menhir.mly"
+# 2358 "parser_cocci_menhir.mly"
( (P.clt2mcode "|" a, b) )
-# 19527 "parser_cocci_menhir.ml"
+# 19570 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let b : 'tv_statement = Obj.magic b in
let a : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 19554 "parser_cocci_menhir.ml"
+# 19597 "parser_cocci_menhir.ml"
) = Obj.magic a in
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_mzl_statement_ =
-# 2370 "parser_cocci_menhir.mly"
+# 2358 "parser_cocci_menhir.mly"
( (P.clt2mcode "|" a, b) )
-# 19561 "parser_cocci_menhir.ml"
+# 19604 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let b : 'tv_struct_decl_one = Obj.magic b in
let a : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 19588 "parser_cocci_menhir.ml"
+# 19631 "parser_cocci_menhir.ml"
) = Obj.magic a in
let _startpos = _startpos_a_ in
let _endpos = _endpos_b_ in
let _v : 'tv_mzl_struct_decl_one_ =
-# 2370 "parser_cocci_menhir.mly"
+# 2358 "parser_cocci_menhir.mly"
( (P.clt2mcode "|" a, b) )
-# 19595 "parser_cocci_menhir.ml"
+# 19638 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_name_opt_decl =
-# 1090 "parser_cocci_menhir.mly"
+# 1078 "parser_cocci_menhir.mly"
( _1 )
-# 19619 "parser_cocci_menhir.ml"
+# 19662 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let rp1 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 19670 "parser_cocci_menhir.ml"
+# 19713 "parser_cocci_menhir.ml"
) = Obj.magic rp1 in
let d : 'tv_decl_list_name_opt_decl_ = Obj.magic d in
let lp1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 19676 "parser_cocci_menhir.ml"
+# 19719 "parser_cocci_menhir.ml"
) = Obj.magic lp1 in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 19681 "parser_cocci_menhir.ml"
+# 19724 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let s : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 19686 "parser_cocci_menhir.ml"
+# 19729 "parser_cocci_menhir.ml"
) = Obj.magic s in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 19691 "parser_cocci_menhir.ml"
+# 19734 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let t : 'tv_ctype = Obj.magic t in
let _startpos = _startpos_t_ in
let _endpos = _endpos_rp1_ in
let _v : 'tv_name_opt_decl =
-# 1093 "parser_cocci_menhir.mly"
+# 1081 "parser_cocci_menhir.mly"
( let fnptr =
Ast0.wrap
(Ast0.FunctionPointer
(t,P.clt2mcode "(" lp,P.clt2mcode "*" s,P.clt2mcode ")" rp,
P.clt2mcode "(" lp1,d,P.clt2mcode ")" rp1)) in
Ast0.wrap(Ast0.Param(fnptr, None)) )
-# 19704 "parser_cocci_menhir.ml"
+# 19747 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nest_after_dots =
-# 2312 "parser_cocci_menhir.mly"
+# 2300 "parser_cocci_menhir.mly"
(_1@_2)
-# 19734 "parser_cocci_menhir.ml"
+# 19777 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nest_after_dots =
-# 2313 "parser_cocci_menhir.mly"
+# 2301 "parser_cocci_menhir.mly"
(_2)
-# 19762 "parser_cocci_menhir.ml"
+# 19805 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nest_after_dots =
-# 2314 "parser_cocci_menhir.mly"
+# 2302 "parser_cocci_menhir.mly"
((Ast0.wrap(Ast0.Exp(_1)))::_2)
-# 19792 "parser_cocci_menhir.ml"
+# 19835 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_nest_after_exp =
-# 2322 "parser_cocci_menhir.mly"
+# 2310 "parser_cocci_menhir.mly"
([])
-# 19809 "parser_cocci_menhir.ml"
+# 19852 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nest_after_exp =
-# 2323 "parser_cocci_menhir.mly"
+# 2311 "parser_cocci_menhir.mly"
(_1::_2)
-# 19839 "parser_cocci_menhir.ml"
+# 19882 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_nest_after_stm =
-# 2317 "parser_cocci_menhir.mly"
+# 2305 "parser_cocci_menhir.mly"
([])
-# 19856 "parser_cocci_menhir.ml"
+# 19899 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nest_after_stm =
-# 2318 "parser_cocci_menhir.mly"
+# 2306 "parser_cocci_menhir.mly"
(_1::_2)
-# 19886 "parser_cocci_menhir.ml"
+# 19929 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nest_after_stm =
-# 2319 "parser_cocci_menhir.mly"
+# 2307 "parser_cocci_menhir.mly"
(_1@_2)
-# 19916 "parser_cocci_menhir.ml"
+# 19959 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let c : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 19947 "parser_cocci_menhir.ml"
+# 19990 "parser_cocci_menhir.ml"
) = Obj.magic c in
let e : 'tv_expr_dots_TEllipsis_ = Obj.magic e in
let _1 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 19953 "parser_cocci_menhir.ml"
+# 19996 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos_c_ in
let _v : 'tv_nest_expressions =
-# 1499 "parser_cocci_menhir.mly"
+# 1487 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.NestExpr(P.clt2mcode "<..." _1,
Ast0.wrap(Ast0.DOTS(e (P.mkedots "..."))),
P.clt2mcode "...>" c, None, false)) )
-# 19962 "parser_cocci_menhir.ml"
+# 20005 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let c : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 19993 "parser_cocci_menhir.ml"
+# 20036 "parser_cocci_menhir.ml"
) = Obj.magic c in
let e : 'tv_expr_dots_TEllipsis_ = Obj.magic e in
let _1 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 19999 "parser_cocci_menhir.ml"
+# 20042 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos_c_ in
let _v : 'tv_nest_expressions =
-# 1503 "parser_cocci_menhir.mly"
+# 1491 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.NestExpr(P.clt2mcode "<+..." _1,
Ast0.wrap(Ast0.DOTS(e (P.mkedots "..."))),
P.clt2mcode "...+>" c, None, true)) )
-# 20008 "parser_cocci_menhir.ml"
+# 20051 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 20029 "parser_cocci_menhir.ml"
+# 20072 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_nest_expressions =
-# 1506 "parser_cocci_menhir.mly"
+# 1494 "parser_cocci_menhir.mly"
( tmeta_to_exp _1 )
-# 20036 "parser_cocci_menhir.ml"
+# 20079 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let c : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 20067 "parser_cocci_menhir.ml"
+# 20110 "parser_cocci_menhir.ml"
) = Obj.magic c in
let e : 'tv_expr_dots_TEllipsis_ = Obj.magic e in
let _1 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 20073 "parser_cocci_menhir.ml"
+# 20116 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos_c_ in
let _v : 'tv_nest_expressions_only =
-# 1510 "parser_cocci_menhir.mly"
+# 1498 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.NestExpr(P.clt2mcode "<..." _1,
Ast0.wrap(Ast0.DOTS(e (P.mkedots "..."))),
P.clt2mcode "...>" c, None, false)) )
-# 20082 "parser_cocci_menhir.ml"
+# 20125 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let c : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 20113 "parser_cocci_menhir.ml"
+# 20156 "parser_cocci_menhir.ml"
) = Obj.magic c in
let e : 'tv_expr_dots_TEllipsis_ = Obj.magic e in
let _1 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 20119 "parser_cocci_menhir.ml"
+# 20162 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos_c_ in
let _v : 'tv_nest_expressions_only =
-# 1514 "parser_cocci_menhir.mly"
+# 1502 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.NestExpr(P.clt2mcode "<+..." _1,
Ast0.wrap(Ast0.DOTS(e (P.mkedots "..."))),
P.clt2mcode "...+>" c, None, true)) )
-# 20128 "parser_cocci_menhir.ml"
+# 20171 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_nest_start =
-# 2309 "parser_cocci_menhir.mly"
+# 2297 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.DOTS(_1)) )
-# 20152 "parser_cocci_menhir.ml"
+# 20195 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (
-# 242 "parser_cocci_menhir.mly"
+# 216 "parser_cocci_menhir.mly"
(unit)
-# 20174 "parser_cocci_menhir.ml"
+# 20217 "parser_cocci_menhir.ml"
) =
-# 2437 "parser_cocci_menhir.mly"
+# 2425 "parser_cocci_menhir.mly"
( () )
-# 20178 "parser_cocci_menhir.ml"
+# 20221 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 242 "parser_cocci_menhir.mly"
+# 216 "parser_cocci_menhir.mly"
(unit)
-# 20204 "parser_cocci_menhir.ml"
+# 20247 "parser_cocci_menhir.ml"
) =
-# 2438 "parser_cocci_menhir.mly"
+# 2426 "parser_cocci_menhir.mly"
( () )
-# 20208 "parser_cocci_menhir.ml"
+# 20251 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : (
-# 242 "parser_cocci_menhir.mly"
+# 216 "parser_cocci_menhir.mly"
(unit)
-# 20230 "parser_cocci_menhir.ml"
+# 20273 "parser_cocci_menhir.ml"
) =
-# 2439 "parser_cocci_menhir.mly"
+# 2427 "parser_cocci_menhir.mly"
( () )
-# 20234 "parser_cocci_menhir.ml"
+# 20277 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_g_ in
let _endpos = _endpos_dg_ in
let _v : 'tv_no_dot_start_end_dexpr_edots_when_TEllipsis_eexpr__ =
-# 1756 "parser_cocci_menhir.mly"
+# 1744 "parser_cocci_menhir.mly"
( function dot_builder ->
g :: (List.concat(List.map (function (d,g) -> [dot_builder d;g]) dg)) )
-# 20265 "parser_cocci_menhir.ml"
+# 20308 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let ty : (
-# 118 "parser_cocci_menhir.mly"
+# 92 "parser_cocci_menhir.mly"
(Data.clt)
-# 20286 "parser_cocci_menhir.ml"
+# 20329 "parser_cocci_menhir.ml"
) = Obj.magic ty in
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_non_signable_types =
-# 677 "parser_cocci_menhir.mly"
+# 665 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.BaseType(Ast.VoidType,[P.clt2mcode "void" ty])) )
-# 20293 "parser_cocci_menhir.ml"
+# 20336 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let ty2 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 20319 "parser_cocci_menhir.ml"
+# 20362 "parser_cocci_menhir.ml"
) = Obj.magic ty2 in
let ty1 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 20324 "parser_cocci_menhir.ml"
+# 20367 "parser_cocci_menhir.ml"
) = Obj.magic ty1 in
let _startpos = _startpos_ty1_ in
let _endpos = _endpos_ty2_ in
let _v : 'tv_non_signable_types =
-# 679 "parser_cocci_menhir.mly"
+# 667 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.BaseType
(Ast.LongDoubleType,
[P.clt2mcode "long" ty1;P.clt2mcode "double" ty2])) )
-# 20334 "parser_cocci_menhir.ml"
+# 20377 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let ty : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 20355 "parser_cocci_menhir.ml"
+# 20398 "parser_cocci_menhir.ml"
) = Obj.magic ty in
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_non_signable_types =
-# 684 "parser_cocci_menhir.mly"
+# 672 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.BaseType(Ast.DoubleType,[P.clt2mcode "double" ty])) )
-# 20362 "parser_cocci_menhir.ml"
+# 20405 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let ty : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 20383 "parser_cocci_menhir.ml"
+# 20426 "parser_cocci_menhir.ml"
) = Obj.magic ty in
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_non_signable_types =
-# 686 "parser_cocci_menhir.mly"
+# 674 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.BaseType(Ast.FloatType,[P.clt2mcode "float" ty])) )
-# 20390 "parser_cocci_menhir.ml"
+# 20433 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let ty : (
-# 117 "parser_cocci_menhir.mly"
+# 91 "parser_cocci_menhir.mly"
(Data.clt)
-# 20411 "parser_cocci_menhir.ml"
+# 20454 "parser_cocci_menhir.ml"
) = Obj.magic ty in
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_non_signable_types =
-# 688 "parser_cocci_menhir.mly"
+# 676 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.BaseType(Ast.SizeType,[P.clt2mcode "size_t" ty])) )
-# 20418 "parser_cocci_menhir.ml"
+# 20461 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let ty : (
-# 117 "parser_cocci_menhir.mly"
+# 91 "parser_cocci_menhir.mly"
(Data.clt)
-# 20439 "parser_cocci_menhir.ml"
+# 20482 "parser_cocci_menhir.ml"
) = Obj.magic ty in
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_non_signable_types =
-# 690 "parser_cocci_menhir.mly"
+# 678 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.BaseType(Ast.SSizeType,[P.clt2mcode "ssize_t" ty])) )
-# 20446 "parser_cocci_menhir.ml"
+# 20489 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let ty : (
-# 117 "parser_cocci_menhir.mly"
+# 91 "parser_cocci_menhir.mly"
(Data.clt)
-# 20467 "parser_cocci_menhir.ml"
+# 20510 "parser_cocci_menhir.ml"
) = Obj.magic ty in
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_non_signable_types =
-# 692 "parser_cocci_menhir.mly"
+# 680 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.BaseType(Ast.PtrDiffType,[P.clt2mcode "ptrdiff_t" ty])) )
-# 20474 "parser_cocci_menhir.ml"
+# 20517 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let i : 'tv_ident = Obj.magic i in
let s : (
-# 118 "parser_cocci_menhir.mly"
+# 92 "parser_cocci_menhir.mly"
(Data.clt)
-# 20501 "parser_cocci_menhir.ml"
+# 20544 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_i_ in
let _v : 'tv_non_signable_types =
-# 694 "parser_cocci_menhir.mly"
+# 682 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.EnumName(P.clt2mcode "enum" s, Some i)) )
-# 20508 "parser_cocci_menhir.ml"
+# 20551 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let r : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 20544 "parser_cocci_menhir.ml"
+# 20587 "parser_cocci_menhir.ml"
) = Obj.magic r in
let ids : 'tv_enum_decl_list = Obj.magic ids in
let l : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 20550 "parser_cocci_menhir.ml"
+# 20593 "parser_cocci_menhir.ml"
) = Obj.magic l in
let s : (
-# 118 "parser_cocci_menhir.mly"
+# 92 "parser_cocci_menhir.mly"
(Data.clt)
-# 20555 "parser_cocci_menhir.ml"
+# 20598 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_r_ in
# 39 "standard.mly"
( None )
-# 20563 "parser_cocci_menhir.ml"
+# 20606 "parser_cocci_menhir.ml"
in
-# 696 "parser_cocci_menhir.mly"
+# 684 "parser_cocci_menhir.mly"
( (if i = None && !Data.in_iso
then failwith "enums must be named in the iso file");
Ast0.wrap(Ast0.EnumDef(Ast0.wrap(Ast0.EnumName(P.clt2mcode "enum" s, i)),
P.clt2mcode "{" l, ids, P.clt2mcode "}" r)) )
-# 20572 "parser_cocci_menhir.ml"
+# 20615 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let r : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 20613 "parser_cocci_menhir.ml"
+# 20656 "parser_cocci_menhir.ml"
) = Obj.magic r in
let ids : 'tv_enum_decl_list = Obj.magic ids in
let l : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 20619 "parser_cocci_menhir.ml"
+# 20662 "parser_cocci_menhir.ml"
) = Obj.magic l in
let x0 : 'tv_ident = Obj.magic x0 in
let s : (
-# 118 "parser_cocci_menhir.mly"
+# 92 "parser_cocci_menhir.mly"
(Data.clt)
-# 20625 "parser_cocci_menhir.ml"
+# 20668 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_r_ in
# 41 "standard.mly"
( Some x )
-# 20634 "parser_cocci_menhir.ml"
+# 20677 "parser_cocci_menhir.ml"
in
-# 696 "parser_cocci_menhir.mly"
+# 684 "parser_cocci_menhir.mly"
( (if i = None && !Data.in_iso
then failwith "enums must be named in the iso file");
Ast0.wrap(Ast0.EnumDef(Ast0.wrap(Ast0.EnumName(P.clt2mcode "enum" s, i)),
P.clt2mcode "{" l, ids, P.clt2mcode "}" r)) )
-# 20643 "parser_cocci_menhir.ml"
+# 20686 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_s_ in
let _endpos = _endpos_i_ in
let _v : 'tv_non_signable_types =
-# 701 "parser_cocci_menhir.mly"
+# 689 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.StructUnionName(s, Some i)) )
-# 20673 "parser_cocci_menhir.ml"
+# 20716 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let r : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 20709 "parser_cocci_menhir.ml"
+# 20752 "parser_cocci_menhir.ml"
) = Obj.magic r in
let d : 'tv_struct_decl_list = Obj.magic d in
let l : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 20715 "parser_cocci_menhir.ml"
+# 20758 "parser_cocci_menhir.ml"
) = Obj.magic l in
let s : 'tv_struct_or_union = Obj.magic s in
let _startpos = _startpos_s_ in
# 39 "standard.mly"
( None )
-# 20724 "parser_cocci_menhir.ml"
+# 20767 "parser_cocci_menhir.ml"
in
-# 704 "parser_cocci_menhir.mly"
+# 692 "parser_cocci_menhir.mly"
( (if i = None && !Data.in_iso
then failwith "structures must be named in the iso file");
Ast0.wrap(Ast0.StructUnionDef(Ast0.wrap(Ast0.StructUnionName(s, i)),
P.clt2mcode "{" l,
d, P.clt2mcode "}" r)) )
-# 20734 "parser_cocci_menhir.ml"
+# 20777 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let r : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 20775 "parser_cocci_menhir.ml"
+# 20818 "parser_cocci_menhir.ml"
) = Obj.magic r in
let d : 'tv_struct_decl_list = Obj.magic d in
let l : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 20781 "parser_cocci_menhir.ml"
+# 20824 "parser_cocci_menhir.ml"
) = Obj.magic l in
let x0 : 'tv_type_ident = Obj.magic x0 in
let s : 'tv_struct_or_union = Obj.magic s in
# 41 "standard.mly"
( Some x )
-# 20792 "parser_cocci_menhir.ml"
+# 20835 "parser_cocci_menhir.ml"
in
-# 704 "parser_cocci_menhir.mly"
+# 692 "parser_cocci_menhir.mly"
( (if i = None && !Data.in_iso
then failwith "structures must be named in the iso file");
Ast0.wrap(Ast0.StructUnionDef(Ast0.wrap(Ast0.StructUnionName(s, i)),
P.clt2mcode "{" l,
d, P.clt2mcode "}" r)) )
-# 20802 "parser_cocci_menhir.ml"
+# 20845 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let r : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 20838 "parser_cocci_menhir.ml"
+# 20881 "parser_cocci_menhir.ml"
) = Obj.magic r in
let d : 'tv_struct_decl_list = Obj.magic d in
let l : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 20844 "parser_cocci_menhir.ml"
+# 20887 "parser_cocci_menhir.ml"
) = Obj.magic l in
let s : (
-# 134 "parser_cocci_menhir.mly"
+# 108 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 20849 "parser_cocci_menhir.ml"
+# 20892 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_r_ in
let _v : 'tv_non_signable_types =
-# 710 "parser_cocci_menhir.mly"
+# 698 "parser_cocci_menhir.mly"
( let (nm,pure,clt) = s in
let ty = Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure)) in
Ast0.wrap(Ast0.StructUnionDef(ty,P.clt2mcode "{" l,d,P.clt2mcode "}" r)) )
-# 20858 "parser_cocci_menhir.ml"
+# 20901 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let p : (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 20879 "parser_cocci_menhir.ml"
+# 20922 "parser_cocci_menhir.ml"
) = Obj.magic p in
let _startpos = _startpos_p_ in
let _endpos = _endpos_p_ in
let _v : 'tv_non_signable_types =
-# 714 "parser_cocci_menhir.mly"
+# 702 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.TypeName(P.id2mcode p)) )
-# 20886 "parser_cocci_menhir.ml"
+# 20929 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let x : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 20907 "parser_cocci_menhir.ml"
+# 20950 "parser_cocci_menhir.ml"
) = Obj.magic x in
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : 'tv_nonempty_list_TMul_ =
# 124 "standard.mly"
( [ x ] )
-# 20914 "parser_cocci_menhir.ml"
+# 20957 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let xs : 'tv_nonempty_list_TMul_ = Obj.magic xs in
let x : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 20941 "parser_cocci_menhir.ml"
+# 20984 "parser_cocci_menhir.ml"
) = Obj.magic x in
let _startpos = _startpos_x_ in
let _endpos = _endpos_xs_ in
let _v : 'tv_nonempty_list_TMul_ =
# 126 "standard.mly"
( x :: xs )
-# 20948 "parser_cocci_menhir.ml"
+# 20991 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_nonempty_list_start_aexpr_TEllipsis_ =
-# 2119 "parser_cocci_menhir.mly"
+# 2107 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
-# 20972 "parser_cocci_menhir.ml"
+# 21015 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 20998 "parser_cocci_menhir.ml"
+# 21041 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_aexpr = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_aexpr_TEllipsis_ =
-# 2121 "parser_cocci_menhir.mly"
+# 2109 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 21007 "parser_cocci_menhir.ml"
+# 21050 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_aexpr_TEllipsis_ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21039 "parser_cocci_menhir.ml"
+# 21082 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_aexpr = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_nonempty_list_start_aexpr_TEllipsis_ =
-# 2124 "parser_cocci_menhir.mly"
+# 2112 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
-# 21049 "parser_cocci_menhir.ml"
+# 21092 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_aexpr_TEllipsis_ =
-# 2127 "parser_cocci_menhir.mly"
+# 2115 "parser_cocci_menhir.mly"
( _2 )
-# 21077 "parser_cocci_menhir.ml"
+# 21120 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 21098 "parser_cocci_menhir.ml"
+# 21141 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : 'tv_nonempty_list_start_aexpr_TEllipsis_ =
-# 2128 "parser_cocci_menhir.mly"
+# 2116 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [(build_dots "..." d)] )
-# 21105 "parser_cocci_menhir.ml"
+# 21148 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21131 "parser_cocci_menhir.ml"
+# 21174 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 21136 "parser_cocci_menhir.ml"
+# 21179 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_aexpr_TEllipsis_ =
-# 2130 "parser_cocci_menhir.mly"
+# 2118 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
[(build_dots "..." d);Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 21144 "parser_cocci_menhir.ml"
+# 21187 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let r : 'tv_continue_list_aexpr_TEllipsis_ = Obj.magic r in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21176 "parser_cocci_menhir.ml"
+# 21219 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 21181 "parser_cocci_menhir.ml"
+# 21224 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_r_ in
let _v : 'tv_nonempty_list_start_aexpr_TEllipsis_ =
-# 2133 "parser_cocci_menhir.mly"
+# 2121 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
(build_dots "..." d)::
(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(r build_dots build_comma) )
-# 21191 "parser_cocci_menhir.ml"
+# 21234 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_nonempty_list_start_dparam_TEllipsis_ =
-# 2119 "parser_cocci_menhir.mly"
+# 2107 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
-# 21215 "parser_cocci_menhir.ml"
+# 21258 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21241 "parser_cocci_menhir.ml"
+# 21284 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_dparam = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_dparam_TEllipsis_ =
-# 2121 "parser_cocci_menhir.mly"
+# 2109 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 21250 "parser_cocci_menhir.ml"
+# 21293 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_dparam_TEllipsis_ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21282 "parser_cocci_menhir.ml"
+# 21325 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_dparam = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_nonempty_list_start_dparam_TEllipsis_ =
-# 2124 "parser_cocci_menhir.mly"
+# 2112 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
-# 21292 "parser_cocci_menhir.ml"
+# 21335 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_dparam_TEllipsis_ =
-# 2127 "parser_cocci_menhir.mly"
+# 2115 "parser_cocci_menhir.mly"
( _2 )
-# 21320 "parser_cocci_menhir.ml"
+# 21363 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 21341 "parser_cocci_menhir.ml"
+# 21384 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : 'tv_nonempty_list_start_dparam_TEllipsis_ =
-# 2128 "parser_cocci_menhir.mly"
+# 2116 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [(build_dots "..." d)] )
-# 21348 "parser_cocci_menhir.ml"
+# 21391 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21374 "parser_cocci_menhir.ml"
+# 21417 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 21379 "parser_cocci_menhir.ml"
+# 21422 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_dparam_TEllipsis_ =
-# 2130 "parser_cocci_menhir.mly"
+# 2118 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
[(build_dots "..." d);Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 21387 "parser_cocci_menhir.ml"
+# 21430 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let r : 'tv_continue_list_dparam_TEllipsis_ = Obj.magic r in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21419 "parser_cocci_menhir.ml"
+# 21462 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 21424 "parser_cocci_menhir.ml"
+# 21467 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_r_ in
let _v : 'tv_nonempty_list_start_dparam_TEllipsis_ =
-# 2133 "parser_cocci_menhir.mly"
+# 2121 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
(build_dots "..." d)::
(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(r build_dots build_comma) )
-# 21434 "parser_cocci_menhir.ml"
+# 21477 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_nonempty_list_start_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ =
-# 2119 "parser_cocci_menhir.mly"
+# 2107 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
-# 21458 "parser_cocci_menhir.ml"
+# 21501 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21484 "parser_cocci_menhir.ml"
+# 21527 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_enum_decl_one = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ =
-# 2121 "parser_cocci_menhir.mly"
+# 2109 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 21493 "parser_cocci_menhir.ml"
+# 21536 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21525 "parser_cocci_menhir.ml"
+# 21568 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_enum_decl_one = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_nonempty_list_start_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ =
-# 2124 "parser_cocci_menhir.mly"
+# 2112 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
-# 21535 "parser_cocci_menhir.ml"
+# 21578 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ =
-# 2127 "parser_cocci_menhir.mly"
+# 2115 "parser_cocci_menhir.mly"
( _2 )
-# 21563 "parser_cocci_menhir.ml"
+# 21606 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : 'tv_nonempty_list_start_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ =
-# 2128 "parser_cocci_menhir.mly"
+# 2116 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [(build_dots "..." d)] )
-# 21587 "parser_cocci_menhir.ml"
+# 21630 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21613 "parser_cocci_menhir.ml"
+# 21656 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : 'tv_edots_when_TEllipsis_enum_decl_one_ = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ =
-# 2130 "parser_cocci_menhir.mly"
+# 2118 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
[(build_dots "..." d);Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 21622 "parser_cocci_menhir.ml"
+# 21665 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let r : 'tv_continue_list_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ = Obj.magic r in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21654 "parser_cocci_menhir.ml"
+# 21697 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : 'tv_edots_when_TEllipsis_enum_decl_one_ = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_r_ in
let _v : 'tv_nonempty_list_start_enum_decl_one_edots_when_TEllipsis_enum_decl_one__ =
-# 2133 "parser_cocci_menhir.mly"
+# 2121 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
(build_dots "..." d)::
(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(r build_dots build_comma) )
-# 21665 "parser_cocci_menhir.ml"
+# 21708 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_nonempty_list_start_initialize2_edots_when_TEllipsis_initialize__ =
-# 2119 "parser_cocci_menhir.mly"
+# 2107 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
-# 21689 "parser_cocci_menhir.ml"
+# 21732 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21715 "parser_cocci_menhir.ml"
+# 21758 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_initialize2 = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_initialize2_edots_when_TEllipsis_initialize__ =
-# 2121 "parser_cocci_menhir.mly"
+# 2109 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 21724 "parser_cocci_menhir.ml"
+# 21767 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_initialize2_edots_when_TEllipsis_initialize__ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21756 "parser_cocci_menhir.ml"
+# 21799 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_initialize2 = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_nonempty_list_start_initialize2_edots_when_TEllipsis_initialize__ =
-# 2124 "parser_cocci_menhir.mly"
+# 2112 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
-# 21766 "parser_cocci_menhir.ml"
+# 21809 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_initialize2_edots_when_TEllipsis_initialize__ =
-# 2127 "parser_cocci_menhir.mly"
+# 2115 "parser_cocci_menhir.mly"
( _2 )
-# 21794 "parser_cocci_menhir.ml"
+# 21837 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : 'tv_nonempty_list_start_initialize2_edots_when_TEllipsis_initialize__ =
-# 2128 "parser_cocci_menhir.mly"
+# 2116 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [(build_dots "..." d)] )
-# 21818 "parser_cocci_menhir.ml"
+# 21861 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21844 "parser_cocci_menhir.ml"
+# 21887 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : 'tv_edots_when_TEllipsis_initialize_ = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_initialize2_edots_when_TEllipsis_initialize__ =
-# 2130 "parser_cocci_menhir.mly"
+# 2118 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
[(build_dots "..." d);Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 21853 "parser_cocci_menhir.ml"
+# 21896 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let r : 'tv_continue_list_initialize2_edots_when_TEllipsis_initialize__ = Obj.magic r in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21885 "parser_cocci_menhir.ml"
+# 21928 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : 'tv_edots_when_TEllipsis_initialize_ = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_r_ in
let _v : 'tv_nonempty_list_start_initialize2_edots_when_TEllipsis_initialize__ =
-# 2133 "parser_cocci_menhir.mly"
+# 2121 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
(build_dots "..." d)::
(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(r build_dots build_comma) )
-# 21896 "parser_cocci_menhir.ml"
+# 21939 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_nonempty_list_start_one_dec_decl__TEllipsis_ =
-# 2119 "parser_cocci_menhir.mly"
+# 2107 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
-# 21920 "parser_cocci_menhir.ml"
+# 21963 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21946 "parser_cocci_menhir.ml"
+# 21989 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_one_dec_decl_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_one_dec_decl__TEllipsis_ =
-# 2121 "parser_cocci_menhir.mly"
+# 2109 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 21955 "parser_cocci_menhir.ml"
+# 21998 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_one_dec_decl__TEllipsis_ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 21987 "parser_cocci_menhir.ml"
+# 22030 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_one_dec_decl_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_nonempty_list_start_one_dec_decl__TEllipsis_ =
-# 2124 "parser_cocci_menhir.mly"
+# 2112 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
-# 21997 "parser_cocci_menhir.ml"
+# 22040 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_one_dec_decl__TEllipsis_ =
-# 2127 "parser_cocci_menhir.mly"
+# 2115 "parser_cocci_menhir.mly"
( _2 )
-# 22025 "parser_cocci_menhir.ml"
+# 22068 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 22046 "parser_cocci_menhir.ml"
+# 22089 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : 'tv_nonempty_list_start_one_dec_decl__TEllipsis_ =
-# 2128 "parser_cocci_menhir.mly"
+# 2116 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [(build_dots "..." d)] )
-# 22053 "parser_cocci_menhir.ml"
+# 22096 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 22079 "parser_cocci_menhir.ml"
+# 22122 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 22084 "parser_cocci_menhir.ml"
+# 22127 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_one_dec_decl__TEllipsis_ =
-# 2130 "parser_cocci_menhir.mly"
+# 2118 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
[(build_dots "..." d);Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 22092 "parser_cocci_menhir.ml"
+# 22135 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let r : 'tv_continue_list_one_dec_decl__TEllipsis_ = Obj.magic r in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 22124 "parser_cocci_menhir.ml"
+# 22167 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 22129 "parser_cocci_menhir.ml"
+# 22172 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_r_ in
let _v : 'tv_nonempty_list_start_one_dec_decl__TEllipsis_ =
-# 2133 "parser_cocci_menhir.mly"
+# 2121 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
(build_dots "..." d)::
(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(r build_dots build_comma) )
-# 22139 "parser_cocci_menhir.ml"
+# 22182 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_nonempty_list_start_one_dec_name_opt_decl__TEllipsis_ =
-# 2119 "parser_cocci_menhir.mly"
+# 2107 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [_1] )
-# 22163 "parser_cocci_menhir.ml"
+# 22206 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 22189 "parser_cocci_menhir.ml"
+# 22232 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_one_dec_name_opt_decl_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_one_dec_name_opt_decl__TEllipsis_ =
-# 2121 "parser_cocci_menhir.mly"
+# 2109 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::[Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 22198 "parser_cocci_menhir.ml"
+# 22241 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_nonempty_list_start_one_dec_name_opt_decl__TEllipsis_ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 22230 "parser_cocci_menhir.ml"
+# 22273 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_one_dec_name_opt_decl_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_nonempty_list_start_one_dec_name_opt_decl__TEllipsis_ =
-# 2124 "parser_cocci_menhir.mly"
+# 2112 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
_1::(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(_3 build_dots build_comma) )
-# 22240 "parser_cocci_menhir.ml"
+# 22283 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_one_dec_name_opt_decl__TEllipsis_ =
-# 2127 "parser_cocci_menhir.mly"
+# 2115 "parser_cocci_menhir.mly"
( _2 )
-# 22268 "parser_cocci_menhir.ml"
+# 22311 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 22289 "parser_cocci_menhir.ml"
+# 22332 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_d_ in
let _v : 'tv_nonempty_list_start_one_dec_name_opt_decl__TEllipsis_ =
-# 2128 "parser_cocci_menhir.mly"
+# 2116 "parser_cocci_menhir.mly"
( fun build_dots build_comma -> [(build_dots "..." d)] )
-# 22296 "parser_cocci_menhir.ml"
+# 22339 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 22322 "parser_cocci_menhir.ml"
+# 22365 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 22327 "parser_cocci_menhir.ml"
+# 22370 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos__2_ in
let _v : 'tv_nonempty_list_start_one_dec_name_opt_decl__TEllipsis_ =
-# 2130 "parser_cocci_menhir.mly"
+# 2118 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
[(build_dots "..." d);Ast0.wrap(build_comma(P.clt2mcode "," _2))] )
-# 22335 "parser_cocci_menhir.ml"
+# 22378 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let r : 'tv_continue_list_one_dec_name_opt_decl__TEllipsis_ = Obj.magic r in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 22367 "parser_cocci_menhir.ml"
+# 22410 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let d : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 22372 "parser_cocci_menhir.ml"
+# 22415 "parser_cocci_menhir.ml"
) = Obj.magic d in
let _startpos = _startpos_d_ in
let _endpos = _endpos_r_ in
let _v : 'tv_nonempty_list_start_one_dec_name_opt_decl__TEllipsis_ =
-# 2133 "parser_cocci_menhir.mly"
+# 2121 "parser_cocci_menhir.mly"
( fun build_dots build_comma ->
(build_dots "..." d)::
(Ast0.wrap(build_comma(P.clt2mcode "," _2)))::
(r build_dots build_comma) )
-# 22382 "parser_cocci_menhir.ml"
+# 22425 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_i_ in
let _v : 'tv_not_ceq =
-# 1952 "parser_cocci_menhir.mly"
+# 1940 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
then failwith "constraints not allowed in a generated rule file");
[i] )
-# 22414 "parser_cocci_menhir.ml"
+# 22457 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_not_ceq =
-# 1958 "parser_cocci_menhir.mly"
+# 1946 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
then failwith "constraints not allowed in a generated rule file");
l )
-# 22454 "parser_cocci_menhir.ml"
+# 22497 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_ceq_ in
let _endpos = _endpos_ceq_ in
let _v : 'tv_not_ceq_or_sub =
-# 1928 "parser_cocci_menhir.mly"
+# 1916 "parser_cocci_menhir.mly"
(Ast0.NotExpCstrt ceq)
-# 22478 "parser_cocci_menhir.ml"
+# 22521 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_s_ in
let _endpos = _endpos_s_ in
let _v : 'tv_not_ceq_or_sub =
-# 1929 "parser_cocci_menhir.mly"
+# 1917 "parser_cocci_menhir.mly"
(Ast0.SubExpCstrt s)
-# 22502 "parser_cocci_menhir.ml"
+# 22545 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_i_ in
let _v : 'tv_not_eqe =
-# 1933 "parser_cocci_menhir.mly"
+# 1921 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
then failwith "constraints not allowed in a generated rule file");
[Ast0.wrap(Ast0.Ident(Ast0.wrap(Ast0.Id(P.id2mcode i))))]
)
-# 22535 "parser_cocci_menhir.ml"
+# 22578 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_not_eqe =
-# 1940 "parser_cocci_menhir.mly"
+# 1928 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
Ast0.wrap(Ast0.Ident(Ast0.wrap(Ast0.Id(P.id2mcode i)))))
l
)
-# 22579 "parser_cocci_menhir.ml"
+# 22622 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_i_ in
let _v : 'tv_not_eqid =
-# 1890 "parser_cocci_menhir.mly"
+# 1878 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
(function mv -> Ast.MetaIdDecl(Ast.NONE,mv)) in
Ast.IdNegIdSet([],[i])
| (None,i) -> Ast.IdNegIdSet([i],[])) )
-# 22619 "parser_cocci_menhir.ml"
+# 22662 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_not_eqid =
-# 1904 "parser_cocci_menhir.mly"
+# 1892 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
([],[]) l in
Ast.IdNegIdSet(str,meta)
)
-# 22671 "parser_cocci_menhir.ml"
+# 22714 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_i_ in
let _v : 'tv_not_pos =
-# 1997 "parser_cocci_menhir.mly"
+# 1985 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
P.check_inherited_constraint i
(function mv -> Ast.MetaPosDecl(Ast.NONE,mv)) in
[i] )
-# 22706 "parser_cocci_menhir.ml"
+# 22749 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_not_pos =
-# 2006 "parser_cocci_menhir.mly"
+# 1994 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
P.check_inherited_constraint i
(function mv -> Ast.MetaPosDecl(Ast.NONE,mv)))
l )
-# 22750 "parser_cocci_menhir.ml"
+# 22793 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_one_dec_decl_ =
-# 2094 "parser_cocci_menhir.mly"
+# 2082 "parser_cocci_menhir.mly"
( _1 )
-# 22774 "parser_cocci_menhir.ml"
+# 22817 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 136 "parser_cocci_menhir.mly"
+# 110 "parser_cocci_menhir.mly"
(Parse_aux.list_info)
-# 22795 "parser_cocci_menhir.ml"
+# 22838 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_one_dec_decl_ =
-# 2096 "parser_cocci_menhir.mly"
+# 2084 "parser_cocci_menhir.mly"
( let (nm,lenname,pure,clt) = _1 in
let nm = P.clt2mcode nm clt in
let lenname =
| Ast.MetaLen nm -> Ast0.MetaListLen(P.clt2mcode nm clt)
| Ast.CstLen n -> Ast0.CstListLen n in
Ast0.wrap(Ast0.MetaParamList(nm,lenname,pure)) )
-# 22809 "parser_cocci_menhir.ml"
+# 22852 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_one_dec_name_opt_decl_ =
-# 2094 "parser_cocci_menhir.mly"
+# 2082 "parser_cocci_menhir.mly"
( _1 )
-# 22833 "parser_cocci_menhir.ml"
+# 22876 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 136 "parser_cocci_menhir.mly"
+# 110 "parser_cocci_menhir.mly"
(Parse_aux.list_info)
-# 22854 "parser_cocci_menhir.ml"
+# 22897 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_one_dec_name_opt_decl_ =
-# 2096 "parser_cocci_menhir.mly"
+# 2084 "parser_cocci_menhir.mly"
( let (nm,lenname,pure,clt) = _1 in
let nm = P.clt2mcode nm clt in
let lenname =
| Ast.MetaLen nm -> Ast0.MetaListLen(P.clt2mcode nm clt)
| Ast.CstLen n -> Ast0.CstListLen n in
Ast0.wrap(Ast0.MetaParamList(nm,lenname,pure)) )
-# 22868 "parser_cocci_menhir.ml"
+# 22911 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 22894 "parser_cocci_menhir.ml"
+# 22937 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let t : 'tv_ctype = Obj.magic t in
let _startpos = _startpos_t_ in
let _endpos = _endpos_pv_ in
let _v : 'tv_one_decl_var =
-# 1288 "parser_cocci_menhir.mly"
+# 1276 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.TyDecl(t,P.clt2mcode ";" pv)) )
-# 22902 "parser_cocci_menhir.ml"
+# 22945 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 22923 "parser_cocci_menhir.ml"
+# 22966 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_one_decl_var =
-# 1289 "parser_cocci_menhir.mly"
+# 1277 "parser_cocci_menhir.mly"
( P.meta_decl _1 )
-# 22930 "parser_cocci_menhir.ml"
+# 22973 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 22961 "parser_cocci_menhir.ml"
+# 23004 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let d : 'tv_d_ident = Obj.magic d in
let t : 'tv_ctype = Obj.magic t in
# 39 "standard.mly"
( None )
-# 22971 "parser_cocci_menhir.ml"
+# 23014 "parser_cocci_menhir.ml"
in
-# 1291 "parser_cocci_menhir.mly"
+# 1279 "parser_cocci_menhir.mly"
( let (id,fn) = d in
Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)) )
-# 22978 "parser_cocci_menhir.ml"
+# 23021 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23014 "parser_cocci_menhir.ml"
+# 23057 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let d : 'tv_d_ident = Obj.magic d in
let t : 'tv_ctype = Obj.magic t in
# 41 "standard.mly"
( Some x )
-# 23026 "parser_cocci_menhir.ml"
+# 23069 "parser_cocci_menhir.ml"
in
-# 1291 "parser_cocci_menhir.mly"
+# 1279 "parser_cocci_menhir.mly"
( let (id,fn) = d in
Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)) )
-# 23033 "parser_cocci_menhir.ml"
+# 23076 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_f_ in
let _endpos = _endpos_f_ in
let _v : 'tv_one_decl_var =
-# 1293 "parser_cocci_menhir.mly"
+# 1281 "parser_cocci_menhir.mly"
( f )
-# 23057 "parser_cocci_menhir.ml"
+# 23100 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23098 "parser_cocci_menhir.ml"
+# 23141 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23104 "parser_cocci_menhir.ml"
+# 23147 "parser_cocci_menhir.ml"
) = Obj.magic q in
let d : 'tv_d_ident = Obj.magic d in
let t : 'tv_ctype = Obj.magic t in
# 39 "standard.mly"
( None )
-# 23114 "parser_cocci_menhir.ml"
+# 23157 "parser_cocci_menhir.ml"
in
-# 1295 "parser_cocci_menhir.mly"
+# 1283 "parser_cocci_menhir.mly"
( let (id,fn) = d in
Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv)) )
-# 23121 "parser_cocci_menhir.ml"
+# 23164 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23167 "parser_cocci_menhir.ml"
+# 23210 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23173 "parser_cocci_menhir.ml"
+# 23216 "parser_cocci_menhir.ml"
) = Obj.magic q in
let d : 'tv_d_ident = Obj.magic d in
let t : 'tv_ctype = Obj.magic t in
# 41 "standard.mly"
( Some x )
-# 23185 "parser_cocci_menhir.ml"
+# 23228 "parser_cocci_menhir.ml"
in
-# 1295 "parser_cocci_menhir.mly"
+# 1283 "parser_cocci_menhir.mly"
( let (id,fn) = d in
Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv)) )
-# 23192 "parser_cocci_menhir.ml"
+# 23235 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23223 "parser_cocci_menhir.ml"
+# 23266 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let d : 'tv_d_ident = Obj.magic d in
let i : 'tv_pure_ident_or_symbol = Obj.magic i in
# 39 "standard.mly"
( None )
-# 23233 "parser_cocci_menhir.ml"
+# 23276 "parser_cocci_menhir.ml"
in
let s =
# 39 "standard.mly"
( None )
-# 23240 "parser_cocci_menhir.ml"
+# 23283 "parser_cocci_menhir.ml"
in
-# 1300 "parser_cocci_menhir.mly"
+# 1288 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
Ast0.wrap(Ast0.UnInit(s,fn idtype,id,P.clt2mcode ";" pv)) )
-# 23248 "parser_cocci_menhir.ml"
+# 23291 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23284 "parser_cocci_menhir.ml"
+# 23327 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let d : 'tv_d_ident = Obj.magic d in
let i : 'tv_pure_ident_or_symbol = Obj.magic i in
# 41 "standard.mly"
( Some x )
-# 23296 "parser_cocci_menhir.ml"
+# 23339 "parser_cocci_menhir.ml"
in
let s =
# 39 "standard.mly"
( None )
-# 23303 "parser_cocci_menhir.ml"
+# 23346 "parser_cocci_menhir.ml"
in
-# 1300 "parser_cocci_menhir.mly"
+# 1288 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
Ast0.wrap(Ast0.UnInit(s,fn idtype,id,P.clt2mcode ";" pv)) )
-# 23311 "parser_cocci_menhir.ml"
+# 23354 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23347 "parser_cocci_menhir.ml"
+# 23390 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let d : 'tv_d_ident = Obj.magic d in
let i : 'tv_pure_ident_or_symbol = Obj.magic i in
# 39 "standard.mly"
( None )
-# 23358 "parser_cocci_menhir.ml"
+# 23401 "parser_cocci_menhir.ml"
in
let s =
# 41 "standard.mly"
( Some x )
-# 23366 "parser_cocci_menhir.ml"
+# 23409 "parser_cocci_menhir.ml"
in
-# 1300 "parser_cocci_menhir.mly"
+# 1288 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
Ast0.wrap(Ast0.UnInit(s,fn idtype,id,P.clt2mcode ";" pv)) )
-# 23374 "parser_cocci_menhir.ml"
+# 23417 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23415 "parser_cocci_menhir.ml"
+# 23458 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let d : 'tv_d_ident = Obj.magic d in
let i : 'tv_pure_ident_or_symbol = Obj.magic i in
# 41 "standard.mly"
( Some x )
-# 23428 "parser_cocci_menhir.ml"
+# 23471 "parser_cocci_menhir.ml"
in
let s =
# 41 "standard.mly"
( Some x )
-# 23436 "parser_cocci_menhir.ml"
+# 23479 "parser_cocci_menhir.ml"
in
-# 1300 "parser_cocci_menhir.mly"
+# 1288 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
Ast0.wrap(Ast0.UnInit(s,fn idtype,id,P.clt2mcode ";" pv)) )
-# 23444 "parser_cocci_menhir.ml"
+# 23487 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23485 "parser_cocci_menhir.ml"
+# 23528 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23491 "parser_cocci_menhir.ml"
+# 23534 "parser_cocci_menhir.ml"
) = Obj.magic q in
let d : 'tv_d_ident = Obj.magic d in
let i : 'tv_pure_ident_or_symbol = Obj.magic i in
# 39 "standard.mly"
( None )
-# 23501 "parser_cocci_menhir.ml"
+# 23544 "parser_cocci_menhir.ml"
in
let s =
# 39 "standard.mly"
( None )
-# 23508 "parser_cocci_menhir.ml"
+# 23551 "parser_cocci_menhir.ml"
in
-# 1305 "parser_cocci_menhir.mly"
+# 1293 "parser_cocci_menhir.mly"
( let (id,fn) = d in
!Data.add_type_name (P.id2name i);
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
Ast0.wrap(Ast0.Init(s,fn idtype,id,P.clt2mcode "=" q,e,
P.clt2mcode ";" pv)) )
-# 23518 "parser_cocci_menhir.ml"
+# 23561 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23564 "parser_cocci_menhir.ml"
+# 23607 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23570 "parser_cocci_menhir.ml"
+# 23613 "parser_cocci_menhir.ml"
) = Obj.magic q in
let d : 'tv_d_ident = Obj.magic d in
let i : 'tv_pure_ident_or_symbol = Obj.magic i in
# 41 "standard.mly"
( Some x )
-# 23582 "parser_cocci_menhir.ml"
+# 23625 "parser_cocci_menhir.ml"
in
let s =
# 39 "standard.mly"
( None )
-# 23589 "parser_cocci_menhir.ml"
+# 23632 "parser_cocci_menhir.ml"
in
-# 1305 "parser_cocci_menhir.mly"
+# 1293 "parser_cocci_menhir.mly"
( let (id,fn) = d in
!Data.add_type_name (P.id2name i);
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
Ast0.wrap(Ast0.Init(s,fn idtype,id,P.clt2mcode "=" q,e,
P.clt2mcode ";" pv)) )
-# 23599 "parser_cocci_menhir.ml"
+# 23642 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23645 "parser_cocci_menhir.ml"
+# 23688 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23651 "parser_cocci_menhir.ml"
+# 23694 "parser_cocci_menhir.ml"
) = Obj.magic q in
let d : 'tv_d_ident = Obj.magic d in
let i : 'tv_pure_ident_or_symbol = Obj.magic i in
# 39 "standard.mly"
( None )
-# 23662 "parser_cocci_menhir.ml"
+# 23705 "parser_cocci_menhir.ml"
in
let s =
# 41 "standard.mly"
( Some x )
-# 23670 "parser_cocci_menhir.ml"
+# 23713 "parser_cocci_menhir.ml"
in
-# 1305 "parser_cocci_menhir.mly"
+# 1293 "parser_cocci_menhir.mly"
( let (id,fn) = d in
!Data.add_type_name (P.id2name i);
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
Ast0.wrap(Ast0.Init(s,fn idtype,id,P.clt2mcode "=" q,e,
P.clt2mcode ";" pv)) )
-# 23680 "parser_cocci_menhir.ml"
+# 23723 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23731 "parser_cocci_menhir.ml"
+# 23774 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23737 "parser_cocci_menhir.ml"
+# 23780 "parser_cocci_menhir.ml"
) = Obj.magic q in
let d : 'tv_d_ident = Obj.magic d in
let i : 'tv_pure_ident_or_symbol = Obj.magic i in
# 41 "standard.mly"
( Some x )
-# 23750 "parser_cocci_menhir.ml"
+# 23793 "parser_cocci_menhir.ml"
in
let s =
# 41 "standard.mly"
( Some x )
-# 23758 "parser_cocci_menhir.ml"
+# 23801 "parser_cocci_menhir.ml"
in
-# 1305 "parser_cocci_menhir.mly"
+# 1293 "parser_cocci_menhir.mly"
( let (id,fn) = d in
!Data.add_type_name (P.id2name i);
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
Ast0.wrap(Ast0.Init(s,fn idtype,id,P.clt2mcode "=" q,e,
P.clt2mcode ";" pv)) )
-# 23768 "parser_cocci_menhir.ml"
+# 23811 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23829 "parser_cocci_menhir.ml"
+# 23872 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let rp2 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 23834 "parser_cocci_menhir.ml"
+# 23877 "parser_cocci_menhir.ml"
) = Obj.magic rp2 in
let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in
let lp2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 23840 "parser_cocci_menhir.ml"
+# 23883 "parser_cocci_menhir.ml"
) = Obj.magic lp2 in
let rp1 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 23845 "parser_cocci_menhir.ml"
+# 23888 "parser_cocci_menhir.ml"
) = Obj.magic rp1 in
let d : 'tv_d_ident = Obj.magic d in
let st : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 23851 "parser_cocci_menhir.ml"
+# 23894 "parser_cocci_menhir.ml"
) = Obj.magic st in
let lp1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 23856 "parser_cocci_menhir.ml"
+# 23899 "parser_cocci_menhir.ml"
) = Obj.magic lp1 in
let t : 'tv_ctype = Obj.magic t in
let _startpos = _startpos_t_ in
# 39 "standard.mly"
( None )
-# 23865 "parser_cocci_menhir.ml"
+# 23908 "parser_cocci_menhir.ml"
in
-# 1315 "parser_cocci_menhir.mly"
+# 1303 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let t =
Ast0.wrap
(t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode ")" rp1,
P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)) )
-# 23877 "parser_cocci_menhir.ml"
+# 23920 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 23943 "parser_cocci_menhir.ml"
+# 23986 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let rp2 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 23948 "parser_cocci_menhir.ml"
+# 23991 "parser_cocci_menhir.ml"
) = Obj.magic rp2 in
let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in
let lp2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 23954 "parser_cocci_menhir.ml"
+# 23997 "parser_cocci_menhir.ml"
) = Obj.magic lp2 in
let rp1 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 23959 "parser_cocci_menhir.ml"
+# 24002 "parser_cocci_menhir.ml"
) = Obj.magic rp1 in
let d : 'tv_d_ident = Obj.magic d in
let st : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 23965 "parser_cocci_menhir.ml"
+# 24008 "parser_cocci_menhir.ml"
) = Obj.magic st in
let lp1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 23970 "parser_cocci_menhir.ml"
+# 24013 "parser_cocci_menhir.ml"
) = Obj.magic lp1 in
let t : 'tv_ctype = Obj.magic t in
let x0 : 'tv_storage = Obj.magic x0 in
# 41 "standard.mly"
( Some x )
-# 23981 "parser_cocci_menhir.ml"
+# 24024 "parser_cocci_menhir.ml"
in
-# 1315 "parser_cocci_menhir.mly"
+# 1303 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let t =
Ast0.wrap
(t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode ")" rp1,
P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
Ast0.wrap(Ast0.UnInit(s,fn t,id,P.clt2mcode ";" pv)) )
-# 23993 "parser_cocci_menhir.ml"
+# 24036 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _5 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 24034 "parser_cocci_menhir.ml"
+# 24077 "parser_cocci_menhir.ml"
) = Obj.magic _5 in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 24039 "parser_cocci_menhir.ml"
+# 24082 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr_list_option = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 24045 "parser_cocci_menhir.ml"
+# 24088 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_decl_ident = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : 'tv_one_decl_var =
-# 1323 "parser_cocci_menhir.mly"
+# 1311 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.MacroDecl(_1,P.clt2mcode "(" _2,_3,
P.clt2mcode ")" _4,P.clt2mcode ";" _5)) )
-# 24054 "parser_cocci_menhir.ml"
+# 24097 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _7 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 24105 "parser_cocci_menhir.ml"
+# 24148 "parser_cocci_menhir.ml"
) = Obj.magic _7 in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 24111 "parser_cocci_menhir.ml"
+# 24154 "parser_cocci_menhir.ml"
) = Obj.magic q in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 24116 "parser_cocci_menhir.ml"
+# 24159 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr_list_option = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 24122 "parser_cocci_menhir.ml"
+# 24165 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_decl_ident = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : 'tv_one_decl_var =
-# 1326 "parser_cocci_menhir.mly"
+# 1314 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.MacroDeclInit
(_1,P.clt2mcode "(" _2,_3,
P.clt2mcode ")" _4,P.clt2mcode "=" q,e,
P.clt2mcode ";" _7)) )
-# 24134 "parser_cocci_menhir.ml"
+# 24177 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 24205 "parser_cocci_menhir.ml"
+# 24248 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 24211 "parser_cocci_menhir.ml"
+# 24254 "parser_cocci_menhir.ml"
) = Obj.magic q in
let rp2 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 24216 "parser_cocci_menhir.ml"
+# 24259 "parser_cocci_menhir.ml"
) = Obj.magic rp2 in
let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in
let lp2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 24222 "parser_cocci_menhir.ml"
+# 24265 "parser_cocci_menhir.ml"
) = Obj.magic lp2 in
let rp1 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 24227 "parser_cocci_menhir.ml"
+# 24270 "parser_cocci_menhir.ml"
) = Obj.magic rp1 in
let d : 'tv_d_ident = Obj.magic d in
let st : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 24233 "parser_cocci_menhir.ml"
+# 24276 "parser_cocci_menhir.ml"
) = Obj.magic st in
let lp1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 24238 "parser_cocci_menhir.ml"
+# 24281 "parser_cocci_menhir.ml"
) = Obj.magic lp1 in
let t : 'tv_ctype = Obj.magic t in
let _startpos = _startpos_t_ in
# 39 "standard.mly"
( None )
-# 24247 "parser_cocci_menhir.ml"
+# 24290 "parser_cocci_menhir.ml"
in
-# 1335 "parser_cocci_menhir.mly"
+# 1323 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let t =
Ast0.wrap
(t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode ")" rp1,
P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv)))
-# 24259 "parser_cocci_menhir.ml"
+# 24302 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 24335 "parser_cocci_menhir.ml"
+# 24378 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let e : 'tv_initialize = Obj.magic e in
let q : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 24341 "parser_cocci_menhir.ml"
+# 24384 "parser_cocci_menhir.ml"
) = Obj.magic q in
let rp2 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 24346 "parser_cocci_menhir.ml"
+# 24389 "parser_cocci_menhir.ml"
) = Obj.magic rp2 in
let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in
let lp2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 24352 "parser_cocci_menhir.ml"
+# 24395 "parser_cocci_menhir.ml"
) = Obj.magic lp2 in
let rp1 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 24357 "parser_cocci_menhir.ml"
+# 24400 "parser_cocci_menhir.ml"
) = Obj.magic rp1 in
let d : 'tv_d_ident = Obj.magic d in
let st : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 24363 "parser_cocci_menhir.ml"
+# 24406 "parser_cocci_menhir.ml"
) = Obj.magic st in
let lp1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 24368 "parser_cocci_menhir.ml"
+# 24411 "parser_cocci_menhir.ml"
) = Obj.magic lp1 in
let t : 'tv_ctype = Obj.magic t in
let x0 : 'tv_storage = Obj.magic x0 in
# 41 "standard.mly"
( Some x )
-# 24379 "parser_cocci_menhir.ml"
+# 24422 "parser_cocci_menhir.ml"
in
-# 1335 "parser_cocci_menhir.mly"
+# 1323 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let t =
Ast0.wrap
(t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode ")" rp1,
P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
Ast0.wrap(Ast0.Init(s,fn t,id,P.clt2mcode "=" q,e,P.clt2mcode ";" pv)))
-# 24391 "parser_cocci_menhir.ml"
+# 24434 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_TLocal_ =
# 29 "standard.mly"
( None )
-# 24408 "parser_cocci_menhir.ml"
+# 24451 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_TLocal_ =
# 31 "standard.mly"
( Some x )
-# 24432 "parser_cocci_menhir.ml"
+# 24475 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_TPosAny_ =
# 29 "standard.mly"
( None )
-# 24449 "parser_cocci_menhir.ml"
+# 24492 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_TPosAny_ =
# 31 "standard.mly"
( Some x )
-# 24473 "parser_cocci_menhir.ml"
+# 24516 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_eexpr_ =
# 29 "standard.mly"
( None )
-# 24490 "parser_cocci_menhir.ml"
+# 24533 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_eexpr_ =
# 31 "standard.mly"
( Some x )
-# 24514 "parser_cocci_menhir.ml"
+# 24557 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_expr_ =
# 29 "standard.mly"
( None )
-# 24531 "parser_cocci_menhir.ml"
+# 24574 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_expr_ =
# 31 "standard.mly"
( Some x )
-# 24555 "parser_cocci_menhir.ml"
+# 24598 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_not_ceq_or_sub_ =
# 29 "standard.mly"
( None )
-# 24572 "parser_cocci_menhir.ml"
+# 24615 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_not_ceq_or_sub_ =
# 31 "standard.mly"
( Some x )
-# 24596 "parser_cocci_menhir.ml"
+# 24639 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_re_or_not_eqe_or_sub_ =
# 29 "standard.mly"
( None )
-# 24613 "parser_cocci_menhir.ml"
+# 24656 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_re_or_not_eqe_or_sub_ =
# 31 "standard.mly"
( Some x )
-# 24637 "parser_cocci_menhir.ml"
+# 24680 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_re_or_not_eqid_ =
# 29 "standard.mly"
( None )
-# 24654 "parser_cocci_menhir.ml"
+# 24697 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_option_re_or_not_eqid_ =
# 31 "standard.mly"
( Some x )
-# 24678 "parser_cocci_menhir.ml"
+# 24721 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_plus_after_dots =
-# 2259 "parser_cocci_menhir.mly"
+# 2247 "parser_cocci_menhir.mly"
([])
-# 24695 "parser_cocci_menhir.ml"
+# 24738 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_after_dots =
-# 2260 "parser_cocci_menhir.mly"
+# 2248 "parser_cocci_menhir.mly"
(_2)
-# 24723 "parser_cocci_menhir.ml"
+# 24766 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_after_dots =
-# 2262 "parser_cocci_menhir.mly"
+# 2250 "parser_cocci_menhir.mly"
( (Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp(_1)))))::_2 )
-# 24753 "parser_cocci_menhir.ml"
+# 24796 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_after_dots =
-# 2263 "parser_cocci_menhir.mly"
+# 2251 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.OTHER(_1))::_2 )
-# 24783 "parser_cocci_menhir.ml"
+# 24826 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_after_dots =
-# 2265 "parser_cocci_menhir.mly"
+# 2253 "parser_cocci_menhir.mly"
( (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) _1)@_2 )
-# 24813 "parser_cocci_menhir.ml"
+# 24856 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_plus_after_exp =
-# 2255 "parser_cocci_menhir.mly"
+# 2243 "parser_cocci_menhir.mly"
([])
-# 24830 "parser_cocci_menhir.ml"
+# 24873 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_after_exp =
-# 2256 "parser_cocci_menhir.mly"
+# 2244 "parser_cocci_menhir.mly"
( (Ast0.wrap(Ast0.OTHER(_1)))::_2 )
-# 24860 "parser_cocci_menhir.ml"
+# 24903 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_plus_after_stm =
-# 2268 "parser_cocci_menhir.mly"
+# 2256 "parser_cocci_menhir.mly"
([])
-# 24877 "parser_cocci_menhir.ml"
+# 24920 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_after_stm =
-# 2269 "parser_cocci_menhir.mly"
+# 2257 "parser_cocci_menhir.mly"
( (Ast0.wrap(Ast0.OTHER(_1)))::_2 )
-# 24907 "parser_cocci_menhir.ml"
+# 24950 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_after_stm =
-# 2270 "parser_cocci_menhir.mly"
+# 2258 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.OTHER(_1))::_2 )
-# 24937 "parser_cocci_menhir.ml"
+# 24980 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_after_stm =
-# 2272 "parser_cocci_menhir.mly"
+# 2260 "parser_cocci_menhir.mly"
( (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) _1)@_2 )
-# 24967 "parser_cocci_menhir.ml"
+# 25010 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_f_ in
let _endpos = _endpos_b_ in
let _v : 'tv_plus_body =
-# 858 "parser_cocci_menhir.mly"
+# 846 "parser_cocci_menhir.mly"
( f@b(*@ew*) )
-# 24997 "parser_cocci_menhir.ml"
+# 25040 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_f_ in
let _endpos = _endpos_b_ in
let _v : 'tv_plus_exp_body =
-# 872 "parser_cocci_menhir.mly"
+# 860 "parser_cocci_menhir.mly"
( f@[b](*@ew*) )
-# 25027 "parser_cocci_menhir.ml"
+# 25070 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 217 "parser_cocci_menhir.mly"
+# 191 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 25055 "parser_cocci_menhir.ml"
+# 25098 "parser_cocci_menhir.ml"
) =
-# 253 "parser_cocci_menhir.mly"
+# 227 "parser_cocci_menhir.mly"
( _1 )
-# 25059 "parser_cocci_menhir.ml"
+# 25102 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_p_ in
let _endpos = _endpos__2_ in
let _v : (
-# 217 "parser_cocci_menhir.mly"
+# 191 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 25087 "parser_cocci_menhir.ml"
+# 25130 "parser_cocci_menhir.ml"
) =
-# 253 "parser_cocci_menhir.mly"
+# 227 "parser_cocci_menhir.mly"
( p )
-# 25091 "parser_cocci_menhir.ml"
+# 25134 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_p_ in
let _endpos = _endpos__2_ in
let _v : (
-# 217 "parser_cocci_menhir.mly"
+# 191 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 25119 "parser_cocci_menhir.ml"
+# 25162 "parser_cocci_menhir.ml"
) =
-# 254 "parser_cocci_menhir.mly"
+# 228 "parser_cocci_menhir.mly"
( p )
-# 25123 "parser_cocci_menhir.ml"
+# 25166 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : (
-# 214 "parser_cocci_menhir.mly"
+# 188 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 25151 "parser_cocci_menhir.ml"
+# 25194 "parser_cocci_menhir.ml"
) =
-# 249 "parser_cocci_menhir.mly"
+# 223 "parser_cocci_menhir.mly"
( _1 )
-# 25155 "parser_cocci_menhir.ml"
+# 25198 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_p_ in
let _endpos = _endpos__2_ in
let _v : (
-# 214 "parser_cocci_menhir.mly"
+# 188 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 25183 "parser_cocci_menhir.ml"
+# 25226 "parser_cocci_menhir.ml"
) =
-# 249 "parser_cocci_menhir.mly"
+# 223 "parser_cocci_menhir.mly"
( p )
-# 25187 "parser_cocci_menhir.ml"
+# 25230 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_p_ in
let _endpos = _endpos__2_ in
let _v : (
-# 214 "parser_cocci_menhir.mly"
+# 188 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 25215 "parser_cocci_menhir.ml"
+# 25258 "parser_cocci_menhir.ml"
) =
-# 250 "parser_cocci_menhir.mly"
+# 224 "parser_cocci_menhir.mly"
( p )
-# 25219 "parser_cocci_menhir.ml"
+# 25262 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_plus_start =
-# 2244 "parser_cocci_menhir.mly"
+# 2232 "parser_cocci_menhir.mly"
( [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Ty(_1))))] )
-# 25243 "parser_cocci_menhir.ml"
+# 25286 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_plus_start =
-# 2245 "parser_cocci_menhir.mly"
+# 2233 "parser_cocci_menhir.mly"
( [Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.TopInit(_1))))] )
-# 25267 "parser_cocci_menhir.ml"
+# 25310 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_start =
-# 2247 "parser_cocci_menhir.mly"
+# 2235 "parser_cocci_menhir.mly"
( (Ast0.wrap(Ast0.OTHER(_1)))::_2 )
-# 25297 "parser_cocci_menhir.ml"
+# 25340 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_start =
-# 2249 "parser_cocci_menhir.mly"
+# 2237 "parser_cocci_menhir.mly"
( (Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp(_1)))))::_2 )
-# 25327 "parser_cocci_menhir.ml"
+# 25370 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_start =
-# 2250 "parser_cocci_menhir.mly"
+# 2238 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.OTHER(_1))::_2 )
-# 25357 "parser_cocci_menhir.ml"
+# 25400 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_plus_start =
-# 2252 "parser_cocci_menhir.mly"
+# 2240 "parser_cocci_menhir.mly"
( (List.map (function x -> Ast0.wrap(Ast0.OTHER(x))) _1)@_2 )
-# 25387 "parser_cocci_menhir.ml"
+# 25430 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_postfix_expr_eexpr_dot_expressions_ =
-# 1672 "parser_cocci_menhir.mly"
+# 1660 "parser_cocci_menhir.mly"
( _1 )
-# 25411 "parser_cocci_menhir.ml"
+# 25454 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _4 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
-# 25447 "parser_cocci_menhir.ml"
+# 25490 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr = Obj.magic _3 in
let _2 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
-# 25453 "parser_cocci_menhir.ml"
+# 25496 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_dot_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_postfix_expr_eexpr_dot_expressions_ =
-# 1674 "parser_cocci_menhir.mly"
+# 1662 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.ArrayAccess (_1,P.clt2mcode "[" _2,_3,
P.clt2mcode "]" _4)) )
-# 25462 "parser_cocci_menhir.ml"
+# 25505 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_disj_ident = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 25494 "parser_cocci_menhir.ml"
+# 25537 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_dot_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_postfix_expr_eexpr_dot_expressions_ =
-# 1677 "parser_cocci_menhir.mly"
+# 1665 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.RecordAccess(_1, P.clt2mcode "." _2, _3)) )
-# 25502 "parser_cocci_menhir.ml"
+# 25545 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_disj_ident = Obj.magic _3 in
let _2 : (
-# 176 "parser_cocci_menhir.mly"
+# 150 "parser_cocci_menhir.mly"
(Data.clt)
-# 25534 "parser_cocci_menhir.ml"
+# 25577 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_dot_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_postfix_expr_eexpr_dot_expressions_ =
-# 1679 "parser_cocci_menhir.mly"
+# 1667 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.RecordPtAccess(_1, P.clt2mcode "->" _2,
_3)) )
-# 25543 "parser_cocci_menhir.ml"
+# 25586 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 25569 "parser_cocci_menhir.ml"
+# 25612 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_dot_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_postfix_expr_eexpr_dot_expressions_ =
-# 1682 "parser_cocci_menhir.mly"
+# 1670 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Inc _2)) )
-# 25577 "parser_cocci_menhir.ml"
+# 25620 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 25603 "parser_cocci_menhir.ml"
+# 25646 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_dot_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_postfix_expr_eexpr_dot_expressions_ =
-# 1684 "parser_cocci_menhir.mly"
+# 1672 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Dec _2)) )
-# 25611 "parser_cocci_menhir.ml"
+# 25654 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 25647 "parser_cocci_menhir.ml"
+# 25690 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr_list_option = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 25653 "parser_cocci_menhir.ml"
+# 25696 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_dot_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_postfix_expr_eexpr_dot_expressions_ =
-# 1686 "parser_cocci_menhir.mly"
+# 1674 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.FunCall(_1,P.clt2mcode "(" _2,
_3,
P.clt2mcode ")" _4)) )
-# 25663 "parser_cocci_menhir.ml"
+# 25706 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _6 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 25709 "parser_cocci_menhir.ml"
+# 25752 "parser_cocci_menhir.ml"
) = Obj.magic _6 in
let _5 : 'tv_initialize_list = Obj.magic _5 in
let _4 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 25715 "parser_cocci_menhir.ml"
+# 25758 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 25720 "parser_cocci_menhir.ml"
+# 25763 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_ctype = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 25726 "parser_cocci_menhir.ml"
+# 25769 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__6_ in
let _v : 'tv_postfix_expr_eexpr_dot_expressions_ =
-# 1692 "parser_cocci_menhir.mly"
+# 1680 "parser_cocci_menhir.mly"
( let init =
if P.struct_initializer _5
then
(Ast0.InitList(P.clt2mcode "{" _4,_5,P.clt2mcode "}" _6,true)) in
Ast0.wrap
(Ast0.Constructor(P.clt2mcode "(" _1, _2, P.clt2mcode ")" _3, init)) )
-# 25743 "parser_cocci_menhir.ml"
+# 25786 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_postfix_expr_eexpr_invalid_ =
-# 1672 "parser_cocci_menhir.mly"
+# 1660 "parser_cocci_menhir.mly"
( _1 )
-# 25767 "parser_cocci_menhir.ml"
+# 25810 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _4 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
-# 25803 "parser_cocci_menhir.ml"
+# 25846 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr = Obj.magic _3 in
let _2 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
-# 25809 "parser_cocci_menhir.ml"
+# 25852 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_postfix_expr_eexpr_invalid_ =
-# 1674 "parser_cocci_menhir.mly"
+# 1662 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.ArrayAccess (_1,P.clt2mcode "[" _2,_3,
P.clt2mcode "]" _4)) )
-# 25818 "parser_cocci_menhir.ml"
+# 25861 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_disj_ident = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 25850 "parser_cocci_menhir.ml"
+# 25893 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_postfix_expr_eexpr_invalid_ =
-# 1677 "parser_cocci_menhir.mly"
+# 1665 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.RecordAccess(_1, P.clt2mcode "." _2, _3)) )
-# 25858 "parser_cocci_menhir.ml"
+# 25901 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_disj_ident = Obj.magic _3 in
let _2 : (
-# 176 "parser_cocci_menhir.mly"
+# 150 "parser_cocci_menhir.mly"
(Data.clt)
-# 25890 "parser_cocci_menhir.ml"
+# 25933 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_postfix_expr_eexpr_invalid_ =
-# 1679 "parser_cocci_menhir.mly"
+# 1667 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.RecordPtAccess(_1, P.clt2mcode "->" _2,
_3)) )
-# 25899 "parser_cocci_menhir.ml"
+# 25942 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 25925 "parser_cocci_menhir.ml"
+# 25968 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_postfix_expr_eexpr_invalid_ =
-# 1682 "parser_cocci_menhir.mly"
+# 1670 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Inc _2)) )
-# 25933 "parser_cocci_menhir.ml"
+# 25976 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 25959 "parser_cocci_menhir.ml"
+# 26002 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_postfix_expr_eexpr_invalid_ =
-# 1684 "parser_cocci_menhir.mly"
+# 1672 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Dec _2)) )
-# 25967 "parser_cocci_menhir.ml"
+# 26010 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 26003 "parser_cocci_menhir.ml"
+# 26046 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr_list_option = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 26009 "parser_cocci_menhir.ml"
+# 26052 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_postfix_expr_eexpr_invalid_ =
-# 1686 "parser_cocci_menhir.mly"
+# 1674 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.FunCall(_1,P.clt2mcode "(" _2,
_3,
P.clt2mcode ")" _4)) )
-# 26019 "parser_cocci_menhir.ml"
+# 26062 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _6 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 26065 "parser_cocci_menhir.ml"
+# 26108 "parser_cocci_menhir.ml"
) = Obj.magic _6 in
let _5 : 'tv_initialize_list = Obj.magic _5 in
let _4 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 26071 "parser_cocci_menhir.ml"
+# 26114 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 26076 "parser_cocci_menhir.ml"
+# 26119 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_ctype = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 26082 "parser_cocci_menhir.ml"
+# 26125 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__6_ in
let _v : 'tv_postfix_expr_eexpr_invalid_ =
-# 1692 "parser_cocci_menhir.mly"
+# 1680 "parser_cocci_menhir.mly"
( let init =
if P.struct_initializer _5
then
(Ast0.InitList(P.clt2mcode "{" _4,_5,P.clt2mcode "}" _6,true)) in
Ast0.wrap
(Ast0.Constructor(P.clt2mcode "(" _1, _2, P.clt2mcode ")" _3, init)) )
-# 26099 "parser_cocci_menhir.ml"
+# 26142 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_postfix_expr_eexpr_nest_expressions_ =
-# 1672 "parser_cocci_menhir.mly"
+# 1660 "parser_cocci_menhir.mly"
( _1 )
-# 26123 "parser_cocci_menhir.ml"
+# 26166 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _4 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
-# 26159 "parser_cocci_menhir.ml"
+# 26202 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr = Obj.magic _3 in
let _2 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
-# 26165 "parser_cocci_menhir.ml"
+# 26208 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_nest_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_postfix_expr_eexpr_nest_expressions_ =
-# 1674 "parser_cocci_menhir.mly"
+# 1662 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.ArrayAccess (_1,P.clt2mcode "[" _2,_3,
P.clt2mcode "]" _4)) )
-# 26174 "parser_cocci_menhir.ml"
+# 26217 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_disj_ident = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 26206 "parser_cocci_menhir.ml"
+# 26249 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_nest_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_postfix_expr_eexpr_nest_expressions_ =
-# 1677 "parser_cocci_menhir.mly"
+# 1665 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.RecordAccess(_1, P.clt2mcode "." _2, _3)) )
-# 26214 "parser_cocci_menhir.ml"
+# 26257 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_disj_ident = Obj.magic _3 in
let _2 : (
-# 176 "parser_cocci_menhir.mly"
+# 150 "parser_cocci_menhir.mly"
(Data.clt)
-# 26246 "parser_cocci_menhir.ml"
+# 26289 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_nest_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_postfix_expr_eexpr_nest_expressions_ =
-# 1679 "parser_cocci_menhir.mly"
+# 1667 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.RecordPtAccess(_1, P.clt2mcode "->" _2,
_3)) )
-# 26255 "parser_cocci_menhir.ml"
+# 26298 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 26281 "parser_cocci_menhir.ml"
+# 26324 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_nest_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_postfix_expr_eexpr_nest_expressions_ =
-# 1682 "parser_cocci_menhir.mly"
+# 1670 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Inc _2)) )
-# 26289 "parser_cocci_menhir.ml"
+# 26332 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 26315 "parser_cocci_menhir.ml"
+# 26358 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_nest_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_postfix_expr_eexpr_nest_expressions_ =
-# 1684 "parser_cocci_menhir.mly"
+# 1672 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Dec _2)) )
-# 26323 "parser_cocci_menhir.ml"
+# 26366 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 26359 "parser_cocci_menhir.ml"
+# 26402 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr_list_option = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 26365 "parser_cocci_menhir.ml"
+# 26408 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_eexpr_nest_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_postfix_expr_eexpr_nest_expressions_ =
-# 1686 "parser_cocci_menhir.mly"
+# 1674 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.FunCall(_1,P.clt2mcode "(" _2,
_3,
P.clt2mcode ")" _4)) )
-# 26375 "parser_cocci_menhir.ml"
+# 26418 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _6 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 26421 "parser_cocci_menhir.ml"
+# 26464 "parser_cocci_menhir.ml"
) = Obj.magic _6 in
let _5 : 'tv_initialize_list = Obj.magic _5 in
let _4 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 26427 "parser_cocci_menhir.ml"
+# 26470 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 26432 "parser_cocci_menhir.ml"
+# 26475 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_ctype = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 26438 "parser_cocci_menhir.ml"
+# 26481 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__6_ in
let _v : 'tv_postfix_expr_eexpr_nest_expressions_ =
-# 1692 "parser_cocci_menhir.mly"
+# 1680 "parser_cocci_menhir.mly"
( let init =
if P.struct_initializer _5
then
(Ast0.InitList(P.clt2mcode "{" _4,_5,P.clt2mcode "}" _6,true)) in
Ast0.wrap
(Ast0.Constructor(P.clt2mcode "(" _1, _2, P.clt2mcode ")" _3, init)) )
-# 26455 "parser_cocci_menhir.ml"
+# 26498 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_postfix_expr_expr_invalid_ =
-# 1672 "parser_cocci_menhir.mly"
+# 1660 "parser_cocci_menhir.mly"
( _1 )
-# 26479 "parser_cocci_menhir.ml"
+# 26522 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _4 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
-# 26515 "parser_cocci_menhir.ml"
+# 26558 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr = Obj.magic _3 in
let _2 : (
-# 174 "parser_cocci_menhir.mly"
+# 148 "parser_cocci_menhir.mly"
(Data.clt)
-# 26521 "parser_cocci_menhir.ml"
+# 26564 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_expr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_postfix_expr_expr_invalid_ =
-# 1674 "parser_cocci_menhir.mly"
+# 1662 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.ArrayAccess (_1,P.clt2mcode "[" _2,_3,
P.clt2mcode "]" _4)) )
-# 26530 "parser_cocci_menhir.ml"
+# 26573 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_disj_ident = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 26562 "parser_cocci_menhir.ml"
+# 26605 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_expr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_postfix_expr_expr_invalid_ =
-# 1677 "parser_cocci_menhir.mly"
+# 1665 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.RecordAccess(_1, P.clt2mcode "." _2, _3)) )
-# 26570 "parser_cocci_menhir.ml"
+# 26613 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_disj_ident = Obj.magic _3 in
let _2 : (
-# 176 "parser_cocci_menhir.mly"
+# 150 "parser_cocci_menhir.mly"
(Data.clt)
-# 26602 "parser_cocci_menhir.ml"
+# 26645 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_expr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_postfix_expr_expr_invalid_ =
-# 1679 "parser_cocci_menhir.mly"
+# 1667 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.RecordPtAccess(_1, P.clt2mcode "->" _2,
_3)) )
-# 26611 "parser_cocci_menhir.ml"
+# 26654 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 26637 "parser_cocci_menhir.ml"
+# 26680 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_expr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_postfix_expr_expr_invalid_ =
-# 1682 "parser_cocci_menhir.mly"
+# 1670 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Inc _2)) )
-# 26645 "parser_cocci_menhir.ml"
+# 26688 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 26671 "parser_cocci_menhir.ml"
+# 26714 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_expr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_postfix_expr_expr_invalid_ =
-# 1684 "parser_cocci_menhir.mly"
+# 1672 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Postfix (_1, P.clt2mcode Ast.Dec _2)) )
-# 26679 "parser_cocci_menhir.ml"
+# 26722 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 26715 "parser_cocci_menhir.ml"
+# 26758 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr_list_option = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 26721 "parser_cocci_menhir.ml"
+# 26764 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_postfix_expr_expr_invalid_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_postfix_expr_expr_invalid_ =
-# 1686 "parser_cocci_menhir.mly"
+# 1674 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.FunCall(_1,P.clt2mcode "(" _2,
_3,
P.clt2mcode ")" _4)) )
-# 26731 "parser_cocci_menhir.ml"
+# 26774 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _6 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 26777 "parser_cocci_menhir.ml"
+# 26820 "parser_cocci_menhir.ml"
) = Obj.magic _6 in
let _5 : 'tv_initialize_list = Obj.magic _5 in
let _4 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 26783 "parser_cocci_menhir.ml"
+# 26826 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 26788 "parser_cocci_menhir.ml"
+# 26831 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_ctype = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 26794 "parser_cocci_menhir.ml"
+# 26837 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__6_ in
let _v : 'tv_postfix_expr_expr_invalid_ =
-# 1692 "parser_cocci_menhir.mly"
+# 1680 "parser_cocci_menhir.mly"
( let init =
if P.struct_initializer _5
then
(Ast0.InitList(P.clt2mcode "{" _4,_5,P.clt2mcode "}" _6,true)) in
Ast0.wrap
(Ast0.Constructor(P.clt2mcode "(" _1, _2, P.clt2mcode ")" _3, init)) )
-# 26811 "parser_cocci_menhir.ml"
+# 26854 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pre_basic_expr_eexpr_dot_expressions_ =
-# 1521 "parser_cocci_menhir.mly"
+# 1509 "parser_cocci_menhir.mly"
( _1 )
-# 26835 "parser_cocci_menhir.ml"
+# 26878 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_basic_expr_eexpr_dot_expressions_ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 26867 "parser_cocci_menhir.ml"
+# 26910 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_pre_basic_expr_eexpr_dot_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_pre_basic_expr_eexpr_dot_expressions_ =
-# 1524 "parser_cocci_menhir.mly"
+# 1512 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Sequence(_1,P.clt2mcode "," _2,_3)) )
-# 26875 "parser_cocci_menhir.ml"
+# 26918 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pre_basic_expr_eexpr_nest_expressions_ =
-# 1521 "parser_cocci_menhir.mly"
+# 1509 "parser_cocci_menhir.mly"
( _1 )
-# 26899 "parser_cocci_menhir.ml"
+# 26942 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_basic_expr_eexpr_nest_expressions_ = Obj.magic _3 in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 26931 "parser_cocci_menhir.ml"
+# 26974 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_pre_basic_expr_eexpr_nest_expressions_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_pre_basic_expr_eexpr_nest_expressions_ =
-# 1524 "parser_cocci_menhir.mly"
+# 1512 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Sequence(_1,P.clt2mcode "," _2,_3)) )
-# 26939 "parser_cocci_menhir.ml"
+# 26982 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1705 "parser_cocci_menhir.mly"
+# 1693 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Ident(_1)) )
-# 26963 "parser_cocci_menhir.ml"
+# 27006 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_ident = Obj.magic _2 in
let _1 : (
-# 162 "parser_cocci_menhir.mly"
+# 136 "parser_cocci_menhir.mly"
(Data.clt)
-# 26990 "parser_cocci_menhir.ml"
+# 27033 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1707 "parser_cocci_menhir.mly"
+# 1695 "parser_cocci_menhir.mly"
( let op = P.clt2mcode Ast.GetRefLabel _1 in
Ast0.wrap(Ast0.Unary(Ast0.wrap(Ast0.Ident(_2)), op)) )
-# 26998 "parser_cocci_menhir.ml"
+# 27041 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27019 "parser_cocci_menhir.ml"
+# 27062 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1710 "parser_cocci_menhir.mly"
+# 1698 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) )
-# 27027 "parser_cocci_menhir.ml"
+# 27070 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27048 "parser_cocci_menhir.ml"
+# 27091 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1713 "parser_cocci_menhir.mly"
+# 1701 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Float x) clt)) )
-# 27056 "parser_cocci_menhir.ml"
+# 27099 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27077 "parser_cocci_menhir.ml"
+# 27120 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1716 "parser_cocci_menhir.mly"
+# 1704 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.String x) clt)) )
-# 27085 "parser_cocci_menhir.ml"
+# 27128 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27106 "parser_cocci_menhir.ml"
+# 27149 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1719 "parser_cocci_menhir.mly"
+# 1707 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Char x) clt)) )
-# 27114 "parser_cocci_menhir.ml"
+# 27157 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 27135 "parser_cocci_menhir.ml"
+# 27178 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1722 "parser_cocci_menhir.mly"
+# 1710 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.CONST,pure)) )
-# 27144 "parser_cocci_menhir.ml"
+# 27187 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 133 "parser_cocci_menhir.mly"
+# 107 "parser_cocci_menhir.mly"
(Parse_aux.expinfo)
-# 27165 "parser_cocci_menhir.ml"
+# 27208 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1726 "parser_cocci_menhir.mly"
+# 1714 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaErr(P.clt2mcode nm clt,constraints,pure)) )
-# 27173 "parser_cocci_menhir.ml"
+# 27216 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 27194 "parser_cocci_menhir.ml"
+# 27237 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1729 "parser_cocci_menhir.mly"
+# 1717 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ANY,pure)) )
-# 27203 "parser_cocci_menhir.ml"
+# 27246 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 27224 "parser_cocci_menhir.ml"
+# 27267 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1733 "parser_cocci_menhir.mly"
+# 1721 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ID,pure)) )
-# 27233 "parser_cocci_menhir.ml"
+# 27276 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 27254 "parser_cocci_menhir.ml"
+# 27297 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1737 "parser_cocci_menhir.mly"
+# 1725 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.LocalID,pure)) )
-# 27263 "parser_cocci_menhir.ml"
+# 27306 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 27294 "parser_cocci_menhir.ml"
+# 27337 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_eexpr = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 27300 "parser_cocci_menhir.ml"
+# 27343 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1741 "parser_cocci_menhir.mly"
+# 1729 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Paren(P.clt2mcode "(" _1,_2,
P.clt2mcode ")" _3)) )
-# 27308 "parser_cocci_menhir.ml"
+# 27351 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 27339 "parser_cocci_menhir.ml"
+# 27382 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_midzero_list_eexpr_eexpr_ = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 27345 "parser_cocci_menhir.ml"
+# 27388 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1744 "parser_cocci_menhir.mly"
+# 1732 "parser_cocci_menhir.mly"
( let (mids,code) = _2 in
Ast0.wrap(Ast0.DisjExpr(P.clt2mcode "(" _1,
code, mids,
P.clt2mcode ")" _3)) )
-# 27355 "parser_cocci_menhir.ml"
+# 27398 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_dot_expressions_ =
-# 1748 "parser_cocci_menhir.mly"
+# 1736 "parser_cocci_menhir.mly"
( _1 )
-# 27379 "parser_cocci_menhir.ml"
+# 27422 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1705 "parser_cocci_menhir.mly"
+# 1693 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Ident(_1)) )
-# 27403 "parser_cocci_menhir.ml"
+# 27446 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_ident = Obj.magic _2 in
let _1 : (
-# 162 "parser_cocci_menhir.mly"
+# 136 "parser_cocci_menhir.mly"
(Data.clt)
-# 27430 "parser_cocci_menhir.ml"
+# 27473 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1707 "parser_cocci_menhir.mly"
+# 1695 "parser_cocci_menhir.mly"
( let op = P.clt2mcode Ast.GetRefLabel _1 in
Ast0.wrap(Ast0.Unary(Ast0.wrap(Ast0.Ident(_2)), op)) )
-# 27438 "parser_cocci_menhir.ml"
+# 27481 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27459 "parser_cocci_menhir.ml"
+# 27502 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1710 "parser_cocci_menhir.mly"
+# 1698 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) )
-# 27467 "parser_cocci_menhir.ml"
+# 27510 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27488 "parser_cocci_menhir.ml"
+# 27531 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1713 "parser_cocci_menhir.mly"
+# 1701 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Float x) clt)) )
-# 27496 "parser_cocci_menhir.ml"
+# 27539 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27517 "parser_cocci_menhir.ml"
+# 27560 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1716 "parser_cocci_menhir.mly"
+# 1704 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.String x) clt)) )
-# 27525 "parser_cocci_menhir.ml"
+# 27568 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27546 "parser_cocci_menhir.ml"
+# 27589 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1719 "parser_cocci_menhir.mly"
+# 1707 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Char x) clt)) )
-# 27554 "parser_cocci_menhir.ml"
+# 27597 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 27575 "parser_cocci_menhir.ml"
+# 27618 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1722 "parser_cocci_menhir.mly"
+# 1710 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.CONST,pure)) )
-# 27584 "parser_cocci_menhir.ml"
+# 27627 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 133 "parser_cocci_menhir.mly"
+# 107 "parser_cocci_menhir.mly"
(Parse_aux.expinfo)
-# 27605 "parser_cocci_menhir.ml"
+# 27648 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1726 "parser_cocci_menhir.mly"
+# 1714 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaErr(P.clt2mcode nm clt,constraints,pure)) )
-# 27613 "parser_cocci_menhir.ml"
+# 27656 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 27634 "parser_cocci_menhir.ml"
+# 27677 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1729 "parser_cocci_menhir.mly"
+# 1717 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ANY,pure)) )
-# 27643 "parser_cocci_menhir.ml"
+# 27686 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 27664 "parser_cocci_menhir.ml"
+# 27707 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1733 "parser_cocci_menhir.mly"
+# 1721 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ID,pure)) )
-# 27673 "parser_cocci_menhir.ml"
+# 27716 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 27694 "parser_cocci_menhir.ml"
+# 27737 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1737 "parser_cocci_menhir.mly"
+# 1725 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.LocalID,pure)) )
-# 27703 "parser_cocci_menhir.ml"
+# 27746 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 27734 "parser_cocci_menhir.ml"
+# 27777 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_eexpr = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 27740 "parser_cocci_menhir.ml"
+# 27783 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1741 "parser_cocci_menhir.mly"
+# 1729 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Paren(P.clt2mcode "(" _1,_2,
P.clt2mcode ")" _3)) )
-# 27748 "parser_cocci_menhir.ml"
+# 27791 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 27779 "parser_cocci_menhir.ml"
+# 27822 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_midzero_list_eexpr_eexpr_ = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 27785 "parser_cocci_menhir.ml"
+# 27828 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1744 "parser_cocci_menhir.mly"
+# 1732 "parser_cocci_menhir.mly"
( let (mids,code) = _2 in
Ast0.wrap(Ast0.DisjExpr(P.clt2mcode "(" _1,
code, mids,
P.clt2mcode ")" _3)) )
-# 27795 "parser_cocci_menhir.ml"
+# 27838 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_invalid_ =
-# 1748 "parser_cocci_menhir.mly"
+# 1736 "parser_cocci_menhir.mly"
( _1 )
-# 27819 "parser_cocci_menhir.ml"
+# 27862 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1705 "parser_cocci_menhir.mly"
+# 1693 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Ident(_1)) )
-# 27843 "parser_cocci_menhir.ml"
+# 27886 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_ident = Obj.magic _2 in
let _1 : (
-# 162 "parser_cocci_menhir.mly"
+# 136 "parser_cocci_menhir.mly"
(Data.clt)
-# 27870 "parser_cocci_menhir.ml"
+# 27913 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1707 "parser_cocci_menhir.mly"
+# 1695 "parser_cocci_menhir.mly"
( let op = P.clt2mcode Ast.GetRefLabel _1 in
Ast0.wrap(Ast0.Unary(Ast0.wrap(Ast0.Ident(_2)), op)) )
-# 27878 "parser_cocci_menhir.ml"
+# 27921 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27899 "parser_cocci_menhir.ml"
+# 27942 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1710 "parser_cocci_menhir.mly"
+# 1698 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) )
-# 27907 "parser_cocci_menhir.ml"
+# 27950 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27928 "parser_cocci_menhir.ml"
+# 27971 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1713 "parser_cocci_menhir.mly"
+# 1701 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Float x) clt)) )
-# 27936 "parser_cocci_menhir.ml"
+# 27979 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27957 "parser_cocci_menhir.ml"
+# 28000 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1716 "parser_cocci_menhir.mly"
+# 1704 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.String x) clt)) )
-# 27965 "parser_cocci_menhir.ml"
+# 28008 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 27986 "parser_cocci_menhir.ml"
+# 28029 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1719 "parser_cocci_menhir.mly"
+# 1707 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Char x) clt)) )
-# 27994 "parser_cocci_menhir.ml"
+# 28037 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 28015 "parser_cocci_menhir.ml"
+# 28058 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1722 "parser_cocci_menhir.mly"
+# 1710 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.CONST,pure)) )
-# 28024 "parser_cocci_menhir.ml"
+# 28067 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 133 "parser_cocci_menhir.mly"
+# 107 "parser_cocci_menhir.mly"
(Parse_aux.expinfo)
-# 28045 "parser_cocci_menhir.ml"
+# 28088 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1726 "parser_cocci_menhir.mly"
+# 1714 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaErr(P.clt2mcode nm clt,constraints,pure)) )
-# 28053 "parser_cocci_menhir.ml"
+# 28096 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 28074 "parser_cocci_menhir.ml"
+# 28117 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1729 "parser_cocci_menhir.mly"
+# 1717 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ANY,pure)) )
-# 28083 "parser_cocci_menhir.ml"
+# 28126 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 28104 "parser_cocci_menhir.ml"
+# 28147 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1733 "parser_cocci_menhir.mly"
+# 1721 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ID,pure)) )
-# 28113 "parser_cocci_menhir.ml"
+# 28156 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 28134 "parser_cocci_menhir.ml"
+# 28177 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1737 "parser_cocci_menhir.mly"
+# 1725 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.LocalID,pure)) )
-# 28143 "parser_cocci_menhir.ml"
+# 28186 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 28174 "parser_cocci_menhir.ml"
+# 28217 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_eexpr = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 28180 "parser_cocci_menhir.ml"
+# 28223 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1741 "parser_cocci_menhir.mly"
+# 1729 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Paren(P.clt2mcode "(" _1,_2,
P.clt2mcode ")" _3)) )
-# 28188 "parser_cocci_menhir.ml"
+# 28231 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 28219 "parser_cocci_menhir.ml"
+# 28262 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_midzero_list_eexpr_eexpr_ = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 28225 "parser_cocci_menhir.ml"
+# 28268 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1744 "parser_cocci_menhir.mly"
+# 1732 "parser_cocci_menhir.mly"
( let (mids,code) = _2 in
Ast0.wrap(Ast0.DisjExpr(P.clt2mcode "(" _1,
code, mids,
P.clt2mcode ")" _3)) )
-# 28235 "parser_cocci_menhir.ml"
+# 28278 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_eexpr_nest_expressions_ =
-# 1748 "parser_cocci_menhir.mly"
+# 1736 "parser_cocci_menhir.mly"
( _1 )
-# 28259 "parser_cocci_menhir.ml"
+# 28302 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1705 "parser_cocci_menhir.mly"
+# 1693 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Ident(_1)) )
-# 28283 "parser_cocci_menhir.ml"
+# 28326 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_ident = Obj.magic _2 in
let _1 : (
-# 162 "parser_cocci_menhir.mly"
+# 136 "parser_cocci_menhir.mly"
(Data.clt)
-# 28310 "parser_cocci_menhir.ml"
+# 28353 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1707 "parser_cocci_menhir.mly"
+# 1695 "parser_cocci_menhir.mly"
( let op = P.clt2mcode Ast.GetRefLabel _1 in
Ast0.wrap(Ast0.Unary(Ast0.wrap(Ast0.Ident(_2)), op)) )
-# 28318 "parser_cocci_menhir.ml"
+# 28361 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 28339 "parser_cocci_menhir.ml"
+# 28382 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1710 "parser_cocci_menhir.mly"
+# 1698 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Int x) clt)) )
-# 28347 "parser_cocci_menhir.ml"
+# 28390 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 28368 "parser_cocci_menhir.ml"
+# 28411 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1713 "parser_cocci_menhir.mly"
+# 1701 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Float x) clt)) )
-# 28376 "parser_cocci_menhir.ml"
+# 28419 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 28397 "parser_cocci_menhir.ml"
+# 28440 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1716 "parser_cocci_menhir.mly"
+# 1704 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.String x) clt)) )
-# 28405 "parser_cocci_menhir.ml"
+# 28448 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 28426 "parser_cocci_menhir.ml"
+# 28469 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1719 "parser_cocci_menhir.mly"
+# 1707 "parser_cocci_menhir.mly"
( let (x,clt) = _1 in
Ast0.wrap(Ast0.Constant (P.clt2mcode (Ast.Char x) clt)) )
-# 28434 "parser_cocci_menhir.ml"
+# 28477 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 28455 "parser_cocci_menhir.ml"
+# 28498 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1722 "parser_cocci_menhir.mly"
+# 1710 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.CONST,pure)) )
-# 28464 "parser_cocci_menhir.ml"
+# 28507 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 133 "parser_cocci_menhir.mly"
+# 107 "parser_cocci_menhir.mly"
(Parse_aux.expinfo)
-# 28485 "parser_cocci_menhir.ml"
+# 28528 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1726 "parser_cocci_menhir.mly"
+# 1714 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaErr(P.clt2mcode nm clt,constraints,pure)) )
-# 28493 "parser_cocci_menhir.ml"
+# 28536 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 28514 "parser_cocci_menhir.ml"
+# 28557 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1729 "parser_cocci_menhir.mly"
+# 1717 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ANY,pure)) )
-# 28523 "parser_cocci_menhir.ml"
+# 28566 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 28544 "parser_cocci_menhir.ml"
+# 28587 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1733 "parser_cocci_menhir.mly"
+# 1721 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.ID,pure)) )
-# 28553 "parser_cocci_menhir.ml"
+# 28596 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 138 "parser_cocci_menhir.mly"
+# 112 "parser_cocci_menhir.mly"
(Parse_aux.typed_expinfo)
-# 28574 "parser_cocci_menhir.ml"
+# 28617 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1737 "parser_cocci_menhir.mly"
+# 1725 "parser_cocci_menhir.mly"
( let (nm,constraints,pure,ty,clt) = _1 in
Ast0.wrap
(Ast0.MetaExpr(P.clt2mcode nm clt,constraints,ty,Ast.LocalID,pure)) )
-# 28583 "parser_cocci_menhir.ml"
+# 28626 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 28614 "parser_cocci_menhir.ml"
+# 28657 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_eexpr = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 28620 "parser_cocci_menhir.ml"
+# 28663 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1741 "parser_cocci_menhir.mly"
+# 1729 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Paren(P.clt2mcode "(" _1,_2,
P.clt2mcode ")" _3)) )
-# 28628 "parser_cocci_menhir.ml"
+# 28671 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 28659 "parser_cocci_menhir.ml"
+# 28702 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_midzero_list_expr_eexpr_ = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 28665 "parser_cocci_menhir.ml"
+# 28708 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1744 "parser_cocci_menhir.mly"
+# 1732 "parser_cocci_menhir.mly"
( let (mids,code) = _2 in
Ast0.wrap(Ast0.DisjExpr(P.clt2mcode "(" _1,
code, mids,
P.clt2mcode ")" _3)) )
-# 28675 "parser_cocci_menhir.ml"
+# 28718 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_primary_expr_expr_invalid_ =
-# 1748 "parser_cocci_menhir.mly"
+# 1736 "parser_cocci_menhir.mly"
( _1 )
-# 28699 "parser_cocci_menhir.ml"
+# 28742 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure =
-# 264 "parser_cocci_menhir.mly"
+# 238 "parser_cocci_menhir.mly"
( Ast0.Pure )
-# 28721 "parser_cocci_menhir.ml"
+# 28764 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure =
-# 265 "parser_cocci_menhir.mly"
+# 239 "parser_cocci_menhir.mly"
( Ast0.Context )
-# 28743 "parser_cocci_menhir.ml"
+# 28786 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_pure =
-# 266 "parser_cocci_menhir.mly"
+# 240 "parser_cocci_menhir.mly"
( Ast0.PureContext )
-# 28769 "parser_cocci_menhir.ml"
+# 28812 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_pure =
-# 267 "parser_cocci_menhir.mly"
+# 241 "parser_cocci_menhir.mly"
( Ast0.PureContext )
-# 28795 "parser_cocci_menhir.ml"
+# 28838 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_pure =
-# 268 "parser_cocci_menhir.mly"
+# 242 "parser_cocci_menhir.mly"
( Ast0.Impure )
-# 28812 "parser_cocci_menhir.ml"
+# 28855 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 28833 "parser_cocci_menhir.ml"
+# 28876 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident =
-# 1762 "parser_cocci_menhir.mly"
+# 1750 "parser_cocci_menhir.mly"
( _1 )
-# 28840 "parser_cocci_menhir.ml"
+# 28883 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1769 "parser_cocci_menhir.mly"
+# 1757 "parser_cocci_menhir.mly"
( "identifier" )
-# 28862 "parser_cocci_menhir.ml"
+# 28905 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1770 "parser_cocci_menhir.mly"
+# 1758 "parser_cocci_menhir.mly"
( "expression" )
-# 28884 "parser_cocci_menhir.ml"
+# 28927 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1771 "parser_cocci_menhir.mly"
+# 1759 "parser_cocci_menhir.mly"
( "statement" )
-# 28906 "parser_cocci_menhir.ml"
+# 28949 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1772 "parser_cocci_menhir.mly"
+# 1760 "parser_cocci_menhir.mly"
( "function" )
-# 28928 "parser_cocci_menhir.ml"
+# 28971 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1773 "parser_cocci_menhir.mly"
+# 1761 "parser_cocci_menhir.mly"
( "local" )
-# 28950 "parser_cocci_menhir.ml"
+# 28993 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1774 "parser_cocci_menhir.mly"
+# 1762 "parser_cocci_menhir.mly"
( "type" )
-# 28972 "parser_cocci_menhir.ml"
+# 29015 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1775 "parser_cocci_menhir.mly"
+# 1763 "parser_cocci_menhir.mly"
( "parameter" )
-# 28994 "parser_cocci_menhir.ml"
+# 29037 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1776 "parser_cocci_menhir.mly"
+# 1764 "parser_cocci_menhir.mly"
( "idexpression" )
-# 29016 "parser_cocci_menhir.ml"
+# 29059 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1777 "parser_cocci_menhir.mly"
+# 1765 "parser_cocci_menhir.mly"
( "initialiser" )
-# 29038 "parser_cocci_menhir.ml"
+# 29081 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1778 "parser_cocci_menhir.mly"
+# 1766 "parser_cocci_menhir.mly"
( "list" )
-# 29060 "parser_cocci_menhir.ml"
+# 29103 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1779 "parser_cocci_menhir.mly"
+# 1767 "parser_cocci_menhir.mly"
( "fresh" )
-# 29082 "parser_cocci_menhir.ml"
+# 29125 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1780 "parser_cocci_menhir.mly"
+# 1768 "parser_cocci_menhir.mly"
( "constant" )
-# 29104 "parser_cocci_menhir.ml"
+# 29147 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1781 "parser_cocci_menhir.mly"
+# 1769 "parser_cocci_menhir.mly"
( "error" )
-# 29126 "parser_cocci_menhir.ml"
+# 29169 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1782 "parser_cocci_menhir.mly"
+# 1770 "parser_cocci_menhir.mly"
( "words" )
-# 29148 "parser_cocci_menhir.ml"
+# 29191 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1783 "parser_cocci_menhir.mly"
+# 1771 "parser_cocci_menhir.mly"
( "pure" )
-# 29170 "parser_cocci_menhir.ml"
+# 29213 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1784 "parser_cocci_menhir.mly"
+# 1772 "parser_cocci_menhir.mly"
( "context" )
-# 29192 "parser_cocci_menhir.ml"
+# 29235 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1785 "parser_cocci_menhir.mly"
+# 1773 "parser_cocci_menhir.mly"
( "generated" )
-# 29214 "parser_cocci_menhir.ml"
+# 29257 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1786 "parser_cocci_menhir.mly"
+# 1774 "parser_cocci_menhir.mly"
( "typedef" )
-# 29236 "parser_cocci_menhir.ml"
+# 29279 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1787 "parser_cocci_menhir.mly"
+# 1775 "parser_cocci_menhir.mly"
( "declarer" )
-# 29258 "parser_cocci_menhir.ml"
+# 29301 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1788 "parser_cocci_menhir.mly"
+# 1776 "parser_cocci_menhir.mly"
( "iterator" )
-# 29280 "parser_cocci_menhir.ml"
+# 29323 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1789 "parser_cocci_menhir.mly"
+# 1777 "parser_cocci_menhir.mly"
( "name" )
-# 29302 "parser_cocci_menhir.ml"
+# 29345 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1790 "parser_cocci_menhir.mly"
+# 1778 "parser_cocci_menhir.mly"
( "position" )
-# 29324 "parser_cocci_menhir.ml"
+# 29367 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_kwd =
-# 1791 "parser_cocci_menhir.mly"
+# 1779 "parser_cocci_menhir.mly"
( "symbol" )
-# 29346 "parser_cocci_menhir.ml"
+# 29389 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_or_meta_ident =
-# 1798 "parser_cocci_menhir.mly"
+# 1786 "parser_cocci_menhir.mly"
( (None,P.id2name _1) )
-# 29370 "parser_cocci_menhir.ml"
+# 29413 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_or_meta_ident =
-# 1799 "parser_cocci_menhir.mly"
+# 1787 "parser_cocci_menhir.mly"
( (None,_1) )
-# 29394 "parser_cocci_menhir.ml"
+# 29437 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_or_meta_ident =
-# 1800 "parser_cocci_menhir.mly"
+# 1788 "parser_cocci_menhir.mly"
( _1 )
-# 29418 "parser_cocci_menhir.ml"
+# 29461 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_i_ in
let _endpos = _endpos_optc_ in
let _v : 'tv_pure_ident_or_meta_ident_with_econstraint_not_ceq_or_sub_ =
-# 1837 "parser_cocci_menhir.mly"
+# 1825 "parser_cocci_menhir.mly"
(
match optc with
None -> (i, Ast0.NoConstraint)
| Some c -> (i, c)
)
-# 29452 "parser_cocci_menhir.ml"
+# 29495 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_i_ in
let _endpos = _endpos_optc_ in
let _v : 'tv_pure_ident_or_meta_ident_with_econstraint_re_or_not_eqe_or_sub_ =
-# 1837 "parser_cocci_menhir.mly"
+# 1825 "parser_cocci_menhir.mly"
(
match optc with
None -> (i, Ast0.NoConstraint)
| Some c -> (i, c)
)
-# 29486 "parser_cocci_menhir.ml"
+# 29529 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_i_ in
let _endpos = _endpos_c_ in
let _v : 'tv_pure_ident_or_meta_ident_with_idconstraint_re_or_not_eqid_ =
-# 1862 "parser_cocci_menhir.mly"
+# 1850 "parser_cocci_menhir.mly"
(
match c with
None -> (i, Ast.IdNoConstraint)
| Some constraint_ -> (i,constraint_)
)
-# 29520 "parser_cocci_menhir.ml"
+# 29563 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_i_ in
let _endpos = _endpos_c_ in
let _v : 'tv_pure_ident_or_meta_ident_with_idconstraint_virt_re_or_not_eqid_ =
-# 1845 "parser_cocci_menhir.mly"
+# 1833 "parser_cocci_menhir.mly"
(
Common.Left
(match c with
None -> (i, Ast.IdNoConstraint)
| Some constraint_ -> (i,constraint_))
)
-# 29555 "parser_cocci_menhir.ml"
+# 29598 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_pure_ident_or_meta_ident_with_idconstraint_virt_re_or_not_eqid_ =
-# 1852 "parser_cocci_menhir.mly"
+# 1840 "parser_cocci_menhir.mly"
(
let nm = P.id2name _3 in
Iteration.parsed_virtual_identifiers :=
!Iteration.parsed_virtual_identifiers;
Common.Right nm
)
-# 29593 "parser_cocci_menhir.ml"
+# 29636 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_or_meta_ident_with_seed =
-# 1806 "parser_cocci_menhir.mly"
+# 1794 "parser_cocci_menhir.mly"
( (_1,Ast.NoVal) )
-# 29617 "parser_cocci_menhir.ml"
+# 29660 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_pure_ident_or_meta_ident_with_seed =
-# 1809 "parser_cocci_menhir.mly"
+# 1797 "parser_cocci_menhir.mly"
( match _3 with
[Ast.SeedString s] -> (_1,Ast.StringSeed s)
| _ -> (_1,Ast.ListSeed _3) )
-# 29653 "parser_cocci_menhir.ml"
+# 29696 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_i_ in
let _endpos = _endpos_l_ in
let _v : 'tv_pure_ident_or_meta_ident_with_x_eq_not_pos_ =
-# 1831 "parser_cocci_menhir.mly"
+# 1819 "parser_cocci_menhir.mly"
(
(i, l)
)
-# 29685 "parser_cocci_menhir.ml"
+# 29728 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_or_symbol =
-# 1765 "parser_cocci_menhir.mly"
+# 1753 "parser_cocci_menhir.mly"
( _1 )
-# 29709 "parser_cocci_menhir.ml"
+# 29752 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 29730 "parser_cocci_menhir.ml"
+# 29773 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_pure_ident_or_symbol =
-# 1766 "parser_cocci_menhir.mly"
+# 1754 "parser_cocci_menhir.mly"
( _1 )
-# 29737 "parser_cocci_menhir.ml"
+# 29780 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_re_ in
let _endpos = _endpos_re_ in
let _v : 'tv_re_or_not_eqe_or_sub =
-# 1923 "parser_cocci_menhir.mly"
+# 1911 "parser_cocci_menhir.mly"
(Ast0.NotIdCstrt re)
-# 29761 "parser_cocci_menhir.ml"
+# 29804 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_ne_ in
let _endpos = _endpos_ne_ in
let _v : 'tv_re_or_not_eqe_or_sub =
-# 1924 "parser_cocci_menhir.mly"
+# 1912 "parser_cocci_menhir.mly"
(Ast0.NotExpCstrt ne)
-# 29785 "parser_cocci_menhir.ml"
+# 29828 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_s_ in
let _endpos = _endpos_s_ in
let _v : 'tv_re_or_not_eqe_or_sub =
-# 1925 "parser_cocci_menhir.mly"
+# 1913 "parser_cocci_menhir.mly"
(Ast0.SubExpCstrt s)
-# 29809 "parser_cocci_menhir.ml"
+# 29852 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_re_ in
let _endpos = _endpos_re_ in
let _v : 'tv_re_or_not_eqid =
-# 1869 "parser_cocci_menhir.mly"
+# 1857 "parser_cocci_menhir.mly"
(Ast.IdRegExpConstraint re)
-# 29833 "parser_cocci_menhir.ml"
+# 29876 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_ne_ in
let _endpos = _endpos_ne_ in
let _v : 'tv_re_or_not_eqid =
-# 1870 "parser_cocci_menhir.mly"
+# 1858 "parser_cocci_menhir.mly"
(ne)
-# 29857 "parser_cocci_menhir.ml"
+# 29900 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let re : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 29882 "parser_cocci_menhir.ml"
+# 29925 "parser_cocci_menhir.ml"
) = Obj.magic re in
let _startpos = _startpos__1_ in
let _endpos = _endpos_re_ in
let _v : 'tv_regexp_eqid =
-# 1874 "parser_cocci_menhir.mly"
+# 1862 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
then failwith "constraints not allowed in a generated rule file");
let (s,_) = re in Ast.IdRegExp (s,Regexp.regexp s)
)
-# 29894 "parser_cocci_menhir.ml"
+# 29937 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let re : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 29919 "parser_cocci_menhir.ml"
+# 29962 "parser_cocci_menhir.ml"
) = Obj.magic re in
let _startpos = _startpos__1_ in
let _endpos = _endpos_re_ in
let _v : 'tv_regexp_eqid =
-# 1881 "parser_cocci_menhir.mly"
+# 1869 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
then failwith "constraints not allowed in a generated rule file");
let (s,_) = re in Ast.IdNotRegExp (s,Regexp.regexp s)
)
-# 29931 "parser_cocci_menhir.ml"
+# 29974 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : (
-# 205 "parser_cocci_menhir.mly"
+# 179 "parser_cocci_menhir.mly"
(unit)
-# 29948 "parser_cocci_menhir.ml"
+# 29991 "parser_cocci_menhir.ml"
) =
-# 246 "parser_cocci_menhir.mly"
+# 220 "parser_cocci_menhir.mly"
( )
-# 29952 "parser_cocci_menhir.ml"
+# 29995 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_rule_elem_statement =
-# 1169 "parser_cocci_menhir.mly"
+# 1157 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Decl((Ast0.default_info(),Ast0.context_befaft()),_1)) )
-# 29976 "parser_cocci_menhir.ml"
+# 30019 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 30002 "parser_cocci_menhir.ml"
+# 30045 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_option_expr_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_rule_elem_statement =
-# 1170 "parser_cocci_menhir.mly"
+# 1158 "parser_cocci_menhir.mly"
( P.exp_stm _1 _2 )
-# 30010 "parser_cocci_menhir.ml"
+# 30053 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 30041 "parser_cocci_menhir.ml"
+# 30084 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_eexpr = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 30047 "parser_cocci_menhir.ml"
+# 30090 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_rule_elem_statement =
-# 1171 "parser_cocci_menhir.mly"
+# 1159 "parser_cocci_menhir.mly"
( P.ret_exp _1 _2 _3 )
-# 30054 "parser_cocci_menhir.ml"
+# 30097 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 30080 "parser_cocci_menhir.ml"
+# 30123 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 30085 "parser_cocci_menhir.ml"
+# 30128 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_rule_elem_statement =
-# 1172 "parser_cocci_menhir.mly"
+# 1160 "parser_cocci_menhir.mly"
( P.ret _1 _2 )
-# 30092 "parser_cocci_menhir.ml"
+# 30135 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 30118 "parser_cocci_menhir.ml"
+# 30161 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 30123 "parser_cocci_menhir.ml"
+# 30166 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_rule_elem_statement =
-# 1173 "parser_cocci_menhir.mly"
+# 1161 "parser_cocci_menhir.mly"
( P.break _1 _2 )
-# 30130 "parser_cocci_menhir.ml"
+# 30173 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 30156 "parser_cocci_menhir.ml"
+# 30199 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 30161 "parser_cocci_menhir.ml"
+# 30204 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_rule_elem_statement =
-# 1174 "parser_cocci_menhir.mly"
+# 1162 "parser_cocci_menhir.mly"
( P.cont _1 _2 )
-# 30168 "parser_cocci_menhir.ml"
+# 30211 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 30199 "parser_cocci_menhir.ml"
+# 30242 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_midzero_list_rule_elem_statement_rule_elem_statement_ = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 30205 "parser_cocci_menhir.ml"
+# 30248 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_rule_elem_statement =
-# 1176 "parser_cocci_menhir.mly"
+# 1164 "parser_cocci_menhir.mly"
( let (mids,code) = _2 in
Ast0.wrap
(Ast0.Disj(P.clt2mcode "(" _1,
List.map (function x -> Ast0.wrap(Ast0.DOTS([x]))) code,
mids, P.clt2mcode ")" _3)) )
-# 30216 "parser_cocci_menhir.ml"
+# 30259 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (
-# 227 "parser_cocci_menhir.mly"
+# 201 "parser_cocci_menhir.mly"
(Ast_cocci.rulename)
-# 30272 "parser_cocci_menhir.ml"
+# 30315 "parser_cocci_menhir.ml"
) = let nm =
# 39 "standard.mly"
( None )
-# 30277 "parser_cocci_menhir.ml"
+# 30320 "parser_cocci_menhir.ml"
in
-# 276 "parser_cocci_menhir.mly"
+# 250 "parser_cocci_menhir.mly"
( P.make_cocci_rule_name_result nm d i a e ee )
-# 30283 "parser_cocci_menhir.ml"
+# 30326 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_x0_ in
let _endpos = _endpos__8_ in
let _v : (
-# 227 "parser_cocci_menhir.mly"
+# 201 "parser_cocci_menhir.mly"
(Ast_cocci.rulename)
-# 30345 "parser_cocci_menhir.ml"
+# 30388 "parser_cocci_menhir.ml"
) = let nm =
let x = x0 in
# 41 "standard.mly"
( Some x )
-# 30351 "parser_cocci_menhir.ml"
+# 30394 "parser_cocci_menhir.ml"
in
-# 276 "parser_cocci_menhir.mly"
+# 250 "parser_cocci_menhir.mly"
( P.make_cocci_rule_name_result nm d i a e ee )
-# 30357 "parser_cocci_menhir.ml"
+# 30400 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__8_ in
let _v : (
-# 227 "parser_cocci_menhir.mly"
+# 201 "parser_cocci_menhir.mly"
(Ast_cocci.rulename)
-# 30417 "parser_cocci_menhir.ml"
+# 30460 "parser_cocci_menhir.ml"
) =
-# 281 "parser_cocci_menhir.mly"
+# 255 "parser_cocci_menhir.mly"
( P.make_generated_rule_name_result None d i a e ee )
-# 30421 "parser_cocci_menhir.ml"
+# 30464 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (
-# 227 "parser_cocci_menhir.mly"
+# 201 "parser_cocci_menhir.mly"
(Ast_cocci.rulename)
-# 30463 "parser_cocci_menhir.ml"
+# 30506 "parser_cocci_menhir.ml"
) = let nm =
# 39 "standard.mly"
( None )
-# 30468 "parser_cocci_menhir.ml"
+# 30511 "parser_cocci_menhir.ml"
in
-# 283 "parser_cocci_menhir.mly"
+# 257 "parser_cocci_menhir.mly"
( P.make_script_rule_name_result lang nm d )
-# 30474 "parser_cocci_menhir.ml"
+# 30517 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__6_ in
let _v : (
-# 227 "parser_cocci_menhir.mly"
+# 201 "parser_cocci_menhir.mly"
(Ast_cocci.rulename)
-# 30522 "parser_cocci_menhir.ml"
+# 30565 "parser_cocci_menhir.ml"
) = let nm =
let x = x0 in
# 41 "standard.mly"
( Some x )
-# 30528 "parser_cocci_menhir.ml"
+# 30571 "parser_cocci_menhir.ml"
in
-# 283 "parser_cocci_menhir.mly"
+# 257 "parser_cocci_menhir.mly"
( P.make_script_rule_name_result lang nm d )
-# 30534 "parser_cocci_menhir.ml"
+# 30577 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (
-# 227 "parser_cocci_menhir.mly"
+# 201 "parser_cocci_menhir.mly"
(Ast_cocci.rulename)
-# 30576 "parser_cocci_menhir.ml"
+# 30619 "parser_cocci_menhir.ml"
) =
-# 285 "parser_cocci_menhir.mly"
+# 259 "parser_cocci_menhir.mly"
( P.make_initial_script_rule_name_result lang d )
-# 30580 "parser_cocci_menhir.ml"
+# 30623 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : (
-# 227 "parser_cocci_menhir.mly"
+# 201 "parser_cocci_menhir.mly"
(Ast_cocci.rulename)
-# 30622 "parser_cocci_menhir.ml"
+# 30665 "parser_cocci_menhir.ml"
) =
-# 287 "parser_cocci_menhir.mly"
+# 261 "parser_cocci_menhir.mly"
( P.make_final_script_rule_name_result lang d )
-# 30626 "parser_cocci_menhir.ml"
+# 30669 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_py_ in
let _endpos = _endpos__2_ in
let _v : (
-# 233 "parser_cocci_menhir.mly"
+# 207 "parser_cocci_menhir.mly"
((string option (*string*) * string option (*ast*)) * (Ast_cocci.meta_name * Ast_cocci.metavar) option)
-# 30654 "parser_cocci_menhir.ml"
+# 30697 "parser_cocci_menhir.ml"
) =
-# 2443 "parser_cocci_menhir.mly"
+# 2431 "parser_cocci_menhir.mly"
( ((Some (P.id2name py), None), None) )
-# 30658 "parser_cocci_menhir.ml"
+# 30701 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_py_ in
let _endpos = _endpos__3_ in
let _v : (
-# 233 "parser_cocci_menhir.mly"
+# 207 "parser_cocci_menhir.mly"
((string option (*string*) * string option (*ast*)) * (Ast_cocci.meta_name * Ast_cocci.metavar) option)
-# 30692 "parser_cocci_menhir.ml"
+# 30735 "parser_cocci_menhir.ml"
) =
-# 2445 "parser_cocci_menhir.mly"
+# 2433 "parser_cocci_menhir.mly"
( ((Some (P.id2name py), None), Some _2) )
-# 30696 "parser_cocci_menhir.ml"
+# 30739 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (
-# 233 "parser_cocci_menhir.mly"
+# 207 "parser_cocci_menhir.mly"
((string option (*string*) * string option (*ast*)) * (Ast_cocci.meta_name * Ast_cocci.metavar) option)
-# 30746 "parser_cocci_menhir.ml"
+# 30789 "parser_cocci_menhir.ml"
) =
-# 2447 "parser_cocci_menhir.mly"
+# 2435 "parser_cocci_menhir.mly"
( ((None, Some (P.id2name ast)), Some _6) )
-# 30750 "parser_cocci_menhir.ml"
+# 30793 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (
-# 233 "parser_cocci_menhir.mly"
+# 207 "parser_cocci_menhir.mly"
((string option (*string*) * string option (*ast*)) * (Ast_cocci.meta_name * Ast_cocci.metavar) option)
-# 30800 "parser_cocci_menhir.ml"
+# 30843 "parser_cocci_menhir.ml"
) =
-# 2449 "parser_cocci_menhir.mly"
+# 2437 "parser_cocci_menhir.mly"
( ((Some (P.id2name str), None), Some _6) )
-# 30804 "parser_cocci_menhir.ml"
+# 30847 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : (
-# 233 "parser_cocci_menhir.mly"
+# 207 "parser_cocci_menhir.mly"
((string option (*string*) * string option (*ast*)) * (Ast_cocci.meta_name * Ast_cocci.metavar) option)
-# 30856 "parser_cocci_menhir.ml"
+# 30899 "parser_cocci_menhir.ml"
) =
-# 2451 "parser_cocci_menhir.mly"
+# 2439 "parser_cocci_menhir.mly"
( ((Some (P.id2name str), Some (P.id2name ast)), Some _6) )
-# 30860 "parser_cocci_menhir.ml"
+# 30903 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let cocci : 'tv_pure_ident = Obj.magic cocci in
let _2 : (
-# 114 "parser_cocci_menhir.mly"
+# 88 "parser_cocci_menhir.mly"
(string)
-# 30895 "parser_cocci_menhir.ml"
+# 30938 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _startpos = _startpos__1_ in
let _endpos = _endpos_cocci_ in
let _v : 'tv_script_name_decl =
-# 2455 "parser_cocci_menhir.mly"
+# 2443 "parser_cocci_menhir.mly"
( let nm = P.id2name cocci in
let mv = Parse_aux.lookup _2 nm in
((_2, nm), mv) )
-# 30904 "parser_cocci_menhir.ml"
+# 30947 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_cocci_ in
let _v : 'tv_script_name_decl =
-# 2459 "parser_cocci_menhir.mly"
+# 2447 "parser_cocci_menhir.mly"
( let nm = P.id2name cocci in
Iteration.parsed_virtual_identifiers :=
Common.union_set [nm]
let name = ("virtual", nm) in
let mv = Ast.MetaIdDecl(Ast.NONE,name) in
(name,mv) )
-# 30946 "parser_cocci_menhir.ml"
+# 30989 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 30967 "parser_cocci_menhir.ml"
+# 31010 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_seed_elem =
-# 1814 "parser_cocci_menhir.mly"
+# 1802 "parser_cocci_menhir.mly"
( let (x,_) = _1 in Ast.SeedString x )
-# 30974 "parser_cocci_menhir.ml"
+# 31017 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 130 "parser_cocci_menhir.mly"
+# 104 "parser_cocci_menhir.mly"
(Parse_aux.midinfo)
-# 30995 "parser_cocci_menhir.ml"
+# 31038 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_seed_elem =
-# 1815 "parser_cocci_menhir.mly"
+# 1803 "parser_cocci_menhir.mly"
( let (x,_,_,_,_) = _1 in Ast.SeedId x )
-# 31002 "parser_cocci_menhir.ml"
+# 31045 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_seed_elem =
-# 1816 "parser_cocci_menhir.mly"
+# 1804 "parser_cocci_menhir.mly"
(failwith "tmeta")
-# 31024 "parser_cocci_menhir.ml"
+# 31067 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_seed_elem =
-# 1818 "parser_cocci_menhir.mly"
+# 1806 "parser_cocci_menhir.mly"
( let nm = ("virtual",P.id2name _3) in
Iteration.parsed_virtual_identifiers :=
Common.union_set [snd nm]
!Iteration.parsed_virtual_identifiers;
try Ast.SeedString (List.assoc (snd nm) !Flag.defined_virtual_env)
with Not_found -> Ast.SeedId nm )
-# 31061 "parser_cocci_menhir.ml"
+# 31104 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _3 : 'tv_pure_ident = Obj.magic _3 in
let _1 : (
-# 114 "parser_cocci_menhir.mly"
+# 88 "parser_cocci_menhir.mly"
(string)
-# 31092 "parser_cocci_menhir.ml"
+# 31135 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_seed_elem =
-# 1825 "parser_cocci_menhir.mly"
+# 1813 "parser_cocci_menhir.mly"
( let nm = (_1,P.id2name _3) in
P.check_meta(Ast.MetaIdDecl(Ast.NONE,nm));
Ast.SeedId nm )
-# 31101 "parser_cocci_menhir.ml"
+# 31144 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let x : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 31122 "parser_cocci_menhir.ml"
+# 31165 "parser_cocci_menhir.ml"
) = Obj.magic x in
let _startpos = _startpos_x_ in
let _endpos = _endpos_x_ in
let _v : 'tv_separated_nonempty_list_TComma_TString_ =
# 144 "standard.mly"
( [ x ] )
-# 31129 "parser_cocci_menhir.ml"
+# 31172 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let xs : 'tv_separated_nonempty_list_TComma_TString_ = Obj.magic xs in
let x : (
-# 159 "parser_cocci_menhir.mly"
+# 133 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 31160 "parser_cocci_menhir.ml"
+# 31203 "parser_cocci_menhir.ml"
) = Obj.magic x in
let _startpos = _startpos_x_ in
let _endpos = _endpos_xs_ in
let _v : 'tv_separated_nonempty_list_TComma_TString_ =
# 146 "standard.mly"
( x :: xs )
-# 31167 "parser_cocci_menhir.ml"
+# 31210 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_any_strict_ =
# 144 "standard.mly"
( [ x ] )
-# 31191 "parser_cocci_menhir.ml"
+# 31234 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_any_strict_ =
# 146 "standard.mly"
( x :: xs )
-# 31225 "parser_cocci_menhir.ml"
+# 31268 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_ctype_ =
# 144 "standard.mly"
( [ x ] )
-# 31249 "parser_cocci_menhir.ml"
+# 31292 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_ctype_ =
# 146 "standard.mly"
( x :: xs )
-# 31283 "parser_cocci_menhir.ml"
+# 31326 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_d_ident_ =
# 144 "standard.mly"
( [ x ] )
-# 31307 "parser_cocci_menhir.ml"
+# 31350 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_d_ident_ =
# 146 "standard.mly"
( x :: xs )
-# 31341 "parser_cocci_menhir.ml"
+# 31384 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_ident_or_const_ =
# 144 "standard.mly"
( [ x ] )
-# 31365 "parser_cocci_menhir.ml"
+# 31408 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_ident_or_const_ =
# 146 "standard.mly"
( x :: xs )
-# 31399 "parser_cocci_menhir.ml"
+# 31442 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_meta_ident_ =
# 144 "standard.mly"
( [ x ] )
-# 31423 "parser_cocci_menhir.ml"
+# 31466 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_meta_ident_ =
# 146 "standard.mly"
( x :: xs )
-# 31457 "parser_cocci_menhir.ml"
+# 31500 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_ =
# 144 "standard.mly"
( [ x ] )
-# 31481 "parser_cocci_menhir.ml"
+# 31524 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_ =
# 146 "standard.mly"
( x :: xs )
-# 31515 "parser_cocci_menhir.ml"
+# 31558 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_ =
# 144 "standard.mly"
( [ x ] )
-# 31539 "parser_cocci_menhir.ml"
+# 31582 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_ =
# 146 "standard.mly"
( x :: xs )
-# 31573 "parser_cocci_menhir.ml"
+# 31616 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_econstraint_not_ceq_or_sub__ =
# 144 "standard.mly"
( [ x ] )
-# 31597 "parser_cocci_menhir.ml"
+# 31640 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_econstraint_not_ceq_or_sub__ =
# 146 "standard.mly"
( x :: xs )
-# 31631 "parser_cocci_menhir.ml"
+# 31674 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_econstraint_re_or_not_eqe_or_sub__ =
# 144 "standard.mly"
( [ x ] )
-# 31655 "parser_cocci_menhir.ml"
+# 31698 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_econstraint_re_or_not_eqe_or_sub__ =
# 146 "standard.mly"
( x :: xs )
-# 31689 "parser_cocci_menhir.ml"
+# 31732 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_idconstraint_re_or_not_eqid__ =
# 144 "standard.mly"
( [ x ] )
-# 31713 "parser_cocci_menhir.ml"
+# 31756 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_idconstraint_re_or_not_eqid__ =
# 146 "standard.mly"
( x :: xs )
-# 31747 "parser_cocci_menhir.ml"
+# 31790 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_idconstraint_virt_re_or_not_eqid__ =
# 144 "standard.mly"
( [ x ] )
-# 31771 "parser_cocci_menhir.ml"
+# 31814 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_idconstraint_virt_re_or_not_eqid__ =
# 146 "standard.mly"
( x :: xs )
-# 31805 "parser_cocci_menhir.ml"
+# 31848 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_seed_ =
# 144 "standard.mly"
( [ x ] )
-# 31829 "parser_cocci_menhir.ml"
+# 31872 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_seed_ =
# 146 "standard.mly"
( x :: xs )
-# 31863 "parser_cocci_menhir.ml"
+# 31906 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_x_eq_not_pos__ =
# 144 "standard.mly"
( [ x ] )
-# 31887 "parser_cocci_menhir.ml"
+# 31930 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_pure_ident_or_meta_ident_with_x_eq_not_pos__ =
# 146 "standard.mly"
( x :: xs )
-# 31921 "parser_cocci_menhir.ml"
+# 31964 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_typedef_ident_ =
# 144 "standard.mly"
( [ x ] )
-# 31945 "parser_cocci_menhir.ml"
+# 31988 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TComma_typedef_ident_ =
# 146 "standard.mly"
( x :: xs )
-# 31979 "parser_cocci_menhir.ml"
+# 32022 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TCppConcatOp_seed_elem_ =
# 144 "standard.mly"
( [ x ] )
-# 32003 "parser_cocci_menhir.ml"
+# 32046 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _v : 'tv_separated_nonempty_list_TCppConcatOp_seed_elem_ =
# 146 "standard.mly"
( x :: xs )
-# 32037 "parser_cocci_menhir.ml"
+# 32080 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let ty : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32058 "parser_cocci_menhir.ml"
+# 32101 "parser_cocci_menhir.ml"
) = Obj.magic ty in
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_signable_types =
-# 638 "parser_cocci_menhir.mly"
+# 626 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.BaseType(Ast.CharType,[P.clt2mcode "char" ty])) )
-# 32065 "parser_cocci_menhir.ml"
+# 32108 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let ty : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32086 "parser_cocci_menhir.ml"
+# 32129 "parser_cocci_menhir.ml"
) = Obj.magic ty in
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_signable_types =
-# 640 "parser_cocci_menhir.mly"
+# 628 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.BaseType(Ast.ShortType,[P.clt2mcode "short" ty])) )
-# 32093 "parser_cocci_menhir.ml"
+# 32136 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let ty2 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32119 "parser_cocci_menhir.ml"
+# 32162 "parser_cocci_menhir.ml"
) = Obj.magic ty2 in
let ty1 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32124 "parser_cocci_menhir.ml"
+# 32167 "parser_cocci_menhir.ml"
) = Obj.magic ty1 in
let _startpos = _startpos_ty1_ in
let _endpos = _endpos_ty2_ in
let _v : 'tv_signable_types =
-# 642 "parser_cocci_menhir.mly"
+# 630 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.BaseType
(Ast.ShortIntType,[P.clt2mcode "short" ty1;P.clt2mcode "int" ty2])) )
-# 32133 "parser_cocci_menhir.ml"
+# 32176 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let ty : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32154 "parser_cocci_menhir.ml"
+# 32197 "parser_cocci_menhir.ml"
) = Obj.magic ty in
let _startpos = _startpos_ty_ in
let _endpos = _endpos_ty_ in
let _v : 'tv_signable_types =
-# 646 "parser_cocci_menhir.mly"
+# 634 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.BaseType(Ast.IntType,[P.clt2mcode "int" ty])) )
-# 32161 "parser_cocci_menhir.ml"
+# 32204 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let p : (
-# 134 "parser_cocci_menhir.mly"
+# 108 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 32182 "parser_cocci_menhir.ml"
+# 32225 "parser_cocci_menhir.ml"
) = Obj.magic p in
let _startpos = _startpos_p_ in
let _endpos = _endpos_p_ in
let _v : 'tv_signable_types =
-# 648 "parser_cocci_menhir.mly"
+# 636 "parser_cocci_menhir.mly"
( let (nm,pure,clt) = p in
Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure)) )
-# 32190 "parser_cocci_menhir.ml"
+# 32233 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let p : (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 32220 "parser_cocci_menhir.ml"
+# 32263 "parser_cocci_menhir.ml"
) = Obj.magic p in
let r : (
-# 114 "parser_cocci_menhir.mly"
+# 88 "parser_cocci_menhir.mly"
(string)
-# 32225 "parser_cocci_menhir.ml"
+# 32268 "parser_cocci_menhir.ml"
) = Obj.magic r in
let _startpos = _startpos_r_ in
let _endpos = _endpos_p_ in
let _v : 'tv_signable_types =
-# 651 "parser_cocci_menhir.mly"
+# 639 "parser_cocci_menhir.mly"
( let nm = (r,P.id2name p) in
(* this is only possible when we are in a metavar decl. Otherwise,
it will be represented already as a MetaType *)
let _ = P.check_meta(Ast.MetaTypeDecl(Ast.NONE,nm)) in
Ast0.wrap(Ast0.MetaType(P.clt2mcode nm (P.id2clt p),
Ast0.Impure (*will be ignored*))) )
-# 32237 "parser_cocci_menhir.ml"
+# 32280 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let ty1 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32258 "parser_cocci_menhir.ml"
+# 32301 "parser_cocci_menhir.ml"
) = Obj.magic ty1 in
let _startpos = _startpos_ty1_ in
let _endpos = _endpos_ty1_ in
let _v : 'tv_signable_types =
-# 658 "parser_cocci_menhir.mly"
+# 646 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.BaseType(Ast.LongType,[P.clt2mcode "long" ty1])) )
-# 32265 "parser_cocci_menhir.ml"
+# 32308 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let ty2 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32291 "parser_cocci_menhir.ml"
+# 32334 "parser_cocci_menhir.ml"
) = Obj.magic ty2 in
let ty1 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32296 "parser_cocci_menhir.ml"
+# 32339 "parser_cocci_menhir.ml"
) = Obj.magic ty1 in
let _startpos = _startpos_ty1_ in
let _endpos = _endpos_ty2_ in
let _v : 'tv_signable_types =
-# 660 "parser_cocci_menhir.mly"
+# 648 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.BaseType
(Ast.LongIntType,[P.clt2mcode "long" ty1;P.clt2mcode "int" ty2])) )
-# 32305 "parser_cocci_menhir.ml"
+# 32348 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let ty2 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32331 "parser_cocci_menhir.ml"
+# 32374 "parser_cocci_menhir.ml"
) = Obj.magic ty2 in
let ty1 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32336 "parser_cocci_menhir.ml"
+# 32379 "parser_cocci_menhir.ml"
) = Obj.magic ty1 in
let _startpos = _startpos_ty1_ in
let _endpos = _endpos_ty2_ in
let _v : 'tv_signable_types =
-# 664 "parser_cocci_menhir.mly"
+# 652 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.BaseType
(Ast.LongLongType,
[P.clt2mcode "long" ty1;P.clt2mcode "long" ty2])) )
-# 32346 "parser_cocci_menhir.ml"
+# 32389 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let ty3 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32377 "parser_cocci_menhir.ml"
+# 32420 "parser_cocci_menhir.ml"
) = Obj.magic ty3 in
let ty2 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32382 "parser_cocci_menhir.ml"
+# 32425 "parser_cocci_menhir.ml"
) = Obj.magic ty2 in
let ty1 : (
-# 116 "parser_cocci_menhir.mly"
+# 90 "parser_cocci_menhir.mly"
(Data.clt)
-# 32387 "parser_cocci_menhir.ml"
+# 32430 "parser_cocci_menhir.ml"
) = Obj.magic ty1 in
let _startpos = _startpos_ty1_ in
let _endpos = _endpos_ty3_ in
let _v : 'tv_signable_types =
-# 669 "parser_cocci_menhir.mly"
+# 657 "parser_cocci_menhir.mly"
( Ast0.wrap
(Ast0.BaseType
(Ast.LongLongIntType,
[P.clt2mcode "long" ty1;P.clt2mcode "long" ty2;
P.clt2mcode "int" ty3])) )
-# 32398 "parser_cocci_menhir.ml"
+# 32441 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_single_statement =
-# 1184 "parser_cocci_menhir.mly"
+# 1172 "parser_cocci_menhir.mly"
( _1 )
-# 32422 "parser_cocci_menhir.ml"
+# 32465 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 32453 "parser_cocci_menhir.ml"
+# 32496 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_midzero_list_statement_statement_ = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 32459 "parser_cocci_menhir.ml"
+# 32502 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_single_statement =
-# 1188 "parser_cocci_menhir.mly"
+# 1176 "parser_cocci_menhir.mly"
( let (mids,code) = _2 in
Ast0.wrap
(Ast0.Disj(P.clt2mcode "(" _1,
List.map (function x -> Ast0.wrap(Ast0.DOTS([x]))) code,
mids, P.clt2mcode ")" _3)) )
-# 32470 "parser_cocci_menhir.ml"
+# 32513 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_statement =
-# 1107 "parser_cocci_menhir.mly"
+# 1095 "parser_cocci_menhir.mly"
( _1 )
-# 32494 "parser_cocci_menhir.ml"
+# 32537 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 32515 "parser_cocci_menhir.ml"
+# 32558 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_statement =
-# 1108 "parser_cocci_menhir.mly"
+# 1096 "parser_cocci_menhir.mly"
( tmeta_to_statement _1)
-# 32522 "parser_cocci_menhir.ml"
+# 32565 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 134 "parser_cocci_menhir.mly"
+# 108 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 32543 "parser_cocci_menhir.ml"
+# 32586 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_statement =
-# 1110 "parser_cocci_menhir.mly"
+# 1098 "parser_cocci_menhir.mly"
( P.meta_stm _1 )
-# 32550 "parser_cocci_menhir.ml"
+# 32593 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 32576 "parser_cocci_menhir.ml"
+# 32619 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_option_expr_ = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_statement =
-# 1112 "parser_cocci_menhir.mly"
+# 1100 "parser_cocci_menhir.mly"
( P.exp_stm _1 _2 )
-# 32584 "parser_cocci_menhir.ml"
+# 32627 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _5 : 'tv_single_statement = Obj.magic _5 in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 32626 "parser_cocci_menhir.ml"
+# 32669 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 32632 "parser_cocci_menhir.ml"
+# 32675 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 32637 "parser_cocci_menhir.ml"
+# 32680 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : 'tv_statement =
-# 1114 "parser_cocci_menhir.mly"
+# 1102 "parser_cocci_menhir.mly"
( P.ifthen _1 _2 _3 _4 _5 )
-# 32644 "parser_cocci_menhir.ml"
+# 32687 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _7 : 'tv_single_statement = Obj.magic _7 in
let _6 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 32696 "parser_cocci_menhir.ml"
+# 32739 "parser_cocci_menhir.ml"
) = Obj.magic _6 in
let _5 : 'tv_single_statement = Obj.magic _5 in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 32702 "parser_cocci_menhir.ml"
+# 32745 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 32708 "parser_cocci_menhir.ml"
+# 32751 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 32713 "parser_cocci_menhir.ml"
+# 32756 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : 'tv_statement =
-# 1116 "parser_cocci_menhir.mly"
+# 1104 "parser_cocci_menhir.mly"
( P.ifthenelse _1 _2 _3 _4 _5 _6 _7 )
-# 32720 "parser_cocci_menhir.ml"
+# 32763 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _9 : 'tv_single_statement = Obj.magic _9 in
let _8 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 32782 "parser_cocci_menhir.ml"
+# 32825 "parser_cocci_menhir.ml"
) = Obj.magic _8 in
let _7 : 'tv_option_eexpr_ = Obj.magic _7 in
let _6 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 32788 "parser_cocci_menhir.ml"
+# 32831 "parser_cocci_menhir.ml"
) = Obj.magic _6 in
let _5 : 'tv_option_eexpr_ = Obj.magic _5 in
let _4 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 32794 "parser_cocci_menhir.ml"
+# 32837 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_option_eexpr_ = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 32800 "parser_cocci_menhir.ml"
+# 32843 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 32805 "parser_cocci_menhir.ml"
+# 32848 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__9_ in
let _v : 'tv_statement =
-# 1119 "parser_cocci_menhir.mly"
+# 1107 "parser_cocci_menhir.mly"
( P.forloop _1 _2 _3 _4 _5 _6 _7 _8 _9 )
-# 32812 "parser_cocci_menhir.ml"
+# 32855 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _8 : 'tv_single_statement = Obj.magic _8 in
let _7 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 32869 "parser_cocci_menhir.ml"
+# 32912 "parser_cocci_menhir.ml"
) = Obj.magic _7 in
let _6 : 'tv_option_eexpr_ = Obj.magic _6 in
let _5 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 32875 "parser_cocci_menhir.ml"
+# 32918 "parser_cocci_menhir.ml"
) = Obj.magic _5 in
let _4 : 'tv_option_eexpr_ = Obj.magic _4 in
let _3 : 'tv_one_decl_var = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 32882 "parser_cocci_menhir.ml"
+# 32925 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 32887 "parser_cocci_menhir.ml"
+# 32930 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__8_ in
let _v : 'tv_statement =
-# 1122 "parser_cocci_menhir.mly"
+# 1110 "parser_cocci_menhir.mly"
( P.forloop2 _1 _2 _3 _4 _5 _6 _7 _8 )
-# 32894 "parser_cocci_menhir.ml"
+# 32937 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _5 : 'tv_single_statement = Obj.magic _5 in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 32936 "parser_cocci_menhir.ml"
+# 32979 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 32942 "parser_cocci_menhir.ml"
+# 32985 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 32947 "parser_cocci_menhir.ml"
+# 32990 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : 'tv_statement =
-# 1124 "parser_cocci_menhir.mly"
+# 1112 "parser_cocci_menhir.mly"
( P.whileloop _1 _2 _3 _4 _5 )
-# 32954 "parser_cocci_menhir.ml"
+# 32997 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _7 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 33005 "parser_cocci_menhir.ml"
+# 33048 "parser_cocci_menhir.ml"
) = Obj.magic _7 in
let _6 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 33010 "parser_cocci_menhir.ml"
+# 33053 "parser_cocci_menhir.ml"
) = Obj.magic _6 in
let _5 : 'tv_eexpr = Obj.magic _5 in
let _4 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 33016 "parser_cocci_menhir.ml"
+# 33059 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 33021 "parser_cocci_menhir.ml"
+# 33064 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_single_statement = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 33027 "parser_cocci_menhir.ml"
+# 33070 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__7_ in
let _v : 'tv_statement =
-# 1126 "parser_cocci_menhir.mly"
+# 1114 "parser_cocci_menhir.mly"
( P.doloop _1 _2 _3 _4 _5 _6 _7 )
-# 33034 "parser_cocci_menhir.ml"
+# 33077 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _5 : 'tv_single_statement = Obj.magic _5 in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 33076 "parser_cocci_menhir.ml"
+# 33119 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr_list_option = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 33082 "parser_cocci_menhir.ml"
+# 33125 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_iter_ident = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__5_ in
let _v : 'tv_statement =
-# 1128 "parser_cocci_menhir.mly"
+# 1116 "parser_cocci_menhir.mly"
( P.iterator _1 _2 _3 _4 _5 )
-# 33090 "parser_cocci_menhir.ml"
+# 33133 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _8 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 33146 "parser_cocci_menhir.ml"
+# 33189 "parser_cocci_menhir.ml"
) = Obj.magic _8 in
let _7 : 'tv_list_case_line_ = Obj.magic _7 in
let _6 : 'tv_list_decl_var_ = Obj.magic _6 in
let _5 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 33153 "parser_cocci_menhir.ml"
+# 33196 "parser_cocci_menhir.ml"
) = Obj.magic _5 in
let _4 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 33158 "parser_cocci_menhir.ml"
+# 33201 "parser_cocci_menhir.ml"
) = Obj.magic _4 in
let _3 : 'tv_eexpr = Obj.magic _3 in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 33164 "parser_cocci_menhir.ml"
+# 33207 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 33169 "parser_cocci_menhir.ml"
+# 33212 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__8_ in
let _v : 'tv_statement =
-# 1130 "parser_cocci_menhir.mly"
+# 1118 "parser_cocci_menhir.mly"
( P.switch _1 _2 _3 _4 _5 (List.concat _6) _7 _8 )
-# 33176 "parser_cocci_menhir.ml"
+# 33219 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 33207 "parser_cocci_menhir.ml"
+# 33250 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_eexpr = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 33213 "parser_cocci_menhir.ml"
+# 33256 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_statement =
-# 1131 "parser_cocci_menhir.mly"
+# 1119 "parser_cocci_menhir.mly"
( P.ret_exp _1 _2 _3 )
-# 33220 "parser_cocci_menhir.ml"
+# 33263 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 33246 "parser_cocci_menhir.ml"
+# 33289 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 125 "parser_cocci_menhir.mly"
+# 99 "parser_cocci_menhir.mly"
(Data.clt)
-# 33251 "parser_cocci_menhir.ml"
+# 33294 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_statement =
-# 1132 "parser_cocci_menhir.mly"
+# 1120 "parser_cocci_menhir.mly"
( P.ret _1 _2 )
-# 33258 "parser_cocci_menhir.ml"
+# 33301 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 33284 "parser_cocci_menhir.ml"
+# 33327 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 33289 "parser_cocci_menhir.ml"
+# 33332 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_statement =
-# 1133 "parser_cocci_menhir.mly"
+# 1121 "parser_cocci_menhir.mly"
( P.break _1 _2 )
-# 33296 "parser_cocci_menhir.ml"
+# 33339 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 33322 "parser_cocci_menhir.ml"
+# 33365 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 33327 "parser_cocci_menhir.ml"
+# 33370 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_statement =
-# 1134 "parser_cocci_menhir.mly"
+# 1122 "parser_cocci_menhir.mly"
( P.cont _1 _2 )
-# 33334 "parser_cocci_menhir.ml"
+# 33377 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 33360 "parser_cocci_menhir.ml"
+# 33403 "parser_cocci_menhir.ml"
) = Obj.magic _2 in
let _1 : 'tv_mident = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_statement =
-# 1135 "parser_cocci_menhir.mly"
+# 1123 "parser_cocci_menhir.mly"
( P.label _1 _2 )
-# 33368 "parser_cocci_menhir.ml"
+# 33411 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 33399 "parser_cocci_menhir.ml"
+# 33442 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_disj_ident = Obj.magic _2 in
let _1 : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 33405 "parser_cocci_menhir.ml"
+# 33448 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_statement =
-# 1136 "parser_cocci_menhir.mly"
+# 1124 "parser_cocci_menhir.mly"
( P.goto _1 _2 _3 )
-# 33412 "parser_cocci_menhir.ml"
+# 33455 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 33443 "parser_cocci_menhir.ml"
+# 33486 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_fun_start = Obj.magic _2 in
let _1 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 33449 "parser_cocci_menhir.ml"
+# 33492 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_statement =
-# 1138 "parser_cocci_menhir.mly"
+# 1126 "parser_cocci_menhir.mly"
( P.seq _1 _2 _3 )
-# 33456 "parser_cocci_menhir.ml"
+# 33499 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let w : 'tv_list_whenppdecs_ = Obj.magic w in
let _1 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 33483 "parser_cocci_menhir.ml"
+# 33526 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos_w_ in
let _v : 'tv_stm_dots =
-# 1142 "parser_cocci_menhir.mly"
+# 1130 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Dots(P.clt2mcode "..." _1, List.concat w)) )
-# 33490 "parser_cocci_menhir.ml"
+# 33533 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let c : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 33526 "parser_cocci_menhir.ml"
+# 33569 "parser_cocci_menhir.ml"
) = Obj.magic c in
let b : 'tv_nest_start = Obj.magic b in
let w : 'tv_list_whenppdecs_ = Obj.magic w in
let _1 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 33533 "parser_cocci_menhir.ml"
+# 33576 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos_c_ in
let _v : 'tv_stm_dots =
-# 1144 "parser_cocci_menhir.mly"
+# 1132 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Nest(P.clt2mcode "<..." _1, b,
P.clt2mcode "...>" c, List.concat w, false)) )
-# 33541 "parser_cocci_menhir.ml"
+# 33584 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let c : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 33577 "parser_cocci_menhir.ml"
+# 33620 "parser_cocci_menhir.ml"
) = Obj.magic c in
let b : 'tv_nest_start = Obj.magic b in
let w : 'tv_list_whenppdecs_ = Obj.magic w in
let _1 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 33584 "parser_cocci_menhir.ml"
+# 33627 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos_c_ in
let _v : 'tv_stm_dots =
-# 1147 "parser_cocci_menhir.mly"
+# 1135 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Nest(P.clt2mcode "<+..." _1, b,
P.clt2mcode "...+>" c, List.concat w, true)) )
-# 33592 "parser_cocci_menhir.ml"
+# 33635 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let s : (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
-# 33613 "parser_cocci_menhir.ml"
+# 33656 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_s_ in
let _v : 'tv_storage =
-# 1068 "parser_cocci_menhir.mly"
+# 1056 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.Static s )
-# 33620 "parser_cocci_menhir.ml"
+# 33663 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let s : (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
-# 33641 "parser_cocci_menhir.ml"
+# 33684 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_s_ in
let _v : 'tv_storage =
-# 1069 "parser_cocci_menhir.mly"
+# 1057 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.Auto s )
-# 33648 "parser_cocci_menhir.ml"
+# 33691 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let s : (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
-# 33669 "parser_cocci_menhir.ml"
+# 33712 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_s_ in
let _v : 'tv_storage =
-# 1070 "parser_cocci_menhir.mly"
+# 1058 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.Register s )
-# 33676 "parser_cocci_menhir.ml"
+# 33719 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let s : (
-# 121 "parser_cocci_menhir.mly"
+# 95 "parser_cocci_menhir.mly"
(Data.clt)
-# 33697 "parser_cocci_menhir.ml"
+# 33740 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_s_ in
let _v : 'tv_storage =
-# 1071 "parser_cocci_menhir.mly"
+# 1059 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.Extern s )
-# 33704 "parser_cocci_menhir.ml"
+# 33747 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_struct_decl =
-# 763 "parser_cocci_menhir.mly"
+# 751 "parser_cocci_menhir.mly"
( [] )
-# 33726 "parser_cocci_menhir.ml"
+# 33769 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_struct_decl =
-# 764 "parser_cocci_menhir.mly"
+# 752 "parser_cocci_menhir.mly"
( [_1] )
-# 33750 "parser_cocci_menhir.ml"
+# 33793 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_struct_decl_list =
-# 792 "parser_cocci_menhir.mly"
+# 780 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.DOTS(_1)) )
-# 33774 "parser_cocci_menhir.ml"
+# 33817 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_struct_decl_list_start =
-# 795 "parser_cocci_menhir.mly"
+# 783 "parser_cocci_menhir.mly"
( _1 )
-# 33798 "parser_cocci_menhir.ml"
+# 33841 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_struct_decl_list_start =
-# 796 "parser_cocci_menhir.mly"
+# 784 "parser_cocci_menhir.mly"
( _1@_2 )
-# 33828 "parser_cocci_menhir.ml"
+# 33871 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_d_ in
let _endpos = _endpos_r_ in
let _v : 'tv_struct_decl_list_start =
-# 798 "parser_cocci_menhir.mly"
+# 786 "parser_cocci_menhir.mly"
( (P.mkddots_one "..." d)::r )
-# 33858 "parser_cocci_menhir.ml"
+# 33901 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 33879 "parser_cocci_menhir.ml"
+# 33922 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_struct_decl_one =
-# 767 "parser_cocci_menhir.mly"
+# 755 "parser_cocci_menhir.mly"
( P.meta_field _1 )
-# 33886 "parser_cocci_menhir.ml"
+# 33929 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 137 "parser_cocci_menhir.mly"
+# 111 "parser_cocci_menhir.mly"
(Parse_aux.list_info)
-# 33907 "parser_cocci_menhir.ml"
+# 33950 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_struct_decl_one =
-# 768 "parser_cocci_menhir.mly"
+# 756 "parser_cocci_menhir.mly"
( P.meta_field_list _1 )
-# 33914 "parser_cocci_menhir.ml"
+# 33957 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 33935 "parser_cocci_menhir.ml"
+# 33978 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_struct_decl_one =
-# 769 "parser_cocci_menhir.mly"
+# 757 "parser_cocci_menhir.mly"
( tmeta_to_field _1 )
-# 33942 "parser_cocci_menhir.ml"
+# 33985 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 33973 "parser_cocci_menhir.ml"
+# 34016 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_midzero_list_struct_decl_one_struct_decl_one_ = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 33979 "parser_cocci_menhir.ml"
+# 34022 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let _startpos = _startpos_lp_ in
let _endpos = _endpos_rp_ in
let _v : 'tv_struct_decl_one =
-# 771 "parser_cocci_menhir.mly"
+# 759 "parser_cocci_menhir.mly"
( let (mids,code) = t in
Ast0.wrap
(Ast0.DisjDecl(P.clt2mcode "(" lp,code,mids, P.clt2mcode ")" rp)) )
-# 33988 "parser_cocci_menhir.ml"
+# 34031 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 34019 "parser_cocci_menhir.ml"
+# 34062 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let d : 'tv_d_ident = Obj.magic d in
let t : 'tv_ctype = Obj.magic t in
let _startpos = _startpos_t_ in
let _endpos = _endpos_pv_ in
let _v : 'tv_struct_decl_one =
-# 775 "parser_cocci_menhir.mly"
+# 763 "parser_cocci_menhir.mly"
( let (id,fn) = d in
Ast0.wrap(Ast0.UnInit(None,fn t,id,P.clt2mcode ";" pv)) )
-# 34029 "parser_cocci_menhir.ml"
+# 34072 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 34090 "parser_cocci_menhir.ml"
+# 34133 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let rp2 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 34095 "parser_cocci_menhir.ml"
+# 34138 "parser_cocci_menhir.ml"
) = Obj.magic rp2 in
let p : 'tv_decl_list_name_opt_decl_ = Obj.magic p in
let lp2 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 34101 "parser_cocci_menhir.ml"
+# 34144 "parser_cocci_menhir.ml"
) = Obj.magic lp2 in
let rp1 : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 34106 "parser_cocci_menhir.ml"
+# 34149 "parser_cocci_menhir.ml"
) = Obj.magic rp1 in
let d : 'tv_d_ident = Obj.magic d in
let st : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 34112 "parser_cocci_menhir.ml"
+# 34155 "parser_cocci_menhir.ml"
) = Obj.magic st in
let lp1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 34117 "parser_cocci_menhir.ml"
+# 34160 "parser_cocci_menhir.ml"
) = Obj.magic lp1 in
let t : 'tv_ctype = Obj.magic t in
let _startpos = _startpos_t_ in
let _endpos = _endpos_pv_ in
let _v : 'tv_struct_decl_one =
-# 779 "parser_cocci_menhir.mly"
+# 767 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let t =
Ast0.wrap
(t,P.clt2mcode "(" lp1,P.clt2mcode "*" st,P.clt2mcode ")" rp1,
P.clt2mcode "(" lp2,p,P.clt2mcode ")" rp2)) in
Ast0.wrap(Ast0.UnInit(None,fn t,id,P.clt2mcode ";" pv)) )
-# 34131 "parser_cocci_menhir.ml"
+# 34174 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 34162 "parser_cocci_menhir.ml"
+# 34205 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let d : 'tv_d_ident = Obj.magic d in
let i : 'tv_pure_ident_or_symbol = Obj.magic i in
# 39 "standard.mly"
( None )
-# 34172 "parser_cocci_menhir.ml"
+# 34215 "parser_cocci_menhir.ml"
in
-# 787 "parser_cocci_menhir.mly"
+# 775 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
Ast0.wrap(Ast0.UnInit(None,fn idtype,id,P.clt2mcode ";" pv)) )
-# 34180 "parser_cocci_menhir.ml"
+# 34223 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let pv : (
-# 179 "parser_cocci_menhir.mly"
+# 153 "parser_cocci_menhir.mly"
(Data.clt)
-# 34216 "parser_cocci_menhir.ml"
+# 34259 "parser_cocci_menhir.ml"
) = Obj.magic pv in
let d : 'tv_d_ident = Obj.magic d in
let i : 'tv_pure_ident_or_symbol = Obj.magic i in
# 41 "standard.mly"
( Some x )
-# 34228 "parser_cocci_menhir.ml"
+# 34271 "parser_cocci_menhir.ml"
in
-# 787 "parser_cocci_menhir.mly"
+# 775 "parser_cocci_menhir.mly"
( let (id,fn) = d in
let idtype = P.make_cv cv (Ast0.wrap (Ast0.TypeName(P.id2mcode i))) in
Ast0.wrap(Ast0.UnInit(None,fn idtype,id,P.clt2mcode ";" pv)) )
-# 34236 "parser_cocci_menhir.ml"
+# 34279 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let s : (
-# 118 "parser_cocci_menhir.mly"
+# 92 "parser_cocci_menhir.mly"
(Data.clt)
-# 34257 "parser_cocci_menhir.ml"
+# 34300 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_s_ in
let _v : 'tv_struct_or_union =
-# 759 "parser_cocci_menhir.mly"
+# 747 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.Struct s )
-# 34264 "parser_cocci_menhir.ml"
+# 34307 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let u : (
-# 118 "parser_cocci_menhir.mly"
+# 92 "parser_cocci_menhir.mly"
(Data.clt)
-# 34285 "parser_cocci_menhir.ml"
+# 34328 "parser_cocci_menhir.ml"
) = Obj.magic u in
let _startpos = _startpos_u_ in
let _endpos = _endpos_u_ in
let _v : 'tv_struct_or_union =
-# 760 "parser_cocci_menhir.mly"
+# 748 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.Union u )
-# 34292 "parser_cocci_menhir.ml"
+# 34335 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos_i_ in
let _v : 'tv_sub =
-# 1969 "parser_cocci_menhir.mly"
+# 1957 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
P.check_inherited_constraint i
(function mv -> Ast.MetaExpDecl(Ast.NONE,mv,None)) in
[i] )
-# 34327 "parser_cocci_menhir.ml"
+# 34370 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_sub =
-# 1978 "parser_cocci_menhir.mly"
+# 1966 "parser_cocci_menhir.mly"
( (if !Data.in_iso
then failwith "constraints not allowed in iso file");
(if !Data.in_generating
P.check_inherited_constraint i
(function mv -> Ast.MetaExpDecl(Ast.NONE,mv,None)))
l)
-# 34371 "parser_cocci_menhir.ml"
+# 34414 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_top_eexpr =
-# 1487 "parser_cocci_menhir.mly"
+# 1475 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.OTHER(Ast0.wrap(Ast0.Exp(_1)))) )
-# 34395 "parser_cocci_menhir.ml"
+# 34438 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let _3 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 34426 "parser_cocci_menhir.ml"
+# 34469 "parser_cocci_menhir.ml"
) = Obj.magic _3 in
let _2 : 'tv_initialize_list = Obj.magic _2 in
let _1 : (
-# 173 "parser_cocci_menhir.mly"
+# 147 "parser_cocci_menhir.mly"
(Data.clt)
-# 34432 "parser_cocci_menhir.ml"
+# 34475 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_top_init =
-# 2232 "parser_cocci_menhir.mly"
+# 2220 "parser_cocci_menhir.mly"
( if P.struct_initializer _2
then
let il = P.drop_dot_commas _2 in
Ast0.wrap(Ast0.InitList(P.clt2mcode "{" _1,il,P.clt2mcode "}" _3,false))
else
Ast0.wrap(Ast0.InitList(P.clt2mcode "{" _1,_2,P.clt2mcode "}" _3,true)) )
-# 34444 "parser_cocci_menhir.ml"
+# 34487 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_toplevel_after_dots =
-# 2220 "parser_cocci_menhir.mly"
+# 2208 "parser_cocci_menhir.mly"
([])
-# 34461 "parser_cocci_menhir.ml"
+# 34504 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_after_dots =
-# 2221 "parser_cocci_menhir.mly"
+# 2209 "parser_cocci_menhir.mly"
(_2)
-# 34489 "parser_cocci_menhir.ml"
+# 34532 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_after_dots =
-# 2222 "parser_cocci_menhir.mly"
+# 2210 "parser_cocci_menhir.mly"
((Ast0.wrap(Ast0.Exp(_1)))::_2)
-# 34519 "parser_cocci_menhir.ml"
+# 34562 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_after_dots =
-# 2223 "parser_cocci_menhir.mly"
+# 2211 "parser_cocci_menhir.mly"
(_1@_2)
-# 34549 "parser_cocci_menhir.ml"
+# 34592 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_after_dots_init =
-# 2211 "parser_cocci_menhir.mly"
+# 2199 "parser_cocci_menhir.mly"
(_2)
-# 34577 "parser_cocci_menhir.ml"
+# 34620 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_after_dots_init =
-# 2212 "parser_cocci_menhir.mly"
+# 2200 "parser_cocci_menhir.mly"
((Ast0.wrap(Ast0.Exp(_1)))::_2)
-# 34607 "parser_cocci_menhir.ml"
+# 34650 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_after_dots_init =
-# 2213 "parser_cocci_menhir.mly"
+# 2201 "parser_cocci_menhir.mly"
(_1@_2)
-# 34637 "parser_cocci_menhir.ml"
+# 34680 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_toplevel_after_exp =
-# 2216 "parser_cocci_menhir.mly"
+# 2204 "parser_cocci_menhir.mly"
([])
-# 34654 "parser_cocci_menhir.ml"
+# 34697 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_after_exp =
-# 2217 "parser_cocci_menhir.mly"
+# 2205 "parser_cocci_menhir.mly"
(_1::_2)
-# 34684 "parser_cocci_menhir.ml"
+# 34727 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _menhir_env.MenhirLib.EngineTypes.lexbuf.Lexing.lex_start_p in
let _endpos = _startpos in
let _v : 'tv_toplevel_after_stm =
-# 2226 "parser_cocci_menhir.mly"
+# 2214 "parser_cocci_menhir.mly"
([])
-# 34701 "parser_cocci_menhir.ml"
+# 34744 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_after_stm =
-# 2227 "parser_cocci_menhir.mly"
+# 2215 "parser_cocci_menhir.mly"
(_1::_2)
-# 34731 "parser_cocci_menhir.ml"
+# 34774 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_after_stm =
-# 2228 "parser_cocci_menhir.mly"
+# 2216 "parser_cocci_menhir.mly"
(_1@_2)
-# 34761 "parser_cocci_menhir.ml"
+# 34804 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_seq_start_toplevel_after_dots_ =
-# 2206 "parser_cocci_menhir.mly"
+# 2194 "parser_cocci_menhir.mly"
( _1::_2 )
-# 34791 "parser_cocci_menhir.ml"
+# 34834 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_seq_start_toplevel_after_dots_ =
-# 2207 "parser_cocci_menhir.mly"
+# 2195 "parser_cocci_menhir.mly"
( (Ast0.wrap(Ast0.Exp(_1)))::_2 )
-# 34821 "parser_cocci_menhir.ml"
+# 34864 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_seq_start_toplevel_after_dots_ =
-# 2208 "parser_cocci_menhir.mly"
+# 2196 "parser_cocci_menhir.mly"
( _1@_2 )
-# 34851 "parser_cocci_menhir.ml"
+# 34894 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let b : 'tv_toplevel_after_dots_init = Obj.magic b in
let w0 : 'tv_list_whenppdecs_ = Obj.magic w0 in
let a0 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 34884 "parser_cocci_menhir.ml"
+# 34927 "parser_cocci_menhir.ml"
) = Obj.magic a0 in
let _startpos = _startpos_a0_ in
let _endpos = _endpos_b_ in
let w = w0 in
let a = a0 in
-# 1152 "parser_cocci_menhir.mly"
+# 1140 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Dots(P.clt2mcode "..." a, List.concat w)) )
-# 34894 "parser_cocci_menhir.ml"
+# 34937 "parser_cocci_menhir.ml"
in
-# 2199 "parser_cocci_menhir.mly"
+# 2187 "parser_cocci_menhir.mly"
( a::b )
-# 34900 "parser_cocci_menhir.ml"
+# 34943 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let b : 'tv_toplevel_after_dots_init = Obj.magic b in
let c0 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 34942 "parser_cocci_menhir.ml"
+# 34985 "parser_cocci_menhir.ml"
) = Obj.magic c0 in
let b0 : 'tv_nest_start = Obj.magic b0 in
let w0 : 'tv_list_whenppdecs_ = Obj.magic w0 in
let a0 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 34949 "parser_cocci_menhir.ml"
+# 34992 "parser_cocci_menhir.ml"
) = Obj.magic a0 in
let _startpos = _startpos_a0_ in
let _endpos = _endpos_b_ in
let w = w0 in
let a = a0 in
-# 1156 "parser_cocci_menhir.mly"
+# 1144 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Nest(P.clt2mcode "<..." a, b,
P.clt2mcode "...>" c, List.concat w, false)) )
-# 34962 "parser_cocci_menhir.ml"
+# 35005 "parser_cocci_menhir.ml"
in
-# 2200 "parser_cocci_menhir.mly"
+# 2188 "parser_cocci_menhir.mly"
( a::b )
-# 34968 "parser_cocci_menhir.ml"
+# 35011 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let b : 'tv_toplevel_after_dots_init = Obj.magic b in
let c0 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 35010 "parser_cocci_menhir.ml"
+# 35053 "parser_cocci_menhir.ml"
) = Obj.magic c0 in
let b0 : 'tv_nest_start = Obj.magic b0 in
let w0 : 'tv_list_whenppdecs_ = Obj.magic w0 in
let a0 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 35017 "parser_cocci_menhir.ml"
+# 35060 "parser_cocci_menhir.ml"
) = Obj.magic a0 in
let _startpos = _startpos_a0_ in
let _endpos = _endpos_b_ in
let w = w0 in
let a = a0 in
-# 1159 "parser_cocci_menhir.mly"
+# 1147 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Nest(P.clt2mcode "<+..." a, b,
P.clt2mcode "...+>" c, List.concat w, true)) )
-# 35030 "parser_cocci_menhir.ml"
+# 35073 "parser_cocci_menhir.ml"
in
-# 2200 "parser_cocci_menhir.mly"
+# 2188 "parser_cocci_menhir.mly"
( a::b )
-# 35036 "parser_cocci_menhir.ml"
+# 35079 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let c0 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 35072 "parser_cocci_menhir.ml"
+# 35115 "parser_cocci_menhir.ml"
) = Obj.magic c0 in
let b0 : 'tv_nest_start = Obj.magic b0 in
let w0 : 'tv_list_whenppdecs_ = Obj.magic w0 in
let a0 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 35079 "parser_cocci_menhir.ml"
+# 35122 "parser_cocci_menhir.ml"
) = Obj.magic a0 in
let _startpos = _startpos_a0_ in
let _endpos = _endpos_c0_ in
let w = w0 in
let a = a0 in
-# 1156 "parser_cocci_menhir.mly"
+# 1144 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Nest(P.clt2mcode "<..." a, b,
P.clt2mcode "...>" c, List.concat w, false)) )
-# 35092 "parser_cocci_menhir.ml"
+# 35135 "parser_cocci_menhir.ml"
in
-# 2201 "parser_cocci_menhir.mly"
+# 2189 "parser_cocci_menhir.mly"
( [a] )
-# 35098 "parser_cocci_menhir.ml"
+# 35141 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let c0 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 35134 "parser_cocci_menhir.ml"
+# 35177 "parser_cocci_menhir.ml"
) = Obj.magic c0 in
let b0 : 'tv_nest_start = Obj.magic b0 in
let w0 : 'tv_list_whenppdecs_ = Obj.magic w0 in
let a0 : (
-# 145 "parser_cocci_menhir.mly"
+# 119 "parser_cocci_menhir.mly"
(Data.clt)
-# 35141 "parser_cocci_menhir.ml"
+# 35184 "parser_cocci_menhir.ml"
) = Obj.magic a0 in
let _startpos = _startpos_a0_ in
let _endpos = _endpos_c0_ in
let w = w0 in
let a = a0 in
-# 1159 "parser_cocci_menhir.mly"
+# 1147 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Nest(P.clt2mcode "<+..." a, b,
P.clt2mcode "...+>" c, List.concat w, true)) )
-# 35154 "parser_cocci_menhir.ml"
+# 35197 "parser_cocci_menhir.ml"
in
-# 2201 "parser_cocci_menhir.mly"
+# 2189 "parser_cocci_menhir.mly"
( [a] )
-# 35160 "parser_cocci_menhir.ml"
+# 35203 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_seq_startne_toplevel_after_dots_init_ =
-# 2202 "parser_cocci_menhir.mly"
+# 2190 "parser_cocci_menhir.mly"
( (Ast0.wrap(Ast0.Exp(_1)))::_2 )
-# 35190 "parser_cocci_menhir.ml"
+# 35233 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_toplevel_seq_startne_toplevel_after_dots_init_ =
-# 2203 "parser_cocci_menhir.mly"
+# 2191 "parser_cocci_menhir.mly"
( _1@_2 )
-# 35220 "parser_cocci_menhir.ml"
+# 35263 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_type_ident =
-# 2057 "parser_cocci_menhir.mly"
+# 2045 "parser_cocci_menhir.mly"
( _1 )
-# 35244 "parser_cocci_menhir.ml"
+# 35287 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 35265 "parser_cocci_menhir.ml"
+# 35308 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_type_ident =
-# 2059 "parser_cocci_menhir.mly"
+# 2047 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Id(P.id2mcode _1)) )
-# 35272 "parser_cocci_menhir.ml"
+# 35315 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
# 39 "standard.mly"
( None )
-# 35303 "parser_cocci_menhir.ml"
+# 35346 "parser_cocci_menhir.ml"
in
-# 749 "parser_cocci_menhir.mly"
+# 737 "parser_cocci_menhir.mly"
( P.pointerify (P.make_cv cv ty) m )
-# 35309 "parser_cocci_menhir.ml"
+# 35352 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
# 41 "standard.mly"
( Some x )
-# 35347 "parser_cocci_menhir.ml"
+# 35390 "parser_cocci_menhir.ml"
in
-# 749 "parser_cocci_menhir.mly"
+# 737 "parser_cocci_menhir.mly"
( P.pointerify (P.make_cv cv ty) m )
-# 35353 "parser_cocci_menhir.ml"
+# 35396 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 35384 "parser_cocci_menhir.ml"
+# 35427 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_midzero_list_mctype_mctype_ = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 35390 "parser_cocci_menhir.ml"
+# 35433 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let _startpos = _startpos_lp_ in
let _endpos = _endpos_rp_ in
let _v : 'tv_typedef_ctype =
-# 751 "parser_cocci_menhir.mly"
+# 739 "parser_cocci_menhir.mly"
( let (mids,code) = t in
Ast0.wrap
(Ast0.DisjType(P.clt2mcode "(" lp,code,mids, P.clt2mcode ")" rp)) )
-# 35399 "parser_cocci_menhir.ml"
+# 35442 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 35420 "parser_cocci_menhir.ml"
+# 35463 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_typedef_ctype =
-# 754 "parser_cocci_menhir.mly"
+# 742 "parser_cocci_menhir.mly"
( tmeta_to_type _1 )
-# 35427 "parser_cocci_menhir.ml"
+# 35470 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_typedef_ident =
-# 2077 "parser_cocci_menhir.mly"
+# 2065 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.TypeName(P.id2mcode _1)) )
-# 35451 "parser_cocci_menhir.ml"
+# 35494 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 135 "parser_cocci_menhir.mly"
+# 109 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 35472 "parser_cocci_menhir.ml"
+# 35515 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_typedef_ident =
-# 2078 "parser_cocci_menhir.mly"
+# 2066 "parser_cocci_menhir.mly"
( tmeta_to_type _1 )
-# 35479 "parser_cocci_menhir.ml"
+# 35522 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 134 "parser_cocci_menhir.mly"
+# 108 "parser_cocci_menhir.mly"
(Parse_aux.info)
-# 35500 "parser_cocci_menhir.ml"
+# 35543 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_typedef_ident =
-# 2080 "parser_cocci_menhir.mly"
+# 2068 "parser_cocci_menhir.mly"
( let (nm,pure,clt) = _1 in
Ast0.wrap(Ast0.MetaType(P.clt2mcode nm clt,pure)) )
-# 35508 "parser_cocci_menhir.ml"
+# 35551 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_unary_expr_eexpr_dot_expressions_ =
-# 1629 "parser_cocci_menhir.mly"
+# 1617 "parser_cocci_menhir.mly"
( _1 )
-# 35532 "parser_cocci_menhir.ml"
+# 35575 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 35559 "parser_cocci_menhir.ml"
+# 35602 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_dot_expressions_ =
-# 1631 "parser_cocci_menhir.mly"
+# 1619 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Inc _1)) )
-# 35566 "parser_cocci_menhir.ml"
+# 35609 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 35593 "parser_cocci_menhir.ml"
+# 35636 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_dot_expressions_ =
-# 1633 "parser_cocci_menhir.mly"
+# 1621 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Dec _1)) )
-# 35600 "parser_cocci_menhir.ml"
+# 35643 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_dot_expressions_ =
-# 1635 "parser_cocci_menhir.mly"
+# 1623 "parser_cocci_menhir.mly"
( let mcode = _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) )
-# 35630 "parser_cocci_menhir.ml"
+# 35673 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 35657 "parser_cocci_menhir.ml"
+# 35700 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_dot_expressions_ =
-# 1637 "parser_cocci_menhir.mly"
+# 1625 "parser_cocci_menhir.mly"
( let mcode = P.clt2mcode Ast.Not _1 in
Ast0.wrap(Ast0.Unary(_2, mcode)) )
-# 35665 "parser_cocci_menhir.ml"
+# 35708 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 35692 "parser_cocci_menhir.ml"
+# 35735 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_dot_expressions_ =
-# 1640 "parser_cocci_menhir.mly"
+# 1628 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.SizeOfExpr (P.clt2mcode "sizeof" _1, _2)) )
-# 35699 "parser_cocci_menhir.ml"
+# 35742 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 35735 "parser_cocci_menhir.ml"
+# 35778 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_ctype = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 35741 "parser_cocci_menhir.ml"
+# 35784 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let s : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 35746 "parser_cocci_menhir.ml"
+# 35789 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_rp_ in
let _v : 'tv_unary_expr_eexpr_dot_expressions_ =
-# 1642 "parser_cocci_menhir.mly"
+# 1630 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.SizeOfType (P.clt2mcode "sizeof" s,
P.clt2mcode "(" lp,t,
P.clt2mcode ")" rp)) )
-# 35755 "parser_cocci_menhir.ml"
+# 35798 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_unary_expr_eexpr_invalid_ =
-# 1629 "parser_cocci_menhir.mly"
+# 1617 "parser_cocci_menhir.mly"
( _1 )
-# 35779 "parser_cocci_menhir.ml"
+# 35822 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 35806 "parser_cocci_menhir.ml"
+# 35849 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_invalid_ =
-# 1631 "parser_cocci_menhir.mly"
+# 1619 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Inc _1)) )
-# 35813 "parser_cocci_menhir.ml"
+# 35856 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 35840 "parser_cocci_menhir.ml"
+# 35883 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_invalid_ =
-# 1633 "parser_cocci_menhir.mly"
+# 1621 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Dec _1)) )
-# 35847 "parser_cocci_menhir.ml"
+# 35890 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_invalid_ =
-# 1635 "parser_cocci_menhir.mly"
+# 1623 "parser_cocci_menhir.mly"
( let mcode = _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) )
-# 35877 "parser_cocci_menhir.ml"
+# 35920 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 35904 "parser_cocci_menhir.ml"
+# 35947 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_invalid_ =
-# 1637 "parser_cocci_menhir.mly"
+# 1625 "parser_cocci_menhir.mly"
( let mcode = P.clt2mcode Ast.Not _1 in
Ast0.wrap(Ast0.Unary(_2, mcode)) )
-# 35912 "parser_cocci_menhir.ml"
+# 35955 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 35939 "parser_cocci_menhir.ml"
+# 35982 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_invalid_ =
-# 1640 "parser_cocci_menhir.mly"
+# 1628 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.SizeOfExpr (P.clt2mcode "sizeof" _1, _2)) )
-# 35946 "parser_cocci_menhir.ml"
+# 35989 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 35982 "parser_cocci_menhir.ml"
+# 36025 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_ctype = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 35988 "parser_cocci_menhir.ml"
+# 36031 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let s : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 35993 "parser_cocci_menhir.ml"
+# 36036 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_rp_ in
let _v : 'tv_unary_expr_eexpr_invalid_ =
-# 1642 "parser_cocci_menhir.mly"
+# 1630 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.SizeOfType (P.clt2mcode "sizeof" s,
P.clt2mcode "(" lp,t,
P.clt2mcode ")" rp)) )
-# 36002 "parser_cocci_menhir.ml"
+# 36045 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_unary_expr_eexpr_nest_expressions_ =
-# 1629 "parser_cocci_menhir.mly"
+# 1617 "parser_cocci_menhir.mly"
( _1 )
-# 36026 "parser_cocci_menhir.ml"
+# 36069 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 36053 "parser_cocci_menhir.ml"
+# 36096 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_nest_expressions_ =
-# 1631 "parser_cocci_menhir.mly"
+# 1619 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Inc _1)) )
-# 36060 "parser_cocci_menhir.ml"
+# 36103 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 36087 "parser_cocci_menhir.ml"
+# 36130 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_nest_expressions_ =
-# 1633 "parser_cocci_menhir.mly"
+# 1621 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Dec _1)) )
-# 36094 "parser_cocci_menhir.ml"
+# 36137 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_nest_expressions_ =
-# 1635 "parser_cocci_menhir.mly"
+# 1623 "parser_cocci_menhir.mly"
( let mcode = _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) )
-# 36124 "parser_cocci_menhir.ml"
+# 36167 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 36151 "parser_cocci_menhir.ml"
+# 36194 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_nest_expressions_ =
-# 1637 "parser_cocci_menhir.mly"
+# 1625 "parser_cocci_menhir.mly"
( let mcode = P.clt2mcode Ast.Not _1 in
Ast0.wrap(Ast0.Unary(_2, mcode)) )
-# 36159 "parser_cocci_menhir.ml"
+# 36202 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 36186 "parser_cocci_menhir.ml"
+# 36229 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_eexpr_nest_expressions_ =
-# 1640 "parser_cocci_menhir.mly"
+# 1628 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.SizeOfExpr (P.clt2mcode "sizeof" _1, _2)) )
-# 36193 "parser_cocci_menhir.ml"
+# 36236 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 36229 "parser_cocci_menhir.ml"
+# 36272 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_ctype = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 36235 "parser_cocci_menhir.ml"
+# 36278 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let s : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 36240 "parser_cocci_menhir.ml"
+# 36283 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_rp_ in
let _v : 'tv_unary_expr_eexpr_nest_expressions_ =
-# 1642 "parser_cocci_menhir.mly"
+# 1630 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.SizeOfType (P.clt2mcode "sizeof" s,
P.clt2mcode "(" lp,t,
P.clt2mcode ")" rp)) )
-# 36249 "parser_cocci_menhir.ml"
+# 36292 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_unary_expr_expr_invalid_ =
-# 1629 "parser_cocci_menhir.mly"
+# 1617 "parser_cocci_menhir.mly"
( _1 )
-# 36273 "parser_cocci_menhir.ml"
+# 36316 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 36300 "parser_cocci_menhir.ml"
+# 36343 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_expr_invalid_ =
-# 1631 "parser_cocci_menhir.mly"
+# 1619 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Inc _1)) )
-# 36307 "parser_cocci_menhir.ml"
+# 36350 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 36334 "parser_cocci_menhir.ml"
+# 36377 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_expr_invalid_ =
-# 1633 "parser_cocci_menhir.mly"
+# 1621 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Dec _1)) )
-# 36341 "parser_cocci_menhir.ml"
+# 36384 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_expr_invalid_ =
-# 1635 "parser_cocci_menhir.mly"
+# 1623 "parser_cocci_menhir.mly"
( let mcode = _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) )
-# 36371 "parser_cocci_menhir.ml"
+# 36414 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 36398 "parser_cocci_menhir.ml"
+# 36441 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_expr_invalid_ =
-# 1637 "parser_cocci_menhir.mly"
+# 1625 "parser_cocci_menhir.mly"
( let mcode = P.clt2mcode Ast.Not _1 in
Ast0.wrap(Ast0.Unary(_2, mcode)) )
-# 36406 "parser_cocci_menhir.ml"
+# 36449 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 36433 "parser_cocci_menhir.ml"
+# 36476 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_expr_invalid_ =
-# 1640 "parser_cocci_menhir.mly"
+# 1628 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.SizeOfExpr (P.clt2mcode "sizeof" _1, _2)) )
-# 36440 "parser_cocci_menhir.ml"
+# 36483 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 36476 "parser_cocci_menhir.ml"
+# 36519 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_ctype = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 36482 "parser_cocci_menhir.ml"
+# 36525 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let s : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 36487 "parser_cocci_menhir.ml"
+# 36530 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_rp_ in
let _v : 'tv_unary_expr_expr_invalid_ =
-# 1642 "parser_cocci_menhir.mly"
+# 1630 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.SizeOfType (P.clt2mcode "sizeof" s,
P.clt2mcode "(" lp,t,
P.clt2mcode ")" rp)) )
-# 36496 "parser_cocci_menhir.ml"
+# 36539 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_unary_expr_bis =
-# 1648 "parser_cocci_menhir.mly"
+# 1636 "parser_cocci_menhir.mly"
( _1 )
-# 36520 "parser_cocci_menhir.ml"
+# 36563 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 36547 "parser_cocci_menhir.ml"
+# 36590 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_bis =
-# 1650 "parser_cocci_menhir.mly"
+# 1638 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Inc _1)) )
-# 36554 "parser_cocci_menhir.ml"
+# 36597 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 157 "parser_cocci_menhir.mly"
+# 131 "parser_cocci_menhir.mly"
(Data.clt)
-# 36581 "parser_cocci_menhir.ml"
+# 36624 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_bis =
-# 1652 "parser_cocci_menhir.mly"
+# 1640 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Infix (_2, P.clt2mcode Ast.Dec _1)) )
-# 36588 "parser_cocci_menhir.ml"
+# 36631 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_bis =
-# 1654 "parser_cocci_menhir.mly"
+# 1642 "parser_cocci_menhir.mly"
( let mcode = _1 in Ast0.wrap(Ast0.Unary(_2, mcode)) )
-# 36618 "parser_cocci_menhir.ml"
+# 36661 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 36645 "parser_cocci_menhir.ml"
+# 36688 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_bis =
-# 1656 "parser_cocci_menhir.mly"
+# 1644 "parser_cocci_menhir.mly"
( let mcode = P.clt2mcode Ast.Not _1 in
Ast0.wrap(Ast0.Unary(_2, mcode)) )
-# 36653 "parser_cocci_menhir.ml"
+# 36696 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
} = _menhir_stack in
let _2 : 'tv_unary_expr_bis = Obj.magic _2 in
let _1 : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 36680 "parser_cocci_menhir.ml"
+# 36723 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_unary_expr_bis =
-# 1659 "parser_cocci_menhir.mly"
+# 1647 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.SizeOfExpr (P.clt2mcode "sizeof" _1, _2)) )
-# 36687 "parser_cocci_menhir.ml"
+# 36730 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
};
} = _menhir_stack in
let rp : (
-# 149 "parser_cocci_menhir.mly"
+# 123 "parser_cocci_menhir.mly"
(Data.clt)
-# 36723 "parser_cocci_menhir.ml"
+# 36766 "parser_cocci_menhir.ml"
) = Obj.magic rp in
let t : 'tv_ctype = Obj.magic t in
let lp : (
-# 148 "parser_cocci_menhir.mly"
+# 122 "parser_cocci_menhir.mly"
(Data.clt)
-# 36729 "parser_cocci_menhir.ml"
+# 36772 "parser_cocci_menhir.ml"
) = Obj.magic lp in
let s : (
-# 126 "parser_cocci_menhir.mly"
+# 100 "parser_cocci_menhir.mly"
(Data.clt)
-# 36734 "parser_cocci_menhir.ml"
+# 36777 "parser_cocci_menhir.ml"
) = Obj.magic s in
let _startpos = _startpos_s_ in
let _endpos = _endpos_rp_ in
let _v : 'tv_unary_expr_bis =
-# 1661 "parser_cocci_menhir.mly"
+# 1649 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.SizeOfType (P.clt2mcode "sizeof" s,
P.clt2mcode "(" lp,t,
P.clt2mcode ")" rp)) )
-# 36743 "parser_cocci_menhir.ml"
+# 36786 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 165 "parser_cocci_menhir.mly"
+# 139 "parser_cocci_menhir.mly"
(Data.clt)
-# 36764 "parser_cocci_menhir.ml"
+# 36807 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_unary_op =
-# 1665 "parser_cocci_menhir.mly"
+# 1653 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.GetRef _1 )
-# 36771 "parser_cocci_menhir.ml"
+# 36814 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 36792 "parser_cocci_menhir.ml"
+# 36835 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_unary_op =
-# 1666 "parser_cocci_menhir.mly"
+# 1654 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.DeRef _1 )
-# 36799 "parser_cocci_menhir.ml"
+# 36842 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
-# 36820 "parser_cocci_menhir.ml"
+# 36863 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_unary_op =
-# 1667 "parser_cocci_menhir.mly"
+# 1655 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.UnPlus _1 )
-# 36827 "parser_cocci_menhir.ml"
+# 36870 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 170 "parser_cocci_menhir.mly"
+# 144 "parser_cocci_menhir.mly"
(Data.clt)
-# 36848 "parser_cocci_menhir.ml"
+# 36891 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_unary_op =
-# 1668 "parser_cocci_menhir.mly"
+# 1656 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.UnMinus _1 )
-# 36855 "parser_cocci_menhir.ml"
+# 36898 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 171 "parser_cocci_menhir.mly"
+# 145 "parser_cocci_menhir.mly"
(Data.clt)
-# 36876 "parser_cocci_menhir.ml"
+# 36919 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_unary_op =
-# 1669 "parser_cocci_menhir.mly"
+# 1657 "parser_cocci_menhir.mly"
( P.clt2mcode Ast.Tilde _1 )
-# 36883 "parser_cocci_menhir.ml"
+# 36926 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_when_start =
-# 2330 "parser_cocci_menhir.mly"
+# 2318 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.DOTS((Ast0.wrap(Ast0.Exp(_1)))::_2)) )
-# 36913 "parser_cocci_menhir.ml"
+# 36956 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__2_ in
let _v : 'tv_when_start =
-# 2332 "parser_cocci_menhir.mly"
+# 2320 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.DOTS(_1@_2)) )
-# 36943 "parser_cocci_menhir.ml"
+# 36986 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos_w_ in
let _endpos = _endpos_w_ in
let _v : 'tv_whenppdecs =
-# 1163 "parser_cocci_menhir.mly"
+# 1151 "parser_cocci_menhir.mly"
( w )
-# 36967 "parser_cocci_menhir.ml"
+# 37010 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_whens_when_start_rule_elem_statement_any_strict_ =
-# 2377 "parser_cocci_menhir.mly"
+# 2365 "parser_cocci_menhir.mly"
( [Ast0.WhenNot w] )
-# 37003 "parser_cocci_menhir.ml"
+# 37046 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_whens_when_start_rule_elem_statement_any_strict_ =
-# 2378 "parser_cocci_menhir.mly"
+# 2366 "parser_cocci_menhir.mly"
( [Ast0.WhenAlways w] )
-# 37039 "parser_cocci_menhir.ml"
+# 37082 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__3_ in
let _v : 'tv_whens_when_start_rule_elem_statement_any_strict_ =
-# 2380 "parser_cocci_menhir.mly"
+# 2368 "parser_cocci_menhir.mly"
( List.map (function x -> Ast0.WhenModifier(x)) _2 )
-# 37071 "parser_cocci_menhir.ml"
+# 37114 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_whens_when_start_rule_elem_statement_any_strict_ =
-# 2381 "parser_cocci_menhir.mly"
+# 2369 "parser_cocci_menhir.mly"
( [Ast0.WhenNotTrue e] )
-# 37107 "parser_cocci_menhir.ml"
+# 37150 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let _startpos = _startpos__1_ in
let _endpos = _endpos__4_ in
let _v : 'tv_whens_when_start_rule_elem_statement_any_strict_ =
-# 2382 "parser_cocci_menhir.mly"
+# 2370 "parser_cocci_menhir.mly"
( [Ast0.WhenNotFalse e] )
-# 37143 "parser_cocci_menhir.ml"
+# 37186 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
MenhirLib.EngineTypes.next = _menhir_stack;
} = _menhir_stack in
let _1 : (
-# 127 "parser_cocci_menhir.mly"
+# 101 "parser_cocci_menhir.mly"
(string * Data.clt)
-# 37164 "parser_cocci_menhir.ml"
+# 37207 "parser_cocci_menhir.ml"
) = Obj.magic _1 in
let _startpos = _startpos__1_ in
let _endpos = _endpos__1_ in
let _v : 'tv_wrapped_sym_ident =
-# 1803 "parser_cocci_menhir.mly"
+# 1791 "parser_cocci_menhir.mly"
( Ast0.wrap(Ast0.Id(P.sym2mcode _1)) )
-# 37171 "parser_cocci_menhir.ml"
+# 37214 "parser_cocci_menhir.ml"
in
_menhir_env.MenhirLib.EngineTypes.stack <- {
MenhirLib.EngineTypes.state = _menhir_s;
let rec script_meta_main =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1829 lexer lexbuf) : (
-# 233 "parser_cocci_menhir.mly"
+ (Obj.magic (MenhirInterpreter.entry 1832 lexer lexbuf) : (
+# 207 "parser_cocci_menhir.mly"
((string option (*string*) * string option (*ast*)) * (Ast_cocci.meta_name * Ast_cocci.metavar) option)
-# 37195 "parser_cocci_menhir.ml"
+# 37238 "parser_cocci_menhir.ml"
))
and rule_name =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1752 lexer lexbuf) : (
-# 227 "parser_cocci_menhir.mly"
+ (Obj.magic (MenhirInterpreter.entry 1755 lexer lexbuf) : (
+# 201 "parser_cocci_menhir.mly"
(Ast_cocci.rulename)
-# 37203 "parser_cocci_menhir.ml"
+# 37246 "parser_cocci_menhir.ml"
))
and reinit =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1750 lexer lexbuf) : (
-# 205 "parser_cocci_menhir.mly"
+ (Obj.magic (MenhirInterpreter.entry 1753 lexer lexbuf) : (
+# 179 "parser_cocci_menhir.mly"
(unit)
-# 37211 "parser_cocci_menhir.ml"
+# 37254 "parser_cocci_menhir.ml"
))
and plus_main =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1714 lexer lexbuf) : (
-# 214 "parser_cocci_menhir.mly"
+ (Obj.magic (MenhirInterpreter.entry 1717 lexer lexbuf) : (
+# 188 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 37219 "parser_cocci_menhir.ml"
+# 37262 "parser_cocci_menhir.ml"
))
and plus_exp_main =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1706 lexer lexbuf) : (
-# 217 "parser_cocci_menhir.mly"
+ (Obj.magic (MenhirInterpreter.entry 1709 lexer lexbuf) : (
+# 191 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 37227 "parser_cocci_menhir.ml"
+# 37270 "parser_cocci_menhir.ml"
))
and never_used =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1700 lexer lexbuf) : (
-# 242 "parser_cocci_menhir.mly"
+ (Obj.magic (MenhirInterpreter.entry 1703 lexer lexbuf) : (
+# 216 "parser_cocci_menhir.mly"
(unit)
-# 37235 "parser_cocci_menhir.ml"
+# 37278 "parser_cocci_menhir.ml"
))
and minus_main =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1615 lexer lexbuf) : (
-# 208 "parser_cocci_menhir.mly"
+ (Obj.magic (MenhirInterpreter.entry 1618 lexer lexbuf) : (
+# 182 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 37243 "parser_cocci_menhir.ml"
+# 37286 "parser_cocci_menhir.ml"
))
and minus_exp_main =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1603 lexer lexbuf) : (
-# 211 "parser_cocci_menhir.mly"
+ (Obj.magic (MenhirInterpreter.entry 1606 lexer lexbuf) : (
+# 185 "parser_cocci_menhir.mly"
(Ast0_cocci.rule)
-# 37251 "parser_cocci_menhir.ml"
+# 37294 "parser_cocci_menhir.ml"
))
and meta_main =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1600 lexer lexbuf) : (
-# 231 "parser_cocci_menhir.mly"
+ (Obj.magic (MenhirInterpreter.entry 1603 lexer lexbuf) : (
+# 205 "parser_cocci_menhir.mly"
((Ast_cocci.metavar,Ast_cocci.metavar) Common.either list)
-# 37259 "parser_cocci_menhir.ml"
+# 37302 "parser_cocci_menhir.ml"
))
and iso_rule_name =
fun lexer lexbuf ->
- (Obj.magic (MenhirInterpreter.entry 1596 lexer lexbuf) : (
-# 223 "parser_cocci_menhir.mly"
+ (Obj.magic (MenhirInterpreter.entry 1599 lexer lexbuf) : (
+# 197 "parser_cocci_menhir.mly"
(Ast_cocci.rulename)
-# 37267 "parser_cocci_menhir.ml"
+# 37310 "parser_cocci_menhir.ml"
))
and iso_meta_main =
fun lexer lexbuf ->
(Obj.magic (MenhirInterpreter.entry 1301 lexer lexbuf) : (
-# 239 "parser_cocci_menhir.mly"
+# 213 "parser_cocci_menhir.mly"
((Ast_cocci.metavar,Ast_cocci.metavar) Common.either list)
-# 37275 "parser_cocci_menhir.ml"
+# 37318 "parser_cocci_menhir.ml"
))
and iso_main =
fun lexer lexbuf ->
(Obj.magic (MenhirInterpreter.entry 18 lexer lexbuf) : (
-# 236 "parser_cocci_menhir.mly"
+# 210 "parser_cocci_menhir.mly"
(Ast0_cocci.anything list list)
-# 37283 "parser_cocci_menhir.ml"
+# 37326 "parser_cocci_menhir.ml"
))
and include_main =
fun lexer lexbuf ->
(Obj.magic (MenhirInterpreter.entry 0 lexer lexbuf) : (
-# 220 "parser_cocci_menhir.mly"
+# 194 "parser_cocci_menhir.mly"
(Data.incl_iso list)
-# 37291 "parser_cocci_menhir.ml"
+# 37334 "parser_cocci_menhir.ml"
))
+(*
+ * Copyright 2012, INRIA
+ * Julia Lawall, Gilles Muller
+ * Copyright 2010-2011, INRIA, University of Copenhagen
+ * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
+ * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
+ * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
+ * This file is part of Coccinelle.
+ *
+ * Coccinelle 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, according to version 2 of the License.
+ *
+ * Coccinelle 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 Coccinelle. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * The authors reserve the right to distribute this or future versions of
+ * Coccinelle under other licenses.
+ *)
+
+
+# 0 "./parser_cocci_menhir.mli"
exception Error
type token =
list_len:
pure_ident_or_meta_ident { Common.Left $1 }
| TInt { let (x,clt) = $1 in Common.Right (int_of_string x) }
+| TVirtual TDot pure_ident
+ { let nm = ("virtual",P.id2name $3) in
+ Iteration.parsed_virtual_identifiers :=
+ Common.union_set [snd nm]
+ !Iteration.parsed_virtual_identifiers;
+ try
+ Common.Right (int_of_string
+ (List.assoc (snd nm) !Flag.defined_virtual_env))
+ with Not_found | Failure "int_of_string" ->
+ begin
+ Common.Left (Some "virtual",P.id2name $3)
+ end
+ }
+
%inline metakind_fresh:
TFresh TIdentifier
--- /dev/null
+Flag_parsing_cocci
+Type_cocci
+Ast_cocci
+Ast0_cocci
+Pretty_print_cocci
+Unparse_ast0
+Visitor_ast0_types
+Visitor_ast
+Visitor_ast0
+Compute_lines
+Comm_assoc
+Iso_pattern
+Iso_compile
+Single_statement
+Simple_assignments
+Get_metas
+Ast0toast
+Check_meta
+Top_level
+Type_infer
+Test_exps
+Unitary_ast0
+Arity
+Index
+Context_neg
+Adjust_pragmas
+Insert_plus
+Function_prototypes
+Unify_ast
+Semantic_cocci
+Data
+Free_vars
+Safe_for_multi_decls
+Parse_aux
+Disjdistr
+Lexer_cocci
+Parser_cocci_menhir
+Lexer_cli
+Lexer_script
+Get_constants2
+Id_utils
+Adjacency
+Parse_cocci
+Command_line
\ No newline at end of file
--- /dev/null
+Flag_parsing_cocci
+Type_cocci
+Ast_cocci
+Ast0_cocci
+Pretty_print_cocci
+Unparse_ast0
+Visitor_ast0_types
+Visitor_ast
+Visitor_ast0
+Compute_lines
+Comm_assoc
+Iso_pattern
+Iso_compile
+Single_statement
+Simple_assignments
+Get_metas
+Ast0toast
+Check_meta
+Top_level
+Type_infer
+Test_exps
+Unitary_ast0
+Arity
+Index
+Context_neg
+Adjust_pragmas
+Insert_plus
+Function_prototypes
+Unify_ast
+Semantic_cocci
+Data
+Free_vars
+Safe_for_multi_decls
+Parse_aux
+Disjdistr
+Lexer_cocci
+Parser_cocci_menhir
+Lexer_cli
+Lexer_script
+Get_constants2
+Id_utils
+Adjacency
+Parse_cocci
+Command_line
\ No newline at end of file
((Ast.unwrap_mcode op) = Ast.SimpleAssign)
let warning e msg =
- Common.pr2
- ("the simple assignment expression on line "^
- (string_of_int (Ast0.get_line e))^
- " contains transformations\n"^
- "that prevent it from matching a declaration ("^msg^")\n");
+ if not !Flag.sgrep_mode2
+ then
+ Common.pr2
+ ("the simple assignment expression on line "^
+ (string_of_int (Ast0.get_line e))^
+ " contains transformations\n"^
+ "that prevent it from matching a declaration ("^msg^")\n");
e
let rebuild e1 left right op simple =
| Ast0.Seq(lbrace,body,rbrace) -> modif_before_mcode lbrace
| Ast0.ExprStatement(Some exp,sem) -> left_expression exp
| Ast0.ExprStatement(None,sem) -> modif_before_mcode sem
- | Ast0.IfThen(iff,lp,exp,rp,branch1,(info,aft)) -> modif_before_mcode iff
- | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(info,aft)) ->
+ | Ast0.IfThen(iff,lp,exp,rp,branch1,aft) -> modif_before_mcode iff
+ | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,aft) ->
modif_before_mcode iff
- | Ast0.While(whl,lp,exp,rp,body,(info,aft)) -> modif_before_mcode whl
+ | Ast0.While(whl,lp,exp,rp,body,aft) -> modif_before_mcode whl
| Ast0.Do(d,body,whl,lp,exp,rp,sem) -> modif_before_mcode d
- | Ast0.For(fr,lp,first,e2,sem2,e3,rp,body,(info,aft)) ->
+ | Ast0.For(fr,lp,first,e2,sem2,e3,rp,body,aft) ->
modif_before_mcode fr
- | Ast0.Iterator(nm,lp,args,rp,body,(info,aft)) -> left_ident nm
+ | Ast0.Iterator(nm,lp,args,rp,body,aft) -> left_ident nm
| Ast0.Switch(switch,lp,exp,rp,lb,decls,cases,rb) ->
modif_before_mcode switch
| Ast0.Break(br,sem) -> modif_before_mcode br
| Ast0.Decl(_,decl) -> right_declaration decl
| Ast0.Seq(lbrace,body,rbrace) -> modif_after_mcode rbrace
| Ast0.ExprStatement(exp,sem) -> modif_after_mcode sem
- | Ast0.IfThen(iff,lp,exp,rp,branch1,(info,aft)) -> modif_after_mcodekind aft
- | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(info,aft)) ->
+ | Ast0.IfThen(iff,lp,exp,rp,branch1,(_,aft,_)) -> modif_after_mcodekind aft
+ | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(_,aft,_)) ->
modif_after_mcodekind aft
- | Ast0.While(whl,lp,exp,rp,body,(info,aft)) -> modif_after_mcodekind aft
+ | Ast0.While(whl,lp,exp,rp,body,(_,aft,_)) -> modif_after_mcodekind aft
| Ast0.Do(d,body,whl,lp,exp,rp,sem) -> modif_after_mcode sem
- | Ast0.For(fr,lp,first,e2,sem2,e3,rp,body,(info,aft)) ->
+ | Ast0.For(fr,lp,first,e2,sem2,e3,rp,body,(_,aft,_)) ->
modif_after_mcodekind aft
- | Ast0.Iterator(nm,lp,args,rp,body,(info,aft)) ->
+ | Ast0.Iterator(nm,lp,args,rp,body,(_,aft,_)) ->
modif_after_mcodekind aft
| Ast0.Switch(switch,lp,exp,rp,lb,decls,cases,rb) -> modif_after_mcode rb
| Ast0.Break(br,sem) -> modif_after_mcode sem
dots force_newline (statement arity) body;
end_block(); print_string arity; mcode print_string rbrace
| Ast0.Decl(_,decl) ->
- Printf.printf "statement mcodekind %s\n"
- (Dumper.dump (Ast0.get_mcodekind s));
- Printf.printf "decl mcodekind %s\n"
- (Dumper.dump (Ast0.get_mcodekind decl));
print_string arity; declaration decl
| Ast0.Seq(lbrace,body,rbrace) ->
print_string arity; mcode print_string lbrace; start_block();
| Ast0.ExprStatement(exp,sem) ->
print_string arity; print_option expression exp;
mcode print_string sem
- | Ast0.IfThen(iff,lp,exp,rp,branch1,(info,aft)) ->
+ | Ast0.IfThen(iff,lp,exp,rp,branch1,(info,aft,adj)) ->
print_string arity;
mcode print_string iff; print_string " "; mcode print_string_box lp;
expression exp; close_box(); mcode print_string rp; print_string " ";
statement arity branch1;
- mcode (function _ -> ()) ((),(),info,aft,ref [],-1)
- | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(info,aft)) ->
+ mcode (function _ -> ()) ((),(),info,aft,ref [],adj)
+ | Ast0.IfThenElse(iff,lp,exp,rp,branch1,els,branch2,(info,aft,adj)) ->
print_string arity;
mcode print_string iff; print_string " "; mcode print_string_box lp;
expression exp; close_box(); mcode print_string rp; print_string " ";
statement arity branch1;
print_string arity; mcode print_string els; print_string " ";
statement arity branch2;
- mcode (function _ -> ()) ((),(),info,aft,ref [],-1)
- | Ast0.While(whl,lp,exp,rp,body,(info,aft)) ->
+ mcode (function _ -> ()) ((),(),info,aft,ref [],adj)
+ | Ast0.While(whl,lp,exp,rp,body,(info,aft,adj)) ->
print_string arity;
mcode print_string whl; print_string " "; mcode print_string_box lp;
expression exp; close_box(); mcode print_string rp; print_string " ";
statement arity body;
- mcode (function _ -> ()) ((),(),info,aft,ref [],-1)
+ mcode (function _ -> ()) ((),(),info,aft,ref [],adj)
| Ast0.Do(d,body,whl,lp,exp,rp,sem) ->
print_string arity; mcode print_string d; print_string " ";
statement arity body;
mcode print_string whl; print_string " "; mcode print_string_box lp;
expression exp; close_box(); mcode print_string rp;
mcode print_string sem
- | Ast0.For(fr,lp,first,e2,sem2,e3,rp,body,(info,aft)) ->
+ | Ast0.For(fr,lp,first,e2,sem2,e3,rp,body,(info,aft,adj)) ->
print_string arity;
mcode print_string fr; mcode print_string_box lp;
(match Ast0.unwrap first with
print_option expression e2; mcode print_string sem2;
print_option expression e3; close_box();
mcode print_string rp; print_string " "; statement arity body;
- mcode (function _ -> ()) ((),(),info,aft,ref [],-1)
- | Ast0.Iterator(nm,lp,args,rp,body,(info,aft)) ->
+ mcode (function _ -> ()) ((),(),info,aft,ref [],adj)
+ | Ast0.Iterator(nm,lp,args,rp,body,(info,aft,adj)) ->
print_string arity;
ident nm; print_string " "; mcode print_string_box lp;
let _ = dots (function _ -> ()) expression args in
close_box(); mcode print_string rp; print_string " ";
statement arity body;
- mcode (function _ -> ()) ((),(),info,aft,ref [],-1)
+ mcode (function _ -> ()) ((),(),info,aft,ref [],adj)
| Ast0.Switch(switch,lp,exp,rp,lb,decls,cases,rb) ->
print_string arity;
mcode print_string switch; print_string " ";
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
+endif
include ../Makefile.common
OBJS = $(SRC:.ml=.cmo)
OPTOBJS = $(SRC:.ml=.cmx)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
all: $(LIB)
all.opt:
@$(MAKE) $(OPTLIB) BUILD_OPT=yes
clean::
rm -f $(LIB) $(TARGET).top
+else
+all:
+ cd .. && $(OCAMLBUILD) popl09/popl09.cma
+
+all.opt:
+ cd .. && $(OCAMLBUILD) popl09/popl09.cmxa
+
+clean::
+ cd .. && $(OCAMLBUILD) -clean
+endif
$(OPTLIB): $(OPTOBJS)
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
+endif
include ../Makefile.common
--- /dev/null
+Ast_popl
+Asttopopl
+Insert_quantifiers
+Pretty_print_popl
+Flag_popl
+Popltoctl
+Popl
--- /dev/null
+Ast_popl
+Asttopopl
+Insert_quantifiers
+Pretty_print_popl
+Flag_popl
+Popltoctl
+Popl
# Coccinelle under other licenses.
+
#############################################################################
# Configuration section
#############################################################################
CTLOBJS = $(CTLSOURCES:.ml=.cmo)
CTLOPTOBJS = $(CTLOBJS:.cmo=.cmx)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
all: $(LIB)
all.opt:
$(OCAMLC_CMD) -a -o $(LIB) $(OBJS)
clean::
- rm -f $(LIB)
+ rm -f $(TARGET).cma $(TARGET).a $(TARGET).o $(TARGET).cmxa
$(OPTLIB): $(OPTOBJS)
$(CTLEXEC): $(CTLOBJS) $(LIBS)
$(OCAMLC_CMD) -o $(CTLEXEC) $(SYSLIBS) $(LIBS) $(CTLOBJS)
-
+else
+all:
+ cd .. && $(OCAMLBUILD) python/python.cma
+all.opt:
+ cd .. && $(OCAMLBUILD) python/python.cmxa
+clean::
+ cd .. && $(OCAMLBUILD) -clean
+endif
clean::
rm -f $(OPTLIB) $(LIB:.cma=.a)
rm -f $(TARGET).byte
rm -f $(CTLTARGET)
rm -f .depend
+ rm -f coccipython.cmxa coccipython.a
distclean::
$(MAKE) -C coccilib $@
rm -f pycocci.ml
- rm -f *.cm[iox] *.o *.annot
+ rm -f *.cm[ioxa] *.o *.annot
##############################################################################
# Generic ocaml rules
ifneq ($(MAKECMDGOALS),clean)
ifneq ($(MAKECMDGOALS),distclean)
+ifneq ($(FEATURE_OCAMLBUILD),yes)
-include .depend
endif
endif
+endif
include ../Makefile.common
--- /dev/null
+Pycocci
+Pycocci_aux
\ No newline at end of file
--- /dev/null
+Pycocci
+Pycocci_aux
\ No newline at end of file
{ name = "pycaml"; ocamls = ps: [ ps.pycaml ]; flags = [ "--enable-pycaml" ]; }
];
+ # Tests using several different types of shells.
shellCfgs = map mkCfgShell [
{ name = "bash"; selShell = pkgs: "${pkgs.bash}/bin/bash"; }
{ name = "dash"; selShell = pkgs: "${pkgs.dash}/bin/dash"; }
# { name = "tcsh"; selShell = pkgs: "${pkgs.tcsh}/bin/tcsh"; }
];
+ #
+ # Configurations for the compilation of coccinelle using ocamlbuild.
+ #
+
+ ocamlbuildZeroCfg = mkCfgMinimal {
+ name = "ocamlbuild-zero";
+ flags = [ "--enable-ocamlbuild" "--enable-release" ];
+ };
+
+ ocamlbuildFullCfg = mkCfgDefault {
+ name = "ocamlbuild-full";
+ flags = [ "--enable-ocamlbuild" "--enable-release" ];
+ };
+
+ ocamlbuildCfgs = map mkCfgOcaml [
+ { name = "ocamlbuild-400nat"; selOcaml = selOcaml400;
+ flags = [ "--enable-ocamlbuild" "--enable-release=yes" ]; }
+ { name = "ocamlbuild-400byte"; selOcaml = selOcaml400;
+ flags = [ "--enable-ocamlbuild" ]; }
+ { name = "ocamlbuild-312"; selOcaml = selOcaml312;
+ flags = [ "--enable-ocamlbuild" "--enable-release" ]; }
+ { name = "ocamlbuild-311"; selOcaml = selOcaml311;
+ flags = [ "--enable-ocamlbuild" ]; }
+ { name = "ocamlbuild-310"; selOcaml = selOcaml310;
+ flags = [ "--enable-ocamlbuild" "--enable-release" ]; }
+ ] ++ [ ocamlbuildZeroCfg ocamlbuildFullCfg ];
+
altCfgs =
[ debugCfg manyOcamlCfg ]
++ minimalCfgs
++ ocamlCfgs ++ pythonCfgs
- ++ pkgCfgs ++ shellCfgs;
+ ++ pkgCfgs ++ shellCfgs
+ ++ ocamlbuildCfgs;
#
ocaml findlib menhir
python pcre patchelf
];
- configureFlagsArray = [ "--enable-release" ];
+ configureFlags = "--enable-release";
buildPhase = ''
export TARGETDIR="$TMPDIR/dists"
--- /dev/null
+# This is a makefile that is not used by this project,
+# except for one purpose only:
+#
+# to all automake -ac in the root directory to (re)generate
+# the files install-sh and missing in the setup subdirectory.
+#
+# The following files (with respect to the top directory)
+# have been included in order not to have a dependency on
+# automake:
+#
+# * setup/{Makefile.am, Makefile.in, install-sh, missing}
+# * configure
+# * Makefile.am
+#
+# Note: Makefile.in in the top directory is not generated
+# from Makefile.am in the top directory! That Makefile.in
+# is the official source file, and that Makefile.am is a
+# placeholder to fool automake (which we do not really use).
+
+all:
+ echo "dummy makefile, do not use"
--- /dev/null
+# Makefile.in generated by automake 1.12.2 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994-2012 Free Software Foundation, Inc.
+
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+# This is a makefile that is not used by this project,
+# except for one purpose only:
+#
+# to all automake -ac in the root directory to (re)generate
+# the files install-sh and missing in the setup subdirectory.
+#
+# The following files (with respect to the top directory)
+# have been included in order not to have a dependency on
+# automake:
+#
+# * setup/{Makefile.am, Makefile.in, install-sh, missing}
+# * configure
+# * Makefile.am
+#
+# Note: Makefile.in in the top directory is not generated
+# from Makefile.am in the top directory! That Makefile.in
+# is the official source file, and that Makefile.am is a
+# placeholder to fool automake (which we do not really use).
+VPATH = @srcdir@
+am__make_dryrun = \
+ { \
+ am__dry=no; \
+ case $$MAKEFLAGS in \
+ *\\[\ \ ]*) \
+ echo 'am--echo: ; @echo "AM" OK' | $(MAKE) -f - 2>/dev/null \
+ | grep '^AM OK$$' >/dev/null || am__dry=yes;; \
+ *) \
+ for am__flg in $$MAKEFLAGS; do \
+ case $$am__flg in \
+ *=*|--*) ;; \
+ *n*) am__dry=yes; break;; \
+ esac; \
+ done;; \
+ esac; \
+ test $$am__dry = yes; \
+ }
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+subdir = setup
+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in install-sh \
+ missing
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/setup/cocci.m4 \
+ $(top_srcdir)/setup/ocaml.m4 $(top_srcdir)/setup/pkg.m4 \
+ $(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+ $(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+SOURCES =
+DIST_SOURCES =
+am__can_run_installinfo = \
+ case $$AM_UPDATE_INFO_DIR in \
+ n|no|NO) false;; \
+ *) (install-info --version) >/dev/null 2>&1;; \
+ esac
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CAMLP4 = @CAMLP4@
+CAMLP4BOOT = @CAMLP4BOOT@
+CAMLP4O = @CAMLP4O@
+CAMLP4OF = @CAMLP4OF@
+CAMLP4OOF = @CAMLP4OOF@
+CAMLP4ORF = @CAMLP4ORF@
+CAMLP4PROF = @CAMLP4PROF@
+CAMLP4R = @CAMLP4R@
+CAMLP4RF = @CAMLP4RF@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+COCCI_OCAML_EXTERNAL = @COCCI_OCAML_EXTERNAL@
+COCCI_SRCDIR = @COCCI_SRCDIR@
+COCCI_VERSION = @COCCI_VERSION@
+CONFIGURE_FLAGS = @CONFIGURE_FLAGS@
+CONFVERSION = @CONFVERSION@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DATE = @DATE@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DYNLINK_IS_NATIVE = @DYNLINK_IS_NATIVE@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EXEEXT = @EXEEXT@
+FEATURE_OCAML = @FEATURE_OCAML@
+FEATURE_OCAMLBUILD = @FEATURE_OCAMLBUILD@
+FEATURE_PYTHON = @FEATURE_PYTHON@
+FEATURE_camlp4 = @FEATURE_camlp4@
+FEATURE_dynlink = @FEATURE_dynlink@
+FEATURE_menhirLib = @FEATURE_menhirLib@
+FEATURE_pcre = @FEATURE_pcre@
+FEATURE_pycaml = @FEATURE_pycaml@
+FLAGS_camlp4 = @FLAGS_camlp4@
+FLAGS_dynlink = @FLAGS_dynlink@
+FLAGS_menhirLib = @FLAGS_menhirLib@
+FLAGS_pcre = @FLAGS_pcre@
+FLAGS_pycaml = @FLAGS_pycaml@
+GIT = @GIT@
+GLOBAL_camlp4 = @GLOBAL_camlp4@
+GLOBAL_dynlink = @GLOBAL_dynlink@
+GLOBAL_menhirLib = @GLOBAL_menhirLib@
+GLOBAL_pcre = @GLOBAL_pcre@
+GLOBAL_pycaml = @GLOBAL_pycaml@
+HAVE_PCRE = @HAVE_PCRE@
+HAVE_PYTHON = @HAVE_PYTHON@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LDFLAGS = @LDFLAGS@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LOCALLIB_camlp4 = @LOCALLIB_camlp4@
+LOCALLIB_dynlink = @LOCALLIB_dynlink@
+LOCALLIB_menhirLib = @LOCALLIB_menhirLib@
+LOCALLIB_pcre = @LOCALLIB_pcre@
+LOCALLIB_pycaml = @LOCALLIB_pycaml@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MAKETARGET_ALL = @MAKETARGET_ALL@
+MAKETARGET_SPATCH = @MAKETARGET_SPATCH@
+MAKE_camlp4 = @MAKE_camlp4@
+MAKE_dynlink = @MAKE_dynlink@
+MAKE_menhirLib = @MAKE_menhirLib@
+MAKE_pcre = @MAKE_pcre@
+MAKE_pycaml = @MAKE_pycaml@
+MENHIR = @MENHIR@
+MKDIR_P = @MKDIR_P@
+MODULESOPT_camlp4 = @MODULESOPT_camlp4@
+MODULESOPT_dynlink = @MODULESOPT_dynlink@
+MODULESOPT_menhirLib = @MODULESOPT_menhirLib@
+MODULESOPT_pcre = @MODULESOPT_pcre@
+MODULESOPT_pycaml = @MODULESOPT_pycaml@
+MODULES_camlp4 = @MODULES_camlp4@
+MODULES_dynlink = @MODULES_dynlink@
+MODULES_menhirLib = @MODULES_menhirLib@
+MODULES_pcre = @MODULES_pcre@
+MODULES_profiling = @MODULES_profiling@
+MODULES_pycaml = @MODULES_pycaml@
+OBJEXT = @OBJEXT@
+OCAML = @OCAML@
+OCAMLATLEAST310 = @OCAMLATLEAST310@
+OCAMLATLEAST311 = @OCAMLATLEAST311@
+OCAMLBEST = @OCAMLBEST@
+OCAMLBUILD = @OCAMLBUILD@
+OCAMLC = @OCAMLC@
+OCAMLCDOTOPT = @OCAMLCDOTOPT@
+OCAMLCOCCI_FILE = @OCAMLCOCCI_FILE@
+OCAMLCOCCI_MODULE = @OCAMLCOCCI_MODULE@
+OCAMLCORIG = @OCAMLCORIG@
+OCAMLDEP = @OCAMLDEP@
+OCAMLDOC = @OCAMLDOC@
+OCAMLFIND = @OCAMLFIND@
+OCAMLLEX = @OCAMLLEX@
+OCAMLLEXDOTOPT = @OCAMLLEXDOTOPT@
+OCAMLLIB = @OCAMLLIB@
+OCAMLMKLIB = @OCAMLMKLIB@
+OCAMLMKTOP = @OCAMLMKTOP@
+OCAMLOPT = @OCAMLOPT@
+OCAMLOPTDOTOPT = @OCAMLOPTDOTOPT@
+OCAMLPROF = @OCAMLPROF@
+OCAMLVERSION = @OCAMLVERSION@
+OCAMLYACC = @OCAMLYACC@
+OCAML_PKG_bigarray = @OCAML_PKG_bigarray@
+OCAML_PKG_camlp4 = @OCAML_PKG_camlp4@
+OCAML_PKG_dynlink = @OCAML_PKG_dynlink@
+OCAML_PKG_menhirLib = @OCAML_PKG_menhirLib@
+OCAML_PKG_num = @OCAML_PKG_num@
+OCAML_PKG_pcre = @OCAML_PKG_pcre@
+OCAML_PKG_pycaml = @OCAML_PKG_pycaml@
+OCAML_PKG_str = @OCAML_PKG_str@
+OCAML_PKG_unix = @OCAML_PKG_unix@
+OPTFLAGS_camlp4 = @OPTFLAGS_camlp4@
+OPTFLAGS_dynlink = @OPTFLAGS_dynlink@
+OPTFLAGS_menhirLib = @OPTFLAGS_menhirLib@
+OPTFLAGS_pcre = @OPTFLAGS_pcre@
+OPTFLAGS_pycaml = @OPTFLAGS_pycaml@
+OPTIMIZED_dynlink = @OPTIMIZED_dynlink@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATCH = @PATCH@
+PATCHELF = @PATCHELF@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PATH_bigarray = @PATH_bigarray@
+PATH_camlp4 = @PATH_camlp4@
+PATH_dynlink = @PATH_dynlink@
+PATH_menhirLib = @PATH_menhirLib@
+PATH_num = @PATH_num@
+PATH_pcre = @PATH_pcre@
+PATH_pycaml = @PATH_pycaml@
+PATH_str = @PATH_str@
+PATH_unix = @PATH_unix@
+PCRE_CFLAGS = @PCRE_CFLAGS@
+PCRE_LIBS = @PCRE_LIBS@
+PDFLATEX = @PDFLATEX@
+PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_ORIG = @PKG_CONFIG_ORIG@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
+PYCOCCI_FILE = @PYCOCCI_FILE@
+PYCOCCI_MODULE = @PYCOCCI_MODULE@
+PYTHON = @PYTHON@
+PYTHON_CFLAGS = @PYTHON_CFLAGS@
+PYTHON_LIBS = @PYTHON_LIBS@
+PYVER = @PYVER@
+PYVER_MAJOR = @PYVER_MAJOR@
+REGEXP_FILE = @REGEXP_FILE@
+REGEXP_MODULE = @REGEXP_MODULE@
+RUNTIME_CAMLP4O_CMD = @RUNTIME_CAMLP4O_CMD@
+RUNTIME_CAMLP4_CMD = @RUNTIME_CAMLP4_CMD@
+RUNTIME_OCAMLC_CMD = @RUNTIME_OCAMLC_CMD@
+RUNTIME_OCAMLDEP_CMD = @RUNTIME_OCAMLDEP_CMD@
+RUNTIME_OCAMLFIND_CMD = @RUNTIME_OCAMLFIND_CMD@
+RUNTIME_OCAMLOPT_CMD = @RUNTIME_OCAMLOPT_CMD@
+SET_MAKE = @SET_MAKE@
+SHAREDIR = @SHAREDIR@
+SHELL = @SHELL@
+SPATCHNAME = @SPATCHNAME@
+STRIP = @STRIP@
+SUBSTITUTED_MENHIR = @SUBSTITUTED_MENHIR@
+SUBSTITUTED_OCAMLFIND = @SUBSTITUTED_OCAMLFIND@
+SUBSTITUTED_OCAMLLEX = @SUBSTITUTED_OCAMLLEX@
+SUBSTITUTED_OCAMLPROF = @SUBSTITUTED_OCAMLPROF@
+SUBSTITUTED_OCAMLYACC = @SUBSTITUTED_OCAMLYACC@
+SUBSTITUTED_PDFLATEX = @SUBSTITUTED_PDFLATEX@
+SUBSTITUTED_PKG_CONFIG = @SUBSTITUTED_PKG_CONFIG@
+SUBSTITUTED_PYTHON = @SUBSTITUTED_PYTHON@
+TAR = @TAR@
+VERSION = @VERSION@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build_alias = @build_alias@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+enable_camlp4 = @enable_camlp4@
+enable_dynlink = @enable_dynlink@
+enable_menhirLib = @enable_menhirLib@
+enable_ocaml = @enable_ocaml@
+enable_opt = @enable_opt@
+enable_pcre = @enable_pcre@
+enable_pcre_syntax = @enable_pcre_syntax@
+enable_pycaml = @enable_pycaml@
+enable_python = @enable_python@
+enable_release = @enable_release@
+exec_prefix = @exec_prefix@
+host_alias = @host_alias@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+with_MENHIR = @with_MENHIR@
+with_OCAMLFIND = @with_OCAMLFIND@
+with_OCAMLLEX = @with_OCAMLLEX@
+with_OCAMLPROF = @with_OCAMLPROF@
+with_OCAMLYACC = @with_OCAMLYACC@
+with_PDFLATEX = @with_PDFLATEX@
+with_PKG_CONFIG = @with_PKG_CONFIG@
+with_PYTHON = @with_PYTHON@
+all: all-am
+
+.SUFFIXES:
+$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
+ @for dep in $?; do \
+ case '$(am__configure_deps)' in \
+ *$$dep*) \
+ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+ && { if test -f $@; then exit 0; else break; fi; }; \
+ exit 1;; \
+ esac; \
+ done; \
+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu setup/Makefile'; \
+ $(am__cd) $(top_srcdir) && \
+ $(AUTOMAKE) --gnu setup/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+ @case '$?' in \
+ *config.status*) \
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+ *) \
+ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+ esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure: $(am__configure_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4): $(am__aclocal_m4_deps)
+ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+tags: TAGS
+TAGS:
+
+ctags: CTAGS
+CTAGS:
+
+cscope cscopelist:
+
+
+distdir: $(DISTFILES)
+ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+ list='$(DISTFILES)'; \
+ dist_files=`for file in $$list; do echo $$file; done | \
+ sed -e "s|^$$srcdirstrip/||;t" \
+ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+ case $$dist_files in \
+ */*) $(MKDIR_P) `echo "$$dist_files" | \
+ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+ sort -u` ;; \
+ esac; \
+ for file in $$dist_files; do \
+ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+ if test -d $$d/$$file; then \
+ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+ if test -d "$(distdir)/$$file"; then \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+ fi; \
+ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+ else \
+ test -f "$(distdir)/$$file" \
+ || cp -p $$d/$$file "$(distdir)/$$file" \
+ || exit 1; \
+ fi; \
+ done
+check-am: all-am
+check: check-am
+all-am: Makefile
+installdirs:
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+ if test -z '$(STRIP)'; then \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ install; \
+ else \
+ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+ fi
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+ @echo "This command is intended for maintainers to use"
+ @echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-generic mostlyclean-am
+
+distclean: distclean-am
+ -rm -f Makefile
+distclean-am: clean-am distclean-generic
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am:
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+ -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-generic
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am:
+
+.MAKE: install-am install-strip
+
+.PHONY: all all-am check check-am clean clean-generic distclean \
+ distclean-generic distdir dvi dvi-am html html-am info info-am \
+ install install-am install-data install-data-am install-dvi \
+ install-dvi-am install-exec install-exec-am install-html \
+ install-html-am install-info install-info-am install-man \
+ install-pdf install-pdf-am install-ps install-ps-am \
+ install-strip installcheck installcheck-am installdirs \
+ maintainer-clean maintainer-clean-generic mostlyclean \
+ mostlyclean-generic pdf pdf-am ps ps-am uninstall uninstall-am
+
+
+all:
+ echo "dummy makefile, do not use"
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
BASH_SOURCE=$0
fi
+
+#
+# Before we actually try to substitute a given
+# command, we first try to execute the original command
+#
+
+# Check if the given program exists.
+if command -v "$1" > /dev/null; then
+ # exits the script if the command succeeds.
+ $@ && exit $?
+fi
+
+
+#
+# Trying a substitute
+#
+
cmdline="$@"
scriptdir=$(dirname "${BASH_SOURCE}")
responsefile="${scriptdir}/replies.txt"
python -c "import sys; print(sys.prefix)"
}
+pythonversion() {
+ python -c "import sys; print('%d.%d' % (sys.version_info[0], sys.version_info[1]))"
+}
+
pythonexists() {
local version=$1
local prefix="$(pythonprefix)"
test $? = 0
+ if test -z "$version"; then
+ version="$(pythonversion)"
+ fi
+
if test ! -f "${prefix}/include/python${version}/Python.h"; then
echo "error: ${prefix}/include/python${version}/Python.h not found (a development version of python is not installed?)" 1>&2
false
if test -n "${found}"; then
MATCH=no
if test -n "${replace}"; then
- MATCH="$(echo "$cmdline" | sed -r "${replace}")"
+ MATCH="$(echo "$cmdline" | sed -E "${replace}")"
fi
if test -n "${response}"; then
exit 0
else
# fallback case
- echo "fake-subst.sh: no substitution for: ${cmdline}" 1>&2
- exit 1
+ echo "fake-subst.sh: no substitution for: ${cmdline}. Running the
+original." 1>&2
+ exec $@
fi
-#! /bin/sh -e
-
-echo "error: no suitable install program found, therefore refusing to install $@" 1>&2
-exit 1
+#!/bin/sh
+# install - install a program, script, or datafile
+
+scriptversion=2011-11-20.07; # UTC
+
+# This originates from X11R5 (mit/util/scripts/install.sh), which was
+# later released in X11R6 (xc/config/util/install.sh) with the
+# following copyright and license.
+#
+# Copyright (C) 1994 X Consortium
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of the X Consortium shall not
+# be used in advertising or otherwise to promote the sale, use or other deal-
+# ings in this Software without prior written authorization from the X Consor-
+# tium.
+#
+#
+# FSF changes to this file are in the public domain.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# 'make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+
+nl='
+'
+IFS=" "" $nl"
+
+# set DOITPROG to echo to test this script
+
+# Don't use :- since 4.3BSD and earlier shells don't like it.
+doit=${DOITPROG-}
+if test -z "$doit"; then
+ doit_exec=exec
+else
+ doit_exec=$doit
+fi
+
+# Put in absolute file names if you don't have them in your path;
+# or use environment vars.
+
+chgrpprog=${CHGRPPROG-chgrp}
+chmodprog=${CHMODPROG-chmod}
+chownprog=${CHOWNPROG-chown}
+cmpprog=${CMPPROG-cmp}
+cpprog=${CPPROG-cp}
+mkdirprog=${MKDIRPROG-mkdir}
+mvprog=${MVPROG-mv}
+rmprog=${RMPROG-rm}
+stripprog=${STRIPPROG-strip}
+
+posix_glob='?'
+initialize_posix_glob='
+ test "$posix_glob" != "?" || {
+ if (set -f) 2>/dev/null; then
+ posix_glob=
+ else
+ posix_glob=:
+ fi
+ }
+'
+
+posix_mkdir=
+
+# Desired mode of installed file.
+mode=0755
+
+chgrpcmd=
+chmodcmd=$chmodprog
+chowncmd=
+mvcmd=$mvprog
+rmcmd="$rmprog -f"
+stripcmd=
+
+src=
+dst=
+dir_arg=
+dst_arg=
+
+copy_on_change=false
+no_target_directory=
+
+usage="\
+Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
+ or: $0 [OPTION]... SRCFILES... DIRECTORY
+ or: $0 [OPTION]... -t DIRECTORY SRCFILES...
+ or: $0 [OPTION]... -d DIRECTORIES...
+
+In the 1st form, copy SRCFILE to DSTFILE.
+In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
+In the 4th, create DIRECTORIES.
+
+Options:
+ --help display this help and exit.
+ --version display version info and exit.
+
+ -c (ignored)
+ -C install only if different (preserve the last data modification time)
+ -d create directories instead of installing files.
+ -g GROUP $chgrpprog installed files to GROUP.
+ -m MODE $chmodprog installed files to MODE.
+ -o USER $chownprog installed files to USER.
+ -s $stripprog installed files.
+ -t DIRECTORY install into DIRECTORY.
+ -T report an error if DSTFILE is a directory.
+
+Environment variables override the default commands:
+ CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
+ RMPROG STRIPPROG
+"
+
+while test $# -ne 0; do
+ case $1 in
+ -c) ;;
+
+ -C) copy_on_change=true;;
+
+ -d) dir_arg=true;;
+
+ -g) chgrpcmd="$chgrpprog $2"
+ shift;;
+
+ --help) echo "$usage"; exit $?;;
+
+ -m) mode=$2
+ case $mode in
+ *' '* | *' '* | *'
+'* | *'*'* | *'?'* | *'['*)
+ echo "$0: invalid mode: $mode" >&2
+ exit 1;;
+ esac
+ shift;;
+
+ -o) chowncmd="$chownprog $2"
+ shift;;
+
+ -s) stripcmd=$stripprog;;
+
+ -t) dst_arg=$2
+ # Protect names problematic for 'test' and other utilities.
+ case $dst_arg in
+ -* | [=\(\)!]) dst_arg=./$dst_arg;;
+ esac
+ shift;;
+
+ -T) no_target_directory=true;;
+
+ --version) echo "$0 $scriptversion"; exit $?;;
+
+ --) shift
+ break;;
+
+ -*) echo "$0: invalid option: $1" >&2
+ exit 1;;
+
+ *) break;;
+ esac
+ shift
+done
+
+if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
+ # When -d is used, all remaining arguments are directories to create.
+ # When -t is used, the destination is already specified.
+ # Otherwise, the last argument is the destination. Remove it from $@.
+ for arg
+ do
+ if test -n "$dst_arg"; then
+ # $@ is not empty: it contains at least $arg.
+ set fnord "$@" "$dst_arg"
+ shift # fnord
+ fi
+ shift # arg
+ dst_arg=$arg
+ # Protect names problematic for 'test' and other utilities.
+ case $dst_arg in
+ -* | [=\(\)!]) dst_arg=./$dst_arg;;
+ esac
+ done
+fi
+
+if test $# -eq 0; then
+ if test -z "$dir_arg"; then
+ echo "$0: no input file specified." >&2
+ exit 1
+ fi
+ # It's OK to call 'install-sh -d' without argument.
+ # This can happen when creating conditional directories.
+ exit 0
+fi
+
+if test -z "$dir_arg"; then
+ do_exit='(exit $ret); exit $ret'
+ trap "ret=129; $do_exit" 1
+ trap "ret=130; $do_exit" 2
+ trap "ret=141; $do_exit" 13
+ trap "ret=143; $do_exit" 15
+
+ # Set umask so as not to create temps with too-generous modes.
+ # However, 'strip' requires both read and write access to temps.
+ case $mode in
+ # Optimize common cases.
+ *644) cp_umask=133;;
+ *755) cp_umask=22;;
+
+ *[0-7])
+ if test -z "$stripcmd"; then
+ u_plus_rw=
+ else
+ u_plus_rw='% 200'
+ fi
+ cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
+ *)
+ if test -z "$stripcmd"; then
+ u_plus_rw=
+ else
+ u_plus_rw=,u+rw
+ fi
+ cp_umask=$mode$u_plus_rw;;
+ esac
+fi
+
+for src
+do
+ # Protect names problematic for 'test' and other utilities.
+ case $src in
+ -* | [=\(\)!]) src=./$src;;
+ esac
+
+ if test -n "$dir_arg"; then
+ dst=$src
+ dstdir=$dst
+ test -d "$dstdir"
+ dstdir_status=$?
+ else
+
+ # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
+ # might cause directories to be created, which would be especially bad
+ # if $src (and thus $dsttmp) contains '*'.
+ if test ! -f "$src" && test ! -d "$src"; then
+ echo "$0: $src does not exist." >&2
+ exit 1
+ fi
+
+ if test -z "$dst_arg"; then
+ echo "$0: no destination specified." >&2
+ exit 1
+ fi
+ dst=$dst_arg
+
+ # If destination is a directory, append the input filename; won't work
+ # if double slashes aren't ignored.
+ if test -d "$dst"; then
+ if test -n "$no_target_directory"; then
+ echo "$0: $dst_arg: Is a directory" >&2
+ exit 1
+ fi
+ dstdir=$dst
+ dst=$dstdir/`basename "$src"`
+ dstdir_status=0
+ else
+ # Prefer dirname, but fall back on a substitute if dirname fails.
+ dstdir=`
+ (dirname "$dst") 2>/dev/null ||
+ expr X"$dst" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ X"$dst" : 'X\(//\)[^/]' \| \
+ X"$dst" : 'X\(//\)$' \| \
+ X"$dst" : 'X\(/\)' \| . 2>/dev/null ||
+ echo X"$dst" |
+ sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)[^/].*/{
+ s//\1/
+ q
+ }
+ /^X\(\/\/\)$/{
+ s//\1/
+ q
+ }
+ /^X\(\/\).*/{
+ s//\1/
+ q
+ }
+ s/.*/./; q'
+ `
+
+ test -d "$dstdir"
+ dstdir_status=$?
+ fi
+ fi
+
+ obsolete_mkdir_used=false
+
+ if test $dstdir_status != 0; then
+ case $posix_mkdir in
+ '')
+ # Create intermediate dirs using mode 755 as modified by the umask.
+ # This is like FreeBSD 'install' as of 1997-10-28.
+ umask=`umask`
+ case $stripcmd.$umask in
+ # Optimize common cases.
+ *[2367][2367]) mkdir_umask=$umask;;
+ .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;;
+
+ *[0-7])
+ mkdir_umask=`expr $umask + 22 \
+ - $umask % 100 % 40 + $umask % 20 \
+ - $umask % 10 % 4 + $umask % 2
+ `;;
+ *) mkdir_umask=$umask,go-w;;
+ esac
+
+ # With -d, create the new directory with the user-specified mode.
+ # Otherwise, rely on $mkdir_umask.
+ if test -n "$dir_arg"; then
+ mkdir_mode=-m$mode
+ else
+ mkdir_mode=
+ fi
+
+ posix_mkdir=false
+ case $umask in
+ *[123567][0-7][0-7])
+ # POSIX mkdir -p sets u+wx bits regardless of umask, which
+ # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+ ;;
+ *)
+ tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+ trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+ if (umask $mkdir_umask &&
+ exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
+ then
+ if test -z "$dir_arg" || {
+ # Check for POSIX incompatibilities with -m.
+ # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+ # other-writable bit of parent directory when it shouldn't.
+ # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+ ls_ld_tmpdir=`ls -ld "$tmpdir"`
+ case $ls_ld_tmpdir in
+ d????-?r-*) different_mode=700;;
+ d????-?--*) different_mode=755;;
+ *) false;;
+ esac &&
+ $mkdirprog -m$different_mode -p -- "$tmpdir" && {
+ ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
+ test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+ }
+ }
+ then posix_mkdir=:
+ fi
+ rmdir "$tmpdir/d" "$tmpdir"
+ else
+ # Remove any dirs left behind by ancient mkdir implementations.
+ rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
+ fi
+ trap '' 0;;
+ esac;;
+ esac
+
+ if
+ $posix_mkdir && (
+ umask $mkdir_umask &&
+ $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+ )
+ then :
+ else
+
+ # The umask is ridiculous, or mkdir does not conform to POSIX,
+ # or it failed possibly due to a race condition. Create the
+ # directory the slow way, step by step, checking for races as we go.
+
+ case $dstdir in
+ /*) prefix='/';;
+ [-=\(\)!]*) prefix='./';;
+ *) prefix='';;
+ esac
+
+ eval "$initialize_posix_glob"
+
+ oIFS=$IFS
+ IFS=/
+ $posix_glob set -f
+ set fnord $dstdir
+ shift
+ $posix_glob set +f
+ IFS=$oIFS
+
+ prefixes=
+
+ for d
+ do
+ test X"$d" = X && continue
+
+ prefix=$prefix$d
+ if test -d "$prefix"; then
+ prefixes=
+ else
+ if $posix_mkdir; then
+ (umask=$mkdir_umask &&
+ $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+ # Don't fail if two instances are running concurrently.
+ test -d "$prefix" || exit 1
+ else
+ case $prefix in
+ *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+ *) qprefix=$prefix;;
+ esac
+ prefixes="$prefixes '$qprefix'"
+ fi
+ fi
+ prefix=$prefix/
+ done
+
+ if test -n "$prefixes"; then
+ # Don't fail if two instances are running concurrently.
+ (umask $mkdir_umask &&
+ eval "\$doit_exec \$mkdirprog $prefixes") ||
+ test -d "$dstdir" || exit 1
+ obsolete_mkdir_used=true
+ fi
+ fi
+ fi
+
+ if test -n "$dir_arg"; then
+ { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
+ { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
+ { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
+ test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
+ else
+
+ # Make a couple of temp file names in the proper directory.
+ dsttmp=$dstdir/_inst.$$_
+ rmtmp=$dstdir/_rm.$$_
+
+ # Trap to clean up those temp files at exit.
+ trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
+
+ # Copy the file name to the temp name.
+ (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
+
+ # and set any options; do chmod last to preserve setuid bits.
+ #
+ # If any of these fail, we abort the whole thing. If we want to
+ # ignore errors from any of these, just make sure not to ignore
+ # errors from the above "$doit $cpprog $src $dsttmp" command.
+ #
+ { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
+ { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
+ { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
+ { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
+
+ # If -C, don't bother to copy if it wouldn't change the file.
+ if $copy_on_change &&
+ old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` &&
+ new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` &&
+
+ eval "$initialize_posix_glob" &&
+ $posix_glob set -f &&
+ set X $old && old=:$2:$4:$5:$6 &&
+ set X $new && new=:$2:$4:$5:$6 &&
+ $posix_glob set +f &&
+
+ test "$old" = "$new" &&
+ $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
+ then
+ rm -f "$dsttmp"
+ else
+ # Rename the file to the real destination.
+ $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
+
+ # The rename failed, perhaps because mv can't rename something else
+ # to itself, or perhaps because mv is so ancient that it does not
+ # support -f.
+ {
+ # Now remove or move aside any old file at destination location.
+ # We try this two ways since rm can't unlink itself on some
+ # systems and the destination file might be busy for other
+ # reasons. In this case, the final cleanup might fail but the new
+ # file should still install successfully.
+ {
+ test ! -f "$dst" ||
+ $doit $rmcmd -f "$dst" 2>/dev/null ||
+ { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+ { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+ } ||
+ { echo "$0: cannot unlink or rename $dst" >&2
+ (exit 1); exit 1
+ }
+ } &&
+
+ # Now rename the file to the real destination.
+ $doit $mvcmd "$dsttmp" "$dst"
+ }
+ fi || exit 1
+
+ trap '' 0
+ fi
+done
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
--- /dev/null
+#! /bin/sh -e
+
+set -e
+
+# wrapper around ocaml-findlib that logs its
+# invocations to ocamlfind.log
+
+echo "ocamlfind $@" >> ocamlfind.log
+exec ocamlfind "$@"
--- /dev/null
+#! /bin/sh
+# Common stub for a few missing GNU programs while installing.
+
+scriptversion=2012-01-06.18; # UTC
+
+# Copyright (C) 1996-2012 Free Software Foundation, Inc.
+# Originally by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
+
+# 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, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+if test $# -eq 0; then
+ echo 1>&2 "Try '$0 --help' for more information"
+ exit 1
+fi
+
+run=:
+sed_output='s/.* --output[ =]\([^ ]*\).*/\1/p'
+sed_minuso='s/.* -o \([^ ]*\).*/\1/p'
+
+# In the cases where this matters, 'missing' is being run in the
+# srcdir already.
+if test -f configure.ac; then
+ configure_ac=configure.ac
+else
+ configure_ac=configure.in
+fi
+
+msg="missing on your system"
+
+case $1 in
+--run)
+ # Try to run requested program, and just exit if it succeeds.
+ run=
+ shift
+ "$@" && exit 0
+ # Exit code 63 means version mismatch. This often happens
+ # when the user try to use an ancient version of a tool on
+ # a file that requires a minimum version. In this case we
+ # we should proceed has if the program had been absent, or
+ # if --run hadn't been passed.
+ if test $? = 63; then
+ run=:
+ msg="probably too old"
+ fi
+ ;;
+
+ -h|--h|--he|--hel|--help)
+ echo "\
+$0 [OPTION]... PROGRAM [ARGUMENT]...
+
+Handle 'PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
+error status if there is no known handling for PROGRAM.
+
+Options:
+ -h, --help display this help and exit
+ -v, --version output version information and exit
+ --run try to run the given command, and emulate it if it fails
+
+Supported PROGRAM values:
+ aclocal touch file 'aclocal.m4'
+ autoconf touch file 'configure'
+ autoheader touch file 'config.h.in'
+ autom4te touch the output file, or create a stub one
+ automake touch all 'Makefile.in' files
+ bison create 'y.tab.[ch]', if possible, from existing .[ch]
+ flex create 'lex.yy.c', if possible, from existing .c
+ help2man touch the output file
+ lex create 'lex.yy.c', if possible, from existing .c
+ makeinfo touch the output file
+ yacc create 'y.tab.[ch]', if possible, from existing .[ch]
+
+Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
+'g' are ignored when checking the name.
+
+Send bug reports to <bug-automake@gnu.org>."
+ exit $?
+ ;;
+
+ -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+ echo "missing $scriptversion (GNU Automake)"
+ exit $?
+ ;;
+
+ -*)
+ echo 1>&2 "$0: Unknown '$1' option"
+ echo 1>&2 "Try '$0 --help' for more information"
+ exit 1
+ ;;
+
+esac
+
+# normalize program name to check for.
+program=`echo "$1" | sed '
+ s/^gnu-//; t
+ s/^gnu//; t
+ s/^g//; t'`
+
+# Now exit if we have it, but it failed. Also exit now if we
+# don't have it and --version was passed (most likely to detect
+# the program). This is about non-GNU programs, so use $1 not
+# $program.
+case $1 in
+ lex*|yacc*)
+ # Not GNU programs, they don't have --version.
+ ;;
+
+ *)
+ if test -z "$run" && ($1 --version) > /dev/null 2>&1; then
+ # We have it, but it failed.
+ exit 1
+ elif test "x$2" = "x--version" || test "x$2" = "x--help"; then
+ # Could not run --version or --help. This is probably someone
+ # running '$TOOL --version' or '$TOOL --help' to check whether
+ # $TOOL exists and not knowing $TOOL uses missing.
+ exit 1
+ fi
+ ;;
+esac
+
+# If it does not exist, or fails to run (possibly an outdated version),
+# try to emulate it.
+case $program in
+ aclocal*)
+ echo 1>&2 "\
+WARNING: '$1' is $msg. You should only need it if
+ you modified 'acinclude.m4' or '${configure_ac}'. You might want
+ to install the Automake and Perl packages. Grab them from
+ any GNU archive site."
+ touch aclocal.m4
+ ;;
+
+ autoconf*)
+ echo 1>&2 "\
+WARNING: '$1' is $msg. You should only need it if
+ you modified '${configure_ac}'. You might want to install the
+ Autoconf and GNU m4 packages. Grab them from any GNU
+ archive site."
+ touch configure
+ ;;
+
+ autoheader*)
+ echo 1>&2 "\
+WARNING: '$1' is $msg. You should only need it if
+ you modified 'acconfig.h' or '${configure_ac}'. You might want
+ to install the Autoconf and GNU m4 packages. Grab them
+ from any GNU archive site."
+ files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' ${configure_ac}`
+ test -z "$files" && files="config.h"
+ touch_files=
+ for f in $files; do
+ case $f in
+ *:*) touch_files="$touch_files "`echo "$f" |
+ sed -e 's/^[^:]*://' -e 's/:.*//'`;;
+ *) touch_files="$touch_files $f.in";;
+ esac
+ done
+ touch $touch_files
+ ;;
+
+ automake*)
+ echo 1>&2 "\
+WARNING: '$1' is $msg. You should only need it if
+ you modified 'Makefile.am', 'acinclude.m4' or '${configure_ac}'.
+ You might want to install the Automake and Perl packages.
+ Grab them from any GNU archive site."
+ find . -type f -name Makefile.am -print |
+ sed 's/\.am$/.in/' |
+ while read f; do touch "$f"; done
+ ;;
+
+ autom4te*)
+ echo 1>&2 "\
+WARNING: '$1' is needed, but is $msg.
+ You might have modified some files without having the
+ proper tools for further handling them.
+ You can get '$1' as part of Autoconf from any GNU
+ archive site."
+
+ file=`echo "$*" | sed -n "$sed_output"`
+ test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+ if test -f "$file"; then
+ touch $file
+ else
+ test -z "$file" || exec >$file
+ echo "#! /bin/sh"
+ echo "# Created by GNU Automake missing as a replacement of"
+ echo "# $ $@"
+ echo "exit 0"
+ chmod +x $file
+ exit 1
+ fi
+ ;;
+
+ bison*|yacc*)
+ echo 1>&2 "\
+WARNING: '$1' $msg. You should only need it if
+ you modified a '.y' file. You may need the Bison package
+ in order for those modifications to take effect. You can get
+ Bison from any GNU archive site."
+ rm -f y.tab.c y.tab.h
+ if test $# -ne 1; then
+ eval LASTARG=\${$#}
+ case $LASTARG in
+ *.y)
+ SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
+ if test -f "$SRCFILE"; then
+ cp "$SRCFILE" y.tab.c
+ fi
+ SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
+ if test -f "$SRCFILE"; then
+ cp "$SRCFILE" y.tab.h
+ fi
+ ;;
+ esac
+ fi
+ if test ! -f y.tab.h; then
+ echo >y.tab.h
+ fi
+ if test ! -f y.tab.c; then
+ echo 'main() { return 0; }' >y.tab.c
+ fi
+ ;;
+
+ lex*|flex*)
+ echo 1>&2 "\
+WARNING: '$1' is $msg. You should only need it if
+ you modified a '.l' file. You may need the Flex package
+ in order for those modifications to take effect. You can get
+ Flex from any GNU archive site."
+ rm -f lex.yy.c
+ if test $# -ne 1; then
+ eval LASTARG=\${$#}
+ case $LASTARG in
+ *.l)
+ SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
+ if test -f "$SRCFILE"; then
+ cp "$SRCFILE" lex.yy.c
+ fi
+ ;;
+ esac
+ fi
+ if test ! -f lex.yy.c; then
+ echo 'main() { return 0; }' >lex.yy.c
+ fi
+ ;;
+
+ help2man*)
+ echo 1>&2 "\
+WARNING: '$1' is $msg. You should only need it if
+ you modified a dependency of a manual page. You may need the
+ Help2man package in order for those modifications to take
+ effect. You can get Help2man from any GNU archive site."
+
+ file=`echo "$*" | sed -n "$sed_output"`
+ test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+ if test -f "$file"; then
+ touch $file
+ else
+ test -z "$file" || exec >$file
+ echo ".ab help2man is required to generate this page"
+ exit $?
+ fi
+ ;;
+
+ makeinfo*)
+ echo 1>&2 "\
+WARNING: '$1' is $msg. You should only need it if
+ you modified a '.texi' or '.texinfo' file, or any other file
+ indirectly affecting the aspect of the manual. The spurious
+ call might also be the consequence of using a buggy 'make' (AIX,
+ DU, IRIX). You might want to install the Texinfo package or
+ the GNU make package. Grab either from any GNU archive site."
+ # The file to touch is that specified with -o ...
+ file=`echo "$*" | sed -n "$sed_output"`
+ test -z "$file" && file=`echo "$*" | sed -n "$sed_minuso"`
+ if test -z "$file"; then
+ # ... or it is the one specified with @setfilename ...
+ infile=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
+ file=`sed -n '
+ /^@setfilename/{
+ s/.* \([^ ]*\) *$/\1/
+ p
+ q
+ }' $infile`
+ # ... or it is derived from the source name (dir/f.texi becomes f.info)
+ test -z "$file" && file=`echo "$infile" | sed 's,.*/,,;s,.[^.]*$,,'`.info
+ fi
+ # If the file does not exist, the user really needs makeinfo;
+ # let's fail without touching anything.
+ test -f $file || exit 1
+ touch $file
+ ;;
+
+ *)
+ echo 1>&2 "\
+WARNING: '$1' is needed, and is $msg.
+ You might have modified some files without having the
+ proper tools for further handling them. Check the 'README' file,
+ it often tells you about the needed prerequisites for installing
+ this package. You may also peek at any GNU archive site, in case
+ some other package would contain this missing '$1' program."
+ exit 1
+ ;;
+esac
+
+exit 0
+
+# Local variables:
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
--- /dev/null
+# pkg.m4 - Macros to locate and utilise pkg-config. -*- Autoconf -*-
+# serial 1 (pkg-config-0.24)
+#
+# Copyright © 2004 Scott James Remnant <scott@netsplit.com>.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# PKG_PROG_PKG_CONFIG([MIN-VERSION])
+# ----------------------------------
+AC_DEFUN([PKG_PROG_PKG_CONFIG],
+[m4_pattern_forbid([^_?PKG_[A-Z_]+$])
+m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$])
+m4_pattern_allow([^PKG_CONFIG_(DISABLE_UNINSTALLED|TOP_BUILD_DIR|DEBUG_SPEW)$])
+AC_ARG_VAR([PKG_CONFIG], [path to pkg-config utility])
+AC_ARG_VAR([PKG_CONFIG_PATH], [directories to add to pkg-config's search path])
+AC_ARG_VAR([PKG_CONFIG_LIBDIR], [path overriding pkg-config's built-in search path])
+
+if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
+ AC_PATH_TOOL([PKG_CONFIG], [pkg-config])
+fi
+if test -n "$PKG_CONFIG"; then
+ _pkg_min_version=m4_default([$1], [0.9.0])
+ AC_MSG_CHECKING([pkg-config is at least version $_pkg_min_version])
+ if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
+ AC_MSG_RESULT([yes])
+ else
+ AC_MSG_RESULT([no])
+ PKG_CONFIG=""
+ fi
+fi[]dnl
+])# PKG_PROG_PKG_CONFIG
+
+# PKG_CHECK_EXISTS(MODULES, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+#
+# Check to see whether a particular set of modules exists. Similar
+# to PKG_CHECK_MODULES(), but does not set variables or print errors.
+#
+# Please remember that m4 expands AC_REQUIRE([PKG_PROG_PKG_CONFIG])
+# only at the first occurence in configure.ac, so if the first place
+# it's called might be skipped (such as if it is within an "if", you
+# have to call PKG_CHECK_EXISTS manually
+# --------------------------------------------------------------
+AC_DEFUN([PKG_CHECK_EXISTS],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+if test -n "$PKG_CONFIG" && \
+ AC_RUN_LOG([$PKG_CONFIG --exists --print-errors "$1"]); then
+ m4_default([$2], [:])
+m4_ifvaln([$3], [else
+ $3])dnl
+fi])
+
+# _PKG_CONFIG([VARIABLE], [COMMAND], [MODULES])
+# ---------------------------------------------
+m4_define([_PKG_CONFIG],
+[if test -n "$$1"; then
+ pkg_cv_[]$1="$$1"
+ elif test -n "$PKG_CONFIG"; then
+ PKG_CHECK_EXISTS([$3],
+ [pkg_cv_[]$1=`$PKG_CONFIG --[]$2 "$3" 2>/dev/null`
+ test "x$?" != "x0" && pkg_failed=yes ],
+ [pkg_failed=yes])
+ else
+ pkg_failed=untried
+fi[]dnl
+])# _PKG_CONFIG
+
+# _PKG_SHORT_ERRORS_SUPPORTED
+# -----------------------------
+AC_DEFUN([_PKG_SHORT_ERRORS_SUPPORTED],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])
+if $PKG_CONFIG --atleast-pkgconfig-version 0.20; then
+ _pkg_short_errors_supported=yes
+else
+ _pkg_short_errors_supported=no
+fi[]dnl
+])# _PKG_SHORT_ERRORS_SUPPORTED
+
+
+# PKG_CHECK_MODULES(VARIABLE-PREFIX, MODULES, [ACTION-IF-FOUND],
+# [ACTION-IF-NOT-FOUND])
+#
+#
+# Note that if there is a possibility the first call to
+# PKG_CHECK_MODULES might not happen, you should be sure to include an
+# explicit call to PKG_PROG_PKG_CONFIG in your configure.ac
+#
+#
+# --------------------------------------------------------------
+AC_DEFUN([PKG_CHECK_MODULES],
+[AC_REQUIRE([PKG_PROG_PKG_CONFIG])dnl
+AC_ARG_VAR([$1][_CFLAGS], [C compiler flags for $1, overriding pkg-config])dnl
+AC_ARG_VAR([$1][_LIBS], [linker flags for $1, overriding pkg-config])dnl
+
+pkg_failed=no
+AC_MSG_CHECKING([for $1])
+
+_PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
+_PKG_CONFIG([$1][_LIBS], [libs], [$2])
+
+m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS
+and $1[]_LIBS to avoid the need to call pkg-config.
+See the pkg-config man page for more details.])
+
+if test $pkg_failed = yes; then
+ AC_MSG_RESULT([no])
+ _PKG_SHORT_ERRORS_SUPPORTED
+ if test $_pkg_short_errors_supported = yes; then
+ $1[]_PKG_ERRORS=`$PKG_CONFIG --short-errors --print-errors --cflags --libs "$2" 2>&1`
+ else
+ $1[]_PKG_ERRORS=`$PKG_CONFIG --print-errors --cflags --libs "$2" 2>&1`
+ fi
+ # Put the nasty error message in config.log where it belongs
+ echo "$$1[]_PKG_ERRORS" >&AS_MESSAGE_LOG_FD
+
+ m4_default([$4], [AC_MSG_ERROR(
+[Package requirements ($2) were not met:
+
+$$1_PKG_ERRORS
+
+Consider adjusting the PKG_CONFIG_PATH environment variable if you
+installed software in a non-standard prefix.
+
+_PKG_TEXT])[]dnl
+ ])
+elif test $pkg_failed = untried; then
+ AC_MSG_RESULT([no])
+ m4_default([$4], [AC_MSG_FAILURE(
+[The pkg-config script could not be found or is too old. Make sure it
+is in your PATH or set the PKG_CONFIG environment variable to the full
+path to pkg-config.
+
+_PKG_TEXT
+
+To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl
+ ])
+else
+ $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
+ $1[]_LIBS=$pkg_cv_[]$1[]_LIBS
+ AC_MSG_RESULT([yes])
+ $3
+fi[]dnl
+])# PKG_CHECK_MODULES
+pkg-config --short-errors --print-errors --cflags --libs libpcre
+
+$(checkpcre)
+
+
+
pkg-config --cflags libpcre
--- /dev/null
+#! /bin/sh -e
+
+set -e
+
+# This wrapper is a work-around to fool ocamlbuild to
+# use menhir but actually using ocamlyacc for some files.
+# Since this wrapper makes some assumptions about how
+# ocamlbuild works, it may break in the future.
+# In particular: the paths to the files may change.
+
+# $1: path to menhir
+# $2: path to ocamlyacc
+
+OCAMLYACC="$1"
+MENHIR="$2"
+shift 2
+
+case "$@" in
+
+# use ocamlyacc for parsing_c/parsing_c.mly
+ *raw-depend*parsing_c/parser_c.mly*)
+ # echo "Notice: using ocamlyacc instead of menhir: skipping apriori dependency generation" 1>&2
+ ;;
+ *parsing_c/parser_c.mly*)
+ # echo "Notice: invoking ocamlyacc instead of menhir." 1>&2
+ exec $OCAMLYACC parsing_c/parser_c.mly
+ ;;
+
+# execute with menhir
+ *)
+ exec $MENHIR "$@"
+ ;;
+esac
*prepare_ocamlcocci.ml*)
noprofile=1
;;
+ *coccilib.ml*)
+ noprofile=1
+ ;;
esac
if test -n "$noprofile"; then
--- /dev/null
+#! /bin/sh -e
+
+set -e
+
+# this command acts as a replacement for ocamlyacc that selectively
+# runs menhir instead for some files.
+
+# $1: path to menhir
+# $2: path to ocamlyacc
+
+MENHIR="$1"
+OCAMLYACC="$2"
+shift 2
+
+domenhir=
+case "$@" in
+ *parsing_cocci_menhir.mly*)
+ domenhir=1
+ ;;
+esac
+
+if test -n "$domenhir"; then
+ exec $OCAMLC "$@"
+else
+ exec $OCAMLYACC "$@"
+fi
#define __initdata_or_module
#define __pminit
#define __pminitdata
+#define __irq_entry
#define __cacheline_aligned
#define ____cacheline_aligned
+++ /dev/null
-let foo_ctl () = failwith "there is no foo_ctl formula"
| Some None ->
pr2 "no modification on the input file";
cfile
- | None -> raise Impossible
+ | None -> raise (Impossible 163)
in
if compare_with_expected_flag
then
begin
expected_result_files +> List.iter (fun res ->
let x =
- if res =~ "\\(.*\\).res" then matched1 res else raise Impossible in
+ if res =~ "\\(.*\\).res" then matched1 res else raise (Impossible 164) in
let base = if x =~ "\\(.*\\)_ver[0-9]+" then matched1 x else x in
let cfile = "tests/" ^ x ^ ".c" in
let cocci_file = "tests/" ^ base ^ ".cocci" in
-@@
-identifier I;
-expression E;
-@@
-
struct i2c_client I = {
.name = E,
- .foo = 16
+ .foo = 16,
};
-@@
-identifier I;
-expression E;
-@@
-
struct i2c_client I = {
.foo = 16,
.dev = {
}
}
+int main () {
+ xxx();
+ if(y)
+ rrr();
+}
+
int d() {}
}
}
+int main () {
+ foo();
+ xxx();
+ foo();
+ if(y) {
+ foo();
+ rrr();
+ }
+}
+
int d() {}
--- /dev/null
+int main () {
+ if (a) {
+ bar();
+ }
+}
--- /dev/null
+@@
+@@
+
+if (...)
+- {
+- bar(
++ foo(
+ );
+- }
--- /dev/null
+int main () {
+ if (a)
+ foo();
+}
--- /dev/null
+struct foo {
+ int a;
+#define FOO 12
+#define BAR 20
+ int b;
+#ifdef FOO
+ int c;
+#else
+ int d;
+#endif
+};
--- /dev/null
+@r@
+field list[n] fs;
+identifier I,x;
+@@
+
+struct I { fs int x; ...};
+
+@script:ocaml@
+n << r.n;
+x << r.x;
+i << r.I;
+@@
+
+Printf.printf "%s at offset %d in %s\n" x n i
--- /dev/null
+struct ty x[] = {
+ {
+ a,
+ }};
--- /dev/null
+@@
+identifier ty,x;
+expression a;
+initializer list is;
+@@
+
+struct ty x[] = {...,
+ {is,
+- a
++ .i = foo(a)
+ ,...}, ...};
--- /dev/null
+struct ty x =
+ {
+ .i = a,
+ };
--- /dev/null
+@@
+identifier ty,x;
+expression a;
+initializer list is;
+@@
+
+struct ty x =
+ {is,
+- .i = a,
++ foo(a),
+ ...};
--- /dev/null
+int main () {
+ for(bit = 0; bit < size; bit++) {
+ if (test_bit(bit, bitmap))
+ x = 12;
+ }
+}
--- /dev/null
+@@
+expression bitmap, size;
+identifier bit;
+statement S1;
+iterator name for_each_set_bit;
+@@
+-for(bit = 0; bit < size; bit++)
++for_each_set_bit(bit, bitmap, size)
+-{
+- if (test_bit(bit, bitmap))
+ S1
+-}
--- /dev/null
+int main () {
+ for_each_set_bit(bit, bitmap, size)
+ x = 12;
+}
--- /dev/null
+int main () {
+ foo();
+ if (x)
+ return 3;
+ bar();
+}
--- /dev/null
+@@
+expression e;
+statement S;
+@@
+
+- if (e) S
++ if (f(e)) S
\ No newline at end of file
--- /dev/null
+int main () {
+ foo();
+ if (f(x))
+ return 3;
+ bar();
+}
--- /dev/null
+int main () {
+ if (new_pe == NULL) {
+ return NULL;
+ }
+}
+
+int main () {
+ if (new_pe == NULL)
+ return NULL;
+}
--- /dev/null
+@@
+expression e;
+statement S;
+@@
+
+- if (e) S
++ if (unlikely(e)) S
--- /dev/null
+int main () {
+ if (unlikely(new_pe == NULL)) {
+ return NULL;
+ }
+}
+
+int main () {
+ if (unlikely(new_pe == NULL))
+ return NULL;
+}
{
dev_link_t *link;
char *ioctl_names[CM_IOC_MAXNR + 1] = {
- [_IOC_NR(CM_IOSDBGLVL)] "CM4000_DBGLVL",
+ [_IOC_NR(CM_IOSDBGLVL)] "CM4000_DBGLVL",
};
}
OCAMLCFLAGS ?= -g
OPTFLAGS ?= -g
-PROGS=spp gitgrep splitpatch extract_c_and_res #generate_dependencies
+SYSLIBS = str.cma unix.cma bigarray.cma
+
+INCLUDE=-I ../commons -I ../extra -I ../parsing_c
+LIBS=../commons/commons.cma ../globals/globals.cma \
+ ../parsing_c/parsing_c.cma ../extra/extra.cma
+
+OCAMLC_CMD=$(OCAMLC) $(OCAMLCFLAGS) $(INCLUDE)
+OCAMLOPT_CMD=$(OCAMLOPT) $(OPTFLAGS) $(INCLUDE)
+OCAMLDEP_CMD=$(OCAMLDEP) $(INCLUDE)
+OCAMLMKTOP_CMD=$(OCAMLMKTOP) -g -custom $(INCLUDE)
+OCAMLYACC_CMD=$(OCAMLYACC) -v
+
-all: $(SUBDIRS) $(PROGS)
+PROGS=spp gitgrep splitpatch extract_c_and_res \
+ gitsort alloc_free bridge \
+ process_isoprofile
+ #generate_dependencies
+
+ifneq ($(FEATURE_OCAMLBUILD),yes)
+all: $(PROGS)
all.opt:
@$(MAKE) $(PROGS) BUILD_OPT=yes
gitsort: gitsort.ml
$(OCAMLOPT) -o gitsort str.cmxa gitsort.ml
-isoprof: process_isoprofile.ml
- $(OCAMLC) -g -o isoprof str.cma process_isoprofile.ml
+process_isoprofile: process_isoprofile.ml
+ $(OCAMLC) -g -o process_isoprofile str.cma process_isoprofile.ml
alloc_free: alloc_free.ml
$(OCAMLOPT) -o alloc_free str.cmxa alloc_free.ml
install_bridge: bridge
cp -f bridge /usr/local/bin
-.PHONY: $(SUBDIRS)
-
-
-SYSLIBS = str.cma unix.cma bigarray.cma
-
-INCLUDE=-I ../commons -I ../extra -I ../parsing_c
-LIBS=../commons/commons.cma ../globals/globals.cma \
- ../parsing_c/parsing_c.cma ../extra/extra.cma
-
-OCAMLC_CMD=$(OCAMLC) $(OCAMLCFLAGS) $(INCLUDE)
-OCAMLOPT_CMD=$(OCAMLOPT) $(OPTFLAGS) $(INCLUDE)
-OCAMLDEP_CMD=$(OCAMLDEP) $(INCLUDE)
-OCAMLMKTOP_CMD=$(OCAMLMKTOP) -g -custom $(INCLUDE)
-OCAMLYACC_CMD=$(OCAMLYACC) -v
-
spp: spp.ml
$(OCAMLC_CMD) -o $@ $(SYSLIBS) $(INCLUDE) $(LIBS) $+
generate_dependencies: generate_dependencies.cmo
$(OCAMLC_CMD) -o $@ $(SYSLIBS) $(INCLUDE) $(LIBS) $+
+else
+.PHONY: $(PROGS) $(PROGS:%.opt) isoprof
+
+all: $(PROGS)
+all.opt: $(PROGS:%=%.opt)
+
+$(PROGS):
+ cd .. && $(OCAMLBUILD) tools/$@.byte
+ cp ../_build/tools/$@.byte $@
+
+$(PROGS:%=%.opt):
+ cd .. && $(OCAMLBUILD) tools/$(@:%.opt=%).native
+ cp ../_build/tools/$(@:%.opt=%).native $(@:%.opt=%)
+
+clean::
+ cd .. && $(OCAMLBUILD) -clean
+ rm -f $(PROGS)
+endif
+
+isoprof: process_isoprofile
+ cp process_isoprofile isoprof
+
.SUFFIXES: .ml .mli .cmo .cmi .cmx
.ml.cmx:
$(OCAMLOPT_CMD) -c $<
-clean:
- rm -f $(PROGS)
+clean::
+ rm -f $(PROGS) isoprof
rm -f *.cm[ioxa] *.o *.a *.cmxa *.annot
rm -f .depend
--- /dev/null
+gitgrep.byte
+gitsort.byte
+process_isoprofile.byte
+alloc_free.byte
+bridge.byte
+spp.byte
+splitpatch.byte
+extract_c_and_res.byte
--- /dev/null
+gitgrep.native
+gitsort.native
+process_isoprofile.native
+alloc_free.native
+bridge.native
+spp.native
+splitpatch.native
+extract_c_and_res.native
--- /dev/null
+(*
+ * Copyright 2012, INRIA
+ * Julia Lawall, Gilles Muller
+ * Copyright 2010-2011, INRIA, University of Copenhagen
+ * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
+ * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
+ * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
+ * This file is part of Coccinelle.
+ *
+ * Coccinelle 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, according to version 2 of the License.
+ *
+ * Coccinelle 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 Coccinelle. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * The authors reserve the right to distribute this or future versions of
+ * Coccinelle under other licenses.
+ *)
+
+
+# 0 "./cstripenv.ml"
+(* This tool strips code from a C file that relies on the external
+ * macro and type environment, which we would obtain via commandline
+ * parameters and includes.
+ * The resulting file is more likely to be analyzable without the
+ * headers, although it does affect the semantics of the original
+ * program.
+ *
+ * It does so by removing toplevel elements that cannot be parsed
+ * correctly because of macro's. Macro's that are interpreted as
+ * functions are still kept.
+ * It also removes expressions that have an unknown type, and
+ * remapping unknown types in types of declarations.
+ *)
+
+
+(* Visitor that hides tokens that cannot be parsed.
+ *)
+let hide_visitor =
+ { Visitor_c.default_visitor_c with
+ Visitor_c.ktoplevel = fun (f, self) p ->
+ begin
+ match p with
+ Ast_c.NotParsedCorrectly ii ->
+ let first_i = List.hd ii in
+ let last_i = List.hd (List.rev ii) in
+ Ast_c.put_annot_info first_i Token_annot.Exclude_start Token_annot.Unit;
+ Ast_c.put_annot_info last_i Token_annot.Exclude_end Token_annot.Unit
+ | _ -> ()
+ end;
+ f p
+ }
+
+(* todo: remap visitor *)
+
+(*
+ Visitor_c.ktype = fun (f, bigf) ft ->
+ let (_, (t, _)) = ft in
+ begin match t with
+ Ast_c.NoType -> Common.pr2 "no type"
+ | Ast_c.BaseType _ -> Common.pr2 "base type"
+ | Ast_c.TypeName (nm, optTp) -> begin
+ match optTp with
+ None -> Common.pr2 ("type name " ^ (Ast_c.str_of_name nm) ^ " without fullType")
+ | Some _ -> Common.pr2 ("type name " ^ (Ast_c.str_of_name nm) ^ " with fullType")
+ end
+ | Ast_c.Pointer _ -> Common.pr2 "pointer"
+ | Ast_c.ParenType _ -> Common.pr2 "parens"
+ | _ -> Common.pr2 "other"
+ end;
+ f ft;
+ *)
+
+let stripenv source_file dest_file =
+ let (ast2,_) = Parse_c.parse_c_and_cpp source_file in
+ let ast = Parse_c.program_of_program2 ast2 in
+ ignore (Type_annoter_c.annotate_program !Type_annoter_c.initial_env ast);
+ ignore (Visitor_c.vk_program hide_visitor ast);
+ Unparse_c.pp_program_default ast2 dest_file
+
+let main () =
+ Common.print_to_stderr := true;
+ Flag_parsing_c.show_parsing_error := true;
+
+ let source = ref None in
+ let dest = ref None in
+ let path_arg ref path = ref := Some path in
+ Arg.parse_argv Sys.argv
+ [("--output",Arg.String (path_arg dest),"path to the output file")]
+ (path_arg source) "cstripenv <source.c>";
+ let source_file =
+ match !source with
+ None -> raise (Arg.Bad "a source file argument is required")
+ | Some path -> path in
+ let dest_file =
+ match !dest with
+ None -> raise (Arg.Bad "an output file argument is required")
+ | Some path -> path in
+ stripenv source_file dest_file
+
+let _ = main ()
-(*
- * Copyright 2012, INRIA
- * Julia Lawall, Gilles Muller
- * Copyright 2010-2011, INRIA, University of Copenhagen
- * Julia Lawall, Rene Rydhof Hansen, Gilles Muller, Nicolas Palix
- * Copyright 2005-2009, Ecole des Mines de Nantes, University of Copenhagen
- * Yoann Padioleau, Julia Lawall, Rene Rydhof Hansen, Henrik Stuart, Gilles Muller, Nicolas Palix
- * This file is part of Coccinelle.
- *
- * Coccinelle 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, according to version 2 of the License.
- *
- * Coccinelle 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 Coccinelle. If not, see <http://www.gnu.org/licenses/>.
- *
- * The authors reserve the right to distribute this or future versions of
- * Coccinelle under other licenses.
- *)
-
-
-# 0 "./generate_dependencies.ml"
open Common
(*****************************************************************************)
-1.0.0-rc15
\ No newline at end of file
+1.0.0-rc16
\ No newline at end of file
--- /dev/null
+let version_date = "Fri, 7 Dec 2012 12:29:06 +0100"
+let configure_flags = "--enable-release --disable-python --disable-pcre-syntax"
HCoop / bpt / coccinelle.git / commitdiff